and password <%(password)s> ' +\\n 'do not match.') % {'username': self.username,\\n 'password': self.password}\\n\\n raise exceptions.AuthError(msg)\\n\\n data = {'action': 'login',\\n 'user': self.username,\\n 'pwd': self.password}\\n\\n # step 1: submit login form\\n response = self._do('POST', self.URLS['auth_step_one'],\\n data=data, allow_redirects=True)\\n check_response(response.text)\\n\\n # step 2: fake second form's submission\\n # todo: sprinkle on some error checking,\\n # even though this is only a redirect\\n response = self._do('POST', self.URLS['auth_step_two'],\\n data=data, allow_redirects=True)\\n check_response(response.text)\\n\\n return True\",\n \"def test_agentpi_connection(self):\\n response = socket_utils.sendJson(conn, { \\\"authenticated\\\": True })\\n\\n self.assertTrue(response.text == \\\"authenticated\\\")\",\n \"def setUp(self):\\n self.transport = StringTransport()\\n self.client = self.clientProtocol()\\n self.client.makeConnection(self.transport)\\n self.client.dataReceived(b'* PREAUTH Hello unittest\\\\r\\\\n')\",\n \"def check_and_test_auth(self):\\r\\n time.sleep(10)\\r\\n webbrowser.open(AUTH_URL)\\r\\n\\r\\n while not self.is_authorized:\\r\\n time.sleep(5)\\r\\n self.get_tokens()\\r\\n\\r\\n # Finally start our polling & refresh threads.\\r\\n self.start_polling_and_refresh()\",\n \"def check_auth():\",\n \"def test_authentication(self):\\n http = FakeHttp([(FakeResponse(401), {}), (FakeResponse(\\n 200, include_auth_header=True), {})])\\n self.mock.Http.return_value = http\\n response, _ = http_utils.request('https://url/', configuration=self.config)\\n\\n # Ensure that all expected requests were made.\\n self.assertEqual(http.replies, [])\\n\\n self.mock.write_data_to_file.assert_called_once_with(\\n 'fake auth token', http_utils.AUTHORIZATION_CACHE_FILE)\\n self.assertEqual(response.status, 200)\",\n \"def test_login_request_with_authentication(self):\\n # create a user and assert the response\\n user_res = self.ph.create_user(self.test_user_name, self.test_user_password)\\n self.assertEqual(user_res.status_code, status.HTTP_201_CREATED) \\n user_res_data = json.loads(user_res.get_data(as_text=True))\\n self.assertEqual(user_res_data['name'], self.test_user_name)\\n\\n # Get the url for the login resource and query it\\n url = url_for('api.userloginresource', _external=True, name=self.test_user_name)\\n res = self.test_client.get(url, headers=self.ph.get_authentication_headers())\\n \\n # assert that the resonse is the same as the one that we created before\\n self.assertTrue(res.status_code == status.HTTP_200_OK)\\n res_data = json.loads(res.get_data(as_text=True))\\n self.assertTrue(res_data['id'], user_res_data['id'])\\n self.assertTrue(res_data['name'], user_res_data['name'])\",\n \"def test_authenticate(self):\\n a = Authenticator( self.logger )\\n authentication_id = a.authenticate(\\n self.patron_barcode, self.api_url_root, self.api_key, self.partnership_id, self.university_code )\\n self.assertEqual(\\n 27, len(authentication_id) )\",\n \"def test_login(self):\\n\\n client = Client('username', 'password')\\n self.setSessionResponse(200)\\n try:\\n client.authenticate()\\n except Exception as e:\\n self.fail(\\\"Exception raised : \\\" + str(e))\",\n \"def test_success(self):\\n \\n result = self.authenticator.authenticate(\\n username=u'thruflo', \\n password=u'secret'\\n )\\n self.assertTrue(result.username == self.user.username)\",\n \"def test_get_authenticated(self):\\n self.verify_get_response(self.client.get(STATUS_PATH))\",\n \"def test_signin_functionality(self):\\n res = self.client.post('/signin',\\n follow_redirects=True, data=dict(\\n username='orange',\\n password='123Orange',\\n ))\\n data = res.data.decode('utf-8')\\n assert 'Profile' in data\\n assert 'Username: orange' in data\\n assert res.status == '200 OK'\",\n \"def test_auth(self):\\n options = Options()\\n options.parseOptions([\\\"--auth\\\", \\\"memory:admin:admin:bob:password\\\"])\\n self.assertEqual(len(options[\\\"credCheckers\\\"]), 1)\\n checker = options[\\\"credCheckers\\\"][0]\\n interfaces = checker.credentialInterfaces\\n registered_checkers = options.service.smtpPortal.checkers\\n for iface in interfaces:\\n self.assertEqual(checker, registered_checkers[iface])\",\n \"def test_step_server_answer(self):\\r\\n sasl_kwargs = {'username': \\\"chris\\\", 'password': \\\"secret\\\"}\\r\\n sasl = PureSASLClient('elwood.innosoft.com',\\r\\n service=\\\"imap\\\",\\r\\n mechanism=self.mechanism,\\r\\n mutual_auth=True,\\r\\n **sasl_kwargs)\\r\\n testChallenge = (\\r\\n b'utf-8,username=\\\"chris\\\",realm=\\\"elwood.innosoft.com\\\",'\\r\\n b'nonce=\\\"OA6MG9tEQGm2hh\\\",nc=00000001,cnonce=\\\"OA6MHXh6VqTrRk\\\",'\\r\\n b'digest-uri=\\\"imap/elwood.innosoft.com\\\",'\\r\\n b'response=d388dad90d4bbd760a152321f2143af7,qop=auth'\\r\\n )\\r\\n sasl.step(testChallenge)\\r\\n sasl._chosen_mech.cnonce = b\\\"OA6MHXh6VqTrRk\\\"\\r\\n\\r\\n serverResponse = (\\r\\n b'rspauth=ea40f60335c427b5527b84dbabcdfffd'\\r\\n )\\r\\n sasl.step(serverResponse)\\r\\n # assert that step choses the only supported QOP for for DIGEST-MD5 \\r\\n self.assertEqual(self.sasl.qop, QOP.AUTH)\",\n \"def func_auth(self, data):\\n check = bytes(data).decode().encode('ascii', 'ignore').decode().lower().rstrip()\\n if check == 'auth login':\\n auth_id = library.q_id_generate(size=12)\\n message = '334 ' + auth_id\\n self.func_sender(message)\\n self.request.recv(self.std_recv_size)\\n auth_id_two = library.q_id_generate(size=12)\\n message_two = '334 ' + auth_id_two\\n self.func_sender(message_two)\\n self.request.recv(self.std_recv_size)\\n message_three = self.conf_th_ic.get_item(q_key='std-messages').get(check)\\n self.func_sender(message_three)\\n return True\",\n \"def start(self):\\n if not self.available:\\n self.get_auth_token()\\n\\n if self.key_required and not self.no_prompt:\\n email = self.login_handler.data[\\\"username\\\"]\\n key = input(\\\"Enter code sent to {}: \\\".format(email))\\n result = self.login_handler.send_auth_key(self, key)\\n self.key_required = not result\\n self.setup_post_verify()\\n elif not self.key_required:\\n self.setup_post_verify()\",\n \"def test_get_main_route_auth():\\n set_token(client, \\\"user0011\\\")\\n\\n response = client.get(url)\\n assert response.status_code == 202\",\n \"def test_logging_running(self):\\n tester = app.test_client(self)\\n response = tester.get('/login', content_type='html/text')\\n self.assertTrue(b'PLEASE LOGIN' in response.data)\",\n \"def test_auth(self):\\n self.api.auth()\\n self.assertIsNotNone(self.api.session, msg=\\\"auth() doesn't return a session\\\")\\n\\n self.api.request('logout')\\n self.assertIn('list', self.api.request('sys.settings.get').data,\\n msg=\\\"auth() doesn't restore sessions expired\\\")\",\n \"def test_step(self):\\r\\n testChallenge = (\\r\\n b'nonce=\\\"rmD6R8aMYVWH+/ih9HGBr3xNGAR6o2DUxpKlgDz6gUQ=\\\",r'\\r\\n b'ealm=\\\"example.org\\\",qop=\\\"auth,auth-int,auth-conf\\\",cipher=\\\"rc4-40,rc'\\r\\n b'4-56,rc4,des,3des\\\",maxbuf=65536,charset=utf-8,algorithm=md5-sess'\\r\\n )\\r\\n result, response = self.sasl.step(testChallenge)\\r\\n self.assertTrue(result)\\r\\n self.assertIsNotNone(response)\",\n \"def test_01_authenticated(self):\\r\\n res = self.signin(email=self.email_addr, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is not None, err_msg\\r\\n\\r\\n self.signout()\\r\\n\\r\\n self.signin(email=self.email_addr2, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be ONLY available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is None, err_msg\",\n \"def test_login(self):\\n res = self.client.get(\\\"/login\\\")\\n data = res.data.decode(\\\"utf-8\\\")\\n assert res.status == \\\"200 OK\\\"\\n assert \\\"Already a member!\\\" in data\",\n \"def test_successful_login(self):\\n pass\",\n \"def test_valid_auth_inputs(login_inputs, expected_result, expected_status_code):\\n with requests.Session() as session:\\n create_next_admin(session)\\n create_test_user(session, USER_INPUT)\\n response = session.post(\\n \\\"http://rbac-server:8000/api/authorization/\\\", json=login_inputs\\n )\\n assert response.json()[\\\"data\\\"][\\\"message\\\"] == expected_result\\n assert response.status_code == expected_status_code\",\n \"def test_auto_auth(mock_auth_approle, mock_is_authenticated, parser_dump_function, parser_name):\\n creds = {\\\"vault_creds\\\": {\\\"auth_method\\\": \\\"approle\\\", \\\"role_id\\\": \\\"test_jim_bob\\\", \\\"secret_id\\\": \\\"test_123password\\\"}}\\n mock_is_authenticated.return_value = False\\n\\n VaultAnyConfig(url=\\\"http://localhost\\\").auto_auth(parser_dump_function(creds), ac_parser=parser_name)\\n\\n mock_auth_approle.assert_called_with(\\n role_id=creds[\\\"vault_creds\\\"][\\\"role_id\\\"], secret_id=creds[\\\"vault_creds\\\"][\\\"secret_id\\\"]\\n )\\n mock_is_authenticated.assert_called_with()\",\n \"def test_auth_json(self):\\n\\n config = get_config()\\n\\n if config.getboolean('auth_test', 'enabled'):\\n\\n # Run only if enabled\\n\\n try:\\n\\n timestamp = config.getint('auth_test', 'timestamp')\\n\\n except ValueError:\\n\\n # If timestamp is set to a none-integer, we'll just assume\\n # that it's unset\\n\\n timestamp = None\\n\\n response = authenticate(\\n config.get('auth_test', 'url'),\\n config.get('auth_test', 'account'),\\n config.get('auth_test', 'preauthkey'),\\n config.get('auth_test', 'account_by'),\\n config.getint('auth_test', 'expires'),\\n timestamp,\\n request_type='json'\\n )\\n\\n self.assertNotEqual(\\n response,\\n None,\\n \\\"Authentication with the configured settings \\\"\\n \\\"was not successful\\\"\\n )\",\n \"def testsignin(self):\\n rv = self.app.get('/signin')\\n self.assertEqual(rv.status_code, 200, \\\"log in page didnot load as expected\\\")\",\n \"def test_auth_success(self):\\n self.assertEqual(Freenas(hostname)._user, 'root')\",\n \"def auth():\\n pass\",\n \"def auth():\\n pass\",\n \"def test_valid_authentication(self):\\n\\n for author in self.authors + [self.super_author]:\\n response: Response = self.client.post(BASE_URL + '/authenticate/', data={\\n 'username': author.username,\\n 'password': 'abcd1432' # Might be a better way to store random passwords.\\n })\\n data = u.get_json(response)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(data, {\\n 'token': author.get_key()\\n })\",\n \"def authTest(token=None):\\n if not token:\\n token = bottle.request.get_header('X-Auth-Token')\\n\\n data = bottle.request.json\\n if not token:\\n user = data.get('user')\\n password = data.get('password')\\n\\n query = odict(bottle.request.query.items())\\n if not user or not password:\\n user = query.get('user')\\n password = query.get('password')\\n\\n if not token and (not user or not password):\\n bottle.abort(400, \\\"Authentication credentials missing.\\\")\\n\\n result = odict(token=token,\\n user=user,\\n password=password,\\n headers=odict(bottle.request.headers.items()),\\n query=query,\\n data=data,\\n )\\n return result\",\n \"def auth(self):\\n ok = False\\n if self.private_token:\\n ok = self.token_auth()\\n if not ok:\\n self.credentials_auth()\",\n \"def test_valid_flow__registration(self):\\n\\n test_env = {\\n \\\"testapp_authority\\\": self.testapp_authority,\\n \\\"testapp_app\\\": self.testapp_app,\\n \\\"extra_environ_app\\\": {\\n \\\"wsgi.url_scheme\\\": \\\"https\\\",\\n \\\"HTTP_HOST\\\": \\\"app.example.com\\\",\\n },\\n \\\"extra_environ_authority\\\": {\\n \\\"wsgi.url_scheme\\\": \\\"https\\\",\\n \\\"HTTP_HOST\\\": \\\"authority.example.com\\\",\\n },\\n \\\"requests_session_app\\\": requests.Session(),\\n \\\"requests_session_authority\\\": requests.Session(),\\n }\\n\\n def callback__request_token(req, test_env=test_env):\\n \\\"\\\"\\\"/authority/oauth1/request_token is visited by the Server\\n\\n py3 needs the 'unicode' wrapper to decode the bystring\\n \\\"\\\"\\\"\\n assert \\\"Authorization\\\" in req.headers\\n assert req.headers[\\\"Authorization\\\"].decode(\\\"utf-8\\\").startswith(\\\"OAuth \\\")\\n assert \\\"User-Agent\\\" in req.headers\\n assert req.headers[\\\"User-Agent\\\"].decode(\\\"utf-8\\\") == \\\"CustomApiClient v0\\\"\\n assert req.url == oauth1_utils.CustomApiClient.OAUTH1_SERVER_REQUEST_TOKEN\\n\\n # request as SERVER, no cookies\\n with IsolatedTestapp(test_env[\\\"testapp_authority\\\"]) as testapp:\\n res = testapp.get(\\n \\\"/authority/oauth1/request_token\\\",\\n headers=req.headers,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n def callback__authenticate_get(req, test_env=test_env):\\n \\\"\\\"\\\"/authority/oauth1/authorize is visited by the USER\\\"\\\"\\\"\\n assert req.url.startswith(OAUTH1__URL_AUTHORITY_AUTHENTICATE)\\n qs = req.url.split(\\\"?\\\")[1]\\n qs = dict(parse_qsl(qs))\\n\\n testapp = test_env[\\\"testapp_authority\\\"]\\n res = testapp.get(\\n \\\"/authority/oauth1/authorize?oauth_token=%s\\\" % qs[\\\"oauth_token\\\"],\\n headers=req.headers,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n testapp.cookies\\n ) # update the session with the cookies from the response\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n def callback__authenticate_post(req, test_env=test_env):\\n \\\"\\\"\\\"/authority/oauth1/authorize is visited by the USER\\\"\\\"\\\"\\n assert req.url.startswith(OAUTH1__URL_AUTHORITY_AUTHENTICATE)\\n payload = dict(parse_qsl(req.body))\\n\\n testapp = test_env[\\\"testapp_authority\\\"]\\n res = testapp.post(\\n \\\"/authority/oauth1/authorize\\\",\\n payload,\\n headers=req.headers,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=302,\\n )\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n testapp.cookies\\n ) # update the session with the cookies from the response\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n def callback__callback(req, test_env=test_env):\\n \\\"\\\"\\\"/application/flow-register/authorized-callback is visited by the USER\\\"\\\"\\\"\\n _path, _qs = req.url.split(\\\"?\\\")\\n\\n testapp = test_env[\\\"testapp_app\\\"]\\n res = testapp.get(\\n \\\"/application/flow-register/authorized-callback?%s\\\" % _qs,\\n headers=req.headers,\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=303,\\n )\\n test_env[\\\"requests_session_app\\\"].cookies.update(\\n testapp.cookies\\n ) # update the session with the cookies from the response\\n\\n # status is '303 See Other'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n def callback__access_token(req, test_env=test_env):\\n \\\"\\\"\\\"/authority/oauth1/access_token is visited by the Server\\\"\\\"\\\"\\n assert \\\"Authorization\\\" in req.headers\\n assert req.headers[\\\"Authorization\\\"].decode(\\\"utf-8\\\").startswith(\\\"OAuth \\\")\\n assert \\\"User-Agent\\\" in req.headers\\n assert req.headers[\\\"User-Agent\\\"].decode(\\\"utf-8\\\") == \\\"CustomApiClient v0\\\"\\n assert req.url == oauth1_utils.CustomApiClient.OAUTH1_SERVER_ACCESS_TOKEN\\n\\n # request as SERVER, no cookies\\n with IsolatedTestapp(test_env[\\\"testapp_authority\\\"]) as testapp:\\n _headers = string_headers(\\n req.headers\\n ) # these can end up being unicode in tests\\n res = testapp.get(\\n \\\"/authority/oauth1/access_token\\\",\\n headers=_headers,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n def callback__callback_success(req, test_env=test_env):\\n \\\"\\\"\\\"/application/flow-register/authorized-callback-success is visited by the USER\\\"\\\"\\\"\\n (_path, _qs) = parse_request_simple(req)\\n\\n testapp = test_env[\\\"testapp_application\\\"]\\n _headers = string_headers(\\n req.headers\\n ) # these can end up being unicode in tests\\n res = testapp.get(\\n \\\"/application/flow-register/authorized-callback-success?%s\\\" % _qs,\\n headers=_headers,\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=200,\\n )\\n test_env[\\\"requests_session_application\\\"].cookies.update(\\n testapp.cookies\\n ) # update the session with the cookies from the response\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\\n\\n with responses.RequestsMock() as rsps:\\n rsps.add_callback(\\n responses.GET,\\n oauth1_utils.CustomApiClient.OAUTH1_SERVER_REQUEST_TOKEN, # /authority/oauth1/request_token\\n callback=callback__request_token,\\n )\\n rsps.add_callback(\\n responses.GET,\\n oauth1_utils.CustomApiClient.OAUTH1_SERVER_ACCESS_TOKEN, # /authority/oauth1/access_token\\n callback=callback__access_token,\\n )\\n\\n # the following were originally handled via `requests.get` but migrated to direct webtest queries\\n #\\n # rsps.add_callback(\\n # responses.GET, OAUTH1__URL_AUTHORITY_AUTHENTICATE, # /authority/oauth1/authorize\\n # callback=callback__authenticate_get,\\n # )\\n # rsps.add_callback(\\n # responses.POST, OAUTH1__URL_AUTHORITY_AUTHENTICATE, # /authority/oauth1/authorize\\n # callback=callback__authenticate_post,\\n # )\\n # rsps.add_callback(\\n # responses.GET, oauth1_model.OAUTH1__URL_APP_FLOW_REGISTER_CALLBACK, # https://example.com/application/flow-register/authorized-callback\\n # callback=callback__callback,\\n # )\\n # rsps.add_callback(\\n # responses.GET, oauth1_model.OAUTH1__URL_APP_FLOW_REGISTER_CALLBACK_SUCCESS, # https://example.com/application/flow-register/authorized-callback-success\\n # callback=callback__callback_success,\\n # )\\n\\n #\\n # actual test flow...\\n #\\n\\n # first we need to log into the oAuth1 Authority\\n # the authority is the account which will be the oAuth identity provider (e.g. Twitter)\\n\\n # User visit\\n res = self.testapp_authority.get(\\n \\\"/authority/account/login-form\\\",\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n assert res.text == \\\"authority|login-form\\\"\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n self.testapp_authority.cookies\\n ) # update the session with the cookies from the response\\n\\n # User visit\\n res = self.testapp_authority.get(\\n \\\"/authority/account/login-submit\\\",\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=303,\\n )\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n self.testapp_authority.cookies\\n ) # update the session with the cookies from the response\\n assert (\\n res.text\\n == \\\"\\\"\\\"303 See Other\\\\n\\\\nThe resource has been moved to /authority/account/home; you should be redirected automatically.\\\\n\\\\n\\\"\\\"\\\"\\n )\\n\\n # User visit\\n res = self.testapp_authority.get(\\n \\\"/authority/account/home\\\",\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n self.testapp_authority.cookies\\n ) # update the session with the cookies from the response\\n assert (\\n res.text\\n == \\\"authority|home|user=%s\\\" % oauth1_model.USERID_ACTIVE__AUTHORITY\\n )\\n\\n #\\n # now we want to visit the application\\n #\\n\\n # User visit's the application\\n #\\n res = self.testapp_app.get(\\n \\\"/application/flow-register\\\",\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=303,\\n )\\n test_env[\\\"requests_session_app\\\"].cookies.update(\\n self.testapp_app.cookies\\n ) # update the session with the cookies from the response\\n assert (\\n res.text\\n == \\\"\\\"\\\"303 See Other\\\\n\\\\nThe resource has been moved to /application/flow-register/oauth1/start; you should be redirected automatically.\\\\n\\\\n\\\"\\\"\\\"\\n )\\n\\n # User visit\\n # however, it makes a behind the scenes visit to\\n # * /authority/oauth1/request_token\\n res = self.testapp_app.get(\\n \\\"/application/flow-register/oauth1/start\\\",\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=303,\\n )\\n test_env[\\\"requests_session_app\\\"].cookies.update(\\n self.testapp_app.cookies\\n ) # update the session with the cookies from the response\\n assert \\\"Location\\\" in res.headers\\n url_auth = res.headers[\\\"Location\\\"]\\n assert res.headers[\\\"Location\\\"].startswith(\\n OAUTH1__URL_AUTHORITY_AUTHENTICATE\\n )\\n\\n # resAuthInbound = test_env['requests_session_authority'].get(url_auth)\\n # then the user is redirected to the authority to approve\\n qs = url_auth.split(\\\"?\\\")[1]\\n url_auth_local = \\\"/authority/oauth1/authorize?%s\\\" % qs\\n resAuthInbound = self.testapp_authority.get(\\n url_auth_local, extra_environ=test_env[\\\"extra_environ_authority\\\"]\\n )\\n assert (\\n '<form action=\\\"/authority/oauth1/authorize\\\" method=\\\"POST\\\" id=\\\"app-action-authorize\\\">'\\n in resAuthInbound.text\\n )\\n csrfs = re_csrf.findall(resAuthInbound.text)\\n assert len(csrfs) == 2 # submit, deny\\n tokens = re_token.findall(resAuthInbound.text)\\n assert len(tokens) == 2 # submit, deny\\n\\n payload = {\\n \\\"csrf_\\\": csrfs[0],\\n \\\"oauth_token\\\": tokens[0],\\n \\\"submit\\\": \\\"authorize\\\",\\n }\\n # payload = {'csrf_': csrfs[0], 'oauth_token': tokens[0], 'submit': 'authorize', }\\n\\n # visited by USER: Authorize the application on the Authority\\n resAuthApprove = self.testapp_authority.post(\\n \\\"/authority/oauth1/authorize\\\",\\n payload,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=302,\\n )\\n test_env[\\\"requests_session_authority\\\"].cookies.update(\\n self.testapp_authority.cookies\\n ) # update the session with the cookies from the response\\n\\n # visited by USER: redirected to the callback page on the APPLICATION\\n assert \\\"Location\\\" in resAuthApprove.headers\\n url_callback = resAuthApprove.headers[\\\"Location\\\"]\\n assert url_callback.startswith(OAUTH1__URL_APP_FLOW_REGISTER_CALLBACK)\\n qs = url_callback.split(\\\"?\\\")[1]\\n url_callback_local = (\\n \\\"/application/flow-register/authorized-callback?%s\\\" % qs\\n )\\n resAuthCallback = self.testapp_app.get(\\n url_callback_local,\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=303,\\n )\\n\\n # visited by USER: redirected to the callback-success page on the APPLICATION\\n assert \\\"Location\\\" in resAuthCallback.headers\\n url_callback_success = resAuthCallback.headers[\\\"Location\\\"]\\n assert url_callback_success.startswith(\\n OAUTH1__URL_APP_FLOW_REGISTER_CALLBACK_SUCCESS\\n )\\n assert len(url_callback_success.split(\\\"?\\\")) == 1\\n url_callback_success_local = (\\n \\\"/application/flow-register/authorized-callback-success\\\"\\n )\\n resAuthCallbackSuccess = self.testapp_app.get(\\n url_callback_success_local,\\n extra_environ=test_env[\\\"extra_environ_app\\\"],\\n status=200,\\n )\\n assert (\\n resAuthCallbackSuccess.text\\n == \\\"application|register|authorized-callback-success|user=%s\\\"\\n % oauth1_model.USERID_ACTIVE__APPLICATION\\n )\\n\\n # ensure logout, just to be safe\\n res = self.testapp_authority.get(\\n \\\"/authority/account/logout\\\",\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=303,\\n )\\n assert (\\n res.text\\n == \\\"\\\"\\\"303 See Other\\\\n\\\\nThe resource has been moved to /authority/account/login-form; you should be redirected automatically.\\\\n\\\\n\\\"\\\"\\\"\\n )\\n\\n res = self.testapp_authority.get(\\n \\\"/authority/account/home\\\",\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=303,\\n )\\n assert (\\n res.text\\n == \\\"\\\"\\\"303 See Other\\\\n\\\\nThe resource has been moved to /authority/account/login-form; you should be redirected automatically.\\\\n\\\\n\\\"\\\"\\\"\\n )\",\n \"def authn_and_authz():\\n authentication()\\n authorization()\",\n \"def test_login(self):\\n\\n print('\\\\n\\\\nEnter a valid LendingClub account information...')\\n email = input('Email:')\\n password = getpass.getpass()\\n\\n self.assertTrue(self.session.authenticate(email, password))\\n print('Authentication successful')\",\n \"def test_login(self):\\n res = self.client.post('api/v2/auth/signup', json=self.user,\\n headers={'Content-Type': 'application/json'})\\n data = res.get_json()\\n\\n self.assertEqual(res.status_code, 201)\\n self.assertEqual(data['status'], 201)\\n self.assertEqual(data['message'], 'User Added Successfully')\\n\\n res_other = self.client.post('/api/v2/auth/login', json={\\n 'username': 'Thomas', 'password': 'Aw3someSauce'}, headers={'Content-Type': 'application/json'})\\n data_other = res_other.get_json()\\n\\n self.assertEqual(res_other.status_code, 201)\\n self.assertEqual(data_other['status'], 201)\\n self.assertEqual(data_other['message'], 'User Logged in Successfully')\",\n \"def test_authentication_required(self):\\n self.client.logout()\\n response = self.client.get(self.path, content_type=JSON_CONTENT_TYPE)\\n assert response.status_code == 401\",\n \"def test_auth(self):\\n response = self.client.get(reverse('requests_edit'))\\n self.assertIn('42 Coffee Cups Test Assignment', response.content)\\n self.client.logout()\\n response = self.client.get(reverse('requests_edit'))\\n self.assertEqual(response.status_code, 302)\\n self.assertTemplateUsed('personal_info/login.html')\",\n \"def test_authenticated_request(self):\\n http = FakeHttp([(FakeResponse(200), {})])\\n self.mock.Http.return_value = http\\n self.mock.read_data_from_file.return_value = 'cached auth token'\\n response, _ = http_utils.request('https://url/', configuration=self.config)\\n\\n # Ensure that all expected requests were made.\\n self.assertEqual(http.replies, [])\\n\\n self.assertEqual(http.last_headers, {\\n 'Authorization': 'cached auth token',\\n 'User-Agent': 'clusterfuzz-reproduce'\\n })\\n self.assertEqual(response.status, 200)\",\n \"def _check_authentication(self) -> NoReturn:\\n if not self.heartbeat():\\n self.authenticate()\",\n \"def test_login(self):\\n self.client_app.post(\\n '/api/v1/auth/signup/',\\n data=json.dumps(dict(\\n last_name='james',\\n email='joe@gmail.com',\\n password='123456sddfdf'\\n )),\\n content_type='application/json'\\n )\\n response = self.client_app.post(\\n '/api/v1/auth/login/',\\n data=json.dumps(dict(\\n email='joe@gmail.com',\\n password='123456sddfdf',\\n )),\\n content_type='application/json'\\n )\\n data = json.loads(response.data.decode())\\n self.assertTrue(data['email'] == 'joe@gmail.com')\\n self.assertTrue(data['auth_token'])\\n self.assertTrue(response.content_type == 'application/json')\\n self.assertEqual(response.status_code, 200)\",\n \"def test_read_o_auth_client_authorization(self):\\n pass\",\n \"def setUpAuth(self):\\n self.user, self.user_headers = self.authUser()\\n self.admin, self.admin_headers = self.authAdmin()\",\n \"def test_auth_xml(self):\\n\\n config = get_config()\\n\\n if config.getboolean('auth_test', 'enabled'):\\n\\n # Run only if enabled\\n\\n try:\\n\\n timestamp = config.getint('auth_test', 'timestamp')\\n\\n except ValueError:\\n\\n # If timestamp is set to a none-integer, we'll just assume\\n # that it's unset\\n\\n timestamp = None\\n\\n response = authenticate(\\n config.get('auth_test', 'url'),\\n config.get('auth_test', 'account'),\\n config.get('auth_test', 'preauthkey'),\\n config.get('auth_test', 'account_by'),\\n config.getint('auth_test', 'expires'),\\n timestamp\\n )\\n\\n self.assertNotEqual(\\n response,\\n None,\\n \\\"Authentication with the configured settings \\\"\\n \\\"was not successful\\\"\\n )\",\n \"def test_user_login(app):\\n login_res = app.post('/auth', data={\\n 'email': 'tracy.tim@cognizant.com',\\n 'password': 'password'\\n },content_type='application/json') \\n assert login_res.status_code == 200\",\n \"def test_dummy_authenticated_endpoint(self):\\n\\n # For all users created in setUp...\\n for user in self.users:\\n\\n # Invokes login\\n event = {\\n \\\"username\\\": user['username'],\\n \\\"pwd\\\": user['pwd']\\n }\\n response = handler.user_login(event=event, context=None)\\n\\n # Exctracts value from response\\n body_dict = json.loads(response['body'])\\n apidataset_dict = body_dict['apidataset']\\n\\n # Invokes authenticated endpoint\\n event = {\\n \\\"sessionToken\\\": apidataset_dict['sessionToken'],\\n \\\"payload\\\": \\\"Look at this payload!\\\"\\n }\\n actual = handler.dummy_authenticated_endpoint(event=event, context=None)\\n\\n # Compares expected and actual values\\n expected = {'statusCode': 200, 'body': '\\\"Look at this payload!\\\"'}\\n self.assertEqual(expected, actual)\",\n \"def test_authenticate_view(self):\\n response = self.client.get('/authenticate/')\\n self.assertEqual(response.status_code, 302)\\n response = self.client.get('/authenticate/', follow=True)\\n self.assertEqual(response.status_code, 404)\\n response = self.client.post('/authenticate/')\\n self.assertEqual(response.status_code, 302)\\n\\n # Dev mode so token does not need to be valid\\n settings.SHOPIFY_APP_DEV_MODE = True\\n response = self.client.get('/authenticate/?shop=test.myshopify.com')\\n self.assertEqual(response.status_code, 302)\\n self.assertGreater(int(self.client.session['_auth_user_id']), 0)\\n self.assertEqual(self.client.session['_auth_user_backend'], 'shopify_auth.backends.ShopUserBackend')\\n self.assertIsNot(self.client.session['_auth_user_hash'], None)\",\n \"def test_successful_get_an_answer(self):\\n self.is_authenticated(self.user1)\\n response = self.get_answer()\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_login(self):\\n # Signup a user\\n response = self.client.post('/api/v1/auth/signup',\\n data=json.dumps(self.new_user2),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 201)\\n\\n # Test user login\\n response = self.client.post('/api/v1/auth/login',\\n data=json.dumps(self.login_details),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 200)\",\n \"async def test_auth_request_with_backend(coresys, mock_auth_backend, mock_api_state):\\n\\n addon = MagicMock()\\n mock_auth_backend.return_value = True\\n mock_api_state.return_value = True\\n\\n assert await coresys.auth.check_login(addon, \\\"username\\\", \\\"password\\\")\\n assert mock_auth_backend.called\",\n \"async def authentication_handler(request: Request, call_next): # type: ignore\\n username = \\\"anonymous\\\"\\n password = \\\"anonymous\\\"\\n if \\\"authorization\\\" in request.headers:\\n header = request.headers[\\\"authorization\\\"]\\n if header.startswith(\\\"Basic \\\"):\\n b64encoded = header.replace(\\\"Basic \\\", \\\"\\\")\\n try:\\n decoded = b64decode(b64encoded).decode()\\n username, password = decoded.split(\\\":\\\")\\n except Exception as exc: # pylint: disable=broad-except\\n logger.error(exc)\\n\\n if not _authenticate_user(username, password):\\n response = ResponsePayload(\\n success=False,\\n message=\\\"Authentication failed.\\\",\\n )\\n return JSONResponse(status_code=401, content=response.dict())\\n\\n request.state.user_info = {\\n \\\"username\\\": username,\\n \\\"password\\\": password,\\n }\\n\\n response = await call_next(request)\\n return response\",\n \"def test_signin_page(self):\\n res = self.client.get('/signup')\\n data = res.data.decode('utf-8')\\n assert res.status == '200 OK'\\n assert 'Sign Up' in data\",\n \"def test_auth_allow(self):\\n # Setting authentication on volume for client1 using ip\\n auth_dict = {'all': [self.mounts[0].client_system]}\\n ret = set_auth_allow(self.volname, self.mnode, auth_dict)\\n self.assertTrue(ret, \\\"Failed to set authentication\\\")\\n g.log.info(\\\"Successfully set authentication on volume\\\")\\n\\n # Mounting volume on client1\\n self.authenticated_mount(self.mounts[0])\\n\\n # Trying to mount volume on client2\\n self.unauthenticated_mount(self.mounts[1])\\n\\n # Verify whether mount failure on client2 is due to auth error\\n log_msg = self.is_auth_failure(self.mounts[1].client_system)\\n prev_log_statement = log_msg\\n\\n g.log.info(\\\"Verification of auth.allow on volume using client IP is \\\"\\n \\\"successful\\\")\\n\\n # Unmount volume from client1\\n ret = self.mounts[0].unmount()\\n self.assertTrue(ret, (\\\"Failed to unmount volume %s from client %s\\\"\\n % (self.volname, self.mounts[0].client_system)))\\n\\n # Obtain hostname of client1\\n ret, hostname_client1, _ = g.run(self.mounts[0].client_system,\\n \\\"hostname\\\")\\n self.assertEqual(ret, 0, (\\\"Failed to obtain hostname of client %s\\\"\\n % self.mounts[0].client_system))\\n g.log.info(\\\"Obtained hostname of client. IP- %s, hostname- %s\\\",\\n self.mounts[0].client_system, hostname_client1.strip())\\n\\n # Setting authentication on volume for client1 using hostname\\n auth_dict = {'all': [hostname_client1.strip()]}\\n ret = set_auth_allow(self.volname, self.mnode, auth_dict)\\n self.assertTrue(ret, \\\"Failed to set authentication\\\")\\n g.log.info(\\\"Successfully set authentication on volume\\\")\\n\\n # Mounting volume on client1\\n self.authenticated_mount(self.mounts[0])\\n\\n # Trying to mount volume on client2\\n self.unauthenticated_mount(self.mounts[1])\\n\\n # Verify whether mount failure on client2 is due to auth error\\n log_msg = self.is_auth_failure(self.mounts[1].client_system,\\n prev_log_statement)\\n prev_log_statement = log_msg\\n\\n g.log.info(\\\"Verification of auth.allow on volume using client \\\"\\n \\\"hostname is successful\\\")\\n\\n # Unmount volume from client1\\n ret = self.mounts[0].unmount()\\n self.assertTrue(ret, (\\\"Failed to unmount volume %s from client %s\\\"\\n % (self.volname, self.mounts[0].client_system)))\",\n \"def test_login(self):\\n with self.client:\\n # user registration\\n credentials = {\\n 'username': 'EdwinKato',\\n 'password': 'qwerty@123'\\n }\\n response = self.client.post('/api/v1/auth/login',\\n data=json.dumps(credentials),\\n content_type='application/json')\\n response_data = json.loads(response.data.decode())\\n self.assertTrue(response_data['status'] == 'success')\\n self.assertTrue(response_data['token'])\\n self.assertTrue(response.content_type == 'application/json')\\n self.assertEqual(response.status_code, 200)\",\n \"def test_auth(self):\\n data = {\\n \\\"username_mappings\\\": [\\n {\\\"test_username_1\\\": \\\"test_new_username_1\\\"},\\n {\\\"test_username_2\\\": \\\"test_new_username_2\\\"}\\n ]\\n }\\n\\n # Test unauthenticated\\n response = self.client.post(self.url, data)\\n assert response.status_code == 401\\n\\n # Test non-service worker\\n random_user = UserFactory()\\n response = self.call_api(random_user, data)\\n assert response.status_code == 403\\n\\n # Test service worker\\n response = self.call_api(self.client_user, data)\\n assert response.status_code == 200\",\n \"def check_auth(requests_session, server, user, logger):\\n logger.debug('Getting {} to test auth'.format(server))\\n test_auth_request = requests_session.get(server)\\n logger.debug('Status: {}'.format(test_auth_request.status_code))\\n\\n if test_auth_request.status_code == 401 or 'Login attempt failed. Please try again.' in test_auth_request.text:\\n message = 'Login attempt failed for {}, please make sure your credentials for user {} are correct!'.format(server, user)\\n logger.critical(message)\\n raise exceptions.XNATLoginFailedError(message)\\n\\n if test_auth_request.status_code != 200:\\n logger.warning('Simple test requests did not return a 200 code! Server might not be functional!')\\n\\n if user is not None:\\n match = re.search(r'<span id=\\\"user_info\\\">Logged in as: <a (id=\\\"[^\\\"]+\\\" )?href=\\\"[^\\\"]+\\\">(?P<username>[^<]+)</a>',\\n test_auth_request.text)\\n\\n if match is None:\\n match = re.search(r'<span id=\\\"user_info\\\">Logged in as: <span style=\\\"color:red;\\\">Guest</span>',\\n test_auth_request.text)\\n if match is None:\\n match = re.search('Your password has expired', test_auth_request.text)\\n if match:\\n message = 'Your password has expired. Please try again after updating your password on XNAT.'\\n logger.error(message)\\n raise exceptions.XNATExpiredCredentialsError(message)\\n else:\\n message = 'Could not determine if login was successful!'\\n logger.error(message)\\n logger.debug(test_auth_request.text)\\n raise exceptions.XNATAuthError(message)\\n else:\\n message = 'Login failed (in guest mode)!'\\n logger.error(message)\\n raise exceptions.XNATLoginFailedError(message)\\n else:\\n username = match.group('username')\\n logger.info('Logged in successfully as {}'.format(username))\\n return username\\n\\n match = re.search(r'<span id=\\\"user_info\\\">Logged in as: <span style=\\\"color:red;\\\">Guest</span>',\\n test_auth_request.text)\\n if match is None:\\n message = 'Could not determine if login was successful!'\\n logger.error(message)\\n raise exceptions.XNATAuthError(message)\\n else:\\n logger.info('Logged in as guest successfully')\\n return 'guest'\",\n \"def test_ApiWillAuthenticate_ValidCredentials_Successfully(self):\\n api = Api(self.userId, self.testToken)\\n self.assertTrue(api.connected())\",\n \"def test_application_running(self):\\n response = self.client.get('/login', content_type='html/text')\\n self.assertEqual(response.status_code, 200)\\n response = self.client.get('/signup', content_type='html/text')\\n self.assertEqual(response.status_code, 200)\",\n \"async def test_validate_login(hass: HomeAssistant, provider, capsys) -> None:\\n data = provider.data\\n data.add_auth(\\\"test-user\\\", \\\"test-pass\\\")\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"test-user\\\", password=\\\"test-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth valid\\\\n\\\"\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"test-user\\\", password=\\\"invalid-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth invalid\\\\n\\\"\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"invalid-user\\\", password=\\\"test-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth invalid\\\\n\\\"\",\n \"def test_successful_login(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n rv = self.login('Bo_theo5@example.com', 'Bo1995')\\n self.assertIn(b'You are now logged in', rv.data)\",\n \"def test_unhandledCredentials(self):\\n realm = TestRealm()\\n portal = Portal(realm)\\n # This portal has no checkers, so all logins will fail with\\n # UnhandledCredentials\\n self.server.portal = portal\\n\\n self.server.challengers[b'LOGIN'] = loginCred = imap4.LOGINCredentials\\n\\n verifyClass(IChallengeResponse, loginCred)\\n\\n cAuth = imap4.LOGINAuthenticator(b'testuser')\\n self.client.registerAuthenticator(cAuth)\\n\\n def auth():\\n return self.client.authenticate(b'secret')\\n\\n d1 = self.connected.addCallback(strip(auth))\\n d1.addErrback(self.assertClientFailureMessage,\\n b\\\"Authentication failed: server misconfigured\\\")\\n d1.addCallbacks(self._cbStopClient, self._ebGeneral)\\n d = defer.gatherResults([self.loopback(), d1])\\n return d\",\n \"def test_login(self):\\n response = self.client.post(\\\"/login\\\", json=self.payload)\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertIsNotNone(response.json.get(\\\"access_token\\\"))\\n self.assertIsNotNone(response.json.get(\\\"refresh_token\\\"))\",\n \"def test_loggin_required(self):\\n response = self.client.get(RESGATE_URL)\\n\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_correct_login(self):\\n self.app.post('/register', data=self.user_reg_details)\\n res = self.app.post('/login', data=self.user_login_details)\\n self.assertEqual(res.status_code, 200)\\n self.assertIn(\\\"Successfully logged in\\\", str(res.data))\",\n \"def test_read_o_auth_client(self):\\n pass\",\n \"def test_authentication_success():\\n d = Dexcom(USERNAME, PASSWORD)\\n d._validate_account()\\n d._validate_session_id()\",\n \"def test_login(self):\\n\\t\\tdata = {'username' : 'testUser2', 'password' : 'passTestUser'}\\n\\t\\tresponse = self.login(data)\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\ttry:\\n\\t\\t\\ttoken = response.data[\\\"token\\\"]\\n\\t\\texcept AttributeError:\\n\\t\\t\\tself.fail(\\\"No token attribute\\\")\",\n \"def testAuthentication(self):\\n\\t\\t#try to get a restricted page and error on bad result\\n\\t\\ttestpage = requests.get(\\\"https://www.furaffinity.net/controls/settings/\\\", cookies=self.cookie)\\n\\t\\tif \\\"Please log in!\\\" in testpage.text: raise AuthenticationError(\\\"FurAffinity authentication failed\\\")\",\n \"def test_login(self):\\n print(\\\"Test Login\\\")\\n self.mock_api.return_value = LOGIN_RESPONSE\\n self.manager.enabled = False\\n assert self.manager.login()\\n all_kwargs = parse_args(self.mock_api)\\n assert assert_test(self.manager.login, all_kwargs, None,\\n self.write_api, self.overwrite)\",\n \"def test_loginBeforeSTARTTLS(self):\\n # Prevent the client from issuing STARTTLS.\\n self.client.startTLS = lambda: defer.succeed(\\n ([], 'OK Begin TLS negotiation now')\\n )\\n self.connected.addCallback(\\n lambda _: self.client.login(b\\\"wrong\\\", b\\\"time\\\"),\\n )\\n\\n self.connected.addErrback(\\n self.assertClientFailureMessage,\\n b\\\"LOGIN is disabled before STARTTLS\\\",\\n )\\n\\n self.connected.addCallback(self._cbStopClient)\\n self.connected.addErrback(self._ebGeneral)\\n\\n return defer.gatherResults([self.loopback(), self.connected])\",\n \"def on_phase_auth_message(self, buf):\\n msg = self.__nanojsonrpc_unpack(buf)\\n method = msg['method']\\n if method == 'auth':\\n self.__ws_conn.send(self.__nanojsonrpc_pack('auth', [self.secret]))\\n elif method == 'ready':\\n self.phase_auth = False\\n else:\\n self.wsapp.keep_running = False\\n raise Error.LogicError(f'Unexpected message: ({msg})!',\\n ModuleErrorCode,\\n FileErrorCode,\\n 12)\",\n \"def test_login_with_correct_authentication_success(self):\\n user = {\\n \\\"Email\\\": \\\"fyi@g.com\\\",\\n \\\"Type\\\": \\\"passenger\\\",\\n \\\"Password\\\": \\\"pass234\\\",\\n \\\"Confirm Password\\\": \\\"pass234\\\"\\n }\\n response = self.client().post('/api/v1/auth/register',\\n data=user)\\n self.assertEqual(response.status_code, 201)\\n logins = {\\\"Email\\\": \\\"fyi@g.com\\\", \\\"Password\\\": \\\"pass234\\\"}\\n res = self.client().post('/api/v1/auth/login', data=logins)\\n self.assertTrue(res.status_code, 200)\",\n \"def test_aio_can_login_to_web_portal(aio):\",\n \"def test_login_GET(self):\\r\\n\\r\\n with self.client:\\r\\n response = self.client.get('/login')\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(\\r\\n b'Please enter your credentials to continue.', response.data)\",\n \"def test_login(self):\\n\\n with self.client as c:\\n result = c.post('/login',\\n data={'email': 'cat@gmail.com', 'password': 'abc'},\\n follow_redirects=True\\n )\\n self.assertEqual(session['user_id'], 1)\\n self.assertIn(\\\"You are logged in\\\", result.data)\\n\\n print \\\"DONE WITH LOGIN CHECK\\\"\",\n \"def test_ApiConnectionWillAuthenticate_ValidCredentials_Successfully(self):\\n connection = ApiConnection(self.userId, self.testToken)\\n self.assertTrue(connection.connected())\",\n \"def test_user_sign_in(self):\\n\\n self.client.post(\\\"/api/v2/auth/signup\\\", data=json.dumps(\\n self.generic_user), content_type=\\\"application/json\\\")\\n res = self.client.post(\\n \\\"/api/v2/auth/login\\\", data=json.dumps(self.generic_user_details),\\n content_type=\\\"application/json\\\")\\n result = json.loads(res.data)\\n self.assertEqual(result[\\\"Success\\\"],\\n \\\"You are logged in as generic@user.com.\\\")\\n self.assertEqual(res.status_code, 201)\",\n \"def test_user_authentication(self):\\n response = self.client.get(self.home_url)\\n user = response.context.get('user')\\n self.assertTrue(user.is_authenticated)\",\n \"def test_login(self, mock):\\n _setup_responses(mock)\\n api = LiveStreamApi(\\\"user\\\", \\\"pass\\\")\\n\\n api.login()\\n\\n with self.subTest(\\\"stores the token on the api object\\\"):\\n self.assertEqual(api._token, \\\"ffffffffffffffffffffffffffffffffffffffff\\\")\\n\\n with self.subTest(\\\"stores ssesyranac cookie on the api object\\\"):\\n self.assertEqual(api._ssesyranac, \\\"ssesyranac\\\")\",\n \"def test_auth_user_calls_auth_route_ok(self):\\n response = self.client.get(reverse('reservation'))\\n self.assertEquals(response.status_code, HTTPStatus.OK)\",\n \"def test_login(self):\\n response = self.client.post(reverse('users:login'), data={\\n 'username': 'username',\\n 'password': '12345678',\\n })\\n self.assertFalse(response.wsgi_request.user.is_authenticated)\\n\\n response = self.client.post(reverse('users:login'), data={\\n 'username': 'temp1',\\n 'password': 'hardpwd123',\\n })\\n self.assertTrue(response.wsgi_request.user.is_authenticated)\\n\\n # And check that we can login with email\\n self.client.logout()\\n response = self.client.post(reverse('users:login'), data={\\n 'username': 'temp1@mail.com',\\n 'password': 'hardpwd123'\\n })\\n self.assertTrue(response.wsgi_request.user.is_authenticated)\",\n \"def test_make_ride_request_if_signed_in_success(self):\\n # signup\\n passenger = {\\n \\\"Email\\\": \\\"dru@gmail.com\\\",\\n \\\"Type\\\": \\\"passenger\\\",\\n \\\"Password\\\": \\\"pass234\\\",\\n \\\"Confirm Password\\\": \\\"pass234\\\"\\n }\\n res = self.client().post('/api/v1/auth/register', data=passenger)\\n self.assertEqual(res.status_code, 201)\\n # login\\n logins = {\\\"Email\\\": \\\"dru@gmail.com\\\", \\\"Password\\\": \\\"pass234\\\"}\\n res = self.client().post('api/v1/auth/login', data=logins)\\n self.assertEqual(res.status_code, 200)\\n\\n # get authorization token\\n token = json.loads(res.data.decode('UTF-8'))\\n access_token = token.get('access-token')\\n\\n # request ride\\n res = self.client().post('api/v1/rides/1/requests',\\n data=self.request, headers={'Authorization': 'Bearer '+access_token})\\n self.assertEqual(res.status_code, 200)\",\n \"def test_customChallengers(self):\\n\\n @implementer(IChallengeResponse, IUsernamePassword)\\n class SPECIALAuth(object):\\n\\n def getChallenge(self):\\n return b'SPECIAL'\\n\\n\\n def setResponse(self, response):\\n self.username, self.password = response.split(None, 1)\\n\\n\\n def moreChallenges(self):\\n return False\\n\\n\\n def checkPassword(self, password):\\n self.password = self.password\\n\\n special = SPECIALAuth()\\n verifyObject(IChallengeResponse, special)\\n\\n server = imap4.IMAP4Server({b'SPECIAL': SPECIALAuth})\\n server.portal = self.portal\\n\\n transport = StringTransport()\\n server.makeConnection(transport)\\n self.addCleanup(server.connectionLost,\\n error.ConnectionDone(\\\"Connection done.\\\"))\\n\\n self.assertIn(b\\\"AUTH=SPECIAL\\\", transport.value())\\n\\n transport.clear()\\n server.dataReceived(b'001 AUTHENTICATE SPECIAL\\\\r\\\\n')\\n\\n self.assertIn(base64.b64encode(special.getChallenge()),\\n transport.value())\\n\\n transport.clear()\\n server.dataReceived(base64.b64encode(b'username password') + b'\\\\r\\\\n')\\n\\n self.assertEqual(transport.value(),\\n b\\\"001 OK Authentication successful\\\\r\\\\n\\\")\",\n \"def test_page_requiring_auth():\\n app = create_ctfd()\\n with app.app_context():\\n gen_page(app.db, title=\\\"Title\\\", route=\\\"this-is-a-route\\\", html=\\\"This is some HTML\\\", auth_required=True)\\n\\n with app.test_client() as client:\\n r = client.get('/this-is-a-route')\\n assert r.status_code == 302\\n assert r.location == 'http://localhost/login?next=%2Fthis-is-a-route'\\n\\n register_user(app)\\n client = login_as_user(app)\\n r = client.get('/this-is-a-route')\\n assert r.status_code == 200\\n destroy_ctfd(app)\",\n \"def test_valid_login(self):\\n self.assertTrue(self.session.authenticate('test@test.com', 'supersecret'))\",\n \"def test_auth_required(self):\\n\\n res = self.client.get(SERVICES_URL)\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"async def authenticate(self, request: Request):\\n\\n pass\",\n \"def test_request(self, kasserver, kasapi):\\n kasserver._request(self.REQUEST_TYPE, self.REQUEST_PARAMS)\\n request = {\\n \\\"KasUser\\\": USERNAME,\\n \\\"KasAuthType\\\": \\\"plain\\\",\\n \\\"KasAuthData\\\": PASSWORD,\\n \\\"KasRequestType\\\": self.REQUEST_TYPE,\\n \\\"KasRequestParams\\\": self.REQUEST_PARAMS,\\n }\\n kasapi.assert_called_once_with(json.dumps(request))\",\n \"def test_authenticatorChallengeResponse(self):\\n username = b'testuser'\\n secret = b'secret'\\n chal = b'challenge'\\n cAuth = imap4.PLAINAuthenticator(username)\\n response = cAuth.challengeResponse(secret, chal)\\n self.assertEqual(response, b'\\\\0' + username + b'\\\\0' + secret)\",\n \"def test_login_required():\\n pass\",\n \"def login(self):\\n \\n try:\\n # Create socket connection and connect to the server\\n self.sck = socket(AF_INET, SOCK_STREAM)\\n self.sck.connect((self.host, self.port))\\n self.sck.send(self.alchallenge_packet()) # Send Auth Logon Challenge\\n srp_rcvd = self.decode_packet(self.sck.recv(1024)) # Read SRP for sending Logon Proof\\n csrp = Srp(srp_rcvd['N'], srp_rcvd['g'], self.I, self.p, srp_rcvd['s'], srp_rcvd['B'])\\n # Do some math...\\n A = csrp.gen_A()\\n u = csrp.gen_u()\\n S = csrp.gen_S()\\n K = csrp.gen_K()\\n M = csrp.gen_M()\\n # Let's send Auth Logon Proof\\n self.sck.send(self.alproof_packet(M.blittle(), A.blittle()))\\n return self.decode_packet(self.sck.recv(1024)).get('login') # 1 if no errors\\n except ValueError:\\n return 0\",\n \"def test_login_user(self):\\n response_decoded_json = requests.post(URL_AUTH['url_login'], \\n data=json.dumps(AUTH_PAYLOADS['payload_user']),\\n headers=HEADER['header'])\\n resp = response_decoded_json.json()\\n assert \\\"User\\\" == resp[\\\"role\\\"], \\\"You don't login with correct role\\\"\\n assert 200 == response_decoded_json.status_code, \\\"You have BAD REQUEST\\\"\",\n \"def test_ucs_log_in(self):\\n api_data = request(\\\"get\\\", \\\"/login\\\")\\n self.assertEqual(api_data['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\\n self.assertNotEqual(api_data[\\\"json\\\"], None,\\n \\\"Expected a token to be returned on login and received None\\\")\\n self.assertNotEqual(type(api_data[\\\"json\\\"]),\\n \\\"unicode\\\", \\\"Unexpected Token was received on Login\\\")\",\n \"def test_is_authenticated(self, mixin, mrequest):\\n assert not mixin.is_authenticated()\\n\\n mrequest.headers['JWT'] = True\\n assert mixin.is_authenticated()\",\n \"def test_auth_success(self):\\n request = self.factory.get(resolve('/'))\\n response = Login.as_view()(request)\\n self.assertEqual(response.status_code, 200)\\n data = {\\n 'username': 'pravin.gordhan',\\n 'password': 'pravin.gordhan'\\n }\\n request = self.factory.post(resolve('/'), data)\\n request.session = self.client.session\\n response = Login.as_view()(request)\\n self.assertEqual(response.url, '/employee/dashboard/')\",\n \"def test_login_required(self):\\n res = self.client.get(RETETA_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_auth_required(self):\\n res = self.client.get(RECIPE_URL)\\n self.assertEqual(res.status_code,status.HTTP_401_UNAUTHORIZED)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69330895","0.6900142","0.6677716","0.6526462","0.6523139","0.6522858","0.65209544","0.65144455","0.6500772","0.6499939","0.6493193","0.64686173","0.63993716","0.6384796","0.6383272","0.6357318","0.63483596","0.6325268","0.63151926","0.6314975","0.63028973","0.6290754","0.6273679","0.62571496","0.62474376","0.6247288","0.62428725","0.6237912","0.6210723","0.62104255","0.6202764","0.6202764","0.6201174","0.61975193","0.61809725","0.61522603","0.6148621","0.6147363","0.612588","0.61127543","0.61126894","0.61098194","0.6104038","0.609803","0.608392","0.60824883","0.6070538","0.60693944","0.6057561","0.6057359","0.60563684","0.6052071","0.6051783","0.60491437","0.6047366","0.604316","0.602921","0.6024595","0.6023738","0.602151","0.6020602","0.6019215","0.6016523","0.6009964","0.5995647","0.59922266","0.59912425","0.59910136","0.59798074","0.59709305","0.5965227","0.5960567","0.59559387","0.5954469","0.5954325","0.5951169","0.59414977","0.5940359","0.59401643","0.5936201","0.59319866","0.59222007","0.5913414","0.59060156","0.5905776","0.5903764","0.5900974","0.58963835","0.5894512","0.5893533","0.5893171","0.589159","0.58789724","0.58775294","0.58764285","0.586979","0.58645684","0.5862369","0.5851545","0.5850125"],"string":"[\n \"0.69330895\",\n \"0.6900142\",\n \"0.6677716\",\n \"0.6526462\",\n \"0.6523139\",\n \"0.6522858\",\n \"0.65209544\",\n \"0.65144455\",\n \"0.6500772\",\n \"0.6499939\",\n \"0.6493193\",\n \"0.64686173\",\n \"0.63993716\",\n \"0.6384796\",\n \"0.6383272\",\n \"0.6357318\",\n \"0.63483596\",\n \"0.6325268\",\n \"0.63151926\",\n \"0.6314975\",\n \"0.63028973\",\n \"0.6290754\",\n \"0.6273679\",\n \"0.62571496\",\n \"0.62474376\",\n \"0.6247288\",\n \"0.62428725\",\n \"0.6237912\",\n \"0.6210723\",\n \"0.62104255\",\n \"0.6202764\",\n \"0.6202764\",\n \"0.6201174\",\n \"0.61975193\",\n \"0.61809725\",\n \"0.61522603\",\n \"0.6148621\",\n \"0.6147363\",\n \"0.612588\",\n \"0.61127543\",\n \"0.61126894\",\n \"0.61098194\",\n \"0.6104038\",\n \"0.609803\",\n \"0.608392\",\n \"0.60824883\",\n \"0.6070538\",\n \"0.60693944\",\n \"0.6057561\",\n \"0.6057359\",\n \"0.60563684\",\n \"0.6052071\",\n \"0.6051783\",\n \"0.60491437\",\n \"0.6047366\",\n \"0.604316\",\n \"0.602921\",\n \"0.6024595\",\n \"0.6023738\",\n \"0.602151\",\n \"0.6020602\",\n \"0.6019215\",\n \"0.6016523\",\n \"0.6009964\",\n \"0.5995647\",\n \"0.59922266\",\n \"0.59912425\",\n \"0.59910136\",\n \"0.59798074\",\n \"0.59709305\",\n \"0.5965227\",\n \"0.5960567\",\n \"0.59559387\",\n \"0.5954469\",\n \"0.5954325\",\n \"0.5951169\",\n \"0.59414977\",\n \"0.5940359\",\n \"0.59401643\",\n \"0.5936201\",\n \"0.59319866\",\n \"0.59222007\",\n \"0.5913414\",\n \"0.59060156\",\n \"0.5905776\",\n \"0.5903764\",\n \"0.5900974\",\n \"0.58963835\",\n \"0.5894512\",\n \"0.5893533\",\n \"0.5893171\",\n \"0.589159\",\n \"0.58789724\",\n \"0.58775294\",\n \"0.58764285\",\n \"0.586979\",\n \"0.58645684\",\n \"0.5862369\",\n \"0.5851545\",\n \"0.5850125\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5979925"},"document_rank":{"kind":"string","value":"68"}}},{"rowIdx":81371,"cells":{"query":{"kind":"string","value":"Apply a mapping of namevaluepairs to a template."},"document":{"kind":"string","value":"def apply(self, mapping):\n mapping = {name: self.str(value, tolerant=self.tolerant)\n for name, value in mapping.items()\n if value is not None or self.tolerant}\n\n if self.tolerant:\n return self.template.safe_substitute(mapping)\n\n return self.template.substitute(mapping)"},"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 map_template(template: dict, input_: dict) -> None:\n for k, v in template.items():\n config_val = input_.get(k)\n\n if isinstance(v, dict) and k != 'NullHandler':\n map_template(v, input_)\n\n if config_val:\n template[k] = config_val.upper() if k == 'level' else config_val","def substitute_names(tmpl_string, dct):\n return Template(tmpl_string).substitute(dct)","def process_map_pair(selector, value, context, current_node):\n from knife.template import Template\n from knife.transformer import Transform, ContextKeyTransform, TemplateTransform, MapTransform\n \n new_node = current_node(selector)\n\n if new_node:\n # Flatten a single-value tuple \n if isinstance(value, tuple):\n if len(value) == 1:\n value = value[0]\n \n # A simple replacement\n if isinstance(value, basestring):\n ContextKeyTransform.transform(value, context, selector, new_node)\n\n elif isinstance(value, Template):\n TemplateTransform.transform(value, context, selector, new_node) \n\n # Or a tuple\n elif isinstance(value, tuple):\n\n if isinstance(value[0], Template):\n TemplateTransform.transform(value, context, selector, new_node)\n\n elif isinstance(value[0], basestring) and isinstance(value[1], dict):\n MapTransform.transform(value[0], context, selector, new_node, map=value[1])\n\n elif isinstance(value[0], basestring) and isinstance(value[1], Transform):\n transformer = value[1].transform(value[0], context, selector, new_node)\n transformer.transform(value[0], context, selector, new_node)\n else:\n raise Error(\"Invalid Option\")","def tmap(app, args):\n tmpl = Template(app, args.template, args.template_args)\n for a in args.template_args:\n print(a)","def template_replace(template, replace_map, result):\n # Read content of source file.\n with open(template) as fp:\n lines = fp.readlines()\n # Replace placeholders.\n for key, value in list(replace_map.items()):\n for i, line in enumerate(lines):\n # Ignore VHDL comments\n if not line.strip().startswith('--'):\n lines[i] = line.replace(key, value)\n # Write content to destination file.\n with open(result, 'w') as fp:\n fp.write(''.join(lines))","def multi_mapping(func_name, arg_value_pairs, module_name = \"__main__\"):\n func, arg_names = get_function_args(module_name = module_name, function_name = func_name)\n \n return list(map(lambda arg_value_pair: call_func_dynamically(function_name = func_name, \n argument_names = arg_names, \n arg_value_pair = arg_value_pair) ,\n arg_value_pairs))","def templateMappings(self):\n raise NotImplementedError","def add_template_scope(node, names, values):\n scope = sortedmap()\n for name, value in zip(names, values):\n scope[name] = value\n node.scope = scope","def substitute(self, substitution_map):\n for element_name in substitution_map:\n\n assert (is_constant(element_name) or is_variable(element_name)) and \\\n type(substitution_map[element_name]) is Term\n return self.subsitute_helper(copy.deepcopy(substitution_map), False)","def apply_custom_template(self, name, filename, context):\n with open(os.path.join(self.build_path, filename), 'r') as f:\n template = actions.ActionsTemplate.from_dict(json.loads(f.read()))\n\n outputs = template.apply(context, self)\n\n for key, value in six.iteritems(outputs):\n context[key] = value","def _render_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:\n output_dict = {}\n\n for key, value in input_dict.items():\n if isinstance(value, str):\n new_value = string.Template(value).substitute(_mapping)\n output_dict[key] = new_value\n elif isinstance(value, dict):\n output_dict[key] = _render_dict(value) # type: ignore\n else:\n output_dict[key] = value\n\n return output_dict","def fill_template_file(filename, value_dict):\n f = open(filename, 'r')\n text = f.read()\n f.close()\n f = open(filename, 'w')\n f.write(text % value_dict)\n f.close()","def apply_to(self, template):\n pass","def template_update(inputs, output_dir, state_ind=None, map_copyfiles=None):\n\n inputs_dict_st = attr.asdict(inputs, recurse=False)\n if map_copyfiles is not None:\n inputs_dict_st.update(map_copyfiles)\n\n if state_ind is not None:\n for k, v in state_ind.items():\n k = k.split(\".\")[1]\n inputs_dict_st[k] = inputs_dict_st[k][v]\n\n from .specs import attr_fields\n\n # Collect templated inputs for which all requirements are satisfied.\n fields_templ = [\n field\n for field in attr_fields(inputs)\n if field.metadata.get(\"output_file_template\")\n and all(\n getattr(inputs, required_field) is not attr.NOTHING\n for required_field in field.metadata.get(\"requires\", ())\n )\n ]\n\n dict_mod = {}\n for fld in fields_templ:\n dict_mod[fld.name] = template_update_single(\n field=fld,\n inputs=inputs,\n inputs_dict_st=inputs_dict_st,\n output_dir=output_dir,\n )\n # adding elements from map_copyfiles to fields with templates\n if map_copyfiles:\n dict_mod.update(map_copyfiles)\n return dict_mod","def map_values(function, dictionary):\n return {k: function(dictionary[k]) for k in dictionary}","def applyMapping(self):\n pass","def fill_template(template, replacements):\n content = template\n for src, target in replacements.iteritems():\n content = content.replace(src, target)\n return content","def update_templated_typemaps(self, node):\n visitor = TemplateTypemap(self.config)\n return visitor.visit(node)","def _substitute(self, mapping: VariableMapping) -> 'Substitution':\n return Substitution(\n # Create a new combined mapping. Later mappings override earlier\n # ones.\n mapping={\n **mapping,\n **{\n variable: term._substitute(mapping)\n for (variable, term) in self.mapping.items()\n }\n }\n )","def map_values(fun, a_dict):\n return dict((k, fun(v)) for (k, v) in a_dict.items())","def context(template):\n\n return {\n v.key: v.read()\n for v in [Variable(name) for name in extract_variables(template)]\n }","def process_variables_loop(template, var_pattern, param_lookup_function):\n # Generic loop for handling a source of key/value tuples (e.g., enumerate() or <dict>.items())\n def process_items_helper(key_value_iterator, data_map):\n made_change = False\n for key, value in key_value_iterator:\n if isinstance(value, str):\n altered_value = value\n for match in var_pattern.finditer(value):\n var_type, var_loc, fallback_type, fallback_loc = _parse_var(match[1])\n source_value = param_lookup_function(var_type, var_loc, fallback_type, fallback_loc)\n\n # If we can't find a value, skip it\n if source_value is None:\n continue\n try:\n if altered_value == match[0]: # complete replacement\n altered_value = source_value\n else: # partial replacement\n\n altered_value = altered_value.replace(match[0], source_value)\n except TypeError:\n pass\n if value != altered_value:\n data_map[key] = altered_value\n made_change = True\n elif isinstance(value, dict):\n if process_variables_loop(value, var_pattern, param_lookup_function):\n made_change = True\n elif isinstance(value, list):\n if process_items_helper(enumerate(value), value):\n made_change = True\n return made_change\n\n return process_items_helper(template.items(), template)","def template_recurse(tmpl, tags):\n if isinstance(tmpl, str):\n ret = tmpl\n for k, v in tags.items():\n # If the value we are replacing is an exact match for a key, return the value as-is - we're assuming\n # here that we are NOT replacing a substring in a larger string \"hello {{name}}\", but that the\n # value should be used as-is, i.e. not converted into a string - i.e. it is a KEY in the JSON, not a VALUE.\n if ret == k:\n return v\n # Try to perform a simple string substitution - this assumes that the value is a string, or can be\n # converted to a string without any issues.\n ret = ret.replace(k, str(v))\n\n return ret\n\n if isinstance(tmpl, list):\n return [template_recurse(v, tags) for v in tmpl]\n\n if isinstance(tmpl, dict):\n return {k:template_recurse(v, tags) for k, v in tmpl.items()}\n\n return tmpl","def buildTagMap(default, *args):\r\n built = {}\r\n for portion in args:\r\n if hasattr(portion, 'items'):\r\n #It's a map. Merge it.\r\n for k,v in portion.items():\r\n built[k] = v\r\n elif isList(portion):\r\n #It's a list. Map each item to the default.\r\n for k in portion:\r\n built[k] = default\r\n else:\r\n #It's a scalar. Map it to the default.\r\n built[portion] = default\r\n return built","def map(keys, values) -> MapValue:\n return ops.Map(keys, values).to_expr()","def parse(self, dict, header=TRUE):\n if type(dict) != types.DictType:\n raise TypeError, \"Second argument must be a dictionary\"\n if not self.template:\n raise OpagMissingPrecondition, \"template path is not set\"\n # Open the file if its not already open. If it is, seek to the\n # beginning of the file.\n if not self.template_file:\n self.template_file = open(self.template, \"r\")\n else:\n self.template_file.seek(0)\n # Instantiate a new bound method to do the replacement.\n replacer = Replacer(dict).replace\n # Read in the entire template into memory. I guess we'd better keep\n # the templates a reasonable size if we're going to keep doing this.\n buffer = self.template_file.read()\n replaced = \"\"\n if header:\n replaced = \"Content-Type: text/html\\n\\n\"\n replaced = replaced + re.sub(\"%%(\\w+)%%\", replacer, buffer)\n return replaced","def map(self, key, value):\n namelist = value.strip().split()\n namelist.insert(0, '')\n namelist.append('')\n n = len(namelist)\n for i in range(1, n - 1):\n self.outputcollector.collect(namelist[i], \\\n tuple2str((namelist[i-1] ,namelist[i+1])))","def do_dict_entry_for_item(parser, token):\r\n bits = token.contents.split()\r\n if len(bits) != 6:\r\n raise template.TemplateSyntaxError(\"'%s' tag takes exactly five arguments\" % bits[0])\r\n if bits[2] != 'from':\r\n raise template.TemplateSyntaxError(\"second argument to '%s' tag must be 'from'\" % bits[0])\r\n if bits[4] != 'as':\r\n raise template.TemplateSyntaxError(\"fourth argument to '%s' tag must be 'as'\" % bits[0])\r\n return DictEntryForItemNode(bits[1], bits[3], bits[5])","def translator(dict):\n f = lambda match: dict.get(match.group(), match.group())\n return lambda expression: _word_pattern.sub(f,expression)","def testTitleTemplateSubstitute(self):\n\n\t\tfield_values = {'abc': 'ABC', 'a.1': 'VALUE'}\n\n\t\ttests = {\n\t\t\t'${abc} $$ ${} ${{{} ${abc}': 'ABC $ ${} ${{{} ABC',\n\t\t\t'$abc ${a.1} $$$$': '$abc VALUE $$'\n\t\t}\n\n\t\tfor test in tests:\n\t\t\tt = TitleTemplate(test)\n\t\t\tself.assertEqual(t.substitute(field_values), tests[test])","def map_named(function: Callable[[str, Any], Any],\n val: Any,\n key: Optional[str] = \"\") -> Any:\n if isinstance(val, Mapping):\n return type(val)(\n **{k: map_named(function, v, key + \"/\" + k) for k, v in val.items()})\n elif isinstance(val, tuple) or isinstance(val, list):\n return type(val)(\n *\n [map_named(function, v, key + \"/\" + str(i)) for i, v in enumerate(val)])\n # check if it's a flax dataclass\n elif hasattr(val, \"__dataclass_fields__\"):\n classname = repr(val).split(\"(\")[0]\n return type(val)(**{\n k: map_named(function, v, f\"{key}/{classname}.{k}\")\n for k, v in val.__dataclass_fields__.items()\n })\n else:\n return function(key, val)","def mapfn(k, v):\n for row in v:\n # completar\n pass","def transform(self, nameList):\n return {name: self.transformSingle(name) for name in nameList}","def extractor(template, options):\n for name, val in options:\n normalised = self.normalise_key(name)\n if normalised in self.values and not isinstance(self.values[normalised], Default):\n continue\n else:\n yield name, val","def multiple_replace(dict, text): \n\n # Create a regular expression from the dictionary keys\n regex = re.compile(\"(%s)\" % \"|\".join(map(re.escape, dict.keys())))\n\n # For each match, look-up corresponding value in dictionary\n return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)","def _transform_value_map(self, value: str, map_: dict, passthrough: bool = False) -> str:\n _default = value if passthrough is True else None\n if isinstance(value, str):\n # a static map is a dict of key/value pairs\n value = map_.get(value.lower(), _default)\n else:\n self.log.warning(\n f'''feature=ti-transform, action=transform-value, '''\n f'''message='static-map-requires-str-value\", value={value}'''\n )\n return value","def zipmap(keys, values):\n z = zip(keys, values)\n data = {k: v for k, v in z}\n return data","def apply(smap, parameters=None):\r\n if parameters is None:\r\n parameters = {}\r\n\r\n for t in smap:\r\n t.properties[STOCHASTIC_DISTRIBUTION] = smap[t]","def _finder_template(\n name: str, mapping: Mapping[str, str], namespaces: Dict[str, List[str]]\n) -> str:\n mapping = dict(sorted(mapping.items(), key=lambda p: p[0]))\n return _FINDER_TEMPLATE.format(name=name, mapping=mapping, namespaces=namespaces)","def dummy_transform(inputs: Dict[str, str]) -> Dict[str, str]:\n outputs = inputs\n outputs[\"greeting\"] = f\"{inputs['first_name']} {inputs['last_name']} says hello\"\n del outputs[\"first_name\"]\n del outputs[\"last_name\"]\n return outputs","def _replace_tags(codes, key, value, tag_dict, i):\n\n # if reaching the end of the tag dictionary\n if i == len(tag_dict):\n codes[key] = value\n return\n\n # check if the i-th <tag> is used in the key\n tag = list(tag_dict)[i]\n if tag in key:\n for tag_key, tag_attrs in tag_dict[tag].items():\n _key = key.replace(tag, tag_key)\n _value = replace_tag_attributes(value, tag, tag_attrs)\n _replace_tags(codes, _key, _value, tag_dict, i + 1)\n else:\n _replace_tags(codes, key, value, tag_dict, i + 1)","def _set_named_args(self, **kv):\n for k in kv:\n self._body['${0}'.format(k)] = kv[k]\n return self","def mapify(text, sep=\",\", kvsep=\"=\", strip_char=\" \", glue= \"\\\"\", parsing=False):\n # text = \"hello=world,good=bye\"\n items = listify(text, sep, glue)\n res = {}\n for item in items:\n item = item.strip(strip_char)\n arr = item.split(kvsep, 1)\n if len(arr)==1:\n key, value = arr[0], \"\"\n elif len(arr)==2:\n key, value = arr\n key, value = key.strip(strip_char).strip(glue), value.strip(strip_char).strip(glue)\n\n if parsing:\n value = parseValue(value)\n\n res[key] = value\n\n return res","def parse_templated_fields(metadata):\n parse_dict = {}\n for field in metadata:\n if \"configurations\" not in field:\n parse_dict.update({field: metadata[field]})\n else:\n parse_dict.update(get_config(metadata, field))\n\n # looping over config sections:\n for config_sec, configs in metadata.items():\n # looping over each field in the current config section\n for cur_key, cur_val in configs.items():\n if cur_val[\"type\"] not in [\"string\", \"array\"]:\n continue # not string fields, template does not support\n \n if cur_val[\"type\"] == \"string\" and \"{\" in cur_val and \"}\" in cur_val[\"value\"]:\n cur_val[\"value\"] = cur_val[\"value\"].format(**parse_dict)\n else: # array\n for index, s in enumerate(cur_val[\"value\"]):\n cur_val[\"value\"][index] = s.format(**parse_dict)\n \n metadata[config_sec][cur_key][\"value\"] = cur_val[\"value\"]\n \n return metadata","def nmtpl_dict(nmtpl):\n keylist=nmtpl._fields\n vallist=tuple(nmtpl)\n return({keylist[i]: vallist[i] for i in range(len(keylist))})","def set_template(self, name, value):\n\n self.templates[name] = value","def _substitute(self, value, group=None, namespace=None):\n if isinstance(value, list):\n return [self._substitute(i, group=group, namespace=namespace)\n for i in value]\n elif isinstance(value, str):\n # Treat a backslash followed by the dollar sign \"\\$\"\n # the same as the string template escape \"$$\" as it is\n # a bit more natural for users\n if r'\\$' in value:\n value = value.replace(r'\\$', '$$')\n tmpl = self.Template(value)\n ret = tmpl.safe_substitute(\n self.StrSubWrapper(self, group=group, namespace=namespace))\n return ret\n elif isinstance(value, dict):\n # Substitute template variables in both key and value\n return {self._substitute(key, group=group, namespace=namespace):\n self._substitute(val, group=group, namespace=namespace)\n for key, val in value.items()}\n else:\n return value","def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)","def _do_mapping(self):\n pass","def _add_template(self, alias, template):\n # Construct a function that will do substitution for any placeholders\n # in the template.\n def fname(**kwargs):\n return _substitute(template, self.files(), kwargs)\n\n # Bind the fname function to this instance of FileNames\n self.__dict__[alias] = fname","def render(data_dict, *args, **kwargs):","def nameYamlMapping(name: str, mapping: Dict[str, Any]) -> Dict[str, Any]:\n # Because we want \"name\" field to be the first member for aesthetic\n # reasons, we create a new dict and copy ``mapping`` to it.\n newMapping = {\"name\": name}\n newMapping.update((key, value) for key, value in mapping.items() if key != \"name\")\n return newMapping","def materialize(template, substitutions):\n\n script_str = template\n for param, value in substitutions.items():\n script_str = re.sub(param, str(value), script_str)\n\n return script_str","def write_template(self, template_file, template_dict, rename_as=None):\n dest_name = rename_as if rename_as else template_file\n return self._write_template_to(template_file, os.path.join(self.dest, dest_name), template_dict)","def mutate_dict_in_place(func, mapping):\n for key, value in mapping.items():\n if isinstance(value, dict):\n mutate_dict_in_place(func, value)\n else:\n mapping[key] = func(value)","def _substitute(template, files, user_values):\n # Get all placeholder names\n placeholders = _get_placeholders(template)\n\n # Pre-fill placeholders based on existing file aliases\n placeholder_values = _prefill_placeholders(placeholders, files,\n user_values)\n\n # Add user specified values for the placeholders\n placeholder_values.update(**user_values)\n\n # Check whether all placeholder values are now properly provided.\n provided = set(placeholder_values.keys())\n needed = set(placeholders)\n missing = needed - provided\n if len(missing) > 0:\n raise ValueError('Cannot construct filename, because the following '\n 'parameters are missing: %s' % missing)\n\n # Do the substitution\n return template.format(**placeholder_values)","def apply_cloudformation_template(self, name, filename, context):\n stack_name = utils.generate_stack_name(context['Stage'], self.name, name)\n stack = utils.create_or_update_cf_stack(\n name=stack_name,\n template_filename=os.path.join(self.build_path, filename),\n context=context,\n timeout_in_minutes=self.timeout_in_minutes,\n bucket=context.get('CodeBucket')\n )\n\n for output in stack.get('Outputs', []):\n context[output['OutputKey']] = output['OutputValue']","def dictionary_map(mapping):\n dictionary = dict()\n\n def add_item_to_dictionary(path, k, v):\n dictionary.update(\n dict_merge(\n dictionary,\n inflate_key_value_pair(\n join(path, k), v\n )\n )\n )\n\n loop_dictionary(\n mapping,\n callback=add_item_to_dictionary\n )\n\n return dictionary","def _template_kwargs(*, logical_name: str, bucket: str, key: str) -> Dict[str, str]:\n if logical_name == \"ArtifactBuilder\":\n return dict(ArtifactBucketName=bucket, WorkersS3Key=key)\n elif logical_name == \"LayerBuilder\":\n return dict(ReplicationBucket=bucket, WorkersS3Key=key)\n else:\n raise ValueError(f\"Unknown logical name: {logical_name}\")","def setTemplateParameter(self,name,value):\n self.tplparam[name] = value","def fill_template(map_filepath, resolution, origin): # NOTE: Copied from generate_map_yaml.py\n template = \"\"\"image: MAP_FILEPATH\nresolution: RESOLUTION\norigin: [ORIGIN_X, ORIGIN_Y, YAW]\nnegate: 0\noccupied_thresh: 0.65\nfree_thresh: 0.196\n\"\"\"\n template = template.replace('MAP_FILEPATH', map_filepath)\n template = template.replace('RESOLUTION', str(resolution))\n template = template.replace('ORIGIN_X', str(origin[0]))\n template = template.replace('ORIGIN_Y', str(origin[1]))\n template = template.replace('YAW', str(origin[2]))\n return template","def apply_replicator(self, replicator, template_values, template_index=-1,\n template_value=None, update_input_references=False):\n return {}","def map_values_c(fun):\n return partial(map_values, fun)","def rhs_name_transform_inplace(self, name_map):\n\n for name in name_map:\n replacment = name_map[name]\n self.rhs = MathUtil.str_expr_replacement(name, replacment,\n self.rhs)","def _template_formatting(field, inputs, inputs_dict_st):\n from .specs import MultiInputObj, MultiOutputFile\n\n # if a template is a function it has to be run first with the inputs as the only arg\n template = field.metadata[\"output_file_template\"]\n if callable(template):\n template = template(inputs)\n\n # as default, we assume that keep_extension is True\n keep_extension = field.metadata.get(\"keep_extension\", True)\n\n inp_fields = re.findall(r\"{\\w+}\", template)\n inp_fields_fl = re.findall(r\"{\\w+:[0-9.]+f}\", template)\n inp_fields += [re.sub(\":[0-9.]+f\", \"\", el) for el in inp_fields_fl]\n if len(inp_fields) == 0:\n return template\n\n val_dict = {}\n file_template = None\n\n for fld in inp_fields:\n fld_name = fld[1:-1] # extracting the name form {field_name}\n if fld_name not in inputs_dict_st:\n raise AttributeError(f\"{fld_name} is not provided in the input\")\n fld_value = inputs_dict_st[fld_name]\n if fld_value is attr.NOTHING:\n # if value is NOTHING, nothing should be added to the command\n return attr.NOTHING\n else:\n # checking for fields that can be treated as a file:\n # have type File, or value that is path like (including str with extensions)\n if isinstance(fld_value, os.PathLike) or (\n isinstance(fld_value, str) and \".\" in fld_value\n ):\n if file_template:\n raise Exception(\n f\"can't have multiple paths in {field.name} template,\"\n f\" but {template} provided\"\n )\n else:\n file_template = (fld_name, fld_value)\n else:\n val_dict[fld_name] = fld_value\n\n # if field is MultiOutputFile and some elements from val_dict are lists,\n # each element of the list should be used separately in the template\n # and return a list with formatted values\n if field.type is MultiOutputFile and any(\n [isinstance(el, (list, MultiInputObj)) for el in val_dict.values()]\n ):\n # all fields that are lists\n keys_list = [\n k for k, el in val_dict.items() if isinstance(el, (list, MultiInputObj))\n ]\n if any(\n [len(val_dict[key]) != len(val_dict[keys_list[0]]) for key in keys_list[1:]]\n ):\n raise Exception(\n f\"all fields used in {field.name} template have to have the same length\"\n f\" or be a single value\"\n )\n formatted_value = []\n for ii in range(len(val_dict[keys_list[0]])):\n val_dict_el = copy(val_dict)\n # updating values to a single element from the list\n for key in keys_list:\n val_dict_el[key] = val_dict[key][ii]\n\n formatted_value.append(\n _element_formatting(\n template, val_dict_el, file_template, keep_extension=keep_extension\n )\n )\n else:\n formatted_value = _element_formatting(\n template, val_dict, file_template, keep_extension=keep_extension\n )\n return formatted_value","def template_function(self, node, ordered_functions):\n oldoptions = node.options\n headers_typedef = collections.OrderedDict()\n\n # targs - ast.TemplateArgument\n for iargs, targs in enumerate(node.template_arguments):\n new = node.clone()\n ordered_functions.append(new)\n self.append_function_index(new)\n\n new._generated = \"cxx_template\"\n\n fmt = new.fmtdict\n if targs.fmtdict:\n fmt.update(targs.fmtdict)\n\n # Use explicit template_suffix if provide.\n # If single template argument, use type's explicit_suffix\n # or the unqualified flat_name.\n # Multiple template arguments, use sequence number.\n if fmt.template_suffix:\n pass\n elif len(targs.asts) == 1:\n ntypemap = targs.asts[0].typemap\n if ntypemap.template_suffix:\n fmt.template_suffix = ntypemap.template_suffix\n else:\n fmt.template_suffix = \"_\" + ntypemap.flat_name\n else:\n fmt.template_suffix = \"_\" + str(iargs)\n\n new.cxx_template = {}\n fmt.CXX_template = targs.instantiation # ex. <int>\n\n # Gather headers required by template arguments.\n for targ in targs.asts:\n ntypemap = targ.typemap\n headers_typedef[ntypemap.name] = ntypemap\n\n self.push_instantiate_scope(new, targs)\n\n if new.ast.template_argument:\n iast = getattr(self.instantiate_scope, new.ast.template_argument)\n new.ast = new.ast.instantiate(node.ast.instantiate(iast))\n # Generics cannot differentiate on return type\n new.options.F_create_generic = False\n\n # Replace templated arguments.\n # arg - declast.Declaration\n newparams = []\n for arg in new.ast.declarator.params:\n if arg.template_argument:\n iast = getattr(self.instantiate_scope, arg.template_argument)\n newparams.append(arg.instantiate(iast))\n else:\n newparams.append(arg)\n new.ast.declarator.params = newparams\n self.pop_instantiate_scope()\n\n new.gen_headers_typedef = headers_typedef\n # Do not process templated node, instead process\n # generated functions above.\n node.wrap.clear()","def transform(attrs: dict) -> dict:\n\n pass","def generate(self, answers):\n\n text = self.template\n\n for (key, val) in answers.items():\n text = text.replace(\"{\" + key + \"}\", val)\n\n return text","def mapalign(aln, keyfunc=lambda x: x, valfunc=lambda x: x):\n\n aln2 = new_align(aln)\n for key, val in aln.iteritems():\n aln2[keyfunc(key)] = valfunc(val)\n return aln2","def apply(\n self,\n input_dict: typing_utils.ArtifactMultiMap,\n ) -> typing_utils.ArtifactMultiMap:","def compile(self, values):\n def is_international(tag) -> bool:\n return tag.endswith('_')\n\n def get_country_code(tag):\n return tag[-2:]\n\n def strip_country_code(tag):\n return tag[:-2]\n\n replacements = list(self.tagset.items())\n\n str = \"\"\n domestic = [t for t in replacements if not is_international(t[0])]\n for key, replacement in domestic:\n try:\n str = str + replacement % values[key]\n except KeyError as e:\n if self.mandatory:\n raise e\n\n international = [t for t in replacements if is_international(t[0])]\n for key, replacement in international:\n try:\n x = [t for t in values.items() if strip_country_code(t[0]) == key]\n int_values_for_key = [(get_country_code(t[0]),t[1]) for t in x]\n for v in int_values_for_key:\n str = str + replacement % v\n except KeyError as e:\n if self.mandatory:\n raise e\n\n return str","def apply_param_transformations(self,params_edict,**kwargs):\n if self.params_transforms == None:\n return params_edict\n for key,transform_function in self.params_transforms.items():\n params_edict[key] = transform_function(params_edict,**kwargs)\n return params_edict","def parse_template(self):\n for line in self.raw_template.split(\"\\n\"):\n line = line.strip()\n if line.startswith('#m3'):\n key, val = line[3:].strip().split('=', 1)\n key = key.strip()\n val = val.strip()\n self.variables[key] = val\n\n for fitem in self.finditem.finditer(self.raw_template):\n fgrp = fitem.groups()\n categ = fgrp[0]\n name = fgrp[1]\n rest_str = fgrp[2]\n rest = {} # type: dict\n for item in rest_str.split('|'):\n item = item.strip()\n if item:\n key, val = item.split('=')\n rest[key] = val\n\n self.data[name] = (categ, rest)","def replace_params(template, data):\n\t# Find all variables between curly braces, potentially with some spaces\n\tmatches = re.findall(\"({{\\s*)(\\w+(-\\w+)*)(\\s*}})\", template)\n\t# Process the matches\n\tfor match in matches:\n\t\tkey = match[1]\n\t\tif key in data:\n\t\t\ttemplate = template.replace(match[0] + match[1] + match[3], data[key])\n\t\t# If no data supplied in dictionary, that was an optional parameter, just delete it\n\t\telse:\n\t\t\ttemplate = template.replace(match[0] + match[1] + match[3], \"\")\n\treturn template","def map_dictionary(dictionary):\n mapping = dict()\n\n def add_item_to_mapping(path, k, v):\n mapping.update({join(path, k): v})\n\n loop_dictionary(\n dictionary,\n callback=add_item_to_mapping\n )\n return mapping","def map_value(self) -> global___Expression.MapValue:","def render_template(template, **template_values):\n # retrieve the html template\n t = jinja_environment.get_template(template)\n\n # render the html template with th given dictionary\n return t.render(template_values)","def test_format_map():\n template_filelist = listdir(RTEMPLATE_PATH)\n\n R_files = []\n json_files = []\n for file in template_filelist:\n if '.r' in file:\n file = file.replace('.r', '')\n R_files.append(file)\n elif '.json' in file:\n file = file.replace('.json', '')\n json_files.append(file)\n\n\n for template in R_files:\n template_filepath = path.join(RTEMPLATE_PATH, template + '.r')\n metadata_filepath = path.join(RTEMPLATE_PATH, template + '.json')\n\n with open(template_filepath, 'r') as t_fp:\n r_text = t_fp.read()\n\n try:\n with open(metadata_filepath, 'r') as m_fp:\n metadata = json.load(m_fp)\n except Exception as err:\n print(metadata_filepath)\n raise err\n\n format_dict = {}\n for key in metadata['required_args']:\n format_dict[key] = 'TEST'\n\n ## Actual test: apply `format_map` to r_text#\n try:\n r_text = r_text.format_map(format_dict)\n except Exception as err:\n print(template_filepath)\n raise err","def create_template_dict(name, cat, boilerplate_name=None, is_common=False):\r\n return {\r\n \"display_name\": name,\r\n \"category\": cat,\r\n \"boilerplate_name\": boilerplate_name,\r\n \"is_common\": is_common\r\n }","def update_template(template, trial):\n assert isinstance(template, dict) or isinstance(template, list)\n items = template.items() if isinstance(template, dict) else enumerate(template)\n\n for key, value in items:\n if isinstance(value, str):\n if value in trial:\n template[key] = trial[value]\n elif isinstance(value, dict) or isinstance(value, list):\n template[key] = ConfigGenerator.update_template(template[key], trial)\n\n return template","def apply(self, args):\n self._check_args(args)\n\n # check if the resource exists:\n if args[0] in self._template.resources:\n # if so, procedurally index the resource for the desired info:\n res = self._template.resources[args[0]]\n\n if self._properties_field_name not in res:\n raise FunctionApplicationException(\n \"'%s': resource has no '%s' field: '%s'.\" %\n (self.name, self._properties_field_name, res)\n )\n\n indexes = [self._properties_field_name] + args[1:]\n\n for i in indexes:\n res = self._get_item(res, i)\n return res\n else:\n raise FunctionApplicationException(\n \"%s: resource '%s' does not exist.\" % (\n self.name, args[0]\n )\n )","def make_links(self, name_url_pairs):\n return {name : {\"href\" : self._render_link(url)}\n for name, url in name_url_pairs.items()}","def mapData(form, data, fromKeyFunc, toKeyFunc):\n rv = {}\n\n def visitItem(node):\n fromName = fromKeyFunc(node)\n toName = toKeyFunc(node)\n\n value = data.get(fromName, MISSING)\n if value != MISSING:\n rv[toName] = value\n\n def visit(node):\n if hasattr(node, 'items'):\n for item in node.items:\n visit(item)\n else:\n visitItem(node)\n\n visit(form)\n return rv","def map_dict(dictionary, transform):\n return dict(transform(k, v) for k, v in dictionary.items())","def add_asm_mappings(self, cs_pairs, log_pfx):\n if cs_pairs is None or len(cs_pairs) < 1:\n return\n asm_v = self.asm_name()\n for pair in cs_pairs:\n higher, lower = pair.strip().split(\"-\")\n sql = r'''insert ignore into meta (species_id, meta_key, meta_value) values\n (1, \"assembly.mapping\", \"{_higher}:{_v}|{_lower}:{_v}\")\n ;'''.format(_v = asm_v, _higher = higher, _lower = lower)\n self.run_sql_req(sql, self.pjc(log_pfx, pair))","def variableSubstitution(d):\n variable = re.compile(r\"^(.*)\\$\\{(.*)\\}(.*)\")\n\n # translate the dictionary to lower-case keys:\n dd = {k.lower():v for k,v in d.iteritems()}\n maxIterations=4\n \n for i in range(maxIterations):\n anyChanges=False\n for k,v in dd.iteritems():\n if not isinstance(v,str):\n # Only operate on string-valued entries\n continue\n m = variable.match(v)\n if not m:\n continue\n anyChanges = True\n vout = str(v)\n while m:\n key = m.group(2).lower()\n if key not in dd.keys():\n print \"ERROR: variable substitution asks for nonexistent Attribute\", key, \"in\", v\n sys.exit(1)\n if key==k:\n print \"ERROR: self-reference to Attribute\", key, \"in\", v\n vv = dd[key]\n if not isinstance(vv,str):\n print \"ERROR: variable substitution using non-string-valued Attribute\",key\n sys.exit(1)\n vout = m.expand(r\"\\g<1>\"+vv+r\"\\g<3>\")\n m = variable.match(vout)\n dd[k] = vout\n if not anyChanges:\n break # Done\n if i==maxIterations:\n print \"ERROR: Too many iterations in variableSubstitution\"\n sys.exit(1)\n # restore case of original dictionary\n for k in d.keys():\n d[k] = dd[k.lower()]\n return","def replace_by_character_map(self, pattern_name: str, characters_map: dict):\n if pattern_name not in self.patterns:\n self.patterns[pattern_name] = generate_multiple_replace_pattern(characters_map)\n\n self.value = multiple_replace(\n characters_map, self.value, self.patterns[pattern_name]\n )\n return self","def op_replace(template_data, field_hierarchy_list, mappings):\n op_trace = []\n\n def replace(json_obj, search_list):\n if len(search_list) == 0:\n return\n\n if isinstance(json_obj, dict):\n for key, value in json_obj.items():\n if key == search_list[0]:\n if len(search_list) > 1:\n replace(value, search_list[1:])\n elif isinstance(value, Hashable):\n new_val = mappings.get(value)\n if new_val is not None:\n op_trace.append('Template {name}, updated {path}: '\n '{from_val} -> {to_val}'.format(name=template_data['templateName'],\n path='/'.join(field_hierarchy_list),\n from_val=value,\n to_val=new_val))\n json_obj[key] = new_val\n else:\n replace(value, search_list)\n\n elif isinstance(json_obj, list):\n for elem in json_obj:\n replace(elem, search_list)\n\n replace(template_data, field_hierarchy_list)\n\n return op_trace","def parse_uinput_mapping(name, mapping):\n axes, buttons, mouse, mouse_options = {}, {}, {}, {}\n description = \"ds4drv custom mapping ({0})\".format(name)\n\n for key, attr in mapping.items():\n key = key.upper()\n if key.startswith(\"BTN_\") or key.startswith(\"KEY_\"):\n buttons[key] = attr\n elif key.startswith(\"ABS_\"):\n axes[key] = attr\n elif key.startswith(\"REL_\"):\n mouse[key] = attr\n elif key.startswith(\"MOUSE_\"):\n mouse_options[key] = attr\n\n create_mapping(name, description, axes=axes, buttons=buttons,\n mouse=mouse, mouse_options=mouse_options)","def transform(self, tags, values_to_sub):\n for tag, properties in tags.items():\n val = values_to_sub.get(tag)\n values_to_sub[tag] = self.transform_val(properties, val)\n if properties.get(\"children\") is not None:\n children = properties.get(\"children\")\n for child_tag, child_properties in children.items():\n child_val = self.transform_val(child_properties, val)\n values_to_sub[child_tag] = child_val\n return values_to_sub","def get_replacement_dict(input_data: Dict[str, Any], mappings: bool = False) -> Dict[str, str]:\n data = {}\n for key in list(k for k in input_data.keys() if k != \"meta\"):\n suit_tags, suit_key = get_suit_tags_and_key(key)\n logging.debug(f\" --- key = {key}.\")\n logging.debug(f\" --- suit_tags = {suit_tags}\")\n logging.debug(f\" --- suit_key = {suit_key}\")\n\n for suit, suit_tag in zip(input_data[key], suit_tags):\n logging.debug(f\" --- suit [name] = {suit['name']}\")\n logging.debug(f\" --- suit_tag = {suit_tag}\")\n tag_for_suit_name = get_tag_for_suit_name(suit, suit_tag)\n data.update(tag_for_suit_name)\n\n card_tag = \"\"\n for card in suit[suit_key]:\n for tag, text_output in card.items():\n if tag == \"value\":\n continue\n\n full_tag = get_full_tag(suit_tag, card[\"value\"], tag)\n\n # Add a translation for \"Joker\"\n if suit_tag == \"WC\" and tag == \"value\":\n full_tag = \"${{{}}}\".format(\"_\".join([suit_tag, card_tag, tag]))\n\n # Mappings is sometimes loaded as a list. Convert to string\n if convert_vars.making_template:\n text1 = check_make_list_into_text(text_output, False)\n data[text1] = full_tag\n if mappings:\n data[text1.replace(\", \", \",\")] = full_tag\n text1 = check_make_list_into_text(text_output, True)\n data[text1] = full_tag\n else:\n data[full_tag] = check_make_list_into_text(text_output, True)\n if convert_vars.args.debug and not mappings:\n debug_txt = \" --- Translation data showing First 4 (key: text):\\n* \"\n debug_txt += \"\\n* \".join(l1 + \": \" + str(data[l1]) for l1 in list(data.keys())[:4])\n logging.debug(debug_txt)\n debug_txt = \" --- Translation data showing Last 4 (key: text):\\n* \"\n debug_txt += \"\\n* \".join(l1 + \": \" + str(data[l1]) for l1 in list(data.keys())[-4:])\n logging.debug(debug_txt)\n return data","def transliterate(re_maps, word):\n for mapping in re_maps:\n word = word_replace(mapping, word)\n return word","def preprocess_data_by_mapping(dicts_count, alias_mapping):\n\n new_mapping_dict = {}\n for (key, value) in dicts_count.items():\n\n # Replace the key with lower string\n new_key = unicode.lower(key)\n\n # Replace the key with object alias\n if new_key in alias_mapping:\n new_key = alias_mapping[new_key]\n\n # Check if the object key is already exists in the dict\n if new_key in new_mapping_dict:\n new_mapping_dict[new_key] += value\n else:\n new_mapping_dict[new_key] = value\n\n return new_mapping_dict","def mapping_for_switch(mapping):\n return {key[0]: value for key, value in mapping.items()}","def mapList(results, key):\n newResult = results.map(lambda x: ee.Dictionary(x).get(key))\n return newResult","def update_name(name, mapping):\n m = street_type_re.search(name)\n if m:\n street_type = m.group()\n for key, value in mapping.iteritems():\n if street_type == key:\n name = name.replace(key,value)\n\n return name","def _unify(self, mapping, kwargs):\n\n if len(kwargs) <= 0:\n return mapping\n\n data = dict(mapping)\n data.update(kwargs)\n return data","def template_typedef(self, node, targs):\n typedefmap = []\n for typ in node.typedefs:\n oldtyp = typ.typemap\n typ.clone_post_class(targs)\n typedefmap.append( (oldtyp, typ.typemap) )\n node.typedef_map = typedefmap\n\n for function in node.functions:\n for arg in function.ast.declarator.params:\n ntypemap = arg.typemap\n for typedef in typedefmap:\n if ntypemap is typedef[0]:\n arg.typemap = typedef[1]\n break","def replace_by_dict(source_string, mapping):\n return_string = copy.copy(source_string)\n for key, value in mapping.items():\n return_string = return_string.replace(key, value)\n return return_string","def create_file_from_template(template_file, output_file, substitution_dict):\n with open(template_file) as fl:\n template = fl.read()\n template = Template(template).safe_substitute(**substitution_dict)\n\n with open(output_file, 'w') as output_handle:\n output_handle.write(template)"],"string":"[\n \"def map_template(template: dict, input_: dict) -> None:\\n for k, v in template.items():\\n config_val = input_.get(k)\\n\\n if isinstance(v, dict) and k != 'NullHandler':\\n map_template(v, input_)\\n\\n if config_val:\\n template[k] = config_val.upper() if k == 'level' else config_val\",\n \"def substitute_names(tmpl_string, dct):\\n return Template(tmpl_string).substitute(dct)\",\n \"def process_map_pair(selector, value, context, current_node):\\n from knife.template import Template\\n from knife.transformer import Transform, ContextKeyTransform, TemplateTransform, MapTransform\\n \\n new_node = current_node(selector)\\n\\n if new_node:\\n # Flatten a single-value tuple \\n if isinstance(value, tuple):\\n if len(value) == 1:\\n value = value[0]\\n \\n # A simple replacement\\n if isinstance(value, basestring):\\n ContextKeyTransform.transform(value, context, selector, new_node)\\n\\n elif isinstance(value, Template):\\n TemplateTransform.transform(value, context, selector, new_node) \\n\\n # Or a tuple\\n elif isinstance(value, tuple):\\n\\n if isinstance(value[0], Template):\\n TemplateTransform.transform(value, context, selector, new_node)\\n\\n elif isinstance(value[0], basestring) and isinstance(value[1], dict):\\n MapTransform.transform(value[0], context, selector, new_node, map=value[1])\\n\\n elif isinstance(value[0], basestring) and isinstance(value[1], Transform):\\n transformer = value[1].transform(value[0], context, selector, new_node)\\n transformer.transform(value[0], context, selector, new_node)\\n else:\\n raise Error(\\\"Invalid Option\\\")\",\n \"def tmap(app, args):\\n tmpl = Template(app, args.template, args.template_args)\\n for a in args.template_args:\\n print(a)\",\n \"def template_replace(template, replace_map, result):\\n # Read content of source file.\\n with open(template) as fp:\\n lines = fp.readlines()\\n # Replace placeholders.\\n for key, value in list(replace_map.items()):\\n for i, line in enumerate(lines):\\n # Ignore VHDL comments\\n if not line.strip().startswith('--'):\\n lines[i] = line.replace(key, value)\\n # Write content to destination file.\\n with open(result, 'w') as fp:\\n fp.write(''.join(lines))\",\n \"def multi_mapping(func_name, arg_value_pairs, module_name = \\\"__main__\\\"):\\n func, arg_names = get_function_args(module_name = module_name, function_name = func_name)\\n \\n return list(map(lambda arg_value_pair: call_func_dynamically(function_name = func_name, \\n argument_names = arg_names, \\n arg_value_pair = arg_value_pair) ,\\n arg_value_pairs))\",\n \"def templateMappings(self):\\n raise NotImplementedError\",\n \"def add_template_scope(node, names, values):\\n scope = sortedmap()\\n for name, value in zip(names, values):\\n scope[name] = value\\n node.scope = scope\",\n \"def substitute(self, substitution_map):\\n for element_name in substitution_map:\\n\\n assert (is_constant(element_name) or is_variable(element_name)) and \\\\\\n type(substitution_map[element_name]) is Term\\n return self.subsitute_helper(copy.deepcopy(substitution_map), False)\",\n \"def apply_custom_template(self, name, filename, context):\\n with open(os.path.join(self.build_path, filename), 'r') as f:\\n template = actions.ActionsTemplate.from_dict(json.loads(f.read()))\\n\\n outputs = template.apply(context, self)\\n\\n for key, value in six.iteritems(outputs):\\n context[key] = value\",\n \"def _render_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:\\n output_dict = {}\\n\\n for key, value in input_dict.items():\\n if isinstance(value, str):\\n new_value = string.Template(value).substitute(_mapping)\\n output_dict[key] = new_value\\n elif isinstance(value, dict):\\n output_dict[key] = _render_dict(value) # type: ignore\\n else:\\n output_dict[key] = value\\n\\n return output_dict\",\n \"def fill_template_file(filename, value_dict):\\n f = open(filename, 'r')\\n text = f.read()\\n f.close()\\n f = open(filename, 'w')\\n f.write(text % value_dict)\\n f.close()\",\n \"def apply_to(self, template):\\n pass\",\n \"def template_update(inputs, output_dir, state_ind=None, map_copyfiles=None):\\n\\n inputs_dict_st = attr.asdict(inputs, recurse=False)\\n if map_copyfiles is not None:\\n inputs_dict_st.update(map_copyfiles)\\n\\n if state_ind is not None:\\n for k, v in state_ind.items():\\n k = k.split(\\\".\\\")[1]\\n inputs_dict_st[k] = inputs_dict_st[k][v]\\n\\n from .specs import attr_fields\\n\\n # Collect templated inputs for which all requirements are satisfied.\\n fields_templ = [\\n field\\n for field in attr_fields(inputs)\\n if field.metadata.get(\\\"output_file_template\\\")\\n and all(\\n getattr(inputs, required_field) is not attr.NOTHING\\n for required_field in field.metadata.get(\\\"requires\\\", ())\\n )\\n ]\\n\\n dict_mod = {}\\n for fld in fields_templ:\\n dict_mod[fld.name] = template_update_single(\\n field=fld,\\n inputs=inputs,\\n inputs_dict_st=inputs_dict_st,\\n output_dir=output_dir,\\n )\\n # adding elements from map_copyfiles to fields with templates\\n if map_copyfiles:\\n dict_mod.update(map_copyfiles)\\n return dict_mod\",\n \"def map_values(function, dictionary):\\n return {k: function(dictionary[k]) for k in dictionary}\",\n \"def applyMapping(self):\\n pass\",\n \"def fill_template(template, replacements):\\n content = template\\n for src, target in replacements.iteritems():\\n content = content.replace(src, target)\\n return content\",\n \"def update_templated_typemaps(self, node):\\n visitor = TemplateTypemap(self.config)\\n return visitor.visit(node)\",\n \"def _substitute(self, mapping: VariableMapping) -> 'Substitution':\\n return Substitution(\\n # Create a new combined mapping. Later mappings override earlier\\n # ones.\\n mapping={\\n **mapping,\\n **{\\n variable: term._substitute(mapping)\\n for (variable, term) in self.mapping.items()\\n }\\n }\\n )\",\n \"def map_values(fun, a_dict):\\n return dict((k, fun(v)) for (k, v) in a_dict.items())\",\n \"def context(template):\\n\\n return {\\n v.key: v.read()\\n for v in [Variable(name) for name in extract_variables(template)]\\n }\",\n \"def process_variables_loop(template, var_pattern, param_lookup_function):\\n # Generic loop for handling a source of key/value tuples (e.g., enumerate() or <dict>.items())\\n def process_items_helper(key_value_iterator, data_map):\\n made_change = False\\n for key, value in key_value_iterator:\\n if isinstance(value, str):\\n altered_value = value\\n for match in var_pattern.finditer(value):\\n var_type, var_loc, fallback_type, fallback_loc = _parse_var(match[1])\\n source_value = param_lookup_function(var_type, var_loc, fallback_type, fallback_loc)\\n\\n # If we can't find a value, skip it\\n if source_value is None:\\n continue\\n try:\\n if altered_value == match[0]: # complete replacement\\n altered_value = source_value\\n else: # partial replacement\\n\\n altered_value = altered_value.replace(match[0], source_value)\\n except TypeError:\\n pass\\n if value != altered_value:\\n data_map[key] = altered_value\\n made_change = True\\n elif isinstance(value, dict):\\n if process_variables_loop(value, var_pattern, param_lookup_function):\\n made_change = True\\n elif isinstance(value, list):\\n if process_items_helper(enumerate(value), value):\\n made_change = True\\n return made_change\\n\\n return process_items_helper(template.items(), template)\",\n \"def template_recurse(tmpl, tags):\\n if isinstance(tmpl, str):\\n ret = tmpl\\n for k, v in tags.items():\\n # If the value we are replacing is an exact match for a key, return the value as-is - we're assuming\\n # here that we are NOT replacing a substring in a larger string \\\"hello {{name}}\\\", but that the\\n # value should be used as-is, i.e. not converted into a string - i.e. it is a KEY in the JSON, not a VALUE.\\n if ret == k:\\n return v\\n # Try to perform a simple string substitution - this assumes that the value is a string, or can be\\n # converted to a string without any issues.\\n ret = ret.replace(k, str(v))\\n\\n return ret\\n\\n if isinstance(tmpl, list):\\n return [template_recurse(v, tags) for v in tmpl]\\n\\n if isinstance(tmpl, dict):\\n return {k:template_recurse(v, tags) for k, v in tmpl.items()}\\n\\n return tmpl\",\n \"def buildTagMap(default, *args):\\r\\n built = {}\\r\\n for portion in args:\\r\\n if hasattr(portion, 'items'):\\r\\n #It's a map. Merge it.\\r\\n for k,v in portion.items():\\r\\n built[k] = v\\r\\n elif isList(portion):\\r\\n #It's a list. Map each item to the default.\\r\\n for k in portion:\\r\\n built[k] = default\\r\\n else:\\r\\n #It's a scalar. Map it to the default.\\r\\n built[portion] = default\\r\\n return built\",\n \"def map(keys, values) -> MapValue:\\n return ops.Map(keys, values).to_expr()\",\n \"def parse(self, dict, header=TRUE):\\n if type(dict) != types.DictType:\\n raise TypeError, \\\"Second argument must be a dictionary\\\"\\n if not self.template:\\n raise OpagMissingPrecondition, \\\"template path is not set\\\"\\n # Open the file if its not already open. If it is, seek to the\\n # beginning of the file.\\n if not self.template_file:\\n self.template_file = open(self.template, \\\"r\\\")\\n else:\\n self.template_file.seek(0)\\n # Instantiate a new bound method to do the replacement.\\n replacer = Replacer(dict).replace\\n # Read in the entire template into memory. I guess we'd better keep\\n # the templates a reasonable size if we're going to keep doing this.\\n buffer = self.template_file.read()\\n replaced = \\\"\\\"\\n if header:\\n replaced = \\\"Content-Type: text/html\\\\n\\\\n\\\"\\n replaced = replaced + re.sub(\\\"%%(\\\\w+)%%\\\", replacer, buffer)\\n return replaced\",\n \"def map(self, key, value):\\n namelist = value.strip().split()\\n namelist.insert(0, '')\\n namelist.append('')\\n n = len(namelist)\\n for i in range(1, n - 1):\\n self.outputcollector.collect(namelist[i], \\\\\\n tuple2str((namelist[i-1] ,namelist[i+1])))\",\n \"def do_dict_entry_for_item(parser, token):\\r\\n bits = token.contents.split()\\r\\n if len(bits) != 6:\\r\\n raise template.TemplateSyntaxError(\\\"'%s' tag takes exactly five arguments\\\" % bits[0])\\r\\n if bits[2] != 'from':\\r\\n raise template.TemplateSyntaxError(\\\"second argument to '%s' tag must be 'from'\\\" % bits[0])\\r\\n if bits[4] != 'as':\\r\\n raise template.TemplateSyntaxError(\\\"fourth argument to '%s' tag must be 'as'\\\" % bits[0])\\r\\n return DictEntryForItemNode(bits[1], bits[3], bits[5])\",\n \"def translator(dict):\\n f = lambda match: dict.get(match.group(), match.group())\\n return lambda expression: _word_pattern.sub(f,expression)\",\n \"def testTitleTemplateSubstitute(self):\\n\\n\\t\\tfield_values = {'abc': 'ABC', 'a.1': 'VALUE'}\\n\\n\\t\\ttests = {\\n\\t\\t\\t'${abc} $$ ${} ${{{} ${abc}': 'ABC $ ${} ${{{} ABC',\\n\\t\\t\\t'$abc ${a.1} $$$$': '$abc VALUE $$'\\n\\t\\t}\\n\\n\\t\\tfor test in tests:\\n\\t\\t\\tt = TitleTemplate(test)\\n\\t\\t\\tself.assertEqual(t.substitute(field_values), tests[test])\",\n \"def map_named(function: Callable[[str, Any], Any],\\n val: Any,\\n key: Optional[str] = \\\"\\\") -> Any:\\n if isinstance(val, Mapping):\\n return type(val)(\\n **{k: map_named(function, v, key + \\\"/\\\" + k) for k, v in val.items()})\\n elif isinstance(val, tuple) or isinstance(val, list):\\n return type(val)(\\n *\\n [map_named(function, v, key + \\\"/\\\" + str(i)) for i, v in enumerate(val)])\\n # check if it's a flax dataclass\\n elif hasattr(val, \\\"__dataclass_fields__\\\"):\\n classname = repr(val).split(\\\"(\\\")[0]\\n return type(val)(**{\\n k: map_named(function, v, f\\\"{key}/{classname}.{k}\\\")\\n for k, v in val.__dataclass_fields__.items()\\n })\\n else:\\n return function(key, val)\",\n \"def mapfn(k, v):\\n for row in v:\\n # completar\\n pass\",\n \"def transform(self, nameList):\\n return {name: self.transformSingle(name) for name in nameList}\",\n \"def extractor(template, options):\\n for name, val in options:\\n normalised = self.normalise_key(name)\\n if normalised in self.values and not isinstance(self.values[normalised], Default):\\n continue\\n else:\\n yield name, val\",\n \"def multiple_replace(dict, text): \\n\\n # Create a regular expression from the dictionary keys\\n regex = re.compile(\\\"(%s)\\\" % \\\"|\\\".join(map(re.escape, dict.keys())))\\n\\n # For each match, look-up corresponding value in dictionary\\n return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)\",\n \"def _transform_value_map(self, value: str, map_: dict, passthrough: bool = False) -> str:\\n _default = value if passthrough is True else None\\n if isinstance(value, str):\\n # a static map is a dict of key/value pairs\\n value = map_.get(value.lower(), _default)\\n else:\\n self.log.warning(\\n f'''feature=ti-transform, action=transform-value, '''\\n f'''message='static-map-requires-str-value\\\", value={value}'''\\n )\\n return value\",\n \"def zipmap(keys, values):\\n z = zip(keys, values)\\n data = {k: v for k, v in z}\\n return data\",\n \"def apply(smap, parameters=None):\\r\\n if parameters is None:\\r\\n parameters = {}\\r\\n\\r\\n for t in smap:\\r\\n t.properties[STOCHASTIC_DISTRIBUTION] = smap[t]\",\n \"def _finder_template(\\n name: str, mapping: Mapping[str, str], namespaces: Dict[str, List[str]]\\n) -> str:\\n mapping = dict(sorted(mapping.items(), key=lambda p: p[0]))\\n return _FINDER_TEMPLATE.format(name=name, mapping=mapping, namespaces=namespaces)\",\n \"def dummy_transform(inputs: Dict[str, str]) -> Dict[str, str]:\\n outputs = inputs\\n outputs[\\\"greeting\\\"] = f\\\"{inputs['first_name']} {inputs['last_name']} says hello\\\"\\n del outputs[\\\"first_name\\\"]\\n del outputs[\\\"last_name\\\"]\\n return outputs\",\n \"def _replace_tags(codes, key, value, tag_dict, i):\\n\\n # if reaching the end of the tag dictionary\\n if i == len(tag_dict):\\n codes[key] = value\\n return\\n\\n # check if the i-th <tag> is used in the key\\n tag = list(tag_dict)[i]\\n if tag in key:\\n for tag_key, tag_attrs in tag_dict[tag].items():\\n _key = key.replace(tag, tag_key)\\n _value = replace_tag_attributes(value, tag, tag_attrs)\\n _replace_tags(codes, _key, _value, tag_dict, i + 1)\\n else:\\n _replace_tags(codes, key, value, tag_dict, i + 1)\",\n \"def _set_named_args(self, **kv):\\n for k in kv:\\n self._body['${0}'.format(k)] = kv[k]\\n return self\",\n \"def mapify(text, sep=\\\",\\\", kvsep=\\\"=\\\", strip_char=\\\" \\\", glue= \\\"\\\\\\\"\\\", parsing=False):\\n # text = \\\"hello=world,good=bye\\\"\\n items = listify(text, sep, glue)\\n res = {}\\n for item in items:\\n item = item.strip(strip_char)\\n arr = item.split(kvsep, 1)\\n if len(arr)==1:\\n key, value = arr[0], \\\"\\\"\\n elif len(arr)==2:\\n key, value = arr\\n key, value = key.strip(strip_char).strip(glue), value.strip(strip_char).strip(glue)\\n\\n if parsing:\\n value = parseValue(value)\\n\\n res[key] = value\\n\\n return res\",\n \"def parse_templated_fields(metadata):\\n parse_dict = {}\\n for field in metadata:\\n if \\\"configurations\\\" not in field:\\n parse_dict.update({field: metadata[field]})\\n else:\\n parse_dict.update(get_config(metadata, field))\\n\\n # looping over config sections:\\n for config_sec, configs in metadata.items():\\n # looping over each field in the current config section\\n for cur_key, cur_val in configs.items():\\n if cur_val[\\\"type\\\"] not in [\\\"string\\\", \\\"array\\\"]:\\n continue # not string fields, template does not support\\n \\n if cur_val[\\\"type\\\"] == \\\"string\\\" and \\\"{\\\" in cur_val and \\\"}\\\" in cur_val[\\\"value\\\"]:\\n cur_val[\\\"value\\\"] = cur_val[\\\"value\\\"].format(**parse_dict)\\n else: # array\\n for index, s in enumerate(cur_val[\\\"value\\\"]):\\n cur_val[\\\"value\\\"][index] = s.format(**parse_dict)\\n \\n metadata[config_sec][cur_key][\\\"value\\\"] = cur_val[\\\"value\\\"]\\n \\n return metadata\",\n \"def nmtpl_dict(nmtpl):\\n keylist=nmtpl._fields\\n vallist=tuple(nmtpl)\\n return({keylist[i]: vallist[i] for i in range(len(keylist))})\",\n \"def set_template(self, name, value):\\n\\n self.templates[name] = value\",\n \"def _substitute(self, value, group=None, namespace=None):\\n if isinstance(value, list):\\n return [self._substitute(i, group=group, namespace=namespace)\\n for i in value]\\n elif isinstance(value, str):\\n # Treat a backslash followed by the dollar sign \\\"\\\\$\\\"\\n # the same as the string template escape \\\"$$\\\" as it is\\n # a bit more natural for users\\n if r'\\\\$' in value:\\n value = value.replace(r'\\\\$', '$$')\\n tmpl = self.Template(value)\\n ret = tmpl.safe_substitute(\\n self.StrSubWrapper(self, group=group, namespace=namespace))\\n return ret\\n elif isinstance(value, dict):\\n # Substitute template variables in both key and value\\n return {self._substitute(key, group=group, namespace=namespace):\\n self._substitute(val, group=group, namespace=namespace)\\n for key, val in value.items()}\\n else:\\n return value\",\n \"def add_attrs(value, arg):\\n try:\\n # Split list on comma\\n kv_pairs = arg.split(\\\",\\\")\\n except ValueError:\\n raise template.TemplateSyntaxError(\\n \\\"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\\\"\\n )\\n\\n\\n # Create dictionary\\n html_attrs = dict()\\n\\n # Clean items and add attribute pairs to dictionary\\n for item in kv_pairs:\\n item = item.strip()\\n k, v = item.split(\\\":\\\")\\n html_attrs.update({k.strip():v.strip()})\\n\\n return value.as_widget(attrs=html_attrs)\",\n \"def _do_mapping(self):\\n pass\",\n \"def _add_template(self, alias, template):\\n # Construct a function that will do substitution for any placeholders\\n # in the template.\\n def fname(**kwargs):\\n return _substitute(template, self.files(), kwargs)\\n\\n # Bind the fname function to this instance of FileNames\\n self.__dict__[alias] = fname\",\n \"def render(data_dict, *args, **kwargs):\",\n \"def nameYamlMapping(name: str, mapping: Dict[str, Any]) -> Dict[str, Any]:\\n # Because we want \\\"name\\\" field to be the first member for aesthetic\\n # reasons, we create a new dict and copy ``mapping`` to it.\\n newMapping = {\\\"name\\\": name}\\n newMapping.update((key, value) for key, value in mapping.items() if key != \\\"name\\\")\\n return newMapping\",\n \"def materialize(template, substitutions):\\n\\n script_str = template\\n for param, value in substitutions.items():\\n script_str = re.sub(param, str(value), script_str)\\n\\n return script_str\",\n \"def write_template(self, template_file, template_dict, rename_as=None):\\n dest_name = rename_as if rename_as else template_file\\n return self._write_template_to(template_file, os.path.join(self.dest, dest_name), template_dict)\",\n \"def mutate_dict_in_place(func, mapping):\\n for key, value in mapping.items():\\n if isinstance(value, dict):\\n mutate_dict_in_place(func, value)\\n else:\\n mapping[key] = func(value)\",\n \"def _substitute(template, files, user_values):\\n # Get all placeholder names\\n placeholders = _get_placeholders(template)\\n\\n # Pre-fill placeholders based on existing file aliases\\n placeholder_values = _prefill_placeholders(placeholders, files,\\n user_values)\\n\\n # Add user specified values for the placeholders\\n placeholder_values.update(**user_values)\\n\\n # Check whether all placeholder values are now properly provided.\\n provided = set(placeholder_values.keys())\\n needed = set(placeholders)\\n missing = needed - provided\\n if len(missing) > 0:\\n raise ValueError('Cannot construct filename, because the following '\\n 'parameters are missing: %s' % missing)\\n\\n # Do the substitution\\n return template.format(**placeholder_values)\",\n \"def apply_cloudformation_template(self, name, filename, context):\\n stack_name = utils.generate_stack_name(context['Stage'], self.name, name)\\n stack = utils.create_or_update_cf_stack(\\n name=stack_name,\\n template_filename=os.path.join(self.build_path, filename),\\n context=context,\\n timeout_in_minutes=self.timeout_in_minutes,\\n bucket=context.get('CodeBucket')\\n )\\n\\n for output in stack.get('Outputs', []):\\n context[output['OutputKey']] = output['OutputValue']\",\n \"def dictionary_map(mapping):\\n dictionary = dict()\\n\\n def add_item_to_dictionary(path, k, v):\\n dictionary.update(\\n dict_merge(\\n dictionary,\\n inflate_key_value_pair(\\n join(path, k), v\\n )\\n )\\n )\\n\\n loop_dictionary(\\n mapping,\\n callback=add_item_to_dictionary\\n )\\n\\n return dictionary\",\n \"def _template_kwargs(*, logical_name: str, bucket: str, key: str) -> Dict[str, str]:\\n if logical_name == \\\"ArtifactBuilder\\\":\\n return dict(ArtifactBucketName=bucket, WorkersS3Key=key)\\n elif logical_name == \\\"LayerBuilder\\\":\\n return dict(ReplicationBucket=bucket, WorkersS3Key=key)\\n else:\\n raise ValueError(f\\\"Unknown logical name: {logical_name}\\\")\",\n \"def setTemplateParameter(self,name,value):\\n self.tplparam[name] = value\",\n \"def fill_template(map_filepath, resolution, origin): # NOTE: Copied from generate_map_yaml.py\\n template = \\\"\\\"\\\"image: MAP_FILEPATH\\nresolution: RESOLUTION\\norigin: [ORIGIN_X, ORIGIN_Y, YAW]\\nnegate: 0\\noccupied_thresh: 0.65\\nfree_thresh: 0.196\\n\\\"\\\"\\\"\\n template = template.replace('MAP_FILEPATH', map_filepath)\\n template = template.replace('RESOLUTION', str(resolution))\\n template = template.replace('ORIGIN_X', str(origin[0]))\\n template = template.replace('ORIGIN_Y', str(origin[1]))\\n template = template.replace('YAW', str(origin[2]))\\n return template\",\n \"def apply_replicator(self, replicator, template_values, template_index=-1,\\n template_value=None, update_input_references=False):\\n return {}\",\n \"def map_values_c(fun):\\n return partial(map_values, fun)\",\n \"def rhs_name_transform_inplace(self, name_map):\\n\\n for name in name_map:\\n replacment = name_map[name]\\n self.rhs = MathUtil.str_expr_replacement(name, replacment,\\n self.rhs)\",\n \"def _template_formatting(field, inputs, inputs_dict_st):\\n from .specs import MultiInputObj, MultiOutputFile\\n\\n # if a template is a function it has to be run first with the inputs as the only arg\\n template = field.metadata[\\\"output_file_template\\\"]\\n if callable(template):\\n template = template(inputs)\\n\\n # as default, we assume that keep_extension is True\\n keep_extension = field.metadata.get(\\\"keep_extension\\\", True)\\n\\n inp_fields = re.findall(r\\\"{\\\\w+}\\\", template)\\n inp_fields_fl = re.findall(r\\\"{\\\\w+:[0-9.]+f}\\\", template)\\n inp_fields += [re.sub(\\\":[0-9.]+f\\\", \\\"\\\", el) for el in inp_fields_fl]\\n if len(inp_fields) == 0:\\n return template\\n\\n val_dict = {}\\n file_template = None\\n\\n for fld in inp_fields:\\n fld_name = fld[1:-1] # extracting the name form {field_name}\\n if fld_name not in inputs_dict_st:\\n raise AttributeError(f\\\"{fld_name} is not provided in the input\\\")\\n fld_value = inputs_dict_st[fld_name]\\n if fld_value is attr.NOTHING:\\n # if value is NOTHING, nothing should be added to the command\\n return attr.NOTHING\\n else:\\n # checking for fields that can be treated as a file:\\n # have type File, or value that is path like (including str with extensions)\\n if isinstance(fld_value, os.PathLike) or (\\n isinstance(fld_value, str) and \\\".\\\" in fld_value\\n ):\\n if file_template:\\n raise Exception(\\n f\\\"can't have multiple paths in {field.name} template,\\\"\\n f\\\" but {template} provided\\\"\\n )\\n else:\\n file_template = (fld_name, fld_value)\\n else:\\n val_dict[fld_name] = fld_value\\n\\n # if field is MultiOutputFile and some elements from val_dict are lists,\\n # each element of the list should be used separately in the template\\n # and return a list with formatted values\\n if field.type is MultiOutputFile and any(\\n [isinstance(el, (list, MultiInputObj)) for el in val_dict.values()]\\n ):\\n # all fields that are lists\\n keys_list = [\\n k for k, el in val_dict.items() if isinstance(el, (list, MultiInputObj))\\n ]\\n if any(\\n [len(val_dict[key]) != len(val_dict[keys_list[0]]) for key in keys_list[1:]]\\n ):\\n raise Exception(\\n f\\\"all fields used in {field.name} template have to have the same length\\\"\\n f\\\" or be a single value\\\"\\n )\\n formatted_value = []\\n for ii in range(len(val_dict[keys_list[0]])):\\n val_dict_el = copy(val_dict)\\n # updating values to a single element from the list\\n for key in keys_list:\\n val_dict_el[key] = val_dict[key][ii]\\n\\n formatted_value.append(\\n _element_formatting(\\n template, val_dict_el, file_template, keep_extension=keep_extension\\n )\\n )\\n else:\\n formatted_value = _element_formatting(\\n template, val_dict, file_template, keep_extension=keep_extension\\n )\\n return formatted_value\",\n \"def template_function(self, node, ordered_functions):\\n oldoptions = node.options\\n headers_typedef = collections.OrderedDict()\\n\\n # targs - ast.TemplateArgument\\n for iargs, targs in enumerate(node.template_arguments):\\n new = node.clone()\\n ordered_functions.append(new)\\n self.append_function_index(new)\\n\\n new._generated = \\\"cxx_template\\\"\\n\\n fmt = new.fmtdict\\n if targs.fmtdict:\\n fmt.update(targs.fmtdict)\\n\\n # Use explicit template_suffix if provide.\\n # If single template argument, use type's explicit_suffix\\n # or the unqualified flat_name.\\n # Multiple template arguments, use sequence number.\\n if fmt.template_suffix:\\n pass\\n elif len(targs.asts) == 1:\\n ntypemap = targs.asts[0].typemap\\n if ntypemap.template_suffix:\\n fmt.template_suffix = ntypemap.template_suffix\\n else:\\n fmt.template_suffix = \\\"_\\\" + ntypemap.flat_name\\n else:\\n fmt.template_suffix = \\\"_\\\" + str(iargs)\\n\\n new.cxx_template = {}\\n fmt.CXX_template = targs.instantiation # ex. <int>\\n\\n # Gather headers required by template arguments.\\n for targ in targs.asts:\\n ntypemap = targ.typemap\\n headers_typedef[ntypemap.name] = ntypemap\\n\\n self.push_instantiate_scope(new, targs)\\n\\n if new.ast.template_argument:\\n iast = getattr(self.instantiate_scope, new.ast.template_argument)\\n new.ast = new.ast.instantiate(node.ast.instantiate(iast))\\n # Generics cannot differentiate on return type\\n new.options.F_create_generic = False\\n\\n # Replace templated arguments.\\n # arg - declast.Declaration\\n newparams = []\\n for arg in new.ast.declarator.params:\\n if arg.template_argument:\\n iast = getattr(self.instantiate_scope, arg.template_argument)\\n newparams.append(arg.instantiate(iast))\\n else:\\n newparams.append(arg)\\n new.ast.declarator.params = newparams\\n self.pop_instantiate_scope()\\n\\n new.gen_headers_typedef = headers_typedef\\n # Do not process templated node, instead process\\n # generated functions above.\\n node.wrap.clear()\",\n \"def transform(attrs: dict) -> dict:\\n\\n pass\",\n \"def generate(self, answers):\\n\\n text = self.template\\n\\n for (key, val) in answers.items():\\n text = text.replace(\\\"{\\\" + key + \\\"}\\\", val)\\n\\n return text\",\n \"def mapalign(aln, keyfunc=lambda x: x, valfunc=lambda x: x):\\n\\n aln2 = new_align(aln)\\n for key, val in aln.iteritems():\\n aln2[keyfunc(key)] = valfunc(val)\\n return aln2\",\n \"def apply(\\n self,\\n input_dict: typing_utils.ArtifactMultiMap,\\n ) -> typing_utils.ArtifactMultiMap:\",\n \"def compile(self, values):\\n def is_international(tag) -> bool:\\n return tag.endswith('_')\\n\\n def get_country_code(tag):\\n return tag[-2:]\\n\\n def strip_country_code(tag):\\n return tag[:-2]\\n\\n replacements = list(self.tagset.items())\\n\\n str = \\\"\\\"\\n domestic = [t for t in replacements if not is_international(t[0])]\\n for key, replacement in domestic:\\n try:\\n str = str + replacement % values[key]\\n except KeyError as e:\\n if self.mandatory:\\n raise e\\n\\n international = [t for t in replacements if is_international(t[0])]\\n for key, replacement in international:\\n try:\\n x = [t for t in values.items() if strip_country_code(t[0]) == key]\\n int_values_for_key = [(get_country_code(t[0]),t[1]) for t in x]\\n for v in int_values_for_key:\\n str = str + replacement % v\\n except KeyError as e:\\n if self.mandatory:\\n raise e\\n\\n return str\",\n \"def apply_param_transformations(self,params_edict,**kwargs):\\n if self.params_transforms == None:\\n return params_edict\\n for key,transform_function in self.params_transforms.items():\\n params_edict[key] = transform_function(params_edict,**kwargs)\\n return params_edict\",\n \"def parse_template(self):\\n for line in self.raw_template.split(\\\"\\\\n\\\"):\\n line = line.strip()\\n if line.startswith('#m3'):\\n key, val = line[3:].strip().split('=', 1)\\n key = key.strip()\\n val = val.strip()\\n self.variables[key] = val\\n\\n for fitem in self.finditem.finditer(self.raw_template):\\n fgrp = fitem.groups()\\n categ = fgrp[0]\\n name = fgrp[1]\\n rest_str = fgrp[2]\\n rest = {} # type: dict\\n for item in rest_str.split('|'):\\n item = item.strip()\\n if item:\\n key, val = item.split('=')\\n rest[key] = val\\n\\n self.data[name] = (categ, rest)\",\n \"def replace_params(template, data):\\n\\t# Find all variables between curly braces, potentially with some spaces\\n\\tmatches = re.findall(\\\"({{\\\\s*)(\\\\w+(-\\\\w+)*)(\\\\s*}})\\\", template)\\n\\t# Process the matches\\n\\tfor match in matches:\\n\\t\\tkey = match[1]\\n\\t\\tif key in data:\\n\\t\\t\\ttemplate = template.replace(match[0] + match[1] + match[3], data[key])\\n\\t\\t# If no data supplied in dictionary, that was an optional parameter, just delete it\\n\\t\\telse:\\n\\t\\t\\ttemplate = template.replace(match[0] + match[1] + match[3], \\\"\\\")\\n\\treturn template\",\n \"def map_dictionary(dictionary):\\n mapping = dict()\\n\\n def add_item_to_mapping(path, k, v):\\n mapping.update({join(path, k): v})\\n\\n loop_dictionary(\\n dictionary,\\n callback=add_item_to_mapping\\n )\\n return mapping\",\n \"def map_value(self) -> global___Expression.MapValue:\",\n \"def render_template(template, **template_values):\\n # retrieve the html template\\n t = jinja_environment.get_template(template)\\n\\n # render the html template with th given dictionary\\n return t.render(template_values)\",\n \"def test_format_map():\\n template_filelist = listdir(RTEMPLATE_PATH)\\n\\n R_files = []\\n json_files = []\\n for file in template_filelist:\\n if '.r' in file:\\n file = file.replace('.r', '')\\n R_files.append(file)\\n elif '.json' in file:\\n file = file.replace('.json', '')\\n json_files.append(file)\\n\\n\\n for template in R_files:\\n template_filepath = path.join(RTEMPLATE_PATH, template + '.r')\\n metadata_filepath = path.join(RTEMPLATE_PATH, template + '.json')\\n\\n with open(template_filepath, 'r') as t_fp:\\n r_text = t_fp.read()\\n\\n try:\\n with open(metadata_filepath, 'r') as m_fp:\\n metadata = json.load(m_fp)\\n except Exception as err:\\n print(metadata_filepath)\\n raise err\\n\\n format_dict = {}\\n for key in metadata['required_args']:\\n format_dict[key] = 'TEST'\\n\\n ## Actual test: apply `format_map` to r_text#\\n try:\\n r_text = r_text.format_map(format_dict)\\n except Exception as err:\\n print(template_filepath)\\n raise err\",\n \"def create_template_dict(name, cat, boilerplate_name=None, is_common=False):\\r\\n return {\\r\\n \\\"display_name\\\": name,\\r\\n \\\"category\\\": cat,\\r\\n \\\"boilerplate_name\\\": boilerplate_name,\\r\\n \\\"is_common\\\": is_common\\r\\n }\",\n \"def update_template(template, trial):\\n assert isinstance(template, dict) or isinstance(template, list)\\n items = template.items() if isinstance(template, dict) else enumerate(template)\\n\\n for key, value in items:\\n if isinstance(value, str):\\n if value in trial:\\n template[key] = trial[value]\\n elif isinstance(value, dict) or isinstance(value, list):\\n template[key] = ConfigGenerator.update_template(template[key], trial)\\n\\n return template\",\n \"def apply(self, args):\\n self._check_args(args)\\n\\n # check if the resource exists:\\n if args[0] in self._template.resources:\\n # if so, procedurally index the resource for the desired info:\\n res = self._template.resources[args[0]]\\n\\n if self._properties_field_name not in res:\\n raise FunctionApplicationException(\\n \\\"'%s': resource has no '%s' field: '%s'.\\\" %\\n (self.name, self._properties_field_name, res)\\n )\\n\\n indexes = [self._properties_field_name] + args[1:]\\n\\n for i in indexes:\\n res = self._get_item(res, i)\\n return res\\n else:\\n raise FunctionApplicationException(\\n \\\"%s: resource '%s' does not exist.\\\" % (\\n self.name, args[0]\\n )\\n )\",\n \"def make_links(self, name_url_pairs):\\n return {name : {\\\"href\\\" : self._render_link(url)}\\n for name, url in name_url_pairs.items()}\",\n \"def mapData(form, data, fromKeyFunc, toKeyFunc):\\n rv = {}\\n\\n def visitItem(node):\\n fromName = fromKeyFunc(node)\\n toName = toKeyFunc(node)\\n\\n value = data.get(fromName, MISSING)\\n if value != MISSING:\\n rv[toName] = value\\n\\n def visit(node):\\n if hasattr(node, 'items'):\\n for item in node.items:\\n visit(item)\\n else:\\n visitItem(node)\\n\\n visit(form)\\n return rv\",\n \"def map_dict(dictionary, transform):\\n return dict(transform(k, v) for k, v in dictionary.items())\",\n \"def add_asm_mappings(self, cs_pairs, log_pfx):\\n if cs_pairs is None or len(cs_pairs) < 1:\\n return\\n asm_v = self.asm_name()\\n for pair in cs_pairs:\\n higher, lower = pair.strip().split(\\\"-\\\")\\n sql = r'''insert ignore into meta (species_id, meta_key, meta_value) values\\n (1, \\\"assembly.mapping\\\", \\\"{_higher}:{_v}|{_lower}:{_v}\\\")\\n ;'''.format(_v = asm_v, _higher = higher, _lower = lower)\\n self.run_sql_req(sql, self.pjc(log_pfx, pair))\",\n \"def variableSubstitution(d):\\n variable = re.compile(r\\\"^(.*)\\\\$\\\\{(.*)\\\\}(.*)\\\")\\n\\n # translate the dictionary to lower-case keys:\\n dd = {k.lower():v for k,v in d.iteritems()}\\n maxIterations=4\\n \\n for i in range(maxIterations):\\n anyChanges=False\\n for k,v in dd.iteritems():\\n if not isinstance(v,str):\\n # Only operate on string-valued entries\\n continue\\n m = variable.match(v)\\n if not m:\\n continue\\n anyChanges = True\\n vout = str(v)\\n while m:\\n key = m.group(2).lower()\\n if key not in dd.keys():\\n print \\\"ERROR: variable substitution asks for nonexistent Attribute\\\", key, \\\"in\\\", v\\n sys.exit(1)\\n if key==k:\\n print \\\"ERROR: self-reference to Attribute\\\", key, \\\"in\\\", v\\n vv = dd[key]\\n if not isinstance(vv,str):\\n print \\\"ERROR: variable substitution using non-string-valued Attribute\\\",key\\n sys.exit(1)\\n vout = m.expand(r\\\"\\\\g<1>\\\"+vv+r\\\"\\\\g<3>\\\")\\n m = variable.match(vout)\\n dd[k] = vout\\n if not anyChanges:\\n break # Done\\n if i==maxIterations:\\n print \\\"ERROR: Too many iterations in variableSubstitution\\\"\\n sys.exit(1)\\n # restore case of original dictionary\\n for k in d.keys():\\n d[k] = dd[k.lower()]\\n return\",\n \"def replace_by_character_map(self, pattern_name: str, characters_map: dict):\\n if pattern_name not in self.patterns:\\n self.patterns[pattern_name] = generate_multiple_replace_pattern(characters_map)\\n\\n self.value = multiple_replace(\\n characters_map, self.value, self.patterns[pattern_name]\\n )\\n return self\",\n \"def op_replace(template_data, field_hierarchy_list, mappings):\\n op_trace = []\\n\\n def replace(json_obj, search_list):\\n if len(search_list) == 0:\\n return\\n\\n if isinstance(json_obj, dict):\\n for key, value in json_obj.items():\\n if key == search_list[0]:\\n if len(search_list) > 1:\\n replace(value, search_list[1:])\\n elif isinstance(value, Hashable):\\n new_val = mappings.get(value)\\n if new_val is not None:\\n op_trace.append('Template {name}, updated {path}: '\\n '{from_val} -> {to_val}'.format(name=template_data['templateName'],\\n path='/'.join(field_hierarchy_list),\\n from_val=value,\\n to_val=new_val))\\n json_obj[key] = new_val\\n else:\\n replace(value, search_list)\\n\\n elif isinstance(json_obj, list):\\n for elem in json_obj:\\n replace(elem, search_list)\\n\\n replace(template_data, field_hierarchy_list)\\n\\n return op_trace\",\n \"def parse_uinput_mapping(name, mapping):\\n axes, buttons, mouse, mouse_options = {}, {}, {}, {}\\n description = \\\"ds4drv custom mapping ({0})\\\".format(name)\\n\\n for key, attr in mapping.items():\\n key = key.upper()\\n if key.startswith(\\\"BTN_\\\") or key.startswith(\\\"KEY_\\\"):\\n buttons[key] = attr\\n elif key.startswith(\\\"ABS_\\\"):\\n axes[key] = attr\\n elif key.startswith(\\\"REL_\\\"):\\n mouse[key] = attr\\n elif key.startswith(\\\"MOUSE_\\\"):\\n mouse_options[key] = attr\\n\\n create_mapping(name, description, axes=axes, buttons=buttons,\\n mouse=mouse, mouse_options=mouse_options)\",\n \"def transform(self, tags, values_to_sub):\\n for tag, properties in tags.items():\\n val = values_to_sub.get(tag)\\n values_to_sub[tag] = self.transform_val(properties, val)\\n if properties.get(\\\"children\\\") is not None:\\n children = properties.get(\\\"children\\\")\\n for child_tag, child_properties in children.items():\\n child_val = self.transform_val(child_properties, val)\\n values_to_sub[child_tag] = child_val\\n return values_to_sub\",\n \"def get_replacement_dict(input_data: Dict[str, Any], mappings: bool = False) -> Dict[str, str]:\\n data = {}\\n for key in list(k for k in input_data.keys() if k != \\\"meta\\\"):\\n suit_tags, suit_key = get_suit_tags_and_key(key)\\n logging.debug(f\\\" --- key = {key}.\\\")\\n logging.debug(f\\\" --- suit_tags = {suit_tags}\\\")\\n logging.debug(f\\\" --- suit_key = {suit_key}\\\")\\n\\n for suit, suit_tag in zip(input_data[key], suit_tags):\\n logging.debug(f\\\" --- suit [name] = {suit['name']}\\\")\\n logging.debug(f\\\" --- suit_tag = {suit_tag}\\\")\\n tag_for_suit_name = get_tag_for_suit_name(suit, suit_tag)\\n data.update(tag_for_suit_name)\\n\\n card_tag = \\\"\\\"\\n for card in suit[suit_key]:\\n for tag, text_output in card.items():\\n if tag == \\\"value\\\":\\n continue\\n\\n full_tag = get_full_tag(suit_tag, card[\\\"value\\\"], tag)\\n\\n # Add a translation for \\\"Joker\\\"\\n if suit_tag == \\\"WC\\\" and tag == \\\"value\\\":\\n full_tag = \\\"${{{}}}\\\".format(\\\"_\\\".join([suit_tag, card_tag, tag]))\\n\\n # Mappings is sometimes loaded as a list. Convert to string\\n if convert_vars.making_template:\\n text1 = check_make_list_into_text(text_output, False)\\n data[text1] = full_tag\\n if mappings:\\n data[text1.replace(\\\", \\\", \\\",\\\")] = full_tag\\n text1 = check_make_list_into_text(text_output, True)\\n data[text1] = full_tag\\n else:\\n data[full_tag] = check_make_list_into_text(text_output, True)\\n if convert_vars.args.debug and not mappings:\\n debug_txt = \\\" --- Translation data showing First 4 (key: text):\\\\n* \\\"\\n debug_txt += \\\"\\\\n* \\\".join(l1 + \\\": \\\" + str(data[l1]) for l1 in list(data.keys())[:4])\\n logging.debug(debug_txt)\\n debug_txt = \\\" --- Translation data showing Last 4 (key: text):\\\\n* \\\"\\n debug_txt += \\\"\\\\n* \\\".join(l1 + \\\": \\\" + str(data[l1]) for l1 in list(data.keys())[-4:])\\n logging.debug(debug_txt)\\n return data\",\n \"def transliterate(re_maps, word):\\n for mapping in re_maps:\\n word = word_replace(mapping, word)\\n return word\",\n \"def preprocess_data_by_mapping(dicts_count, alias_mapping):\\n\\n new_mapping_dict = {}\\n for (key, value) in dicts_count.items():\\n\\n # Replace the key with lower string\\n new_key = unicode.lower(key)\\n\\n # Replace the key with object alias\\n if new_key in alias_mapping:\\n new_key = alias_mapping[new_key]\\n\\n # Check if the object key is already exists in the dict\\n if new_key in new_mapping_dict:\\n new_mapping_dict[new_key] += value\\n else:\\n new_mapping_dict[new_key] = value\\n\\n return new_mapping_dict\",\n \"def mapping_for_switch(mapping):\\n return {key[0]: value for key, value in mapping.items()}\",\n \"def mapList(results, key):\\n newResult = results.map(lambda x: ee.Dictionary(x).get(key))\\n return newResult\",\n \"def update_name(name, mapping):\\n m = street_type_re.search(name)\\n if m:\\n street_type = m.group()\\n for key, value in mapping.iteritems():\\n if street_type == key:\\n name = name.replace(key,value)\\n\\n return name\",\n \"def _unify(self, mapping, kwargs):\\n\\n if len(kwargs) <= 0:\\n return mapping\\n\\n data = dict(mapping)\\n data.update(kwargs)\\n return data\",\n \"def template_typedef(self, node, targs):\\n typedefmap = []\\n for typ in node.typedefs:\\n oldtyp = typ.typemap\\n typ.clone_post_class(targs)\\n typedefmap.append( (oldtyp, typ.typemap) )\\n node.typedef_map = typedefmap\\n\\n for function in node.functions:\\n for arg in function.ast.declarator.params:\\n ntypemap = arg.typemap\\n for typedef in typedefmap:\\n if ntypemap is typedef[0]:\\n arg.typemap = typedef[1]\\n break\",\n \"def replace_by_dict(source_string, mapping):\\n return_string = copy.copy(source_string)\\n for key, value in mapping.items():\\n return_string = return_string.replace(key, value)\\n return return_string\",\n \"def create_file_from_template(template_file, output_file, substitution_dict):\\n with open(template_file) as fl:\\n template = fl.read()\\n template = Template(template).safe_substitute(**substitution_dict)\\n\\n with open(output_file, 'w') as output_handle:\\n output_handle.write(template)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6347333","0.6122666","0.5724706","0.55872214","0.5524677","0.5517751","0.549768","0.5487899","0.53845775","0.530882","0.5244786","0.52417064","0.5239383","0.5211652","0.5148122","0.51388305","0.51228106","0.51005185","0.5080841","0.5061058","0.50332797","0.50193125","0.50037783","0.49808487","0.4956307","0.49523157","0.49461165","0.49386868","0.493462","0.49236318","0.490501","0.49033335","0.48998865","0.4886505","0.48822957","0.48819947","0.48758993","0.4869217","0.48599917","0.48505473","0.47899657","0.4784079","0.47710884","0.47429776","0.47124687","0.47004566","0.46931875","0.46916154","0.4690019","0.46865952","0.46826708","0.46759656","0.46742687","0.46670568","0.4651397","0.46432465","0.46405664","0.46312198","0.46252936","0.46236834","0.46198177","0.46175814","0.4614499","0.4614325","0.46138963","0.46136513","0.46094635","0.4596851","0.45895803","0.45859575","0.45766416","0.4576148","0.45758042","0.45742577","0.4567473","0.45649737","0.45619747","0.45559078","0.4553065","0.4545296","0.45439398","0.45439017","0.45407137","0.45372814","0.45330867","0.45302305","0.45250875","0.45172277","0.45078808","0.4502087","0.45020768","0.4484663","0.44755358","0.44734862","0.44720235","0.4464494","0.44609883","0.44561648","0.44492126","0.44490722"],"string":"[\n \"0.6347333\",\n \"0.6122666\",\n \"0.5724706\",\n \"0.55872214\",\n \"0.5524677\",\n \"0.5517751\",\n \"0.549768\",\n \"0.5487899\",\n \"0.53845775\",\n \"0.530882\",\n \"0.5244786\",\n \"0.52417064\",\n \"0.5239383\",\n \"0.5211652\",\n \"0.5148122\",\n \"0.51388305\",\n \"0.51228106\",\n \"0.51005185\",\n \"0.5080841\",\n \"0.5061058\",\n \"0.50332797\",\n \"0.50193125\",\n \"0.50037783\",\n \"0.49808487\",\n \"0.4956307\",\n \"0.49523157\",\n \"0.49461165\",\n \"0.49386868\",\n \"0.493462\",\n \"0.49236318\",\n \"0.490501\",\n \"0.49033335\",\n \"0.48998865\",\n \"0.4886505\",\n \"0.48822957\",\n \"0.48819947\",\n \"0.48758993\",\n \"0.4869217\",\n \"0.48599917\",\n \"0.48505473\",\n \"0.47899657\",\n \"0.4784079\",\n \"0.47710884\",\n \"0.47429776\",\n \"0.47124687\",\n \"0.47004566\",\n \"0.46931875\",\n \"0.46916154\",\n \"0.4690019\",\n \"0.46865952\",\n \"0.46826708\",\n \"0.46759656\",\n \"0.46742687\",\n \"0.46670568\",\n \"0.4651397\",\n \"0.46432465\",\n \"0.46405664\",\n \"0.46312198\",\n \"0.46252936\",\n \"0.46236834\",\n \"0.46198177\",\n \"0.46175814\",\n \"0.4614499\",\n \"0.4614325\",\n \"0.46138963\",\n \"0.46136513\",\n \"0.46094635\",\n \"0.4596851\",\n \"0.45895803\",\n \"0.45859575\",\n \"0.45766416\",\n \"0.4576148\",\n \"0.45758042\",\n \"0.45742577\",\n \"0.4567473\",\n \"0.45649737\",\n \"0.45619747\",\n \"0.45559078\",\n \"0.4553065\",\n \"0.4545296\",\n \"0.45439398\",\n \"0.45439017\",\n \"0.45407137\",\n \"0.45372814\",\n \"0.45330867\",\n \"0.45302305\",\n \"0.45250875\",\n \"0.45172277\",\n \"0.45078808\",\n \"0.4502087\",\n \"0.45020768\",\n \"0.4484663\",\n \"0.44755358\",\n \"0.44734862\",\n \"0.44720235\",\n \"0.4464494\",\n \"0.44609883\",\n \"0.44561648\",\n \"0.44492126\",\n \"0.44490722\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6634928"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81372,"cells":{"query":{"kind":"string","value":"Test case for create_nas_share_by_nas"},"document":{"kind":"string","value":"def test_create_nas_share_by_nas(self):\n pass"},"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_test_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_dashboards_v2_share(self):\n pass","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_create_cluster_network(self):\n pass","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def ensure_share(self, context, share, share_server=None):\n pass","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def share():\n return True","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_dashboards_v2_list_shares(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def test_kyc_put_legal_share_holder(self):\n pass","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def test_add_asset_share_feed(self):\n pass","def test_create_cloned_volume(self, mock_ghn):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10,\n 'provider_id': 'space_orig'}\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10}\n pid = self.driver.create_cloned_volume(clone, orig)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': 'clone1', 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'clone1'}\n self.assertDictMatch(expected_pid, pid)","def test_deploy_instance_with_new_network_and_metadata(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n instance_name = TEST_SERVER_PREFIX + \"_network_metadata_\" + suffix\n instance_meta = {\"test_item\": \"test_value\"}\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 251\n self.__deploy_instance_helper__(instance_name=instance_name,\n network_name=network_name,\n network_cidr=network_cidr,\n metadata=instance_meta)","def test_create_snapshot(self, mock_ghn):\n # Now snapshot the volume and check commands\n snapshot = {'volume_name': 'volume10',\n 'volume_id': 'xxx', 'display_name': 'snap10',\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\n 'volume': {'provider_id': 'space10'}}\n ret = self.driver.create_snapshot(snapshot)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': snapshot['display_name'], 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'snap10'}\n self.assertDictMatch(expected_pid, ret)","def test_post_creation(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)","def createCifsShare(self,sharename=\"opt\",sharepath=\"/opt\",rootpasswd=\"rooter\"):\n self.install(\"samba\")\n self.writeTemplate(\"/etc/samba/smb.conf\",q.system.fs.joinPaths(q.dirs.baseDir,\"utils\",\"defaults\",\"etc\",\"smb.conf\"),[[\"$sharename$\",sharename],[\"$sharepath$\",sharepath]])\n self.execute(\"echo -ne \\\"%s\\\\n%s\\\\n\\\" | smbpasswd -a -s root\" %(rootpasswd,rootpasswd))\n self.execute(\"/etc/init.d/samba restart\")","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_03_network_create(self):\n # Validate the following\n # 1. Create a project.\n # 2. Add virtual/direct network resource to the project. User shared\n # network resource for the project\n # 3. Verify any number of Project level Virtual/Direct networks can be\n # created and used for vm deployment within the project.\n # 4. Verify shared networks (zone and domain wide) from outside the\n # project can also be used in a project.\n\n # Create project as a domain admin\n project = Project.create(\n self.apiclient,\n self.services[\"project\"],\n account=self.account.name,\n domainid=self.account.domainid\n )\n # Cleanup created project at end of test\n self.cleanup.append(project)\n self.debug(\"Created project with domain admin with ID: %s\" %\n project.id)\n\n network_offerings = list_network_offerings(\n self.apiclient,\n projectid=project.id,\n supportedServices='SourceNat',\n type='isolated',\n state='Enabled'\n )\n self.assertEqual(\n isinstance(network_offerings, list),\n True,\n \"Check for the valid network offerings\"\n )\n network_offering = network_offerings[0]\n\n self.debug(\"creating a network with network offering ID: %s\" %\n network_offering.id)\n self.services[\"network\"][\"zoneid\"] = self.zone.id\n network = Network.create(\n self.apiclient,\n self.services[\"network\"],\n networkofferingid=network_offering.id,\n projectid=project.id\n )\n self.debug(\"Created network with ID: %s\" % network.id)\n networks = Network.list(\n self.apiclient,\n projectid=project.id,\n listall=True\n )\n self.assertEqual(\n isinstance(networks, list),\n True,\n \"Check for the valid network list response\"\n )\n\n self.debug(\"Deploying VM with network: %s\" % network.id)\n\n virtual_machine = VirtualMachine.create(\n self.apiclient,\n self.services[\"server\"],\n templateid=self.template.id,\n networkids=[str(network.id)],\n serviceofferingid=self.service_offering.id,\n projectid=project.id\n )\n self.debug(\"Deployed VM with ID: %s\" % virtual_machine.id)\n # Verify VM state\n self.assertEqual(\n virtual_machine.state,\n 'Running',\n \"Check VM state is Running or not\"\n )\n\n network_offerings = list_network_offerings(\n self.apiclient,\n state='Enabled',\n guestiptype='Shared',\n name='DefaultSharedNetworkOffering',\n displaytext='Offering for Shared networks'\n )\n self.assertEqual(\n isinstance(network_offerings, list),\n True,\n \"Check for the valid network offerings\"\n )\n network_offering = network_offerings[0]\n\n self.debug(\"creating a shared network in domain: %s\" %\n self.domain.id)\n\n # Getting physical network and free vlan in it\n physical_network, vlan = get_free_vlan(self.apiclient, self.zone.id)\n\n self.services[\"domain_network\"][\"vlan\"] = vlan\n self.services[\"domain_network\"][\"physicalnetworkid\"] = physical_network.id\n\n # Generating random subnet number for shared network creation\n shared_network_subnet_number = random.randrange(1,254)\n\n self.services[\"domain_network\"][\"gateway\"] = \"172.16.\"+str(shared_network_subnet_number)+\".1\"\n self.services[\"domain_network\"][\"startip\"] = \"172.16.\"+str(shared_network_subnet_number)+\".2\"\n self.services[\"domain_network\"][\"endip\"] = \"172.16.\"+str(shared_network_subnet_number)+\".20\"\n\n domain_network = Network.create(\n self.apiclient,\n self.services[\"domain_network\"],\n domainid=self.domain.id,\n networkofferingid=network_offering.id,\n zoneid=self.zone.id\n )\n self.cleanup.append(domain_network)\n self.debug(\"Created network with ID: %s\" % domain_network.id)\n\n virtual_machine = VirtualMachine.create(\n self.apiclient,\n self.services[\"server\"],\n templateid=self.template.id,\n networkids=[str(domain_network.id)],\n serviceofferingid=self.service_offering.id,\n projectid=project.id\n )\n self.debug(\"Deployed VM with ID: %s\" % virtual_machine.id)\n # Verify VM state\n self.assertEqual(\n virtual_machine.state,\n 'Running',\n \"Check VM state is Running or not\"\n )\n\n # Delete VM before network gets deleted in cleanup\n virtual_machine.delete(self.apiclient, expunge=True)\n return","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_create_net_namespace(self):\n pass","def test_create_network_and_subnet(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 254\n self.__create_network_and_subnet_test_helper__(network_name, network_cidr)","def __fake_data__(self):\n\n # Set directory for configuration files\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\n \n # Add some share's\n for i in xrange(3):\n share = NFSShare()\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\n self.shares[share.name] = share","def test_create_hyperflex_cluster_network_policy(self):\n pass","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_nova_create(tiny_cirros_server):\n\n assert ping_from_mnaio(tiny_cirros_server.accessIPv4)\n\n @pytest.mark.testinfra('ansible://' + tiny_cirros_server.accessIPv4)\n @pytest.mark.test_id('57f87c9e-3adb-11e9-b2ca-6a00035510c0')\n @pytest.mark.jira('ASC-31')\n def test_nova_create_connect(host):\n f = host.file('/etc/hosts')\n assert f.exists\n assert f.user == 'root'\n assert f.group == 'root'","def cli(env, identifier, account_id):\n\n image_mgr = SoftLayer.ImageManager(env.client)\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\n shared_image = image_mgr.share_image(image_id, account_id)\n\n if shared_image:\n env.fout(f\"Image template {identifier} was shared to account {account_id}.\")","def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\n if minimum_shares > 255 or nof_shares > 255:\n raise ValueError(\"Can only create up to 255 shares\")\n secret, shares = make_random_shares(\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\n )\n secret_bits = bits_in_number(secret)\n mnemonic_secret = number_to_mnemonic(secret)\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\n return mnemonic_secret, secret_bits, mnemonic_shares,","def test_networking_project_network_create(self):\n pass","def test_deploy_instance_with_new_network(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n instance_name = TEST_SERVER_PREFIX + \"_network_\" + suffix\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 252\n self.__deploy_instance_helper__(instance_name=instance_name,\n network_name=network_name,\n network_cidr=network_cidr)","def test_deploy_instance_with_new_network_and_keypair(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n instance_name = TEST_SERVER_PREFIX + \"_network_keypair_\" + suffix\n keypair_name = TEST_KEYPAIR_PREFIX + \"_\" + suffix\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 250\n self.__deploy_instance_helper__(instance_name=instance_name,\n network_name=network_name,\n network_cidr=network_cidr,\n keypair_name=keypair_name)","def test_create_network():\n _network = Network()","def create_share_from_snapshot(self, context, share, snapshot,\n share_server=None):\n raise NotImplementedError()","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def create_share_from_snapshot(\r\n self,\r\n context,\r\n share,\r\n snapshot,\r\n share_server=None):\r\n LOG.debug(\"Create share from snapshot.\")\r\n raise NotImplementedError()","def test_kyc_post_legal_share_holder(self):\n pass","def from_shares(share, precision=None, src=0, device=None):\n result = BinarySharedTensor(src=SENTINEL)\n share = share.to(device) if device is not None else share\n result.share = CUDALongTensor(share) if share.is_cuda else share\n result.encoder = FixedPointEncoder(precision_bits=precision)\n return result","def test_create_hyperflex_cluster_storage_policy(self):\n pass","def dvs_remote_sg_simple(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(3)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.show_step(4)\n _sg_rules = os_conn.neutron.list_security_group_rules()\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\n for rule in sg_rules:\n os_conn.neutron.delete_security_group_rule(rule['id'])\n\n self.show_step(5)\n self.show_step(6)\n for sg in [sg1, sg2]:\n for rule in [self.icmp, self.tcp]:\n rule[\"security_group_rule\"][\"security_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(rule)\n rule[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(rule)\n\n # Create access_point to instances from SG1 and SG2\n _, access_point_ip = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg1.name, sg2.name])\n\n self.show_step(7)\n istances_sg1 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg1.name])\n\n self.show_step(8)\n istances_sg2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg2.name])\n openstack.verify_instance_state(os_conn)\n\n # Get private ips of instances\n ips = {\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg1],\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg2]\n }\n\n self.show_step(9)\n self.show_step(10)\n for group in ips:\n ip_pair = dict.fromkeys(ips[group])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips[group] if key != value]\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, timeout=60 * 5)\n\n self.show_step(11)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = ips['SG2']\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_deploy_instance_with_new_network_and_sec_group(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n instance_name = TEST_SERVER_PREFIX + \"_network_sec_group_\" + suffix\n sec_group_name = TEST_SEC_GROUP_PREFIX + \"_\" + suffix\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 249\n self.__deploy_instance_helper__(instance_name=instance_name,\n network_name=network_name,\n network_cidr=network_cidr,\n sec_group_name=sec_group_name)","def test_deploy_instance_with_new_network_and_all_params(self):\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\n instance_name = TEST_SERVER_PREFIX + \"_network_all_params_\" + suffix\n instance_meta = {\"test_item\": \"test_value\"}\n keypair_name = TEST_KEYPAIR_PREFIX + \"_\" + suffix\n sec_group_name = TEST_SEC_GROUP_PREFIX + \"_\" + suffix\n network_name = TEST_NETWORK_PREFIX + \"_\" + suffix\n network_cidr = TEST_CIDR_PATTERN % 248\n self.__deploy_instance_helper__(instance_name=instance_name,\n network_name=network_name,\n network_cidr=network_cidr,\n metadata=instance_meta,\n keypair_name=keypair_name,\n sec_group_name=sec_group_name)","def create_net(self, net_name, shared=\"false\"):\n _url = \"http://\" + self.host_ip + \":9696/v2.0/networks.json\"\n _headers = {'Content-type': 'application/json',\n 'x-auth-token': self.project_info[\"token_project\"]}\n _net_info = {\"network\":\n {\"name\": net_name,\n \"shared\": shared,\n \"admin_state_up\": True}}\n _body = json.dumps(_net_info)\n\n response = self.request(\"POST\", _url, _headers, _body)\n if response is None:\n LOG_OBJ.error(\"No response from Server while creating network.\")\n return response\n\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\"Creation of network Failed with status %s \" %\n response.status)\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"Network is created successfully. Details : %s \" %\n output['network'])\n\n return output['network']['id']","def __init__(self, logger):\n self.share_names = []\n self.share_info = []\n self.logger = logger\n self.rz = zeroconf.Zeroconf()\n self.renamed = {}\n old_titles = self.scan()\n address = socket.inet_aton(config.get_ip())\n port = int(config.getPort())\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\n for section, settings in config.getShares():\n try:\n plugin = GetPlugin(settings['type'])\n ct = plugin.CONTENT_TYPE\n # if the plugin provides a test for validity use it otherwise assume valid\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\n logger.warning('share \"%s\" is invalid. It will be ignored (maybe check that path exists)', section)\n continue\n except Exception as e:\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\n continue\n\n if ct.startswith('x-container/'):\n if 'video' in ct:\n platform = PLATFORM_VIDEO\n else:\n platform = PLATFORM_MAIN\n\n logger.info('Registering: %s' % section)\n self.share_names.append(section)\n\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\n b'platform': bytes(platform, 'utf-8'),\n b'protocol': b'http',\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\n tt = ct.split('/')[1]\n title = section\n count = 1\n while title in old_titles:\n # debugging info while I try to figure out what this loop is for\n logger.info(\" title b4: {}\".format(title))\n count += 1\n title = '%s [%d]' % (section, count)\n self.renamed[section] = title\n # more debugging info\n logger.info(\" title after: {}\\n section: {}\".format(title, section))\n\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\n '%s._%s._tcp.local.' % (title, tt),\n port=port, addresses=[address], properties=desc)\n\n log_serviceinfo(self.logger, info)\n self.rz.register_service(info)\n self.share_info.append(info)","def test_clone_system(self):\n pass","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","def test_create_host_subnet(self):\n pass","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_instance_naming_creation(os_info):\n NEUTRON.list_security_groups = mock.MagicMock(\n return_value=iter([{\"security_groups\": []}]))\n NEUTRON.create_subnet = mock.MagicMock(\n return_value={\"subnet\": SUBNETS}\n )\n\n instance_names = os_info.nodes_names\n for i in range(len(instance_names)):\n assert instance_names[i] == 'test-node-{}'.format(i + 1)","def test_create_cluster_resource_quota(self):\n pass","def canShare(self):\n return False","def dvs_instances_batch_mix_sg(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network is created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n # Get max count of instances which we can create according to\n # resource limit\n vm_count = min(\n [os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']\n for h in os_conn.nova.hypervisors.list()])\n\n self.show_step(3)\n self.show_step(4)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.icmp[\"security_group_rule\"][\"security_group_id\"] = sg1.id\n self.icmp[\"security_group_rule\"][\"remote_group_id\"] = sg1.id\n self.icmp[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(self.icmp)\n self.icmp[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(self.icmp)\n\n for sg in [sg1, sg2]:\n self.tcp[\"security_group_rule\"][\"security_group_id\"] = sg.id\n self.tcp[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n self.tcp[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(self.tcp)\n self.tcp[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(self.tcp)\n\n # Add rules for ssh and ping\n os_conn.goodbye_security()\n _s_groups = os_conn.neutron.list_security_groups()['security_groups']\n _srv_tenant_id = os_conn.get_tenant(SERVTEST_TENANT).id\n default_sg = [sg for sg in _s_groups\n if sg['tenant_id'] == _srv_tenant_id and\n sg['name'] == 'default'][0]\n\n for step in (5, 9):\n self.show_step(step) # step 5, 9\n step += 1\n self.show_step(step) # step 6, 10\n step += 1\n\n openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=vm_count,\n security_groups=[sg1.name, sg2.name, default_sg['name']])\n openstack.verify_instance_state(os_conn)\n\n self.show_step(step) # step 7, 11\n step += 1\n\n instances = os_conn.nova.servers.list()\n fip = openstack.create_and_assign_floating_ips(os_conn, instances)\n ip_pair = dict.fromkeys(fip)\n for key in ip_pair:\n ip_pair[key] = [value for value in fip if key != value]\n openstack.check_connection_vms(ip_pair,\n timeout=60 * 5,\n interval=10)\n\n self.show_step(step) # step 8, 12\n step += 1\n\n for instance in instances:\n os_conn.nova.servers.delete(instance)\n logger.info(\"Check that instance was deleted.\")\n os_conn.verify_srv_deleted(instance)","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_create(self):\n isok, response = self.onep.create(\n self.cik,\n 'client',\n {\n 'writeinterval': 'inherit',\n 'name': 'testclient',\n 'visibility': 'parent',\n 'limits': {\n 'dataport': 'inherit',\n 'datarule': 'inherit',\n 'dispatch': 'inherit',\n 'disk': 'inherit',\n 'io': 'inherit',\n 'share': 'inherit',\n 'client': 'inherit',\n 'sms': 'inherit',\n 'sms_bucket': 'inherit',\n 'email': 'inherit',\n 'email_bucket': 'inherit',\n 'http': 'inherit',\n 'http_bucket': 'inherit',\n 'xmpp': 'inherit',\n 'xmpp_bucket': 'inherit'}\n })\n client_rid = response\n self.assertTrue(isok, 'client creation succeeded')\n self.assertTrue(re.match(\"^[0-9a-f]{40}$\", client_rid), 'rid is formatted correctly')\n\n isok, response = self.onep.info(\n self.cik,\n client_rid,\n {'key': True}\n )\n client_cik = response['key']\n\n # Add a dataport\n isok, response = self.onep.create(\n client_cik,\n 'dataport',\n {\n 'format': 'string',\n 'retention': {\n 'count': 'infinity',\n 'duration': 'infinity',\n },\n 'limits': {\n 'dataport': 'inherit',\n 'datarule': 'inherit',\n 'dispatch': 'inherit',\n 'disk': 'inherit',\n 'io': 'inherit',\n 'share': 'inherit',\n 'client': 'inherit',\n 'sms': 'inherit',\n 'sms_bucket': 'inherit',\n 'email': 'inherit',\n 'email_bucket': 'inherit',\n 'http': 'inherit',\n 'http_bucket': 'inherit',\n 'xmpp': 'inherit',\n 'xmpp_bucket': 'inherit',\n }\n }\n )\n dataport_rid = response\n self.assertTrue(isok, 'dataport creation succeeded')\n self.assertTrue(re.match(\"^[0-9a-f]{40}$\", dataport_rid), 'rid is formatted correctly')","def create_task(request):\n\n db_task = None\n params = request.POST.dict()\n params['owner'] = request.user\n slogger.glob.info(\"create task with params = {}\".format(params))\n try:\n db_task = task.create_empty(params)\n target_paths = []\n source_paths = []\n upload_dir = db_task.get_upload_dirname()\n share_root = settings.SHARE_ROOT\n if params['storage'] == 'share':\n data_list = request.POST.getlist('data')\n data_list.sort(key=len)\n for share_path in data_list:\n relpath = os.path.normpath(share_path).lstrip('/')\n if '..' in relpath.split(os.path.sep):\n raise Exception('Permission denied')\n abspath = os.path.abspath(os.path.join(share_root, relpath))\n if os.path.commonprefix([share_root, abspath]) != share_root:\n raise Exception('Bad file path on share: ' + abspath)\n source_paths.append(abspath)\n target_paths.append(os.path.join(upload_dir, relpath))\n else:\n data_list = request.FILES.getlist('data')\n\n if len(data_list) > settings.LOCAL_LOAD_MAX_FILES_COUNT:\n raise Exception('Too many files. Please use download via share')\n common_size = 0\n for f in data_list:\n common_size += f.size\n if common_size > settings.LOCAL_LOAD_MAX_FILES_SIZE:\n raise Exception('Too many size. Please use download via share')\n\n for data_file in data_list:\n source_paths.append(data_file.name)\n path = os.path.join(upload_dir, data_file.name)\n target_paths.append(path)\n with open(path, 'wb') as upload_file:\n for chunk in data_file.chunks():\n upload_file.write(chunk)\n\n params['SOURCE_PATHS'] = source_paths\n params['TARGET_PATHS'] = target_paths\n\n task.create(db_task.id, params)\n\n return JsonResponse({'tid': db_task.id})\n except Exception as exc:\n slogger.glob.error(\"cannot create task {}\".format(params['task_name']), exc_info=True)\n db_task.delete()\n return HttpResponseBadRequest(str(exc))\n\n return JsonResponse({'tid': db_task.id})","def create_shares(\n self,\n body, # type: \"models.MicrosoftGraphPrinterShare\"\n **kwargs # type: Any\n ):\n # type: (...) -> \"models.MicrosoftGraphPrinterShare\"\n cls = kwargs.pop('cls', None) # type: ClsType[\"models.MicrosoftGraphPrinterShare\"]\n error_map = {\n 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError\n }\n error_map.update(kwargs.pop('error_map', {}))\n content_type = kwargs.pop(\"content_type\", \"application/json\")\n accept = \"application/json\"\n\n # Construct URL\n url = self.create_shares.metadata['url'] # type: ignore\n\n # Construct parameters\n query_parameters = {} # type: Dict[str, Any]\n\n # Construct headers\n header_parameters = {} # type: Dict[str, Any]\n header_parameters['Content-Type'] = self._serialize.header(\"content_type\", content_type, 'str')\n header_parameters['Accept'] = self._serialize.header(\"accept\", accept, 'str')\n\n body_content_kwargs = {} # type: Dict[str, Any]\n body_content = self._serialize.body(body, 'MicrosoftGraphPrinterShare')\n body_content_kwargs['content'] = body_content\n request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs)\n pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)\n response = pipeline_response.http_response\n\n if response.status_code not in [201]:\n map_error(status_code=response.status_code, response=response, error_map=error_map)\n error = self._deserialize(models.OdataError, response)\n raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)\n\n deserialized = self._deserialize('MicrosoftGraphPrinterShare', pipeline_response)\n\n if cls:\n return cls(pipeline_response, deserialized, {})\n\n return deserialized","def share(observer, tid):\n try:\n manager = Actions()\n manager.share_task(observer, tid)\n except Exception as e:\n click.echo(e)","def process_outgoing_share(private_key: bytes, feed_id: bytes, name: str, password: str, package: bytes):\n if not package:\n raise SecretSharingError(\"No package given.\")\n return core.create_sub_event(t=core.E_TYPE.SHARE, sk=private_key, pk=feed_id, name=name, shard=package, password=password)","def create_host(self, conf, tenant_id, network_id, params):\n\t\tpass","def testNanotecSharedMemory():\n\t\n\tmemoryClient = NanotecSharedMemoryClient()\n\t\n\t\n\t\n\tserialPort1 = memoryClient.sendInstruction(\"NanotecMotor,/dev/ttyACM0,17\")\n\t\n\tID1 = memoryClient.sendInstruction(\"getID,\" + serialPort1)\n\tprint(\"ID1 (actual): \" + ID1 + \", expected: 17\")\n\tprint(\"\")\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tID1 = memoryClient.sendInstruction(\"getSerialPort,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"ID Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tposition = memoryClient.sendInstruction(\"getAbsoluteAngularPosition,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"Position Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\treturn","def create( # pylint: disable=inconsistent-return-statements\n self,\n timeout: Optional[int] = None,\n metadata: Optional[Dict[str, str]] = None,\n quota: Optional[int] = None,\n access_tier: Optional[Union[str, _models.ShareAccessTier]] = None,\n enabled_protocols: Optional[str] = None,\n root_squash: Optional[Union[str, _models.ShareRootSquash]] = None,\n **kwargs: Any\n ) -> None:\n error_map = {\n 401: ClientAuthenticationError,\n 404: ResourceNotFoundError,\n 409: ResourceExistsError,\n 304: ResourceNotModifiedError,\n }\n error_map.update(kwargs.pop(\"error_map\", {}) or {})\n\n _headers = kwargs.pop(\"headers\", {}) or {}\n _params = case_insensitive_dict(kwargs.pop(\"params\", {}) or {})\n\n restype: Literal[\"share\"] = kwargs.pop(\"restype\", _params.pop(\"restype\", \"share\"))\n cls: ClsType[None] = kwargs.pop(\"cls\", None)\n\n request = build_create_request(\n url=self._config.url,\n timeout=timeout,\n metadata=metadata,\n quota=quota,\n access_tier=access_tier,\n enabled_protocols=enabled_protocols,\n root_squash=root_squash,\n restype=restype,\n version=self._config.version,\n template_url=self.create.metadata[\"url\"],\n headers=_headers,\n params=_params,\n )\n request = _convert_request(request)\n request.url = self._client.format_url(request.url)\n\n _stream = False\n pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access\n request, stream=_stream, **kwargs\n )\n\n response = pipeline_response.http_response\n\n if response.status_code not in [201]:\n map_error(status_code=response.status_code, response=response, error_map=error_map)\n error = self._deserialize.failsafe_deserialize(_models.StorageError, pipeline_response)\n raise HttpResponseError(response=response, model=error)\n\n response_headers = {}\n response_headers[\"ETag\"] = self._deserialize(\"str\", response.headers.get(\"ETag\"))\n response_headers[\"Last-Modified\"] = self._deserialize(\"rfc-1123\", response.headers.get(\"Last-Modified\"))\n response_headers[\"x-ms-request-id\"] = self._deserialize(\"str\", response.headers.get(\"x-ms-request-id\"))\n response_headers[\"x-ms-version\"] = self._deserialize(\"str\", response.headers.get(\"x-ms-version\"))\n response_headers[\"Date\"] = self._deserialize(\"rfc-1123\", response.headers.get(\"Date\"))\n\n if cls:\n return cls(pipeline_response, None, response_headers)","def __deploy_instance_helper__(self, instance_name,\n network_name=None, network_cidr=None, is_network_new=True,\n keypair_name=None, is_keypair_new=True,\n sec_group_name=None, metadata=None):\n\n flavor_id = self.nova_operations.get_any_flavor_id()\n self.assertIsNotNone(flavor_id, \"Problems retrieving a flavor\")\n\n image_id = self.nova_operations.find_image_id_by_name(image_name=BASE_IMAGE_NAME)\n self.assertIsNotNone(image_id, \"Problems retrieving the image '{}'\".format(BASE_IMAGE_NAME))\n\n # instance prerequisites\n try:\n network_id_list = None\n if network_name:\n if is_network_new:\n # Create the given network\n cidr = network_cidr or TEST_CIDR_DEFAULT\n network = self.neutron_operations.create_network_and_subnet(network_name, cidr=cidr)\n self.test_world['networks'].append(network['id'])\n network_id_list = [{'net-id': network['id']}]\n else:\n # Look for the network id\n net_list = self.neutron_operations.find_networks(name=network_name)\n self.assertTrue(len(net_list) != 0, \"Required network '%s' could not be found\" % network_name)\n network_id_list = [{'net-id': net_list[0]['id']}]\n\n except NeutronClientException as e:\n self.logger.debug(\"Required network could not be created: %s\", e)\n self.fail(e)\n\n try:\n if keypair_name:\n if is_keypair_new:\n self.nova_operations.create_keypair(keypair_name)\n self.test_world['keypair_names'].append(keypair_name)\n else:\n keypair_found = self.nova_operations.find_keypair(name=keypair_name)\n self.assertIsNotNone(keypair_found, \"Required Keypair '%s' could not be found\" % keypair_name)\n except NovaClientException as e:\n self.logger.debug(\"Required keypair could not be created: %s\", e)\n self.fail(e)\n\n try:\n security_group_name_list = None\n if sec_group_name:\n sec_group_id = self.nova_operations.create_security_group_and_rules(sec_group_name)\n self.test_world['sec_groups'].append(sec_group_id)\n security_group_name_list = [sec_group_name]\n except NovaClientException as e:\n self.logger.debug(\"Required security group could not be created: %s\", e)\n self.fail(e)\n\n # create new instance\n try:\n server_data = self.nova_operations.launch_instance(instance_name=instance_name,\n flavor_id=flavor_id,\n image_id=image_id,\n metadata=metadata,\n keypair_name=keypair_name,\n security_group_name_list=security_group_name_list,\n network_id_list=network_id_list)\n except Forbidden as e:\n self.logger.debug(\"Quota exceeded when launching a new instance\")\n self.fail(e)\n except OverLimit as e:\n self.logger.debug(\"Not enough resources to launch new instance: %s\", e)\n self.fail(e)\n else:\n self.test_world['servers'].append(server_data['id'])\n\n # Wait for status=ACTIVE\n status, detail = self.nova_operations.wait_for_task_status(server_data['id'], 'ACTIVE')\n self.assertEqual(status, 'ACTIVE', \"{detail}. Current status is {status}\".format(detail=detail, status=status))\n\n return server_data['id']","def sendShare(self, program_counter, share):\n self.sendData(program_counter, SHARE, hex(share.value))"],"string":"[\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def share():\\n return True\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_create_cloned_volume(self, mock_ghn):\\n ctxt = context.get_admin_context()\\n extra_specs = {}\\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10,\\n 'provider_id': 'space_orig'}\\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10}\\n pid = self.driver.create_cloned_volume(clone, orig)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': 'clone1', 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'clone1'}\\n self.assertDictMatch(expected_pid, pid)\",\n \"def test_deploy_instance_with_new_network_and_metadata(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n instance_name = TEST_SERVER_PREFIX + \\\"_network_metadata_\\\" + suffix\\n instance_meta = {\\\"test_item\\\": \\\"test_value\\\"}\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 251\\n self.__deploy_instance_helper__(instance_name=instance_name,\\n network_name=network_name,\\n network_cidr=network_cidr,\\n metadata=instance_meta)\",\n \"def test_create_snapshot(self, mock_ghn):\\n # Now snapshot the volume and check commands\\n snapshot = {'volume_name': 'volume10',\\n 'volume_id': 'xxx', 'display_name': 'snap10',\\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\\n 'volume': {'provider_id': 'space10'}}\\n ret = self.driver.create_snapshot(snapshot)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': snapshot['display_name'], 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'snap10'}\\n self.assertDictMatch(expected_pid, ret)\",\n \"def test_post_creation(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\",\n \"def createCifsShare(self,sharename=\\\"opt\\\",sharepath=\\\"/opt\\\",rootpasswd=\\\"rooter\\\"):\\n self.install(\\\"samba\\\")\\n self.writeTemplate(\\\"/etc/samba/smb.conf\\\",q.system.fs.joinPaths(q.dirs.baseDir,\\\"utils\\\",\\\"defaults\\\",\\\"etc\\\",\\\"smb.conf\\\"),[[\\\"$sharename$\\\",sharename],[\\\"$sharepath$\\\",sharepath]])\\n self.execute(\\\"echo -ne \\\\\\\"%s\\\\\\\\n%s\\\\\\\\n\\\\\\\" | smbpasswd -a -s root\\\" %(rootpasswd,rootpasswd))\\n self.execute(\\\"/etc/init.d/samba restart\\\")\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_03_network_create(self):\\n # Validate the following\\n # 1. Create a project.\\n # 2. Add virtual/direct network resource to the project. User shared\\n # network resource for the project\\n # 3. Verify any number of Project level Virtual/Direct networks can be\\n # created and used for vm deployment within the project.\\n # 4. Verify shared networks (zone and domain wide) from outside the\\n # project can also be used in a project.\\n\\n # Create project as a domain admin\\n project = Project.create(\\n self.apiclient,\\n self.services[\\\"project\\\"],\\n account=self.account.name,\\n domainid=self.account.domainid\\n )\\n # Cleanup created project at end of test\\n self.cleanup.append(project)\\n self.debug(\\\"Created project with domain admin with ID: %s\\\" %\\n project.id)\\n\\n network_offerings = list_network_offerings(\\n self.apiclient,\\n projectid=project.id,\\n supportedServices='SourceNat',\\n type='isolated',\\n state='Enabled'\\n )\\n self.assertEqual(\\n isinstance(network_offerings, list),\\n True,\\n \\\"Check for the valid network offerings\\\"\\n )\\n network_offering = network_offerings[0]\\n\\n self.debug(\\\"creating a network with network offering ID: %s\\\" %\\n network_offering.id)\\n self.services[\\\"network\\\"][\\\"zoneid\\\"] = self.zone.id\\n network = Network.create(\\n self.apiclient,\\n self.services[\\\"network\\\"],\\n networkofferingid=network_offering.id,\\n projectid=project.id\\n )\\n self.debug(\\\"Created network with ID: %s\\\" % network.id)\\n networks = Network.list(\\n self.apiclient,\\n projectid=project.id,\\n listall=True\\n )\\n self.assertEqual(\\n isinstance(networks, list),\\n True,\\n \\\"Check for the valid network list response\\\"\\n )\\n\\n self.debug(\\\"Deploying VM with network: %s\\\" % network.id)\\n\\n virtual_machine = VirtualMachine.create(\\n self.apiclient,\\n self.services[\\\"server\\\"],\\n templateid=self.template.id,\\n networkids=[str(network.id)],\\n serviceofferingid=self.service_offering.id,\\n projectid=project.id\\n )\\n self.debug(\\\"Deployed VM with ID: %s\\\" % virtual_machine.id)\\n # Verify VM state\\n self.assertEqual(\\n virtual_machine.state,\\n 'Running',\\n \\\"Check VM state is Running or not\\\"\\n )\\n\\n network_offerings = list_network_offerings(\\n self.apiclient,\\n state='Enabled',\\n guestiptype='Shared',\\n name='DefaultSharedNetworkOffering',\\n displaytext='Offering for Shared networks'\\n )\\n self.assertEqual(\\n isinstance(network_offerings, list),\\n True,\\n \\\"Check for the valid network offerings\\\"\\n )\\n network_offering = network_offerings[0]\\n\\n self.debug(\\\"creating a shared network in domain: %s\\\" %\\n self.domain.id)\\n\\n # Getting physical network and free vlan in it\\n physical_network, vlan = get_free_vlan(self.apiclient, self.zone.id)\\n\\n self.services[\\\"domain_network\\\"][\\\"vlan\\\"] = vlan\\n self.services[\\\"domain_network\\\"][\\\"physicalnetworkid\\\"] = physical_network.id\\n\\n # Generating random subnet number for shared network creation\\n shared_network_subnet_number = random.randrange(1,254)\\n\\n self.services[\\\"domain_network\\\"][\\\"gateway\\\"] = \\\"172.16.\\\"+str(shared_network_subnet_number)+\\\".1\\\"\\n self.services[\\\"domain_network\\\"][\\\"startip\\\"] = \\\"172.16.\\\"+str(shared_network_subnet_number)+\\\".2\\\"\\n self.services[\\\"domain_network\\\"][\\\"endip\\\"] = \\\"172.16.\\\"+str(shared_network_subnet_number)+\\\".20\\\"\\n\\n domain_network = Network.create(\\n self.apiclient,\\n self.services[\\\"domain_network\\\"],\\n domainid=self.domain.id,\\n networkofferingid=network_offering.id,\\n zoneid=self.zone.id\\n )\\n self.cleanup.append(domain_network)\\n self.debug(\\\"Created network with ID: %s\\\" % domain_network.id)\\n\\n virtual_machine = VirtualMachine.create(\\n self.apiclient,\\n self.services[\\\"server\\\"],\\n templateid=self.template.id,\\n networkids=[str(domain_network.id)],\\n serviceofferingid=self.service_offering.id,\\n projectid=project.id\\n )\\n self.debug(\\\"Deployed VM with ID: %s\\\" % virtual_machine.id)\\n # Verify VM state\\n self.assertEqual(\\n virtual_machine.state,\\n 'Running',\\n \\\"Check VM state is Running or not\\\"\\n )\\n\\n # Delete VM before network gets deleted in cleanup\\n virtual_machine.delete(self.apiclient, expunge=True)\\n return\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_create_net_namespace(self):\\n pass\",\n \"def test_create_network_and_subnet(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 254\\n self.__create_network_and_subnet_test_helper__(network_name, network_cidr)\",\n \"def __fake_data__(self):\\n\\n # Set directory for configuration files\\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\\n \\n # Add some share's\\n for i in xrange(3):\\n share = NFSShare()\\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\\n self.shares[share.name] = share\",\n \"def test_create_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_nova_create(tiny_cirros_server):\\n\\n assert ping_from_mnaio(tiny_cirros_server.accessIPv4)\\n\\n @pytest.mark.testinfra('ansible://' + tiny_cirros_server.accessIPv4)\\n @pytest.mark.test_id('57f87c9e-3adb-11e9-b2ca-6a00035510c0')\\n @pytest.mark.jira('ASC-31')\\n def test_nova_create_connect(host):\\n f = host.file('/etc/hosts')\\n assert f.exists\\n assert f.user == 'root'\\n assert f.group == 'root'\",\n \"def cli(env, identifier, account_id):\\n\\n image_mgr = SoftLayer.ImageManager(env.client)\\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\\n shared_image = image_mgr.share_image(image_id, account_id)\\n\\n if shared_image:\\n env.fout(f\\\"Image template {identifier} was shared to account {account_id}.\\\")\",\n \"def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\\n if minimum_shares > 255 or nof_shares > 255:\\n raise ValueError(\\\"Can only create up to 255 shares\\\")\\n secret, shares = make_random_shares(\\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\\n )\\n secret_bits = bits_in_number(secret)\\n mnemonic_secret = number_to_mnemonic(secret)\\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\\n return mnemonic_secret, secret_bits, mnemonic_shares,\",\n \"def test_networking_project_network_create(self):\\n pass\",\n \"def test_deploy_instance_with_new_network(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n instance_name = TEST_SERVER_PREFIX + \\\"_network_\\\" + suffix\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 252\\n self.__deploy_instance_helper__(instance_name=instance_name,\\n network_name=network_name,\\n network_cidr=network_cidr)\",\n \"def test_deploy_instance_with_new_network_and_keypair(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n instance_name = TEST_SERVER_PREFIX + \\\"_network_keypair_\\\" + suffix\\n keypair_name = TEST_KEYPAIR_PREFIX + \\\"_\\\" + suffix\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 250\\n self.__deploy_instance_helper__(instance_name=instance_name,\\n network_name=network_name,\\n network_cidr=network_cidr,\\n keypair_name=keypair_name)\",\n \"def test_create_network():\\n _network = Network()\",\n \"def create_share_from_snapshot(self, context, share, snapshot,\\n share_server=None):\\n raise NotImplementedError()\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def create_share_from_snapshot(\\r\\n self,\\r\\n context,\\r\\n share,\\r\\n snapshot,\\r\\n share_server=None):\\r\\n LOG.debug(\\\"Create share from snapshot.\\\")\\r\\n raise NotImplementedError()\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def from_shares(share, precision=None, src=0, device=None):\\n result = BinarySharedTensor(src=SENTINEL)\\n share = share.to(device) if device is not None else share\\n result.share = CUDALongTensor(share) if share.is_cuda else share\\n result.encoder = FixedPointEncoder(precision_bits=precision)\\n return result\",\n \"def test_create_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def dvs_remote_sg_simple(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(3)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.show_step(4)\\n _sg_rules = os_conn.neutron.list_security_group_rules()\\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\\n for rule in sg_rules:\\n os_conn.neutron.delete_security_group_rule(rule['id'])\\n\\n self.show_step(5)\\n self.show_step(6)\\n for sg in [sg1, sg2]:\\n for rule in [self.icmp, self.tcp]:\\n rule[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n\\n # Create access_point to instances from SG1 and SG2\\n _, access_point_ip = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg1.name, sg2.name])\\n\\n self.show_step(7)\\n istances_sg1 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg1.name])\\n\\n self.show_step(8)\\n istances_sg2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg2.name])\\n openstack.verify_instance_state(os_conn)\\n\\n # Get private ips of instances\\n ips = {\\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg1],\\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg2]\\n }\\n\\n self.show_step(9)\\n self.show_step(10)\\n for group in ips:\\n ip_pair = dict.fromkeys(ips[group])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips[group] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, timeout=60 * 5)\\n\\n self.show_step(11)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = ips['SG2']\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_deploy_instance_with_new_network_and_sec_group(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n instance_name = TEST_SERVER_PREFIX + \\\"_network_sec_group_\\\" + suffix\\n sec_group_name = TEST_SEC_GROUP_PREFIX + \\\"_\\\" + suffix\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 249\\n self.__deploy_instance_helper__(instance_name=instance_name,\\n network_name=network_name,\\n network_cidr=network_cidr,\\n sec_group_name=sec_group_name)\",\n \"def test_deploy_instance_with_new_network_and_all_params(self):\\n suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')\\n instance_name = TEST_SERVER_PREFIX + \\\"_network_all_params_\\\" + suffix\\n instance_meta = {\\\"test_item\\\": \\\"test_value\\\"}\\n keypair_name = TEST_KEYPAIR_PREFIX + \\\"_\\\" + suffix\\n sec_group_name = TEST_SEC_GROUP_PREFIX + \\\"_\\\" + suffix\\n network_name = TEST_NETWORK_PREFIX + \\\"_\\\" + suffix\\n network_cidr = TEST_CIDR_PATTERN % 248\\n self.__deploy_instance_helper__(instance_name=instance_name,\\n network_name=network_name,\\n network_cidr=network_cidr,\\n metadata=instance_meta,\\n keypair_name=keypair_name,\\n sec_group_name=sec_group_name)\",\n \"def create_net(self, net_name, shared=\\\"false\\\"):\\n _url = \\\"http://\\\" + self.host_ip + \\\":9696/v2.0/networks.json\\\"\\n _headers = {'Content-type': 'application/json',\\n 'x-auth-token': self.project_info[\\\"token_project\\\"]}\\n _net_info = {\\\"network\\\":\\n {\\\"name\\\": net_name,\\n \\\"shared\\\": shared,\\n \\\"admin_state_up\\\": True}}\\n _body = json.dumps(_net_info)\\n\\n response = self.request(\\\"POST\\\", _url, _headers, _body)\\n if response is None:\\n LOG_OBJ.error(\\\"No response from Server while creating network.\\\")\\n return response\\n\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\\"Creation of network Failed with status %s \\\" %\\n response.status)\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"Network is created successfully. Details : %s \\\" %\\n output['network'])\\n\\n return output['network']['id']\",\n \"def __init__(self, logger):\\n self.share_names = []\\n self.share_info = []\\n self.logger = logger\\n self.rz = zeroconf.Zeroconf()\\n self.renamed = {}\\n old_titles = self.scan()\\n address = socket.inet_aton(config.get_ip())\\n port = int(config.getPort())\\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\\n for section, settings in config.getShares():\\n try:\\n plugin = GetPlugin(settings['type'])\\n ct = plugin.CONTENT_TYPE\\n # if the plugin provides a test for validity use it otherwise assume valid\\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\\n logger.warning('share \\\"%s\\\" is invalid. It will be ignored (maybe check that path exists)', section)\\n continue\\n except Exception as e:\\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\\n continue\\n\\n if ct.startswith('x-container/'):\\n if 'video' in ct:\\n platform = PLATFORM_VIDEO\\n else:\\n platform = PLATFORM_MAIN\\n\\n logger.info('Registering: %s' % section)\\n self.share_names.append(section)\\n\\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\\n b'platform': bytes(platform, 'utf-8'),\\n b'protocol': b'http',\\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\\n tt = ct.split('/')[1]\\n title = section\\n count = 1\\n while title in old_titles:\\n # debugging info while I try to figure out what this loop is for\\n logger.info(\\\" title b4: {}\\\".format(title))\\n count += 1\\n title = '%s [%d]' % (section, count)\\n self.renamed[section] = title\\n # more debugging info\\n logger.info(\\\" title after: {}\\\\n section: {}\\\".format(title, section))\\n\\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\\n '%s._%s._tcp.local.' % (title, tt),\\n port=port, addresses=[address], properties=desc)\\n\\n log_serviceinfo(self.logger, info)\\n self.rz.register_service(info)\\n self.share_info.append(info)\",\n \"def test_clone_system(self):\\n pass\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"def test_create_host_subnet(self):\\n pass\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_instance_naming_creation(os_info):\\n NEUTRON.list_security_groups = mock.MagicMock(\\n return_value=iter([{\\\"security_groups\\\": []}]))\\n NEUTRON.create_subnet = mock.MagicMock(\\n return_value={\\\"subnet\\\": SUBNETS}\\n )\\n\\n instance_names = os_info.nodes_names\\n for i in range(len(instance_names)):\\n assert instance_names[i] == 'test-node-{}'.format(i + 1)\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def canShare(self):\\n return False\",\n \"def dvs_instances_batch_mix_sg(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network is created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n # Get max count of instances which we can create according to\\n # resource limit\\n vm_count = min(\\n [os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']\\n for h in os_conn.nova.hypervisors.list()])\\n\\n self.show_step(3)\\n self.show_step(4)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.icmp[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg1.id\\n self.icmp[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg1.id\\n self.icmp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(self.icmp)\\n self.icmp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(self.icmp)\\n\\n for sg in [sg1, sg2]:\\n self.tcp[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n self.tcp[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n self.tcp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n self.tcp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n\\n # Add rules for ssh and ping\\n os_conn.goodbye_security()\\n _s_groups = os_conn.neutron.list_security_groups()['security_groups']\\n _srv_tenant_id = os_conn.get_tenant(SERVTEST_TENANT).id\\n default_sg = [sg for sg in _s_groups\\n if sg['tenant_id'] == _srv_tenant_id and\\n sg['name'] == 'default'][0]\\n\\n for step in (5, 9):\\n self.show_step(step) # step 5, 9\\n step += 1\\n self.show_step(step) # step 6, 10\\n step += 1\\n\\n openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=vm_count,\\n security_groups=[sg1.name, sg2.name, default_sg['name']])\\n openstack.verify_instance_state(os_conn)\\n\\n self.show_step(step) # step 7, 11\\n step += 1\\n\\n instances = os_conn.nova.servers.list()\\n fip = openstack.create_and_assign_floating_ips(os_conn, instances)\\n ip_pair = dict.fromkeys(fip)\\n for key in ip_pair:\\n ip_pair[key] = [value for value in fip if key != value]\\n openstack.check_connection_vms(ip_pair,\\n timeout=60 * 5,\\n interval=10)\\n\\n self.show_step(step) # step 8, 12\\n step += 1\\n\\n for instance in instances:\\n os_conn.nova.servers.delete(instance)\\n logger.info(\\\"Check that instance was deleted.\\\")\\n os_conn.verify_srv_deleted(instance)\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_create(self):\\n isok, response = self.onep.create(\\n self.cik,\\n 'client',\\n {\\n 'writeinterval': 'inherit',\\n 'name': 'testclient',\\n 'visibility': 'parent',\\n 'limits': {\\n 'dataport': 'inherit',\\n 'datarule': 'inherit',\\n 'dispatch': 'inherit',\\n 'disk': 'inherit',\\n 'io': 'inherit',\\n 'share': 'inherit',\\n 'client': 'inherit',\\n 'sms': 'inherit',\\n 'sms_bucket': 'inherit',\\n 'email': 'inherit',\\n 'email_bucket': 'inherit',\\n 'http': 'inherit',\\n 'http_bucket': 'inherit',\\n 'xmpp': 'inherit',\\n 'xmpp_bucket': 'inherit'}\\n })\\n client_rid = response\\n self.assertTrue(isok, 'client creation succeeded')\\n self.assertTrue(re.match(\\\"^[0-9a-f]{40}$\\\", client_rid), 'rid is formatted correctly')\\n\\n isok, response = self.onep.info(\\n self.cik,\\n client_rid,\\n {'key': True}\\n )\\n client_cik = response['key']\\n\\n # Add a dataport\\n isok, response = self.onep.create(\\n client_cik,\\n 'dataport',\\n {\\n 'format': 'string',\\n 'retention': {\\n 'count': 'infinity',\\n 'duration': 'infinity',\\n },\\n 'limits': {\\n 'dataport': 'inherit',\\n 'datarule': 'inherit',\\n 'dispatch': 'inherit',\\n 'disk': 'inherit',\\n 'io': 'inherit',\\n 'share': 'inherit',\\n 'client': 'inherit',\\n 'sms': 'inherit',\\n 'sms_bucket': 'inherit',\\n 'email': 'inherit',\\n 'email_bucket': 'inherit',\\n 'http': 'inherit',\\n 'http_bucket': 'inherit',\\n 'xmpp': 'inherit',\\n 'xmpp_bucket': 'inherit',\\n }\\n }\\n )\\n dataport_rid = response\\n self.assertTrue(isok, 'dataport creation succeeded')\\n self.assertTrue(re.match(\\\"^[0-9a-f]{40}$\\\", dataport_rid), 'rid is formatted correctly')\",\n \"def create_task(request):\\n\\n db_task = None\\n params = request.POST.dict()\\n params['owner'] = request.user\\n slogger.glob.info(\\\"create task with params = {}\\\".format(params))\\n try:\\n db_task = task.create_empty(params)\\n target_paths = []\\n source_paths = []\\n upload_dir = db_task.get_upload_dirname()\\n share_root = settings.SHARE_ROOT\\n if params['storage'] == 'share':\\n data_list = request.POST.getlist('data')\\n data_list.sort(key=len)\\n for share_path in data_list:\\n relpath = os.path.normpath(share_path).lstrip('/')\\n if '..' in relpath.split(os.path.sep):\\n raise Exception('Permission denied')\\n abspath = os.path.abspath(os.path.join(share_root, relpath))\\n if os.path.commonprefix([share_root, abspath]) != share_root:\\n raise Exception('Bad file path on share: ' + abspath)\\n source_paths.append(abspath)\\n target_paths.append(os.path.join(upload_dir, relpath))\\n else:\\n data_list = request.FILES.getlist('data')\\n\\n if len(data_list) > settings.LOCAL_LOAD_MAX_FILES_COUNT:\\n raise Exception('Too many files. Please use download via share')\\n common_size = 0\\n for f in data_list:\\n common_size += f.size\\n if common_size > settings.LOCAL_LOAD_MAX_FILES_SIZE:\\n raise Exception('Too many size. Please use download via share')\\n\\n for data_file in data_list:\\n source_paths.append(data_file.name)\\n path = os.path.join(upload_dir, data_file.name)\\n target_paths.append(path)\\n with open(path, 'wb') as upload_file:\\n for chunk in data_file.chunks():\\n upload_file.write(chunk)\\n\\n params['SOURCE_PATHS'] = source_paths\\n params['TARGET_PATHS'] = target_paths\\n\\n task.create(db_task.id, params)\\n\\n return JsonResponse({'tid': db_task.id})\\n except Exception as exc:\\n slogger.glob.error(\\\"cannot create task {}\\\".format(params['task_name']), exc_info=True)\\n db_task.delete()\\n return HttpResponseBadRequest(str(exc))\\n\\n return JsonResponse({'tid': db_task.id})\",\n \"def create_shares(\\n self,\\n body, # type: \\\"models.MicrosoftGraphPrinterShare\\\"\\n **kwargs # type: Any\\n ):\\n # type: (...) -> \\\"models.MicrosoftGraphPrinterShare\\\"\\n cls = kwargs.pop('cls', None) # type: ClsType[\\\"models.MicrosoftGraphPrinterShare\\\"]\\n error_map = {\\n 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError\\n }\\n error_map.update(kwargs.pop('error_map', {}))\\n content_type = kwargs.pop(\\\"content_type\\\", \\\"application/json\\\")\\n accept = \\\"application/json\\\"\\n\\n # Construct URL\\n url = self.create_shares.metadata['url'] # type: ignore\\n\\n # Construct parameters\\n query_parameters = {} # type: Dict[str, Any]\\n\\n # Construct headers\\n header_parameters = {} # type: Dict[str, Any]\\n header_parameters['Content-Type'] = self._serialize.header(\\\"content_type\\\", content_type, 'str')\\n header_parameters['Accept'] = self._serialize.header(\\\"accept\\\", accept, 'str')\\n\\n body_content_kwargs = {} # type: Dict[str, Any]\\n body_content = self._serialize.body(body, 'MicrosoftGraphPrinterShare')\\n body_content_kwargs['content'] = body_content\\n request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs)\\n pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)\\n response = pipeline_response.http_response\\n\\n if response.status_code not in [201]:\\n map_error(status_code=response.status_code, response=response, error_map=error_map)\\n error = self._deserialize(models.OdataError, response)\\n raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)\\n\\n deserialized = self._deserialize('MicrosoftGraphPrinterShare', pipeline_response)\\n\\n if cls:\\n return cls(pipeline_response, deserialized, {})\\n\\n return deserialized\",\n \"def share(observer, tid):\\n try:\\n manager = Actions()\\n manager.share_task(observer, tid)\\n except Exception as e:\\n click.echo(e)\",\n \"def process_outgoing_share(private_key: bytes, feed_id: bytes, name: str, password: str, package: bytes):\\n if not package:\\n raise SecretSharingError(\\\"No package given.\\\")\\n return core.create_sub_event(t=core.E_TYPE.SHARE, sk=private_key, pk=feed_id, name=name, shard=package, password=password)\",\n \"def create_host(self, conf, tenant_id, network_id, params):\\n\\t\\tpass\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\",\n \"def create( # pylint: disable=inconsistent-return-statements\\n self,\\n timeout: Optional[int] = None,\\n metadata: Optional[Dict[str, str]] = None,\\n quota: Optional[int] = None,\\n access_tier: Optional[Union[str, _models.ShareAccessTier]] = None,\\n enabled_protocols: Optional[str] = None,\\n root_squash: Optional[Union[str, _models.ShareRootSquash]] = None,\\n **kwargs: Any\\n ) -> None:\\n error_map = {\\n 401: ClientAuthenticationError,\\n 404: ResourceNotFoundError,\\n 409: ResourceExistsError,\\n 304: ResourceNotModifiedError,\\n }\\n error_map.update(kwargs.pop(\\\"error_map\\\", {}) or {})\\n\\n _headers = kwargs.pop(\\\"headers\\\", {}) or {}\\n _params = case_insensitive_dict(kwargs.pop(\\\"params\\\", {}) or {})\\n\\n restype: Literal[\\\"share\\\"] = kwargs.pop(\\\"restype\\\", _params.pop(\\\"restype\\\", \\\"share\\\"))\\n cls: ClsType[None] = kwargs.pop(\\\"cls\\\", None)\\n\\n request = build_create_request(\\n url=self._config.url,\\n timeout=timeout,\\n metadata=metadata,\\n quota=quota,\\n access_tier=access_tier,\\n enabled_protocols=enabled_protocols,\\n root_squash=root_squash,\\n restype=restype,\\n version=self._config.version,\\n template_url=self.create.metadata[\\\"url\\\"],\\n headers=_headers,\\n params=_params,\\n )\\n request = _convert_request(request)\\n request.url = self._client.format_url(request.url)\\n\\n _stream = False\\n pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access\\n request, stream=_stream, **kwargs\\n )\\n\\n response = pipeline_response.http_response\\n\\n if response.status_code not in [201]:\\n map_error(status_code=response.status_code, response=response, error_map=error_map)\\n error = self._deserialize.failsafe_deserialize(_models.StorageError, pipeline_response)\\n raise HttpResponseError(response=response, model=error)\\n\\n response_headers = {}\\n response_headers[\\\"ETag\\\"] = self._deserialize(\\\"str\\\", response.headers.get(\\\"ETag\\\"))\\n response_headers[\\\"Last-Modified\\\"] = self._deserialize(\\\"rfc-1123\\\", response.headers.get(\\\"Last-Modified\\\"))\\n response_headers[\\\"x-ms-request-id\\\"] = self._deserialize(\\\"str\\\", response.headers.get(\\\"x-ms-request-id\\\"))\\n response_headers[\\\"x-ms-version\\\"] = self._deserialize(\\\"str\\\", response.headers.get(\\\"x-ms-version\\\"))\\n response_headers[\\\"Date\\\"] = self._deserialize(\\\"rfc-1123\\\", response.headers.get(\\\"Date\\\"))\\n\\n if cls:\\n return cls(pipeline_response, None, response_headers)\",\n \"def __deploy_instance_helper__(self, instance_name,\\n network_name=None, network_cidr=None, is_network_new=True,\\n keypair_name=None, is_keypair_new=True,\\n sec_group_name=None, metadata=None):\\n\\n flavor_id = self.nova_operations.get_any_flavor_id()\\n self.assertIsNotNone(flavor_id, \\\"Problems retrieving a flavor\\\")\\n\\n image_id = self.nova_operations.find_image_id_by_name(image_name=BASE_IMAGE_NAME)\\n self.assertIsNotNone(image_id, \\\"Problems retrieving the image '{}'\\\".format(BASE_IMAGE_NAME))\\n\\n # instance prerequisites\\n try:\\n network_id_list = None\\n if network_name:\\n if is_network_new:\\n # Create the given network\\n cidr = network_cidr or TEST_CIDR_DEFAULT\\n network = self.neutron_operations.create_network_and_subnet(network_name, cidr=cidr)\\n self.test_world['networks'].append(network['id'])\\n network_id_list = [{'net-id': network['id']}]\\n else:\\n # Look for the network id\\n net_list = self.neutron_operations.find_networks(name=network_name)\\n self.assertTrue(len(net_list) != 0, \\\"Required network '%s' could not be found\\\" % network_name)\\n network_id_list = [{'net-id': net_list[0]['id']}]\\n\\n except NeutronClientException as e:\\n self.logger.debug(\\\"Required network could not be created: %s\\\", e)\\n self.fail(e)\\n\\n try:\\n if keypair_name:\\n if is_keypair_new:\\n self.nova_operations.create_keypair(keypair_name)\\n self.test_world['keypair_names'].append(keypair_name)\\n else:\\n keypair_found = self.nova_operations.find_keypair(name=keypair_name)\\n self.assertIsNotNone(keypair_found, \\\"Required Keypair '%s' could not be found\\\" % keypair_name)\\n except NovaClientException as e:\\n self.logger.debug(\\\"Required keypair could not be created: %s\\\", e)\\n self.fail(e)\\n\\n try:\\n security_group_name_list = None\\n if sec_group_name:\\n sec_group_id = self.nova_operations.create_security_group_and_rules(sec_group_name)\\n self.test_world['sec_groups'].append(sec_group_id)\\n security_group_name_list = [sec_group_name]\\n except NovaClientException as e:\\n self.logger.debug(\\\"Required security group could not be created: %s\\\", e)\\n self.fail(e)\\n\\n # create new instance\\n try:\\n server_data = self.nova_operations.launch_instance(instance_name=instance_name,\\n flavor_id=flavor_id,\\n image_id=image_id,\\n metadata=metadata,\\n keypair_name=keypair_name,\\n security_group_name_list=security_group_name_list,\\n network_id_list=network_id_list)\\n except Forbidden as e:\\n self.logger.debug(\\\"Quota exceeded when launching a new instance\\\")\\n self.fail(e)\\n except OverLimit as e:\\n self.logger.debug(\\\"Not enough resources to launch new instance: %s\\\", e)\\n self.fail(e)\\n else:\\n self.test_world['servers'].append(server_data['id'])\\n\\n # Wait for status=ACTIVE\\n status, detail = self.nova_operations.wait_for_task_status(server_data['id'], 'ACTIVE')\\n self.assertEqual(status, 'ACTIVE', \\\"{detail}. Current status is {status}\\\".format(detail=detail, status=status))\\n\\n return server_data['id']\",\n \"def sendShare(self, program_counter, share):\\n self.sendData(program_counter, SHARE, hex(share.value))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.87092817","0.8525568","0.8476073","0.8432505","0.811207","0.8111951","0.79742056","0.7967393","0.7931208","0.7835071","0.7778211","0.7645673","0.7638049","0.75317097","0.7366997","0.7344222","0.7333957","0.7017911","0.6752469","0.66835386","0.65300155","0.65233326","0.6445796","0.64004135","0.63362306","0.62642187","0.62388015","0.6217243","0.61507595","0.60564053","0.6001915","0.5999423","0.59667534","0.5965803","0.5891566","0.58389646","0.5830381","0.5825669","0.5811826","0.5806076","0.5803458","0.57883567","0.5780043","0.57725656","0.5771448","0.5746271","0.57255113","0.56699306","0.5643118","0.5626986","0.56105834","0.5552695","0.5549272","0.5537618","0.5517273","0.55165637","0.55062103","0.54970884","0.5494724","0.548465","0.5480142","0.5420772","0.5419649","0.5375622","0.5369937","0.5364001","0.5351813","0.5345845","0.5345223","0.5312683","0.53057295","0.5301634","0.5299758","0.5293874","0.52894384","0.5264478","0.5263255","0.52624696","0.5225667","0.5216789","0.5209948","0.52095133","0.5208989","0.5208263","0.52011436","0.51970696","0.51893514","0.5189342","0.5181992","0.51732737","0.5173034","0.5164304","0.51623917","0.5154713","0.51465994","0.5141977","0.5139152","0.51119405","0.51097655","0.5088797"],"string":"[\n \"0.87092817\",\n \"0.8525568\",\n \"0.8476073\",\n \"0.8432505\",\n \"0.811207\",\n \"0.8111951\",\n \"0.79742056\",\n \"0.7967393\",\n \"0.7931208\",\n \"0.7835071\",\n \"0.7778211\",\n \"0.7645673\",\n \"0.7638049\",\n \"0.75317097\",\n \"0.7366997\",\n \"0.7344222\",\n \"0.7333957\",\n \"0.7017911\",\n \"0.6752469\",\n \"0.66835386\",\n \"0.65300155\",\n \"0.65233326\",\n \"0.6445796\",\n \"0.64004135\",\n \"0.63362306\",\n \"0.62642187\",\n \"0.62388015\",\n \"0.6217243\",\n \"0.61507595\",\n \"0.60564053\",\n \"0.6001915\",\n \"0.5999423\",\n \"0.59667534\",\n \"0.5965803\",\n \"0.5891566\",\n \"0.58389646\",\n \"0.5830381\",\n \"0.5825669\",\n \"0.5811826\",\n \"0.5806076\",\n \"0.5803458\",\n \"0.57883567\",\n \"0.5780043\",\n \"0.57725656\",\n \"0.5771448\",\n \"0.5746271\",\n \"0.57255113\",\n \"0.56699306\",\n \"0.5643118\",\n \"0.5626986\",\n \"0.56105834\",\n \"0.5552695\",\n \"0.5549272\",\n \"0.5537618\",\n \"0.5517273\",\n \"0.55165637\",\n \"0.55062103\",\n \"0.54970884\",\n \"0.5494724\",\n \"0.548465\",\n \"0.5480142\",\n \"0.5420772\",\n \"0.5419649\",\n \"0.5375622\",\n \"0.5369937\",\n \"0.5364001\",\n \"0.5351813\",\n \"0.5345845\",\n \"0.5345223\",\n \"0.5312683\",\n \"0.53057295\",\n \"0.5301634\",\n \"0.5299758\",\n \"0.5293874\",\n \"0.52894384\",\n \"0.5264478\",\n \"0.5263255\",\n \"0.52624696\",\n \"0.5225667\",\n \"0.5216789\",\n \"0.5209948\",\n \"0.52095133\",\n \"0.5208989\",\n \"0.5208263\",\n \"0.52011436\",\n \"0.51970696\",\n \"0.51893514\",\n \"0.5189342\",\n \"0.5181992\",\n \"0.51732737\",\n \"0.5173034\",\n \"0.5164304\",\n \"0.51623917\",\n \"0.5154713\",\n \"0.51465994\",\n \"0.5141977\",\n \"0.5139152\",\n \"0.51119405\",\n \"0.51097655\",\n \"0.5088797\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.95934916"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81373,"cells":{"query":{"kind":"string","value":"Test case for destroy_nas_share"},"document":{"kind":"string","value":"def test_destroy_nas_share(self):\n pass"},"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_destroy_nas_share_by_nas(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def _cleanup_create_share(self, share_path, share_name):\n if os.path.exists(share_path):\n cmd = ['rm', '-rf', share_path]\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError as exc:\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\n 'during its creation, but exists in GlusterFS '\n 'volume.'), share_name)\n raise exception.GlusterfsException(exc)","def delete_share(self, context, share, share_server=None):\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n if not volume_uuid:\n LOG.warning(\"No volume found for \"\n \"share %(project_id)s/%(name)s\",\n {\"project_id\": share['project_id'],\n \"name\": share['name']})\n return\n\n if self.configuration.quobyte_delete_shares:\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\n else:\n self.rpc.call('exportVolume', {\"volume_uuid\": volume_uuid,\n \"remove_export\": True,\n })","def delete_share(self, pool, project, share):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.delete(svc)\n if ret.status != restclient.Status.NO_CONTENT:\n exception_msg = (('Error deleting '\n 'share: %(share)s to '\n 'pool: %(pool)s '\n 'project: %(project)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.'),\n {'share': share,\n 'pool': pool,\n 'project': project,\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n LOG.error(exception_msg)","def test_show_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def delete_share(self, context, share, share_server=None):\n local_share_path = self._get_local_share_path(share)\n cmd = ['rm', '-rf', local_share_path]\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError:\n LOG.error(_LE('Unable to delete share %s'), share['name'])\n raise","def test_sg_delete_non_associated(self):\n\n # Add a faked storage group to be tested and another one\n faked_storage_group = self.add_storage_group1()\n self.add_storage_group2()\n\n storage_group_mgr = self.console.storage_groups\n\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\n\n # Execute the code to be tested.\n storage_group.delete()\n\n # Check that the storage group no longer exists\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=faked_storage_group.name)","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_delete_net_namespace(self):\n pass","def test_delete_cluster_network(self):\n pass","def test_delete_hyperflex_cluster_storage_policy(self):\n pass","def test_delete_network(self):\n pass","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_delete_hyperflex_cluster_network_policy(self):\n pass","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_delete_hyperflex_cluster_profile(self):\n pass","def test_destroy_container(self):\n pass","def destroy():\n pass","def destroy():\n pass","def test_delete_cluster_resource_quota(self):\n pass","def check_instance_shared_storage_cleanup(self, context, data):\n pass","def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\n network_delete_mock.assert_called_with(resources.network)\n self.assertTrue(resources._hypervisor.close.called)","def test_destroy_container_privilege(self):\n pass","def SafeBridgeDestroy(bridge):\n #try:\n # bridge.destroy()\n #except requests.HTTPError as e:\n # if e.response.status_code != requests.codes.not_found:\n # print e.response.status_code\n try:\n bridge.destroy()\n except:\n return","async def test_endpoint_delete_container_shares_correct(self):\n with self.patch_json_dump:\n resp = await delete_container_shares_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_aws_service_api_volume_delete(self):\n pass","def umount_nfs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\n {'source_path': '/bar',\n 'target_path': '/baz'}})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')","def test_004_delete(self):\n ret = svcmgr.main(argv=[\"delete\", \"-s\", SVCNAME, \"--local\"])\n assert ret == 0","def destroy_node(self):\n driver = self.driver\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\n driver.destroy_node(self.node)\n sleep(15)\n for volume in self.volumes:\n driver.destroy_volume(volume)","def test_index_nas_shares_by_pool(self):\n pass","def destroy(name, call=None):\n if call == \"function\":\n raise SaltCloudSystemExit(\n \"The destroy action must be called with -d, --destroy, -a or --action.\"\n )\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroying instance\",\n \"salt/cloud/{}/destroying\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n datacenter_id = get_datacenter_id()\n conn = get_conn()\n node = get_node(conn, name)\n attached_volumes = None\n\n delete_volumes = config.get_cloud_config_value(\n \"delete_volumes\", get_configured_provider(), __opts__, search_global=False\n )\n # Get volumes before the server is deleted\n attached_volumes = conn.get_attached_volumes(\n datacenter_id=datacenter_id, server_id=node[\"id\"]\n )\n\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\"id\"])\n\n # The server is deleted and now is safe to delete the volumes\n if delete_volumes:\n for vol in attached_volumes[\"items\"]:\n log.debug(\"Deleting volume %s\", vol[\"id\"])\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\"id\"])\n log.debug(\"Deleted volume %s\", vol[\"id\"])\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroyed instance\",\n \"salt/cloud/{}/destroyed\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n if __opts__.get(\"update_cachedir\", False) is True:\n __utils__[\"cloud.delete_minion_cachedir\"](\n name, _get_active_provider_name().split(\":\")[0], __opts__\n )\n\n return True","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_create_delete_space(self):\n\n # Make clients\n kibana = Kibana(host=self.kibana_host, username=self.username, password=self.password)\n\n # Parameters\n space_id = random_id()\n\n try:\n # Create spaces\n result = kibana.create_space(space_id, \"Test Space\")\n self.assertTrue(result)\n\n # Delete space\n result = kibana.delete_space(space_id)\n self.assertFalse(result)\n finally:\n # Delete space\n kibana.delete_space(space_id)","def test_deallocate_virt_realm(self):\n pass","def test_delete_system_asset(self):\n pass","def remove(self):\n\t\tcall_sdk_function('PrlShare_Remove', self.handle)","def test_destroy_exit_code(destroy_result: Result) -> None:\n assert destroy_result.exit_code == 0","def _delete_network_vm(args):\n libvirtConn = libvirt.openReadOnly(None)\n if libvirtConn is None:\n print('Cannot contact hypervisor', file=sys.stderr)\n return 1\n net = None\n try:\n net = libvirtConn.networkLookupByName(args.network_name)\n except libvirt.libvirtError:\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\n return 1\n print('Network found:\\n')\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\" \", newl=''))\n print('')\n\n if not args.yes:\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\n return 1\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_delete_device(self):\n pass","def test_delete_device(self):\n pass","def test_delete__network(self):\n arglist = [\n '--network',\n self.projects[0].id,\n ]\n verifylist = [\n ('service', 'network'),\n ('project', self.projects[0].id),\n ]\n\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\n\n result = self.cmd.take_action(parsed_args)\n\n self.assertIsNone(result)\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\n self.compute_quotas_mock.delete.assert_not_called()\n self.volume_quotas_mock.delete.assert_not_called()\n self.network_mock.delete_quota.assert_called_once_with(\n self.projects[0].id,\n )","def test_delete_ns_descriptors_nsdinfoid(delete_ns_descriptors_nsdinfoid_keys):\r\n sonata_vnfpkgm = SONATAClient.VnfPkgm(HOST_URL)\r\n sonata_nsd = SONATAClient.Nsd(HOST_URL)\r\n sonata_auth = SONATAClient.Auth(HOST_URL)\r\n _token = json.loads(sonata_auth.auth(username=USERNAME, password=PASSWORD))\r\n _token = json.loads(_token[\"data\"])\r\n \r\n _nsd_list = json.loads(sonata_nsd.get_ns_descriptors(\r\n token=_token[\"token\"][\"access_token\"]))\r\n _nsd_list = json.loads(_nsd_list[\"data\"])\r\n \r\n _nsd = None\r\n for _n in _nsd_list:\r\n if \"sonata-demo\" == _n['nsd']['name']:\r\n _nsd = _n['uuid']\r\n \r\n \r\n time.sleep(10) # Wait for NSD onboarding\r\n response = json.loads(sonata_nsd.delete_ns_descriptors_nsdinfoid(\r\n token=_token[\"token\"][\"access_token\"],\r\n nsdinfoid=_nsd))\r\n assert isinstance(response, dict)\r\n assert response[\"data\"] == \"{\\\"error\\\":\\\"The NSD ID None does not exist\\\"}\"\r\n \r\n time.sleep(2) #Wait for NSD onboarding\r\n\r\n _vnfd_list = json.loads(sonata_vnfpkgm.get_vnf_packages(\r\n token=_token[\"token\"][\"access_token\"]))\r\n _vnfd_list = json.loads(_vnfd_list[\"data\"])\r\n\r\n _vnfd = None\r\n for _v in _vnfd_list:\r\n if \"vnfd_example\" == _v['uuid']: \r\n _vnfd = _v['uuid']\r\n\r\n response = None\r\n if _vnfd:\r\n response = json.loads(sonata_vnfpkgm.delete_vnf_packages_vnfpkgid(\r\n token=_token[\"token\"][\"access_token\"], vnfPkgId=_vnfd))\r\n assert isinstance(response, dict)\r\n assert response[\"data\"] == \"\"","def test_delete_cluster_policy(self):\n pass","def cleanup(self, context, instance, network_info, block_device_info=None,\n destroy_disks=True):\n pass","def test_delete_namespaced_image_stream(self):\n pass","def test_aws_service_api_vm_delete(self):\n pass","def test_delete_stream(self):\n pass","def _unprovision_node(self, conn):\n conn.run(f\"rm -rf {EXPORTER_HOME}\")","def delete_cluster(self):","def test_ipam_vrfs_delete(self):\n pass","def doDestroyMe(self, *args, **kwargs):\n self.target_domain = None\n self.renew_years = None\n self.sync_contacts = None\n self.sync_nameservers = None\n self.verify_owner = None\n self.latest_domain_info = None\n self.destroy()","def test_delete_host_subnet(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def delete_volume(self, volume):\n nfs_share = volume.get('provider_location')\n if nfs_share:\n nms = self.share2nms[nfs_share]\n vol, parent_folder = self._get_share_datasets(nfs_share)\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\n mount_path = self.remote_path(volume).strip(\n '/%s' % self.VOLUME_FILE_NAME)\n if mount_path in self._remotefsclient._read_mounts():\n cinder.privsep.fs.umount(mount_path)\n try:\n props = nms.folder.get_child_props(folder, 'origin') or {}\n nms.folder.destroy(folder, '-r')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Folder %s does not exist, it was '\n 'already deleted.', folder)\n return\n raise\n self._get_capacity_info(nfs_share)\n origin = props.get('origin')\n if origin and self._is_clone_snapshot_name(origin):\n try:\n nms.snapshot.destroy(origin, '')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Snapshot %s does not exist, it was '\n 'already deleted.', origin)\n return\n raise","def umount_cifs_share(self, **kwargs):\n mount_point = kwargs.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def test_delete_hyperflex_server_firmware_version(self):\n pass","def test_delete_cloud(self):\n pass","def test_delete_volume_failure_modes(self):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n volume = {'id': '1', 'name': 'volume1',\n 'display_name': '',\n 'volume_type_id': type_ref['id'],\n 'size': 10,\n 'provider_id': 'volume10'}\n self._fail_space_delete = True\n # This should not throw an exception, space-delete failure not problem\n self.driver.delete_volume(volume)\n self._fail_space_delete = False\n volume['provider_id'] = None\n # This should also not throw an exception\n self.driver.delete_volume(volume)","def test_destroy_owner(self):\n\n self.assertEqual(first=1, second=Post.objects.all().count())\n url = reverse('post-detail', args=(self.post.id,))\n self.client.credentials(HTTP_AUTHORIZATION=self.token)\n response = self.client.delete(path=url)\n self.assertEqual(first=204, second=response.status_code)\n self.assertEqual(first=0, second=Post.objects.all().count())","def test_delete_underscore():\n pytest.raises(SaltInvocationError, mac_group.delete, \"_Test\")","def _unshare_dir(target):\n logging.debug(\"Un-sharing directory %s\" % target)\n os.rmdir(target)","def test_sg_delete_create_same(self):\n\n # Add a faked storage_group to be tested and another one\n faked_storage_group = self.add_storage_group1()\n storage_group_name = faked_storage_group.name\n self.add_storage_group2()\n\n # Construct the input properties for a third storage_group\n sg3_props = copy.deepcopy(faked_storage_group.properties)\n sg3_props['description'] = 'Third storage_group'\n\n storage_group_mgr = self.console.storage_groups\n storage_group = storage_group_mgr.find(name=storage_group_name)\n\n # Execute the deletion code to be tested.\n storage_group.delete()\n\n # Check that the storage_group no longer exists\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=storage_group_name)\n\n # Execute the creation code to be tested.\n storage_group_mgr.create(sg3_props)\n\n # Check that the storage_group exists again under that name\n storage_group3 = storage_group_mgr.find(name=storage_group_name)\n description = storage_group3.get_property('description')\n assert description == 'Third storage_group'","def do_destroy(self, arg):\n obj = self.verify(arg, 2)\n if obj:\n del storage.all()[obj]\n storage.save()","def destroy(self):","def destroy(self):","def destroy(self):","def test_unshare_template_registration(self):\n pass","def safe_to_destroy(osd_id, timeout=300):\n ret = subprocess.call([\n 'ceph', '--id', 'osd-removal',\n 'osd', 'safe-to-destroy', osd_id\n ], timeout=timeout)\n return ret == 0","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def _destroy(self):","def destroy(self, context, instance, network_info, cleanup=True):\n LOG.debug(\"destroy\")\n\n bmm = db.bmm_get_by_instance_id(context, instance[\"id\"])\n db.bmm_update(context, bmm[\"id\"], {\"status\": \"processing\"})\n mac = self._get_pxe_mac(bmm)\n\n # update ofc\n self._update_ofc_for_destroy(context, bmm)\n db.bmm_update(context, bmm[\"id\"], {\"vlan_id\": None,\n \"availability_zone\": \"resource_pool\"})\n\n # begin to delete os\n self._cp_template(\"delete.sh\",\n self._get_cobbler_instance_path(instance, \"delete.sh\"), \n {\"INSTANCE_ID\": instance[\"id\"],\n \"COBBLER\": FLAGS.cobbler,\n \"MONITOR_PORT\": FLAGS.dodai_monitor_port})\n self._cp_template(\"pxeboot_action\",\n self._get_pxe_boot_file(mac),\n {\"INSTANCE_ID\": instance[\"id\"], \n \"COBBLER\": FLAGS.cobbler,\n \"PXE_MAC\": bmm[\"pxe_mac\"],\n \"ACTION\": \"delete\"})\n self._reboot_or_power_on(bmm[\"ipmi_ip\"])\n\n # wait until starting to delete os\n while self._get_state(context, instance) != \"deleted\":\n greenthread.sleep(20)\n LOG.debug(\"Wait until data of instance %s was deleted.\" % instance[\"id\"])\n\n utils.execute(\"rm\", \"-rf\", self._get_cobbler_instance_path(instance));\n\n # update db\n db.bmm_update(context, bmm[\"id\"], {\"instance_id\": None, \n \"service_ip\": None})\n\n return db.bmm_get(context, bmm[\"id\"])","def test_delete_hyperflex_server_model(self):\n pass","def test_delete_remote(self):\n # Create source site and remote project\n source_site = self.make_site(\n name=REMOTE_SITE_NAME,\n url=REMOTE_SITE_URL,\n mode=SITE_MODE_SOURCE,\n description=REMOTE_SITE_DESC,\n secret=REMOTE_SITE_SECRET,\n )\n self.make_remote_project(\n project_uuid=self.project.sodar_uuid,\n project=self.project,\n site=source_site,\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\n )\n self.assertEqual(RoleAssignment.objects.count(), 3)\n url = reverse(\n 'projectroles:api_role_destroy',\n kwargs={'roleassignment': self.update_as.sodar_uuid},\n )\n response = self.request_knox(url, method='DELETE')\n self.assertEqual(response.status_code, 400, msg=response.content)\n self.assertEqual(RoleAssignment.objects.count(), 3)","def destroy_check(self):\n pass","def delete_remote_access_session(arn=None):\n pass","def test_networking_project_network_delete(self):\n pass","def Destroy(sliver_name):\n rec = sliver_name\n if rec['instantiation'] == 'delegated':\n account.get(rec['name']).ensure_destroyed()\n logger.log(\"api_calls: Destroy %s\"%rec['name'])\n else:\n raise Exception, \"Only PLC can destroy non delegated slivers.\"","def destroy_snapshot(snapname, dataset='', recursive=True, zpool=None):\n fullsnapname = \"%s%s@%s\" % (zpool, dataset, snapname)\n print \"Destroying snapshot '%s'\" % fullsnapname\n if recursive:\n command = 'zfs destroy -r %s' % fullsnapname\n else:\n command = 'zfs destroy %s' % fullsnapname\n #print \"Exec '%s'\" % command\n assert command.find('@') != -1 # we are not destroying datasets, only snapshots\n p = subprocess.Popen(command.split(' '))\n p.wait()\n if p.returncode != 0 and p.returncode != 1: # 1 = snapshot did not exist. We can stand that\n raise Exception(\"Error executing '%s': %d\" % (command, p.returncode))","def test_remove_provider_from_inst_alloc_no_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)"],"string":"[\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def _cleanup_create_share(self, share_path, share_name):\\n if os.path.exists(share_path):\\n cmd = ['rm', '-rf', share_path]\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError as exc:\\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\\n 'during its creation, but exists in GlusterFS '\\n 'volume.'), share_name)\\n raise exception.GlusterfsException(exc)\",\n \"def delete_share(self, context, share, share_server=None):\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n if not volume_uuid:\\n LOG.warning(\\\"No volume found for \\\"\\n \\\"share %(project_id)s/%(name)s\\\",\\n {\\\"project_id\\\": share['project_id'],\\n \\\"name\\\": share['name']})\\n return\\n\\n if self.configuration.quobyte_delete_shares:\\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\\n else:\\n self.rpc.call('exportVolume', {\\\"volume_uuid\\\": volume_uuid,\\n \\\"remove_export\\\": True,\\n })\",\n \"def delete_share(self, pool, project, share):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.delete(svc)\\n if ret.status != restclient.Status.NO_CONTENT:\\n exception_msg = (('Error deleting '\\n 'share: %(share)s to '\\n 'pool: %(pool)s '\\n 'project: %(project)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.'),\\n {'share': share,\\n 'pool': pool,\\n 'project': project,\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n LOG.error(exception_msg)\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def delete_share(self, context, share, share_server=None):\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['rm', '-rf', local_share_path]\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError:\\n LOG.error(_LE('Unable to delete share %s'), share['name'])\\n raise\",\n \"def test_sg_delete_non_associated(self):\\n\\n # Add a faked storage group to be tested and another one\\n faked_storage_group = self.add_storage_group1()\\n self.add_storage_group2()\\n\\n storage_group_mgr = self.console.storage_groups\\n\\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\\n\\n # Execute the code to be tested.\\n storage_group.delete()\\n\\n # Check that the storage group no longer exists\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=faked_storage_group.name)\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_delete_net_namespace(self):\\n pass\",\n \"def test_delete_cluster_network(self):\\n pass\",\n \"def test_delete_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_delete_network(self):\\n pass\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_delete_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_delete_hyperflex_cluster_profile(self):\\n pass\",\n \"def test_destroy_container(self):\\n pass\",\n \"def destroy():\\n pass\",\n \"def destroy():\\n pass\",\n \"def test_delete_cluster_resource_quota(self):\\n pass\",\n \"def check_instance_shared_storage_cleanup(self, context, data):\\n pass\",\n \"def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\\n network_delete_mock.assert_called_with(resources.network)\\n self.assertTrue(resources._hypervisor.close.called)\",\n \"def test_destroy_container_privilege(self):\\n pass\",\n \"def SafeBridgeDestroy(bridge):\\n #try:\\n # bridge.destroy()\\n #except requests.HTTPError as e:\\n # if e.response.status_code != requests.codes.not_found:\\n # print e.response.status_code\\n try:\\n bridge.destroy()\\n except:\\n return\",\n \"async def test_endpoint_delete_container_shares_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_container_shares_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_aws_service_api_volume_delete(self):\\n pass\",\n \"def umount_nfs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\\n {'source_path': '/bar',\\n 'target_path': '/baz'}})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')\",\n \"def test_004_delete(self):\\n ret = svcmgr.main(argv=[\\\"delete\\\", \\\"-s\\\", SVCNAME, \\\"--local\\\"])\\n assert ret == 0\",\n \"def destroy_node(self):\\n driver = self.driver\\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\\n driver.destroy_node(self.node)\\n sleep(15)\\n for volume in self.volumes:\\n driver.destroy_volume(volume)\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def destroy(name, call=None):\\n if call == \\\"function\\\":\\n raise SaltCloudSystemExit(\\n \\\"The destroy action must be called with -d, --destroy, -a or --action.\\\"\\n )\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroying instance\\\",\\n \\\"salt/cloud/{}/destroying\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n datacenter_id = get_datacenter_id()\\n conn = get_conn()\\n node = get_node(conn, name)\\n attached_volumes = None\\n\\n delete_volumes = config.get_cloud_config_value(\\n \\\"delete_volumes\\\", get_configured_provider(), __opts__, search_global=False\\n )\\n # Get volumes before the server is deleted\\n attached_volumes = conn.get_attached_volumes(\\n datacenter_id=datacenter_id, server_id=node[\\\"id\\\"]\\n )\\n\\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\\\"id\\\"])\\n\\n # The server is deleted and now is safe to delete the volumes\\n if delete_volumes:\\n for vol in attached_volumes[\\\"items\\\"]:\\n log.debug(\\\"Deleting volume %s\\\", vol[\\\"id\\\"])\\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\\\"id\\\"])\\n log.debug(\\\"Deleted volume %s\\\", vol[\\\"id\\\"])\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroyed instance\\\",\\n \\\"salt/cloud/{}/destroyed\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n if __opts__.get(\\\"update_cachedir\\\", False) is True:\\n __utils__[\\\"cloud.delete_minion_cachedir\\\"](\\n name, _get_active_provider_name().split(\\\":\\\")[0], __opts__\\n )\\n\\n return True\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_create_delete_space(self):\\n\\n # Make clients\\n kibana = Kibana(host=self.kibana_host, username=self.username, password=self.password)\\n\\n # Parameters\\n space_id = random_id()\\n\\n try:\\n # Create spaces\\n result = kibana.create_space(space_id, \\\"Test Space\\\")\\n self.assertTrue(result)\\n\\n # Delete space\\n result = kibana.delete_space(space_id)\\n self.assertFalse(result)\\n finally:\\n # Delete space\\n kibana.delete_space(space_id)\",\n \"def test_deallocate_virt_realm(self):\\n pass\",\n \"def test_delete_system_asset(self):\\n pass\",\n \"def remove(self):\\n\\t\\tcall_sdk_function('PrlShare_Remove', self.handle)\",\n \"def test_destroy_exit_code(destroy_result: Result) -> None:\\n assert destroy_result.exit_code == 0\",\n \"def _delete_network_vm(args):\\n libvirtConn = libvirt.openReadOnly(None)\\n if libvirtConn is None:\\n print('Cannot contact hypervisor', file=sys.stderr)\\n return 1\\n net = None\\n try:\\n net = libvirtConn.networkLookupByName(args.network_name)\\n except libvirt.libvirtError:\\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\\n return 1\\n print('Network found:\\\\n')\\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\\\" \\\", newl=''))\\n print('')\\n\\n if not args.yes:\\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\\n return 1\\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_delete__network(self):\\n arglist = [\\n '--network',\\n self.projects[0].id,\\n ]\\n verifylist = [\\n ('service', 'network'),\\n ('project', self.projects[0].id),\\n ]\\n\\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\\n\\n result = self.cmd.take_action(parsed_args)\\n\\n self.assertIsNone(result)\\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\\n self.compute_quotas_mock.delete.assert_not_called()\\n self.volume_quotas_mock.delete.assert_not_called()\\n self.network_mock.delete_quota.assert_called_once_with(\\n self.projects[0].id,\\n )\",\n \"def test_delete_ns_descriptors_nsdinfoid(delete_ns_descriptors_nsdinfoid_keys):\\r\\n sonata_vnfpkgm = SONATAClient.VnfPkgm(HOST_URL)\\r\\n sonata_nsd = SONATAClient.Nsd(HOST_URL)\\r\\n sonata_auth = SONATAClient.Auth(HOST_URL)\\r\\n _token = json.loads(sonata_auth.auth(username=USERNAME, password=PASSWORD))\\r\\n _token = json.loads(_token[\\\"data\\\"])\\r\\n \\r\\n _nsd_list = json.loads(sonata_nsd.get_ns_descriptors(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"]))\\r\\n _nsd_list = json.loads(_nsd_list[\\\"data\\\"])\\r\\n \\r\\n _nsd = None\\r\\n for _n in _nsd_list:\\r\\n if \\\"sonata-demo\\\" == _n['nsd']['name']:\\r\\n _nsd = _n['uuid']\\r\\n \\r\\n \\r\\n time.sleep(10) # Wait for NSD onboarding\\r\\n response = json.loads(sonata_nsd.delete_ns_descriptors_nsdinfoid(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"],\\r\\n nsdinfoid=_nsd))\\r\\n assert isinstance(response, dict)\\r\\n assert response[\\\"data\\\"] == \\\"{\\\\\\\"error\\\\\\\":\\\\\\\"The NSD ID None does not exist\\\\\\\"}\\\"\\r\\n \\r\\n time.sleep(2) #Wait for NSD onboarding\\r\\n\\r\\n _vnfd_list = json.loads(sonata_vnfpkgm.get_vnf_packages(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"]))\\r\\n _vnfd_list = json.loads(_vnfd_list[\\\"data\\\"])\\r\\n\\r\\n _vnfd = None\\r\\n for _v in _vnfd_list:\\r\\n if \\\"vnfd_example\\\" == _v['uuid']: \\r\\n _vnfd = _v['uuid']\\r\\n\\r\\n response = None\\r\\n if _vnfd:\\r\\n response = json.loads(sonata_vnfpkgm.delete_vnf_packages_vnfpkgid(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"], vnfPkgId=_vnfd))\\r\\n assert isinstance(response, dict)\\r\\n assert response[\\\"data\\\"] == \\\"\\\"\",\n \"def test_delete_cluster_policy(self):\\n pass\",\n \"def cleanup(self, context, instance, network_info, block_device_info=None,\\n destroy_disks=True):\\n pass\",\n \"def test_delete_namespaced_image_stream(self):\\n pass\",\n \"def test_aws_service_api_vm_delete(self):\\n pass\",\n \"def test_delete_stream(self):\\n pass\",\n \"def _unprovision_node(self, conn):\\n conn.run(f\\\"rm -rf {EXPORTER_HOME}\\\")\",\n \"def delete_cluster(self):\",\n \"def test_ipam_vrfs_delete(self):\\n pass\",\n \"def doDestroyMe(self, *args, **kwargs):\\n self.target_domain = None\\n self.renew_years = None\\n self.sync_contacts = None\\n self.sync_nameservers = None\\n self.verify_owner = None\\n self.latest_domain_info = None\\n self.destroy()\",\n \"def test_delete_host_subnet(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def delete_volume(self, volume):\\n nfs_share = volume.get('provider_location')\\n if nfs_share:\\n nms = self.share2nms[nfs_share]\\n vol, parent_folder = self._get_share_datasets(nfs_share)\\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\\n mount_path = self.remote_path(volume).strip(\\n '/%s' % self.VOLUME_FILE_NAME)\\n if mount_path in self._remotefsclient._read_mounts():\\n cinder.privsep.fs.umount(mount_path)\\n try:\\n props = nms.folder.get_child_props(folder, 'origin') or {}\\n nms.folder.destroy(folder, '-r')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Folder %s does not exist, it was '\\n 'already deleted.', folder)\\n return\\n raise\\n self._get_capacity_info(nfs_share)\\n origin = props.get('origin')\\n if origin and self._is_clone_snapshot_name(origin):\\n try:\\n nms.snapshot.destroy(origin, '')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Snapshot %s does not exist, it was '\\n 'already deleted.', origin)\\n return\\n raise\",\n \"def umount_cifs_share(self, **kwargs):\\n mount_point = kwargs.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def test_delete_hyperflex_server_firmware_version(self):\\n pass\",\n \"def test_delete_cloud(self):\\n pass\",\n \"def test_delete_volume_failure_modes(self):\\n ctxt = context.get_admin_context()\\n extra_specs = {}\\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\\n volume = {'id': '1', 'name': 'volume1',\\n 'display_name': '',\\n 'volume_type_id': type_ref['id'],\\n 'size': 10,\\n 'provider_id': 'volume10'}\\n self._fail_space_delete = True\\n # This should not throw an exception, space-delete failure not problem\\n self.driver.delete_volume(volume)\\n self._fail_space_delete = False\\n volume['provider_id'] = None\\n # This should also not throw an exception\\n self.driver.delete_volume(volume)\",\n \"def test_destroy_owner(self):\\n\\n self.assertEqual(first=1, second=Post.objects.all().count())\\n url = reverse('post-detail', args=(self.post.id,))\\n self.client.credentials(HTTP_AUTHORIZATION=self.token)\\n response = self.client.delete(path=url)\\n self.assertEqual(first=204, second=response.status_code)\\n self.assertEqual(first=0, second=Post.objects.all().count())\",\n \"def test_delete_underscore():\\n pytest.raises(SaltInvocationError, mac_group.delete, \\\"_Test\\\")\",\n \"def _unshare_dir(target):\\n logging.debug(\\\"Un-sharing directory %s\\\" % target)\\n os.rmdir(target)\",\n \"def test_sg_delete_create_same(self):\\n\\n # Add a faked storage_group to be tested and another one\\n faked_storage_group = self.add_storage_group1()\\n storage_group_name = faked_storage_group.name\\n self.add_storage_group2()\\n\\n # Construct the input properties for a third storage_group\\n sg3_props = copy.deepcopy(faked_storage_group.properties)\\n sg3_props['description'] = 'Third storage_group'\\n\\n storage_group_mgr = self.console.storage_groups\\n storage_group = storage_group_mgr.find(name=storage_group_name)\\n\\n # Execute the deletion code to be tested.\\n storage_group.delete()\\n\\n # Check that the storage_group no longer exists\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=storage_group_name)\\n\\n # Execute the creation code to be tested.\\n storage_group_mgr.create(sg3_props)\\n\\n # Check that the storage_group exists again under that name\\n storage_group3 = storage_group_mgr.find(name=storage_group_name)\\n description = storage_group3.get_property('description')\\n assert description == 'Third storage_group'\",\n \"def do_destroy(self, arg):\\n obj = self.verify(arg, 2)\\n if obj:\\n del storage.all()[obj]\\n storage.save()\",\n \"def destroy(self):\",\n \"def destroy(self):\",\n \"def destroy(self):\",\n \"def test_unshare_template_registration(self):\\n pass\",\n \"def safe_to_destroy(osd_id, timeout=300):\\n ret = subprocess.call([\\n 'ceph', '--id', 'osd-removal',\\n 'osd', 'safe-to-destroy', osd_id\\n ], timeout=timeout)\\n return ret == 0\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def _destroy(self):\",\n \"def destroy(self, context, instance, network_info, cleanup=True):\\n LOG.debug(\\\"destroy\\\")\\n\\n bmm = db.bmm_get_by_instance_id(context, instance[\\\"id\\\"])\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"status\\\": \\\"processing\\\"})\\n mac = self._get_pxe_mac(bmm)\\n\\n # update ofc\\n self._update_ofc_for_destroy(context, bmm)\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"vlan_id\\\": None,\\n \\\"availability_zone\\\": \\\"resource_pool\\\"})\\n\\n # begin to delete os\\n self._cp_template(\\\"delete.sh\\\",\\n self._get_cobbler_instance_path(instance, \\\"delete.sh\\\"), \\n {\\\"INSTANCE_ID\\\": instance[\\\"id\\\"],\\n \\\"COBBLER\\\": FLAGS.cobbler,\\n \\\"MONITOR_PORT\\\": FLAGS.dodai_monitor_port})\\n self._cp_template(\\\"pxeboot_action\\\",\\n self._get_pxe_boot_file(mac),\\n {\\\"INSTANCE_ID\\\": instance[\\\"id\\\"], \\n \\\"COBBLER\\\": FLAGS.cobbler,\\n \\\"PXE_MAC\\\": bmm[\\\"pxe_mac\\\"],\\n \\\"ACTION\\\": \\\"delete\\\"})\\n self._reboot_or_power_on(bmm[\\\"ipmi_ip\\\"])\\n\\n # wait until starting to delete os\\n while self._get_state(context, instance) != \\\"deleted\\\":\\n greenthread.sleep(20)\\n LOG.debug(\\\"Wait until data of instance %s was deleted.\\\" % instance[\\\"id\\\"])\\n\\n utils.execute(\\\"rm\\\", \\\"-rf\\\", self._get_cobbler_instance_path(instance));\\n\\n # update db\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"instance_id\\\": None, \\n \\\"service_ip\\\": None})\\n\\n return db.bmm_get(context, bmm[\\\"id\\\"])\",\n \"def test_delete_hyperflex_server_model(self):\\n pass\",\n \"def test_delete_remote(self):\\n # Create source site and remote project\\n source_site = self.make_site(\\n name=REMOTE_SITE_NAME,\\n url=REMOTE_SITE_URL,\\n mode=SITE_MODE_SOURCE,\\n description=REMOTE_SITE_DESC,\\n secret=REMOTE_SITE_SECRET,\\n )\\n self.make_remote_project(\\n project_uuid=self.project.sodar_uuid,\\n project=self.project,\\n site=source_site,\\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\\n )\\n self.assertEqual(RoleAssignment.objects.count(), 3)\\n url = reverse(\\n 'projectroles:api_role_destroy',\\n kwargs={'roleassignment': self.update_as.sodar_uuid},\\n )\\n response = self.request_knox(url, method='DELETE')\\n self.assertEqual(response.status_code, 400, msg=response.content)\\n self.assertEqual(RoleAssignment.objects.count(), 3)\",\n \"def destroy_check(self):\\n pass\",\n \"def delete_remote_access_session(arn=None):\\n pass\",\n \"def test_networking_project_network_delete(self):\\n pass\",\n \"def Destroy(sliver_name):\\n rec = sliver_name\\n if rec['instantiation'] == 'delegated':\\n account.get(rec['name']).ensure_destroyed()\\n logger.log(\\\"api_calls: Destroy %s\\\"%rec['name'])\\n else:\\n raise Exception, \\\"Only PLC can destroy non delegated slivers.\\\"\",\n \"def destroy_snapshot(snapname, dataset='', recursive=True, zpool=None):\\n fullsnapname = \\\"%s%s@%s\\\" % (zpool, dataset, snapname)\\n print \\\"Destroying snapshot '%s'\\\" % fullsnapname\\n if recursive:\\n command = 'zfs destroy -r %s' % fullsnapname\\n else:\\n command = 'zfs destroy %s' % fullsnapname\\n #print \\\"Exec '%s'\\\" % command\\n assert command.find('@') != -1 # we are not destroying datasets, only snapshots\\n p = subprocess.Popen(command.split(' '))\\n p.wait()\\n if p.returncode != 0 and p.returncode != 1: # 1 = snapshot did not exist. We can stand that\\n raise Exception(\\\"Error executing '%s': %d\\\" % (command, p.returncode))\",\n \"def test_remove_provider_from_inst_alloc_no_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9389554","0.8792524","0.76362747","0.75515646","0.7297889","0.7273542","0.7258762","0.7239002","0.71278036","0.71259034","0.71167296","0.7033105","0.6955307","0.6797405","0.67879903","0.67438823","0.6702528","0.669155","0.6557659","0.6553244","0.6280817","0.6250385","0.62459373","0.6156349","0.6143228","0.61209244","0.6119562","0.6063461","0.6034978","0.6034613","0.6030586","0.5980643","0.596645","0.5945962","0.5926647","0.59063435","0.59063435","0.5893659","0.58920294","0.5868269","0.5861146","0.58353984","0.58241135","0.5814466","0.5803031","0.5791704","0.5791197","0.57641584","0.5751666","0.57457316","0.5718963","0.57063895","0.5701664","0.56997913","0.5672023","0.5670968","0.5658507","0.5644327","0.5637266","0.5627591","0.5627591","0.5625852","0.5617357","0.56134975","0.5599002","0.55949605","0.5590869","0.5586326","0.55855966","0.55854076","0.558119","0.5580362","0.5578975","0.55775535","0.5576282","0.55703616","0.5538084","0.55331767","0.55309683","0.55286247","0.55252385","0.5517644","0.55102575","0.5509505","0.55090046","0.55090046","0.55090046","0.5508254","0.55057245","0.5499616","0.5498002","0.5496351","0.5483791","0.54758686","0.54715264","0.54589194","0.5450737","0.5443742","0.5438833","0.5433151"],"string":"[\n \"0.9389554\",\n \"0.8792524\",\n \"0.76362747\",\n \"0.75515646\",\n \"0.7297889\",\n \"0.7273542\",\n \"0.7258762\",\n \"0.7239002\",\n \"0.71278036\",\n \"0.71259034\",\n \"0.71167296\",\n \"0.7033105\",\n \"0.6955307\",\n \"0.6797405\",\n \"0.67879903\",\n \"0.67438823\",\n \"0.6702528\",\n \"0.669155\",\n \"0.6557659\",\n \"0.6553244\",\n \"0.6280817\",\n \"0.6250385\",\n \"0.62459373\",\n \"0.6156349\",\n \"0.6143228\",\n \"0.61209244\",\n \"0.6119562\",\n \"0.6063461\",\n \"0.6034978\",\n \"0.6034613\",\n \"0.6030586\",\n \"0.5980643\",\n \"0.596645\",\n \"0.5945962\",\n \"0.5926647\",\n \"0.59063435\",\n \"0.59063435\",\n \"0.5893659\",\n \"0.58920294\",\n \"0.5868269\",\n \"0.5861146\",\n \"0.58353984\",\n \"0.58241135\",\n \"0.5814466\",\n \"0.5803031\",\n \"0.5791704\",\n \"0.5791197\",\n \"0.57641584\",\n \"0.5751666\",\n \"0.57457316\",\n \"0.5718963\",\n \"0.57063895\",\n \"0.5701664\",\n \"0.56997913\",\n \"0.5672023\",\n \"0.5670968\",\n \"0.5658507\",\n \"0.5644327\",\n \"0.5637266\",\n \"0.5627591\",\n \"0.5627591\",\n \"0.5625852\",\n \"0.5617357\",\n \"0.56134975\",\n \"0.5599002\",\n \"0.55949605\",\n \"0.5590869\",\n \"0.5586326\",\n \"0.55855966\",\n \"0.55854076\",\n \"0.558119\",\n \"0.5580362\",\n \"0.5578975\",\n \"0.55775535\",\n \"0.5576282\",\n \"0.55703616\",\n \"0.5538084\",\n \"0.55331767\",\n \"0.55309683\",\n \"0.55286247\",\n \"0.55252385\",\n \"0.5517644\",\n \"0.55102575\",\n \"0.5509505\",\n \"0.55090046\",\n \"0.55090046\",\n \"0.55090046\",\n \"0.5508254\",\n \"0.55057245\",\n \"0.5499616\",\n \"0.5498002\",\n \"0.5496351\",\n \"0.5483791\",\n \"0.54758686\",\n \"0.54715264\",\n \"0.54589194\",\n \"0.5450737\",\n \"0.5443742\",\n \"0.5438833\",\n \"0.5433151\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.95384085"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81374,"cells":{"query":{"kind":"string","value":"Test case for destroy_nas_share_by_nas"},"document":{"kind":"string","value":"def test_destroy_nas_share_by_nas(self):\n pass"},"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_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_mount_status_nas_share_by_pool(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def delete_share(self, context, share, share_server=None):\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n if not volume_uuid:\n LOG.warning(\"No volume found for \"\n \"share %(project_id)s/%(name)s\",\n {\"project_id\": share['project_id'],\n \"name\": share['name']})\n return\n\n if self.configuration.quobyte_delete_shares:\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\n else:\n self.rpc.call('exportVolume', {\"volume_uuid\": volume_uuid,\n \"remove_export\": True,\n })","def delete_share(self, pool, project, share):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.delete(svc)\n if ret.status != restclient.Status.NO_CONTENT:\n exception_msg = (('Error deleting '\n 'share: %(share)s to '\n 'pool: %(pool)s '\n 'project: %(project)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.'),\n {'share': share,\n 'pool': pool,\n 'project': project,\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n LOG.error(exception_msg)","def test_index_nas_shares(self):\n pass","def _cleanup_create_share(self, share_path, share_name):\n if os.path.exists(share_path):\n cmd = ['rm', '-rf', share_path]\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError as exc:\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\n 'during its creation, but exists in GlusterFS '\n 'volume.'), share_name)\n raise exception.GlusterfsException(exc)","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_delete_cluster_network(self):\n pass","def delete_share(self, context, share, share_server=None):\n local_share_path = self._get_local_share_path(share)\n cmd = ['rm', '-rf', local_share_path]\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError:\n LOG.error(_LE('Unable to delete share %s'), share['name'])\n raise","def test_delete_network(self):\n pass","def test_sg_delete_non_associated(self):\n\n # Add a faked storage group to be tested and another one\n faked_storage_group = self.add_storage_group1()\n self.add_storage_group2()\n\n storage_group_mgr = self.console.storage_groups\n\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\n\n # Execute the code to be tested.\n storage_group.delete()\n\n # Check that the storage group no longer exists\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=faked_storage_group.name)","def test_delete_hyperflex_cluster_network_policy(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_delete_net_namespace(self):\n pass","async def test_endpoint_delete_container_shares_correct(self):\n with self.patch_json_dump:\n resp = await delete_container_shares_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_delete_hyperflex_cluster_storage_policy(self):\n pass","def test_delete_cluster_resource_quota(self):\n pass","def test_delete_hyperflex_cluster_profile(self):\n pass","def delete_cluster(self):","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_delete_ns_descriptors_nsdinfoid(delete_ns_descriptors_nsdinfoid_keys):\r\n sonata_vnfpkgm = SONATAClient.VnfPkgm(HOST_URL)\r\n sonata_nsd = SONATAClient.Nsd(HOST_URL)\r\n sonata_auth = SONATAClient.Auth(HOST_URL)\r\n _token = json.loads(sonata_auth.auth(username=USERNAME, password=PASSWORD))\r\n _token = json.loads(_token[\"data\"])\r\n \r\n _nsd_list = json.loads(sonata_nsd.get_ns_descriptors(\r\n token=_token[\"token\"][\"access_token\"]))\r\n _nsd_list = json.loads(_nsd_list[\"data\"])\r\n \r\n _nsd = None\r\n for _n in _nsd_list:\r\n if \"sonata-demo\" == _n['nsd']['name']:\r\n _nsd = _n['uuid']\r\n \r\n \r\n time.sleep(10) # Wait for NSD onboarding\r\n response = json.loads(sonata_nsd.delete_ns_descriptors_nsdinfoid(\r\n token=_token[\"token\"][\"access_token\"],\r\n nsdinfoid=_nsd))\r\n assert isinstance(response, dict)\r\n assert response[\"data\"] == \"{\\\"error\\\":\\\"The NSD ID None does not exist\\\"}\"\r\n \r\n time.sleep(2) #Wait for NSD onboarding\r\n\r\n _vnfd_list = json.loads(sonata_vnfpkgm.get_vnf_packages(\r\n token=_token[\"token\"][\"access_token\"]))\r\n _vnfd_list = json.loads(_vnfd_list[\"data\"])\r\n\r\n _vnfd = None\r\n for _v in _vnfd_list:\r\n if \"vnfd_example\" == _v['uuid']: \r\n _vnfd = _v['uuid']\r\n\r\n response = None\r\n if _vnfd:\r\n response = json.loads(sonata_vnfpkgm.delete_vnf_packages_vnfpkgid(\r\n token=_token[\"token\"][\"access_token\"], vnfPkgId=_vnfd))\r\n assert isinstance(response, dict)\r\n assert response[\"data\"] == \"\"","def test_delete__network(self):\n arglist = [\n '--network',\n self.projects[0].id,\n ]\n verifylist = [\n ('service', 'network'),\n ('project', self.projects[0].id),\n ]\n\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\n\n result = self.cmd.take_action(parsed_args)\n\n self.assertIsNone(result)\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\n self.compute_quotas_mock.delete.assert_not_called()\n self.volume_quotas_mock.delete.assert_not_called()\n self.network_mock.delete_quota.assert_called_once_with(\n self.projects[0].id,\n )","def remove(self):\n\t\tcall_sdk_function('PrlShare_Remove', self.handle)","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_004_delete(self):\n ret = svcmgr.main(argv=[\"delete\", \"-s\", SVCNAME, \"--local\"])\n assert ret == 0","def test_delete_cluster_policy(self):\n pass","def test_delete_host_subnet(self):\n pass","def check_instance_shared_storage_cleanup(self, context, data):\n pass","def test_delete_remote(self):\n # Create source site and remote project\n source_site = self.make_site(\n name=REMOTE_SITE_NAME,\n url=REMOTE_SITE_URL,\n mode=SITE_MODE_SOURCE,\n description=REMOTE_SITE_DESC,\n secret=REMOTE_SITE_SECRET,\n )\n self.make_remote_project(\n project_uuid=self.project.sodar_uuid,\n project=self.project,\n site=source_site,\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\n )\n self.assertEqual(RoleAssignment.objects.count(), 3)\n url = reverse(\n 'projectroles:api_role_destroy',\n kwargs={'roleassignment': self.update_as.sodar_uuid},\n )\n response = self.request_knox(url, method='DELETE')\n self.assertEqual(response.status_code, 400, msg=response.content)\n self.assertEqual(RoleAssignment.objects.count(), 3)","def destroy_node(self):\n driver = self.driver\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\n driver.destroy_node(self.node)\n sleep(15)\n for volume in self.volumes:\n driver.destroy_volume(volume)","def test_destroy_container(self):\n pass","def test_delete_underscore():\n pytest.raises(SaltInvocationError, mac_group.delete, \"_Test\")","def test_create_delete_space(self):\n\n # Make clients\n kibana = Kibana(host=self.kibana_host, username=self.username, password=self.password)\n\n # Parameters\n space_id = random_id()\n\n try:\n # Create spaces\n result = kibana.create_space(space_id, \"Test Space\")\n self.assertTrue(result)\n\n # Delete space\n result = kibana.delete_space(space_id)\n self.assertFalse(result)\n finally:\n # Delete space\n kibana.delete_space(space_id)","def _delete_network_vm(args):\n libvirtConn = libvirt.openReadOnly(None)\n if libvirtConn is None:\n print('Cannot contact hypervisor', file=sys.stderr)\n return 1\n net = None\n try:\n net = libvirtConn.networkLookupByName(args.network_name)\n except libvirt.libvirtError:\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\n return 1\n print('Network found:\\n')\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\" \", newl=''))\n print('')\n\n if not args.yes:\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\n return 1\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)","def test_delete_hyperflex_server_model(self):\n pass","def unShare(sharedItem):\n sharedItem.store.query(Share, Share.sharedItem == sharedItem).deleteFromStore()","def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\n network_delete_mock.assert_called_with(resources.network)\n self.assertTrue(resources._hypervisor.close.called)","def umount_nfs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_remove_provider_from_inst_alloc_no_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def test_delete_device(self):\n pass","def test_delete_device(self):\n pass","def test_networking_project_network_delete(self):\n pass","def test_ipam_vrfs_delete(self):\n pass","def test_delete_system_asset(self):\n pass","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_destroy_container_privilege(self):\n pass","def test_delete_collection_cluster_network(self):\n pass","def test_sg_delete_create_same(self):\n\n # Add a faked storage_group to be tested and another one\n faked_storage_group = self.add_storage_group1()\n storage_group_name = faked_storage_group.name\n self.add_storage_group2()\n\n # Construct the input properties for a third storage_group\n sg3_props = copy.deepcopy(faked_storage_group.properties)\n sg3_props['description'] = 'Third storage_group'\n\n storage_group_mgr = self.console.storage_groups\n storage_group = storage_group_mgr.find(name=storage_group_name)\n\n # Execute the deletion code to be tested.\n storage_group.delete()\n\n # Check that the storage_group no longer exists\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=storage_group_name)\n\n # Execute the creation code to be tested.\n storage_group_mgr.create(sg3_props)\n\n # Check that the storage_group exists again under that name\n storage_group3 = storage_group_mgr.find(name=storage_group_name)\n description = storage_group3.get_property('description')\n assert description == 'Third storage_group'","def destroy(name, call=None):\n if call == \"function\":\n raise SaltCloudSystemExit(\n \"The destroy action must be called with -d, --destroy, -a or --action.\"\n )\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroying instance\",\n \"salt/cloud/{}/destroying\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n datacenter_id = get_datacenter_id()\n conn = get_conn()\n node = get_node(conn, name)\n attached_volumes = None\n\n delete_volumes = config.get_cloud_config_value(\n \"delete_volumes\", get_configured_provider(), __opts__, search_global=False\n )\n # Get volumes before the server is deleted\n attached_volumes = conn.get_attached_volumes(\n datacenter_id=datacenter_id, server_id=node[\"id\"]\n )\n\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\"id\"])\n\n # The server is deleted and now is safe to delete the volumes\n if delete_volumes:\n for vol in attached_volumes[\"items\"]:\n log.debug(\"Deleting volume %s\", vol[\"id\"])\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\"id\"])\n log.debug(\"Deleted volume %s\", vol[\"id\"])\n\n __utils__[\"cloud.fire_event\"](\n \"event\",\n \"destroyed instance\",\n \"salt/cloud/{}/destroyed\".format(name),\n args={\"name\": name},\n sock_dir=__opts__[\"sock_dir\"],\n transport=__opts__[\"transport\"],\n )\n\n if __opts__.get(\"update_cachedir\", False) is True:\n __utils__[\"cloud.delete_minion_cachedir\"](\n name, _get_active_provider_name().split(\":\")[0], __opts__\n )\n\n return True","def test_destroy_owner(self):\n\n self.assertEqual(first=1, second=Post.objects.all().count())\n url = reverse('post-detail', args=(self.post.id,))\n self.client.credentials(HTTP_AUTHORIZATION=self.token)\n response = self.client.delete(path=url)\n self.assertEqual(first=204, second=response.status_code)\n self.assertEqual(first=0, second=Post.objects.all().count())","def _quota_destroy_all_by_share_type(context, share_type_id, project_id=None):\n share_type_quotas = model_query(\n context, models.ProjectShareTypeQuota,\n read_deleted=\"no\",\n ).filter_by(share_type_id=share_type_id)\n\n share_type_quota_usages = model_query(\n context, models.QuotaUsage, read_deleted=\"no\",\n ).filter_by(share_type_id=share_type_id)\n\n share_type_quota_reservations = model_query(\n context, models.Reservation, read_deleted=\"no\",\n ).filter_by(share_type_id=share_type_id)\n\n if project_id is not None:\n share_type_quotas = share_type_quotas.filter_by(\n project_id=project_id,\n )\n share_type_quota_usages = share_type_quota_usages.filter_by(\n project_id=project_id,\n )\n share_type_quota_reservations = (\n share_type_quota_reservations.filter_by(project_id=project_id)\n )\n\n share_type_quotas.soft_delete(synchronize_session=False)\n share_type_quota_usages.soft_delete(synchronize_session=False)\n share_type_quota_reservations.soft_delete(synchronize_session=False)","def destroy():\n pass","def destroy():\n pass","def test_aws_service_api_volume_delete(self):\n pass","def test_aws_service_api_vm_delete(self):\n pass","def doDestroyMe(self, *args, **kwargs):\n self.target_domain = None\n self.renew_years = None\n self.sync_contacts = None\n self.sync_nameservers = None\n self.verify_owner = None\n self.latest_domain_info = None\n self.destroy()","def cleanup(self, context, instance, network_info, block_device_info=None,\n destroy_disks=True):\n pass","def destroy(self, context, instance, network_info, cleanup=True):\n LOG.debug(\"destroy\")\n\n bmm = db.bmm_get_by_instance_id(context, instance[\"id\"])\n db.bmm_update(context, bmm[\"id\"], {\"status\": \"processing\"})\n mac = self._get_pxe_mac(bmm)\n\n # update ofc\n self._update_ofc_for_destroy(context, bmm)\n db.bmm_update(context, bmm[\"id\"], {\"vlan_id\": None,\n \"availability_zone\": \"resource_pool\"})\n\n # begin to delete os\n self._cp_template(\"delete.sh\",\n self._get_cobbler_instance_path(instance, \"delete.sh\"), \n {\"INSTANCE_ID\": instance[\"id\"],\n \"COBBLER\": FLAGS.cobbler,\n \"MONITOR_PORT\": FLAGS.dodai_monitor_port})\n self._cp_template(\"pxeboot_action\",\n self._get_pxe_boot_file(mac),\n {\"INSTANCE_ID\": instance[\"id\"], \n \"COBBLER\": FLAGS.cobbler,\n \"PXE_MAC\": bmm[\"pxe_mac\"],\n \"ACTION\": \"delete\"})\n self._reboot_or_power_on(bmm[\"ipmi_ip\"])\n\n # wait until starting to delete os\n while self._get_state(context, instance) != \"deleted\":\n greenthread.sleep(20)\n LOG.debug(\"Wait until data of instance %s was deleted.\" % instance[\"id\"])\n\n utils.execute(\"rm\", \"-rf\", self._get_cobbler_instance_path(instance));\n\n # update db\n db.bmm_update(context, bmm[\"id\"], {\"instance_id\": None, \n \"service_ip\": None})\n\n return db.bmm_get(context, bmm[\"id\"])","def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\n {'source_path': '/bar',\n 'target_path': '/baz'}})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')","def test_unshare_template_registration(self):\n pass","def test_delete_owner(self):\n self.assertEqual(RoleAssignment.objects.count(), 3)\n url = reverse(\n 'projectroles:api_role_destroy',\n kwargs={'roleassignment': self.owner_as.sodar_uuid},\n )\n response = self.request_knox(url, method='DELETE')\n self.assertEqual(response.status_code, 400, msg=response.content)\n self.assertEqual(RoleAssignment.objects.count(), 3)","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_remove_provider_from_inst_alloc_with_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def test_dashboards_v2_share(self):\n pass","def delete():","def test_delete_cloud(self):\n pass","def SafeBridgeDestroy(bridge):\n #try:\n # bridge.destroy()\n #except requests.HTTPError as e:\n # if e.response.status_code != requests.codes.not_found:\n # print e.response.status_code\n try:\n bridge.destroy()\n except:\n return","def test_cluster_delete(self, mock_is_service_available):\n\n mock_is_service_available.return_value = True\n fake_cluster = FakeCluster(**RETURN_CLUSTER_1)\n cluster = self._create_test_cluster(\n fake_cluster, 'stack_delete', CREATE_CLUSTER_ARG_1)\n scheduler.TaskRunner(cluster.create)()\n self.m.UnsetStubs()\n self.setup_cluster_delete(cluster)\n scheduler.TaskRunner(cluster.delete)()\n self.assertEqual((cluster.DELETE, cluster.COMPLETE), cluster.state)\n self.m.VerifyAll()\n self.m.UnsetStubs()","def test_delete_hyperflex_node_profile(self):\n pass","def test_delete_bios_policy(self):\n pass","def test_01_self_unshare_resource(self):\n holes = self.holes\n cat = self.cat\n dog = self.dog\n cat.uaccess.share_resource_with_user(holes, dog, PrivilegeCodes.CHANGE)\n self.assertTrue(dog in holes.raccess.edit_users)\n self.assertTrue(dog in holes.raccess.view_users)\n self.assertTrue(\n is_equal_to_as_set(\n [dog],\n dog.uaccess.get_resource_unshare_users(holes)))\n dog.uaccess.unshare_resource_with_user(holes, dog)\n self.assertFalse(dog in holes.raccess.edit_users)\n self.assertFalse(dog in holes.raccess.view_users)\n self.assertTrue(\n is_equal_to_as_set(\n [], dog.uaccess.get_resource_unshare_users(holes)))","def test_delete_namespaced_image_stream(self):\n pass","def test_delete_hyperflex_server_firmware_version(self):\n pass","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def delete_remote_access_session(arn=None):\n pass","def delete_volume(self, volume):\n nfs_share = volume.get('provider_location')\n if nfs_share:\n nms = self.share2nms[nfs_share]\n vol, parent_folder = self._get_share_datasets(nfs_share)\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\n mount_path = self.remote_path(volume).strip(\n '/%s' % self.VOLUME_FILE_NAME)\n if mount_path in self._remotefsclient._read_mounts():\n cinder.privsep.fs.umount(mount_path)\n try:\n props = nms.folder.get_child_props(folder, 'origin') or {}\n nms.folder.destroy(folder, '-r')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Folder %s does not exist, it was '\n 'already deleted.', folder)\n return\n raise\n self._get_capacity_info(nfs_share)\n origin = props.get('origin')\n if origin and self._is_clone_snapshot_name(origin):\n try:\n nms.snapshot.destroy(origin, '')\n except utils.NexentaException as exc:\n if 'does not exist' in exc.args[0]:\n LOG.info('Snapshot %s does not exist, it was '\n 'already deleted.', origin)\n return\n raise","def perform_destroy(self, instance):\n pass","def test_deallocate_virt_realm(self):\n pass","def test_destroy_exit_code(destroy_result: Result) -> None:\n assert destroy_result.exit_code == 0","def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\n wallet = tt.Wallet(attach_to=node)\n\n wallet.create_account(\"goku1\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\n wallet.create_account(\"steem\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\n\n with wallet.in_single_transaction():\n wallet.api.delegate_vesting_shares(\"goku1\", \"steem\", tt.Asset.Vest(5))\n wallet.api.delegate_vesting_shares(\"steem\", \"goku1\", tt.Asset.Vest(10))\n\n assert get_hardfork_version(node) == \"0.22.0\"\n assert_account_resources(node, \"goku1\", operator.gt)\n assert_account_resources(node, \"steem\", operator.gt)\n\n __wait_for_hardfork_23_application(node)\n assert get_hardfork_version(node) == \"0.23.0\"\n\n assert_account_resources(node, \"goku1\", operator.eq)\n assert_account_resources(node, \"steem\", operator.eq)\n\n assert_cleared_resources_in_hardfork_hive_operation(node, \"goku1\")\n assert_cleared_resources_in_hardfork_hive_operation(node, \"steem\")","def do_destroy(self, arg):\n obj = self.verify(arg, 2)\n if obj:\n del storage.all()[obj]\n storage.save()"],"string":"[\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def delete_share(self, context, share, share_server=None):\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n if not volume_uuid:\\n LOG.warning(\\\"No volume found for \\\"\\n \\\"share %(project_id)s/%(name)s\\\",\\n {\\\"project_id\\\": share['project_id'],\\n \\\"name\\\": share['name']})\\n return\\n\\n if self.configuration.quobyte_delete_shares:\\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\\n else:\\n self.rpc.call('exportVolume', {\\\"volume_uuid\\\": volume_uuid,\\n \\\"remove_export\\\": True,\\n })\",\n \"def delete_share(self, pool, project, share):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.delete(svc)\\n if ret.status != restclient.Status.NO_CONTENT:\\n exception_msg = (('Error deleting '\\n 'share: %(share)s to '\\n 'pool: %(pool)s '\\n 'project: %(project)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.'),\\n {'share': share,\\n 'pool': pool,\\n 'project': project,\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n LOG.error(exception_msg)\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def _cleanup_create_share(self, share_path, share_name):\\n if os.path.exists(share_path):\\n cmd = ['rm', '-rf', share_path]\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError as exc:\\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\\n 'during its creation, but exists in GlusterFS '\\n 'volume.'), share_name)\\n raise exception.GlusterfsException(exc)\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_delete_cluster_network(self):\\n pass\",\n \"def delete_share(self, context, share, share_server=None):\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['rm', '-rf', local_share_path]\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError:\\n LOG.error(_LE('Unable to delete share %s'), share['name'])\\n raise\",\n \"def test_delete_network(self):\\n pass\",\n \"def test_sg_delete_non_associated(self):\\n\\n # Add a faked storage group to be tested and another one\\n faked_storage_group = self.add_storage_group1()\\n self.add_storage_group2()\\n\\n storage_group_mgr = self.console.storage_groups\\n\\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\\n\\n # Execute the code to be tested.\\n storage_group.delete()\\n\\n # Check that the storage group no longer exists\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=faked_storage_group.name)\",\n \"def test_delete_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_delete_net_namespace(self):\\n pass\",\n \"async def test_endpoint_delete_container_shares_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_container_shares_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_delete_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_delete_cluster_resource_quota(self):\\n pass\",\n \"def test_delete_hyperflex_cluster_profile(self):\\n pass\",\n \"def delete_cluster(self):\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_delete_ns_descriptors_nsdinfoid(delete_ns_descriptors_nsdinfoid_keys):\\r\\n sonata_vnfpkgm = SONATAClient.VnfPkgm(HOST_URL)\\r\\n sonata_nsd = SONATAClient.Nsd(HOST_URL)\\r\\n sonata_auth = SONATAClient.Auth(HOST_URL)\\r\\n _token = json.loads(sonata_auth.auth(username=USERNAME, password=PASSWORD))\\r\\n _token = json.loads(_token[\\\"data\\\"])\\r\\n \\r\\n _nsd_list = json.loads(sonata_nsd.get_ns_descriptors(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"]))\\r\\n _nsd_list = json.loads(_nsd_list[\\\"data\\\"])\\r\\n \\r\\n _nsd = None\\r\\n for _n in _nsd_list:\\r\\n if \\\"sonata-demo\\\" == _n['nsd']['name']:\\r\\n _nsd = _n['uuid']\\r\\n \\r\\n \\r\\n time.sleep(10) # Wait for NSD onboarding\\r\\n response = json.loads(sonata_nsd.delete_ns_descriptors_nsdinfoid(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"],\\r\\n nsdinfoid=_nsd))\\r\\n assert isinstance(response, dict)\\r\\n assert response[\\\"data\\\"] == \\\"{\\\\\\\"error\\\\\\\":\\\\\\\"The NSD ID None does not exist\\\\\\\"}\\\"\\r\\n \\r\\n time.sleep(2) #Wait for NSD onboarding\\r\\n\\r\\n _vnfd_list = json.loads(sonata_vnfpkgm.get_vnf_packages(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"]))\\r\\n _vnfd_list = json.loads(_vnfd_list[\\\"data\\\"])\\r\\n\\r\\n _vnfd = None\\r\\n for _v in _vnfd_list:\\r\\n if \\\"vnfd_example\\\" == _v['uuid']: \\r\\n _vnfd = _v['uuid']\\r\\n\\r\\n response = None\\r\\n if _vnfd:\\r\\n response = json.loads(sonata_vnfpkgm.delete_vnf_packages_vnfpkgid(\\r\\n token=_token[\\\"token\\\"][\\\"access_token\\\"], vnfPkgId=_vnfd))\\r\\n assert isinstance(response, dict)\\r\\n assert response[\\\"data\\\"] == \\\"\\\"\",\n \"def test_delete__network(self):\\n arglist = [\\n '--network',\\n self.projects[0].id,\\n ]\\n verifylist = [\\n ('service', 'network'),\\n ('project', self.projects[0].id),\\n ]\\n\\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\\n\\n result = self.cmd.take_action(parsed_args)\\n\\n self.assertIsNone(result)\\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\\n self.compute_quotas_mock.delete.assert_not_called()\\n self.volume_quotas_mock.delete.assert_not_called()\\n self.network_mock.delete_quota.assert_called_once_with(\\n self.projects[0].id,\\n )\",\n \"def remove(self):\\n\\t\\tcall_sdk_function('PrlShare_Remove', self.handle)\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_004_delete(self):\\n ret = svcmgr.main(argv=[\\\"delete\\\", \\\"-s\\\", SVCNAME, \\\"--local\\\"])\\n assert ret == 0\",\n \"def test_delete_cluster_policy(self):\\n pass\",\n \"def test_delete_host_subnet(self):\\n pass\",\n \"def check_instance_shared_storage_cleanup(self, context, data):\\n pass\",\n \"def test_delete_remote(self):\\n # Create source site and remote project\\n source_site = self.make_site(\\n name=REMOTE_SITE_NAME,\\n url=REMOTE_SITE_URL,\\n mode=SITE_MODE_SOURCE,\\n description=REMOTE_SITE_DESC,\\n secret=REMOTE_SITE_SECRET,\\n )\\n self.make_remote_project(\\n project_uuid=self.project.sodar_uuid,\\n project=self.project,\\n site=source_site,\\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\\n )\\n self.assertEqual(RoleAssignment.objects.count(), 3)\\n url = reverse(\\n 'projectroles:api_role_destroy',\\n kwargs={'roleassignment': self.update_as.sodar_uuid},\\n )\\n response = self.request_knox(url, method='DELETE')\\n self.assertEqual(response.status_code, 400, msg=response.content)\\n self.assertEqual(RoleAssignment.objects.count(), 3)\",\n \"def destroy_node(self):\\n driver = self.driver\\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\\n driver.destroy_node(self.node)\\n sleep(15)\\n for volume in self.volumes:\\n driver.destroy_volume(volume)\",\n \"def test_destroy_container(self):\\n pass\",\n \"def test_delete_underscore():\\n pytest.raises(SaltInvocationError, mac_group.delete, \\\"_Test\\\")\",\n \"def test_create_delete_space(self):\\n\\n # Make clients\\n kibana = Kibana(host=self.kibana_host, username=self.username, password=self.password)\\n\\n # Parameters\\n space_id = random_id()\\n\\n try:\\n # Create spaces\\n result = kibana.create_space(space_id, \\\"Test Space\\\")\\n self.assertTrue(result)\\n\\n # Delete space\\n result = kibana.delete_space(space_id)\\n self.assertFalse(result)\\n finally:\\n # Delete space\\n kibana.delete_space(space_id)\",\n \"def _delete_network_vm(args):\\n libvirtConn = libvirt.openReadOnly(None)\\n if libvirtConn is None:\\n print('Cannot contact hypervisor', file=sys.stderr)\\n return 1\\n net = None\\n try:\\n net = libvirtConn.networkLookupByName(args.network_name)\\n except libvirt.libvirtError:\\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\\n return 1\\n print('Network found:\\\\n')\\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\\\" \\\", newl=''))\\n print('')\\n\\n if not args.yes:\\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\\n return 1\\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)\",\n \"def test_delete_hyperflex_server_model(self):\\n pass\",\n \"def unShare(sharedItem):\\n sharedItem.store.query(Share, Share.sharedItem == sharedItem).deleteFromStore()\",\n \"def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\\n network_delete_mock.assert_called_with(resources.network)\\n self.assertTrue(resources._hypervisor.close.called)\",\n \"def umount_nfs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_remove_provider_from_inst_alloc_no_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_networking_project_network_delete(self):\\n pass\",\n \"def test_ipam_vrfs_delete(self):\\n pass\",\n \"def test_delete_system_asset(self):\\n pass\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_destroy_container_privilege(self):\\n pass\",\n \"def test_delete_collection_cluster_network(self):\\n pass\",\n \"def test_sg_delete_create_same(self):\\n\\n # Add a faked storage_group to be tested and another one\\n faked_storage_group = self.add_storage_group1()\\n storage_group_name = faked_storage_group.name\\n self.add_storage_group2()\\n\\n # Construct the input properties for a third storage_group\\n sg3_props = copy.deepcopy(faked_storage_group.properties)\\n sg3_props['description'] = 'Third storage_group'\\n\\n storage_group_mgr = self.console.storage_groups\\n storage_group = storage_group_mgr.find(name=storage_group_name)\\n\\n # Execute the deletion code to be tested.\\n storage_group.delete()\\n\\n # Check that the storage_group no longer exists\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=storage_group_name)\\n\\n # Execute the creation code to be tested.\\n storage_group_mgr.create(sg3_props)\\n\\n # Check that the storage_group exists again under that name\\n storage_group3 = storage_group_mgr.find(name=storage_group_name)\\n description = storage_group3.get_property('description')\\n assert description == 'Third storage_group'\",\n \"def destroy(name, call=None):\\n if call == \\\"function\\\":\\n raise SaltCloudSystemExit(\\n \\\"The destroy action must be called with -d, --destroy, -a or --action.\\\"\\n )\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroying instance\\\",\\n \\\"salt/cloud/{}/destroying\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n datacenter_id = get_datacenter_id()\\n conn = get_conn()\\n node = get_node(conn, name)\\n attached_volumes = None\\n\\n delete_volumes = config.get_cloud_config_value(\\n \\\"delete_volumes\\\", get_configured_provider(), __opts__, search_global=False\\n )\\n # Get volumes before the server is deleted\\n attached_volumes = conn.get_attached_volumes(\\n datacenter_id=datacenter_id, server_id=node[\\\"id\\\"]\\n )\\n\\n conn.delete_server(datacenter_id=datacenter_id, server_id=node[\\\"id\\\"])\\n\\n # The server is deleted and now is safe to delete the volumes\\n if delete_volumes:\\n for vol in attached_volumes[\\\"items\\\"]:\\n log.debug(\\\"Deleting volume %s\\\", vol[\\\"id\\\"])\\n conn.delete_volume(datacenter_id=datacenter_id, volume_id=vol[\\\"id\\\"])\\n log.debug(\\\"Deleted volume %s\\\", vol[\\\"id\\\"])\\n\\n __utils__[\\\"cloud.fire_event\\\"](\\n \\\"event\\\",\\n \\\"destroyed instance\\\",\\n \\\"salt/cloud/{}/destroyed\\\".format(name),\\n args={\\\"name\\\": name},\\n sock_dir=__opts__[\\\"sock_dir\\\"],\\n transport=__opts__[\\\"transport\\\"],\\n )\\n\\n if __opts__.get(\\\"update_cachedir\\\", False) is True:\\n __utils__[\\\"cloud.delete_minion_cachedir\\\"](\\n name, _get_active_provider_name().split(\\\":\\\")[0], __opts__\\n )\\n\\n return True\",\n \"def test_destroy_owner(self):\\n\\n self.assertEqual(first=1, second=Post.objects.all().count())\\n url = reverse('post-detail', args=(self.post.id,))\\n self.client.credentials(HTTP_AUTHORIZATION=self.token)\\n response = self.client.delete(path=url)\\n self.assertEqual(first=204, second=response.status_code)\\n self.assertEqual(first=0, second=Post.objects.all().count())\",\n \"def _quota_destroy_all_by_share_type(context, share_type_id, project_id=None):\\n share_type_quotas = model_query(\\n context, models.ProjectShareTypeQuota,\\n read_deleted=\\\"no\\\",\\n ).filter_by(share_type_id=share_type_id)\\n\\n share_type_quota_usages = model_query(\\n context, models.QuotaUsage, read_deleted=\\\"no\\\",\\n ).filter_by(share_type_id=share_type_id)\\n\\n share_type_quota_reservations = model_query(\\n context, models.Reservation, read_deleted=\\\"no\\\",\\n ).filter_by(share_type_id=share_type_id)\\n\\n if project_id is not None:\\n share_type_quotas = share_type_quotas.filter_by(\\n project_id=project_id,\\n )\\n share_type_quota_usages = share_type_quota_usages.filter_by(\\n project_id=project_id,\\n )\\n share_type_quota_reservations = (\\n share_type_quota_reservations.filter_by(project_id=project_id)\\n )\\n\\n share_type_quotas.soft_delete(synchronize_session=False)\\n share_type_quota_usages.soft_delete(synchronize_session=False)\\n share_type_quota_reservations.soft_delete(synchronize_session=False)\",\n \"def destroy():\\n pass\",\n \"def destroy():\\n pass\",\n \"def test_aws_service_api_volume_delete(self):\\n pass\",\n \"def test_aws_service_api_vm_delete(self):\\n pass\",\n \"def doDestroyMe(self, *args, **kwargs):\\n self.target_domain = None\\n self.renew_years = None\\n self.sync_contacts = None\\n self.sync_nameservers = None\\n self.verify_owner = None\\n self.latest_domain_info = None\\n self.destroy()\",\n \"def cleanup(self, context, instance, network_info, block_device_info=None,\\n destroy_disks=True):\\n pass\",\n \"def destroy(self, context, instance, network_info, cleanup=True):\\n LOG.debug(\\\"destroy\\\")\\n\\n bmm = db.bmm_get_by_instance_id(context, instance[\\\"id\\\"])\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"status\\\": \\\"processing\\\"})\\n mac = self._get_pxe_mac(bmm)\\n\\n # update ofc\\n self._update_ofc_for_destroy(context, bmm)\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"vlan_id\\\": None,\\n \\\"availability_zone\\\": \\\"resource_pool\\\"})\\n\\n # begin to delete os\\n self._cp_template(\\\"delete.sh\\\",\\n self._get_cobbler_instance_path(instance, \\\"delete.sh\\\"), \\n {\\\"INSTANCE_ID\\\": instance[\\\"id\\\"],\\n \\\"COBBLER\\\": FLAGS.cobbler,\\n \\\"MONITOR_PORT\\\": FLAGS.dodai_monitor_port})\\n self._cp_template(\\\"pxeboot_action\\\",\\n self._get_pxe_boot_file(mac),\\n {\\\"INSTANCE_ID\\\": instance[\\\"id\\\"], \\n \\\"COBBLER\\\": FLAGS.cobbler,\\n \\\"PXE_MAC\\\": bmm[\\\"pxe_mac\\\"],\\n \\\"ACTION\\\": \\\"delete\\\"})\\n self._reboot_or_power_on(bmm[\\\"ipmi_ip\\\"])\\n\\n # wait until starting to delete os\\n while self._get_state(context, instance) != \\\"deleted\\\":\\n greenthread.sleep(20)\\n LOG.debug(\\\"Wait until data of instance %s was deleted.\\\" % instance[\\\"id\\\"])\\n\\n utils.execute(\\\"rm\\\", \\\"-rf\\\", self._get_cobbler_instance_path(instance));\\n\\n # update db\\n db.bmm_update(context, bmm[\\\"id\\\"], {\\\"instance_id\\\": None, \\n \\\"service_ip\\\": None})\\n\\n return db.bmm_get(context, bmm[\\\"id\\\"])\",\n \"def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\\n {'source_path': '/bar',\\n 'target_path': '/baz'}})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')\",\n \"def test_unshare_template_registration(self):\\n pass\",\n \"def test_delete_owner(self):\\n self.assertEqual(RoleAssignment.objects.count(), 3)\\n url = reverse(\\n 'projectroles:api_role_destroy',\\n kwargs={'roleassignment': self.owner_as.sodar_uuid},\\n )\\n response = self.request_knox(url, method='DELETE')\\n self.assertEqual(response.status_code, 400, msg=response.content)\\n self.assertEqual(RoleAssignment.objects.count(), 3)\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_remove_provider_from_inst_alloc_with_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def delete():\",\n \"def test_delete_cloud(self):\\n pass\",\n \"def SafeBridgeDestroy(bridge):\\n #try:\\n # bridge.destroy()\\n #except requests.HTTPError as e:\\n # if e.response.status_code != requests.codes.not_found:\\n # print e.response.status_code\\n try:\\n bridge.destroy()\\n except:\\n return\",\n \"def test_cluster_delete(self, mock_is_service_available):\\n\\n mock_is_service_available.return_value = True\\n fake_cluster = FakeCluster(**RETURN_CLUSTER_1)\\n cluster = self._create_test_cluster(\\n fake_cluster, 'stack_delete', CREATE_CLUSTER_ARG_1)\\n scheduler.TaskRunner(cluster.create)()\\n self.m.UnsetStubs()\\n self.setup_cluster_delete(cluster)\\n scheduler.TaskRunner(cluster.delete)()\\n self.assertEqual((cluster.DELETE, cluster.COMPLETE), cluster.state)\\n self.m.VerifyAll()\\n self.m.UnsetStubs()\",\n \"def test_delete_hyperflex_node_profile(self):\\n pass\",\n \"def test_delete_bios_policy(self):\\n pass\",\n \"def test_01_self_unshare_resource(self):\\n holes = self.holes\\n cat = self.cat\\n dog = self.dog\\n cat.uaccess.share_resource_with_user(holes, dog, PrivilegeCodes.CHANGE)\\n self.assertTrue(dog in holes.raccess.edit_users)\\n self.assertTrue(dog in holes.raccess.view_users)\\n self.assertTrue(\\n is_equal_to_as_set(\\n [dog],\\n dog.uaccess.get_resource_unshare_users(holes)))\\n dog.uaccess.unshare_resource_with_user(holes, dog)\\n self.assertFalse(dog in holes.raccess.edit_users)\\n self.assertFalse(dog in holes.raccess.view_users)\\n self.assertTrue(\\n is_equal_to_as_set(\\n [], dog.uaccess.get_resource_unshare_users(holes)))\",\n \"def test_delete_namespaced_image_stream(self):\\n pass\",\n \"def test_delete_hyperflex_server_firmware_version(self):\\n pass\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def delete_remote_access_session(arn=None):\\n pass\",\n \"def delete_volume(self, volume):\\n nfs_share = volume.get('provider_location')\\n if nfs_share:\\n nms = self.share2nms[nfs_share]\\n vol, parent_folder = self._get_share_datasets(nfs_share)\\n folder = '%s/%s/%s' % (vol, parent_folder, volume['name'])\\n mount_path = self.remote_path(volume).strip(\\n '/%s' % self.VOLUME_FILE_NAME)\\n if mount_path in self._remotefsclient._read_mounts():\\n cinder.privsep.fs.umount(mount_path)\\n try:\\n props = nms.folder.get_child_props(folder, 'origin') or {}\\n nms.folder.destroy(folder, '-r')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Folder %s does not exist, it was '\\n 'already deleted.', folder)\\n return\\n raise\\n self._get_capacity_info(nfs_share)\\n origin = props.get('origin')\\n if origin and self._is_clone_snapshot_name(origin):\\n try:\\n nms.snapshot.destroy(origin, '')\\n except utils.NexentaException as exc:\\n if 'does not exist' in exc.args[0]:\\n LOG.info('Snapshot %s does not exist, it was '\\n 'already deleted.', origin)\\n return\\n raise\",\n \"def perform_destroy(self, instance):\\n pass\",\n \"def test_deallocate_virt_realm(self):\\n pass\",\n \"def test_destroy_exit_code(destroy_result: Result) -> None:\\n assert destroy_result.exit_code == 0\",\n \"def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\\n wallet = tt.Wallet(attach_to=node)\\n\\n wallet.create_account(\\\"goku1\\\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\\n wallet.create_account(\\\"steem\\\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\\n\\n with wallet.in_single_transaction():\\n wallet.api.delegate_vesting_shares(\\\"goku1\\\", \\\"steem\\\", tt.Asset.Vest(5))\\n wallet.api.delegate_vesting_shares(\\\"steem\\\", \\\"goku1\\\", tt.Asset.Vest(10))\\n\\n assert get_hardfork_version(node) == \\\"0.22.0\\\"\\n assert_account_resources(node, \\\"goku1\\\", operator.gt)\\n assert_account_resources(node, \\\"steem\\\", operator.gt)\\n\\n __wait_for_hardfork_23_application(node)\\n assert get_hardfork_version(node) == \\\"0.23.0\\\"\\n\\n assert_account_resources(node, \\\"goku1\\\", operator.eq)\\n assert_account_resources(node, \\\"steem\\\", operator.eq)\\n\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"goku1\\\")\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"steem\\\")\",\n \"def do_destroy(self, arg):\\n obj = self.verify(arg, 2)\\n if obj:\\n del storage.all()[obj]\\n storage.save()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9417224","0.8834285","0.7744262","0.758655","0.75549483","0.7326083","0.7300899","0.7292167","0.72800195","0.71851236","0.71172214","0.70820516","0.69532496","0.690352","0.67362416","0.6723919","0.67131734","0.67035735","0.6650557","0.6545809","0.6408519","0.63759446","0.63657004","0.63494784","0.61962914","0.6162761","0.61355436","0.61142975","0.606124","0.6050766","0.60006636","0.5942741","0.5898523","0.589036","0.58788884","0.5833212","0.5805301","0.57856774","0.5764875","0.5758553","0.57486606","0.56798786","0.56777424","0.56708366","0.5652078","0.56460524","0.5640503","0.5634639","0.56332517","0.5631501","0.56201434","0.5614425","0.5613901","0.5608905","0.55856377","0.5584779","0.55837876","0.55809754","0.55795944","0.55795944","0.557739","0.5573986","0.55562437","0.5552855","0.5540529","0.55282074","0.55277866","0.55254877","0.5523902","0.5520826","0.5511406","0.5511406","0.54840636","0.5475237","0.5466053","0.54604113","0.5442384","0.54393977","0.5438954","0.5438484","0.54306346","0.5430256","0.54270166","0.5425607","0.5400239","0.53976625","0.5397093","0.53932154","0.53896725","0.538334","0.5380258","0.53755206","0.5373822","0.53660524","0.5366014","0.53650403","0.5364774","0.53614074","0.5360985","0.53603387"],"string":"[\n \"0.9417224\",\n \"0.8834285\",\n \"0.7744262\",\n \"0.758655\",\n \"0.75549483\",\n \"0.7326083\",\n \"0.7300899\",\n \"0.7292167\",\n \"0.72800195\",\n \"0.71851236\",\n \"0.71172214\",\n \"0.70820516\",\n \"0.69532496\",\n \"0.690352\",\n \"0.67362416\",\n \"0.6723919\",\n \"0.67131734\",\n \"0.67035735\",\n \"0.6650557\",\n \"0.6545809\",\n \"0.6408519\",\n \"0.63759446\",\n \"0.63657004\",\n \"0.63494784\",\n \"0.61962914\",\n \"0.6162761\",\n \"0.61355436\",\n \"0.61142975\",\n \"0.606124\",\n \"0.6050766\",\n \"0.60006636\",\n \"0.5942741\",\n \"0.5898523\",\n \"0.589036\",\n \"0.58788884\",\n \"0.5833212\",\n \"0.5805301\",\n \"0.57856774\",\n \"0.5764875\",\n \"0.5758553\",\n \"0.57486606\",\n \"0.56798786\",\n \"0.56777424\",\n \"0.56708366\",\n \"0.5652078\",\n \"0.56460524\",\n \"0.5640503\",\n \"0.5634639\",\n \"0.56332517\",\n \"0.5631501\",\n \"0.56201434\",\n \"0.5614425\",\n \"0.5613901\",\n \"0.5608905\",\n \"0.55856377\",\n \"0.5584779\",\n \"0.55837876\",\n \"0.55809754\",\n \"0.55795944\",\n \"0.55795944\",\n \"0.557739\",\n \"0.5573986\",\n \"0.55562437\",\n \"0.5552855\",\n \"0.5540529\",\n \"0.55282074\",\n \"0.55277866\",\n \"0.55254877\",\n \"0.5523902\",\n \"0.5520826\",\n \"0.5511406\",\n \"0.5511406\",\n \"0.54840636\",\n \"0.5475237\",\n \"0.5466053\",\n \"0.54604113\",\n \"0.5442384\",\n \"0.54393977\",\n \"0.5438954\",\n \"0.5438484\",\n \"0.54306346\",\n \"0.5430256\",\n \"0.54270166\",\n \"0.5425607\",\n \"0.5400239\",\n \"0.53976625\",\n \"0.5397093\",\n \"0.53932154\",\n \"0.53896725\",\n \"0.538334\",\n \"0.5380258\",\n \"0.53755206\",\n \"0.5373822\",\n \"0.53660524\",\n \"0.5366014\",\n \"0.53650403\",\n \"0.5364774\",\n \"0.53614074\",\n \"0.5360985\",\n \"0.53603387\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9542495"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81375,"cells":{"query":{"kind":"string","value":"Test case for destroy_nas_share_by_pool"},"document":{"kind":"string","value":"def test_destroy_nas_share_by_pool(self):\n pass"},"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_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_update_nas_share(self):\n pass","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_dashboards_v2_delete_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_delete_cluster_network(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_delete_hyperflex_cluster_network_policy(self):\n pass","def delete_pool(self, pool):\r\n return self.delete(self.pool_path % (pool))","def delete_share(self, pool, project, share):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.delete(svc)\n if ret.status != restclient.Status.NO_CONTENT:\n exception_msg = (('Error deleting '\n 'share: %(share)s to '\n 'pool: %(pool)s '\n 'project: %(project)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.'),\n {'share': share,\n 'pool': pool,\n 'project': project,\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n LOG.error(exception_msg)","def delete_device_pool(arn=None):\n pass","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_delete_cluster_resource_quota(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_delete_network(self):\n pass","def mac_pool_remove(handle, name, parent_dn=\"org-root\"):\r\n dn = parent_dn + '/mac-pool-' + name\r\n mo = handle.query_dn(dn)\r\n if mo:\r\n handle.remove_mo(mo)\r\n handle.commit()\r\n else:\r\n raise ValueError(\"MAC Pool is not available\")","def test_delete_hyperflex_cluster_storage_policy(self):\n pass","def test_delete_hyperflex_cluster_profile(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_sg_delete_non_associated(self):\n\n # Add a faked storage group to be tested and another one\n faked_storage_group = self.add_storage_group1()\n self.add_storage_group2()\n\n storage_group_mgr = self.console.storage_groups\n\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\n\n # Execute the code to be tested.\n storage_group.delete()\n\n # Check that the storage group no longer exists\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=faked_storage_group.name)","def execute(self, pool, vthunder):\n try:\n axapi_version = acos_client.AXAPI_21 if vthunder.axapi_version == 21 else acos_client.AXAPI_30\n c = self.client_factory(vthunder)\n #need to put algorithm logic\n out = c.slb.service_group.delete(pool.id)\n LOG.info(\"Pool deleted successfully.\")\n except Exception as e:\n print(str(e))\n LOG.info(\"Error occurred\")","def test_delete_cluster_policy(self):\n pass","def test_delete_collection_cluster_network(self):\n pass","def test_dhcp_pool_uninstall(self):\n self._common_uninstall_delete(\n 'esg_id|pool_id', dhcp_pool.delete,\n {'pool': {}},\n delete_args=['dhcpPoolID'],\n delete_kwargs={\n 'uri_parameters': {'edgeId': 'esg_id', 'poolID': 'pool_id'}\n }\n )","def test_remove_provider_from_inst_alloc_no_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def destroy_pool(self, context, pool_id=None, host=None):\n if self.cache.get_by_pool_id(pool_id):\n self.destroy_device(pool_id)","def delete_cluster(self):","def test_destroy_container(self):\n pass","def test_delete_net_namespace(self):\n pass","def _clean_up(self):\n StratisCli.destroy_all()\n self.assertEqual(0, len(StratisCli.pool_list()))","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\n network_delete_mock.assert_called_with(resources.network)\n self.assertTrue(resources._hypervisor.close.called)","def delete(self):\n self._lbcall('delete_pool', [self._name])","def test_index_nas_shares(self):\n pass","def test_destroy_container_privilege(self):\n pass","def _cleanup_create_share(self, share_path, share_name):\n if os.path.exists(share_path):\n cmd = ['rm', '-rf', share_path]\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError as exc:\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\n 'during its creation, but exists in GlusterFS '\n 'volume.'), share_name)\n raise exception.GlusterfsException(exc)","def test_delete_resource_used_in_ns_bucket_rpc(\n self, mcg_obj, cld_mgr, ns_resource_factory, bucket_factory\n ):\n # Create the namespace resources and verify health\n _, resource1 = ns_resource_factory()\n _, resource2 = ns_resource_factory()\n\n # Create the namespace bucket on top of the namespace resource\n bucket_factory(\n amount=1,\n interface=\"mcg-namespace\",\n write_ns_resource=resource1,\n read_ns_resources=[resource1, resource2],\n )\n response = mcg_obj.send_rpc_query(\n \"pool_api\", \"delete_namespace_resource\", {\"name\": resource2}\n )\n assert \"error\" in response.json()","def cleanup():\n dist.destroy_process_group()","def test_delete_collection_cluster_resource_quota(self):\n pass","def delete_pool(self, argu):\n\n if not argu:\n LOG.error(\"In delete_pool, it should not pass the None.\")\n\n # delete policy\n self._delete_policy(\n argu['listener_id'],\n argu['session_persistence_type'],\n argu['lb_algorithm']\n )\n\n cmd_apv_no_group = ADCDevice.no_group(argu['pool_id'])\n for base_rest_url in self.base_rest_urls:\n self.run_cli_extend(base_rest_url, cmd_apv_no_group)","def test_remove_provider_from_inst_alloc_with_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def test_delete_cluster_policy_binding(self):\n pass","def check_instance_shared_storage_cleanup(self, context, data):\n pass","def test_delete__network(self):\n arglist = [\n '--network',\n self.projects[0].id,\n ]\n verifylist = [\n ('service', 'network'),\n ('project', self.projects[0].id),\n ]\n\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\n\n result = self.cmd.take_action(parsed_args)\n\n self.assertIsNone(result)\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\n self.compute_quotas_mock.delete.assert_not_called()\n self.volume_quotas_mock.delete.assert_not_called()\n self.network_mock.delete_quota.assert_called_once_with(\n self.projects[0].id,\n )","def test_cleanup_procs(self):\n self.skip_teardown = True\n pool = self.get_pool()\n container = self.get_container(pool)\n dfuse = get_dfuse(self, self.hostlist_clients)\n start_dfuse(self, dfuse, pool=pool, container=container)","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def dist_cleanup():\n dist.destroy_process_group()","def test_delete_host_subnet(self):\n pass","def test_disconnect_volume_no_op(self, mock_remove_p_maps):\n # Mock Data\n inst = mock.MagicMock()\n inst.task_state = None\n\n # Invoke\n self.vol_drv.disconnect_volume(self.adpt, 'host_uuid', 'vm_uuid',\n inst, mock.MagicMock())\n\n # Verify\n self.assertEqual(0, mock_remove_p_maps.call_count)","def destroy_node(self):\n driver = self.driver\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\n driver.destroy_node(self.node)\n sleep(15)\n for volume in self.volumes:\n driver.destroy_volume(volume)","def testAPICleanup(self):\n\n api = API({})\n api.pool = ThreadPool()\n\n # pylint: disable=C2801\n api.__del__()\n\n self.assertIsNone(api.pool)","async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 5,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.current.pool_url == \"\"\n assert status.current.relative_lock_height == 0\n assert status.current.state == 1\n assert status.current.version == 1\n\n assert status.target\n assert status.target.pool_url == \"https://pool.example.com\"\n assert status.target.relative_lock_height == 5\n assert status.target.state == 3\n assert status.target.version == 1\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\n assert leave_pool_tx[\"transaction\"].wallet_id == wallet_id\n assert leave_pool_tx[\"transaction\"].amount == 1\n\n async def status_is_leaving():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\n\n async def status_is_self_pooling():\n # Farm enough blocks to wait for relative_lock_height\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_networking_project_network_delete(self):\n pass","def delete_entity(self, context, pool):\n resource_path = \"%s/%s/%s\" % (RESOURCE_PREFIX, POOLS_RESOURCE,\n pool.id)\n msg = _(\"NetScaler driver pool removal: %s\") % pool.id\n LOG.debug(msg)\n self.client.remove_resource(context.tenant_id, resource_path)","def test_sync_clear_mempool(self):\n logging.info(\">>> Entered : test_sync_clear_mempool \\n\")\n try:\n # clear out the mempool\n mostly_sync_mempools(self.nodes)\n for index1, n in enumerate(self.nodes):\n n.generate(2)\n sync_blocks(self.nodes)\n for index2, n in enumerate(self.nodes):\n while len(n.getrawmempool()):\n n.generate(1)\n sync_blocks(self.nodes)\n logging.info(\"cleared mempool: %s\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\n base = [x.getrawmempool() for x in self.nodes]\n assert_equal(base, [base[0]] * 4)\n except (Exception, JSONRPCException) as e1:\n logging.info(e1)\n exc_type, exc_obj, exc_tb = sys.exc_info()\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\n raise TestAssertionError({\"file_name\": fname, \"line_num\": exc_tb.tb_lineno, \\\n \"error_type\": exc_type.__name__, \"error_msg\": str( e1 ), \\\n \"n1\" : self.bins[index1], \"n2\" : self.bins[index2], \"amount\" : \"N/A\", \"numsig\" : \"N/A\"})","def network_cleanup(self, args):\n pass","def test_delete_underscore():\n pytest.raises(SaltInvocationError, mac_group.delete, \"_Test\")","def test_remove_provider_from_inst_alloc_no_source(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n # Act like the allocations already did not include the source host\n # for some reason\n {\n 'allocations': {\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n consumer_uuid = uuids.consumer_uuid\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n self.ks_adap_mock.get.assert_called()\n self.ks_adap_mock.put.assert_not_called()\n\n self.assertTrue(res)","def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\n {'source_path': '/bar',\n 'target_path': '/baz'}})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_deallocate_virt_realm(self):\n pass","def test_ipam_vlan_groups_delete(self):\n pass","def resources_cleanup(namespace, image_uuids=None):\n resources = [\n constants.DEPLOYMENT,\n constants.POD,\n constants.VOLUME_REPLICATION_GROUP,\n constants.VOLUME_REPLICATION,\n constants.PVC,\n constants.PV,\n ]\n log.info(\"Cleaning up leftover resources in managed clusters\")\n for cluster in get_non_acm_cluster_config():\n config.switch_ctx(cluster.MULTICLUSTER[\"multicluster_index\"])\n for resource in resources:\n sleep(10) # Wait 10 seconds before getting the list of items\n log.info(f\"Cleaning up {resource} resources\")\n ocp_obj = ocp.OCP(kind=resource, namespace=namespace)\n item_list = ocp_obj.get()[\"items\"]\n for item in item_list:\n resource_name = item[\"metadata\"][\"name\"]\n try:\n if resource == constants.PV:\n if item[\"spec\"][\"claimRef\"][\"namespace\"] != namespace:\n continue\n ocp_obj.delete(resource_name=resource_name)\n ocp_obj.wait_for_delete(resource_name=resource_name)\n else:\n ocp_obj.delete(resource_name=resource_name, wait=False)\n ocp_obj.patch(\n resource_name=resource_name,\n params='{\"metadata\": {\"finalizers\":null}}',\n format_type=\"merge\",\n )\n ocp_obj.wait_for_delete(resource_name=resource_name)\n\n except CommandFailed as ex:\n if \"NotFound\" in str(ex):\n log.info(\n f\"{resource} {resource_name} got deleted successfully\"\n )\n else:\n raise ex\n\n for cluster in get_non_acm_cluster_config():\n config.switch_ctx(cluster.MULTICLUSTER[\"multicluster_index\"])\n for image_uuid in image_uuids:\n delete_volume_in_backend(\n img_uuid=image_uuid,\n pool_name=constants.DEFAULT_CEPHBLOCKPOOL,\n disable_mirroring=True,\n )","def test_delete_collection_cluster_policy(self):\n pass","def test_remove_vm(self, instance_name):\n self.instances.pop(instance_name)","def _delete_network_vm(args):\n libvirtConn = libvirt.openReadOnly(None)\n if libvirtConn is None:\n print('Cannot contact hypervisor', file=sys.stderr)\n return 1\n net = None\n try:\n net = libvirtConn.networkLookupByName(args.network_name)\n except libvirt.libvirtError:\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\n return 1\n print('Network found:\\n')\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\" \", newl=''))\n print('')\n\n if not args.yes:\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\n return 1\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)","def test_aws_service_api_vm_delete(self):\n pass","def test_delete_collection_host_subnet(self):\n pass","def SafeBridgeDestroy(bridge):\n #try:\n # bridge.destroy()\n #except requests.HTTPError as e:\n # if e.response.status_code != requests.codes.not_found:\n # print e.response.status_code\n try:\n bridge.destroy()\n except:\n return","def cleanup(self, context, instance, network_info, block_device_info=None,\n destroy_disks=True):\n pass","def task(ctx, config):\n if config is None:\n config = {}\n assert isinstance(config, dict), \\\n 'Resolve stuck peering only accepts a dict for config'\n\n manager = ctx.managers['ceph']\n\n while len(manager.get_osd_status()['up']) < 3:\n time.sleep(10)\n\n\n manager.wait_for_clean()\n\n dummyfile = '/etc/fstab'\n dummyfile1 = '/etc/resolv.conf'\n\n #create 1 PG pool\n pool='foo'\n log.info('creating pool foo')\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\n\n #set min_size of the pool to 1\n #so that we can continue with I/O\n #when 2 osds are down\n manager.set_pool_property(pool, \"min_size\", 1)\n\n osds = [0, 1, 2]\n\n primary = manager.get_pg_primary('foo', 0)\n log.info(\"primary osd is %d\", primary)\n\n others = list(osds)\n others.remove(primary)\n\n log.info('writing initial objects')\n first_mon = teuthology.get_first_mon(ctx, config)\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\n #create few objects\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\n\n manager.wait_for_clean()\n\n #kill other osds except primary\n log.info('killing other osds except primary')\n for i in others:\n manager.kill_osd(i)\n for i in others:\n manager.mark_down_osd(i)\n\n\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\n\n #kill primary osd\n manager.kill_osd(primary)\n manager.mark_down_osd(primary)\n\n #revive other 2 osds\n for i in others:\n manager.revive_osd(i)\n\n #make sure that pg is down\n #Assuming pg number for single pg pool will start from 0\n pgnum=0\n pgstr = manager.get_pgid(pool, pgnum)\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=60\n start=time.time()\n\n while 'down' not in stats['state']:\n assert time.time() - start < timeout, \\\n 'failed to reach down state before timeout expired'\n stats = manager.get_single_pg_stats(pgstr)\n\n #mark primary as lost\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\n '--yes-i-really-mean-it')\n\n\n #expect the pg status to be active+undersized+degraded\n #pg should recover and become active+clean within timeout\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=10\n start=time.time()\n\n while manager.get_num_down():\n assert time.time() - start < timeout, \\\n 'failed to recover before timeout expired'\n\n manager.revive_osd(primary)","def deletePool(self,ippool_name): \n self.__deletePoolCheckInput(ippool_name)\n ippool_obj=ippool_main.getLoader().getIPpoolByName(ippool_name)\n self.__deletePoolDB(ippool_obj.getIPpoolID())\n ippool_main.getLoader().unloadIPpoolByID(ippool_obj.getIPpoolID())","def delete_share(self, context, share, share_server=None):\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n if not volume_uuid:\n LOG.warning(\"No volume found for \"\n \"share %(project_id)s/%(name)s\",\n {\"project_id\": share['project_id'],\n \"name\": share['name']})\n return\n\n if self.configuration.quobyte_delete_shares:\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\n else:\n self.rpc.call('exportVolume', {\"volume_uuid\": volume_uuid,\n \"remove_export\": True,\n })","def test_unshare_template_registration(self):\n pass","def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\n wallet = tt.Wallet(attach_to=node)\n\n wallet.create_account(\"goku1\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\n wallet.create_account(\"steem\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\n\n with wallet.in_single_transaction():\n wallet.api.delegate_vesting_shares(\"goku1\", \"steem\", tt.Asset.Vest(5))\n wallet.api.delegate_vesting_shares(\"steem\", \"goku1\", tt.Asset.Vest(10))\n\n assert get_hardfork_version(node) == \"0.22.0\"\n assert_account_resources(node, \"goku1\", operator.gt)\n assert_account_resources(node, \"steem\", operator.gt)\n\n __wait_for_hardfork_23_application(node)\n assert get_hardfork_version(node) == \"0.23.0\"\n\n assert_account_resources(node, \"goku1\", operator.eq)\n assert_account_resources(node, \"steem\", operator.eq)\n\n assert_cleared_resources_in_hardfork_hive_operation(node, \"goku1\")\n assert_cleared_resources_in_hardfork_hive_operation(node, \"steem\")","def clearPool(self):\n return self.request('clearPool')","def _unprovision_node(self, conn):\n conn.run(f\"rm -rf {EXPORTER_HOME}\")","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def remove_pool(ctx, pool_name):\n \n entryFound = False\n table = \"NAT_POOL\"\n key = pool_name\n\n if len(pool_name) > 32:\n ctx.fail(\"Invalid pool name. Maximum allowed pool name is 32 characters !!\")\n\n config_db = ConfigDBConnector()\n config_db.connect()\n\n data = config_db.get_entry(table, key)\n if not data:\n click.echo(\"Trying to delete pool, which is not present.\")\n entryFound = True\n\n binding_dict = config_db.get_table('NAT_BINDINGS')\n if binding_dict and entryFound == False: \n for binding_name, binding_values in binding_dict.items():\n if binding_values['nat_pool'] == pool_name:\n click.echo(\"Pool is not removed, as it is mapped to Binding {}, remove the pool binding first !!\".format(binding_name))\n entryFound = True\n break\n\n if entryFound == False:\n config_db.set_entry(table, key, None)","def test_aws_service_api_vm_security_group_delete(self):\n pass","def test_delete_bios_policy(self):\n pass","def test_delete_resource_group(self):\n pass","def clean_up(self):\n dist.destroy_process_group()","def destroy():\n pass","def destroy():\n pass","def rm_network(c):\n print('Stopping local test network and removing containers')\n with c.cd('images'):\n c.run('sudo docker-compose down -v', hide='stderr')\n\n c.run('sudo rm -rf volumes/stellar-core/opt/stellar-core/buckets')\n c.run('sudo rm -f volumes/stellar-core/opt/stellar-core/*.log')\n c.run('sudo rm -rf volumes/stellar-core/tmp')","def test_004_delete(self):\n ret = svcmgr.main(argv=[\"delete\", \"-s\", SVCNAME, \"--local\"])\n assert ret == 0","def test_delete_hyperflex_node_profile(self):\n pass","def test_rebuild_with_wrong_shared_storage(self, mock_remove_allocs):\n with mock.patch.object(self.compute.driver, 'instance_on_disk',\n side_effect=lambda x: True) as mock_inst:\n self.assertRaises(exception.InvalidSharedStorage,\n lambda: self._rebuild(on_shared_storage=False))\n\n # Should remain on original host\n instance = db.instance_get(self.context, self.inst.id)\n self.assertEqual(instance['host'], 'fake_host_2')\n self.assertTrue(mock_inst.called)\n mock_remove_allocs.assert_called_once_with(\n mock.ANY, instance.uuid, self.rt.compute_nodes[NODENAME].uuid)"],"string":"[\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_delete_cluster_network(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_delete_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def delete_pool(self, pool):\\r\\n return self.delete(self.pool_path % (pool))\",\n \"def delete_share(self, pool, project, share):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.delete(svc)\\n if ret.status != restclient.Status.NO_CONTENT:\\n exception_msg = (('Error deleting '\\n 'share: %(share)s to '\\n 'pool: %(pool)s '\\n 'project: %(project)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.'),\\n {'share': share,\\n 'pool': pool,\\n 'project': project,\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n LOG.error(exception_msg)\",\n \"def delete_device_pool(arn=None):\\n pass\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_delete_cluster_resource_quota(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_delete_network(self):\\n pass\",\n \"def mac_pool_remove(handle, name, parent_dn=\\\"org-root\\\"):\\r\\n dn = parent_dn + '/mac-pool-' + name\\r\\n mo = handle.query_dn(dn)\\r\\n if mo:\\r\\n handle.remove_mo(mo)\\r\\n handle.commit()\\r\\n else:\\r\\n raise ValueError(\\\"MAC Pool is not available\\\")\",\n \"def test_delete_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_delete_hyperflex_cluster_profile(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_sg_delete_non_associated(self):\\n\\n # Add a faked storage group to be tested and another one\\n faked_storage_group = self.add_storage_group1()\\n self.add_storage_group2()\\n\\n storage_group_mgr = self.console.storage_groups\\n\\n storage_group = storage_group_mgr.find(name=faked_storage_group.name)\\n\\n # Execute the code to be tested.\\n storage_group.delete()\\n\\n # Check that the storage group no longer exists\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=faked_storage_group.name)\",\n \"def execute(self, pool, vthunder):\\n try:\\n axapi_version = acos_client.AXAPI_21 if vthunder.axapi_version == 21 else acos_client.AXAPI_30\\n c = self.client_factory(vthunder)\\n #need to put algorithm logic\\n out = c.slb.service_group.delete(pool.id)\\n LOG.info(\\\"Pool deleted successfully.\\\")\\n except Exception as e:\\n print(str(e))\\n LOG.info(\\\"Error occurred\\\")\",\n \"def test_delete_cluster_policy(self):\\n pass\",\n \"def test_delete_collection_cluster_network(self):\\n pass\",\n \"def test_dhcp_pool_uninstall(self):\\n self._common_uninstall_delete(\\n 'esg_id|pool_id', dhcp_pool.delete,\\n {'pool': {}},\\n delete_args=['dhcpPoolID'],\\n delete_kwargs={\\n 'uri_parameters': {'edgeId': 'esg_id', 'poolID': 'pool_id'}\\n }\\n )\",\n \"def test_remove_provider_from_inst_alloc_no_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def destroy_pool(self, context, pool_id=None, host=None):\\n if self.cache.get_by_pool_id(pool_id):\\n self.destroy_device(pool_id)\",\n \"def delete_cluster(self):\",\n \"def test_destroy_container(self):\\n pass\",\n \"def test_delete_net_namespace(self):\\n pass\",\n \"def _clean_up(self):\\n StratisCli.destroy_all()\\n self.assertEqual(0, len(StratisCli.pool_list()))\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\\n network_delete_mock.assert_called_with(resources.network)\\n self.assertTrue(resources._hypervisor.close.called)\",\n \"def delete(self):\\n self._lbcall('delete_pool', [self._name])\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_destroy_container_privilege(self):\\n pass\",\n \"def _cleanup_create_share(self, share_path, share_name):\\n if os.path.exists(share_path):\\n cmd = ['rm', '-rf', share_path]\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError as exc:\\n LOG.error(_LE('Cannot cleanup share, %s, that errored out '\\n 'during its creation, but exists in GlusterFS '\\n 'volume.'), share_name)\\n raise exception.GlusterfsException(exc)\",\n \"def test_delete_resource_used_in_ns_bucket_rpc(\\n self, mcg_obj, cld_mgr, ns_resource_factory, bucket_factory\\n ):\\n # Create the namespace resources and verify health\\n _, resource1 = ns_resource_factory()\\n _, resource2 = ns_resource_factory()\\n\\n # Create the namespace bucket on top of the namespace resource\\n bucket_factory(\\n amount=1,\\n interface=\\\"mcg-namespace\\\",\\n write_ns_resource=resource1,\\n read_ns_resources=[resource1, resource2],\\n )\\n response = mcg_obj.send_rpc_query(\\n \\\"pool_api\\\", \\\"delete_namespace_resource\\\", {\\\"name\\\": resource2}\\n )\\n assert \\\"error\\\" in response.json()\",\n \"def cleanup():\\n dist.destroy_process_group()\",\n \"def test_delete_collection_cluster_resource_quota(self):\\n pass\",\n \"def delete_pool(self, argu):\\n\\n if not argu:\\n LOG.error(\\\"In delete_pool, it should not pass the None.\\\")\\n\\n # delete policy\\n self._delete_policy(\\n argu['listener_id'],\\n argu['session_persistence_type'],\\n argu['lb_algorithm']\\n )\\n\\n cmd_apv_no_group = ADCDevice.no_group(argu['pool_id'])\\n for base_rest_url in self.base_rest_urls:\\n self.run_cli_extend(base_rest_url, cmd_apv_no_group)\",\n \"def test_remove_provider_from_inst_alloc_with_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def test_delete_cluster_policy_binding(self):\\n pass\",\n \"def check_instance_shared_storage_cleanup(self, context, data):\\n pass\",\n \"def test_delete__network(self):\\n arglist = [\\n '--network',\\n self.projects[0].id,\\n ]\\n verifylist = [\\n ('service', 'network'),\\n ('project', self.projects[0].id),\\n ]\\n\\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\\n\\n result = self.cmd.take_action(parsed_args)\\n\\n self.assertIsNone(result)\\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\\n self.compute_quotas_mock.delete.assert_not_called()\\n self.volume_quotas_mock.delete.assert_not_called()\\n self.network_mock.delete_quota.assert_called_once_with(\\n self.projects[0].id,\\n )\",\n \"def test_cleanup_procs(self):\\n self.skip_teardown = True\\n pool = self.get_pool()\\n container = self.get_container(pool)\\n dfuse = get_dfuse(self, self.hostlist_clients)\\n start_dfuse(self, dfuse, pool=pool, container=container)\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def dist_cleanup():\\n dist.destroy_process_group()\",\n \"def test_delete_host_subnet(self):\\n pass\",\n \"def test_disconnect_volume_no_op(self, mock_remove_p_maps):\\n # Mock Data\\n inst = mock.MagicMock()\\n inst.task_state = None\\n\\n # Invoke\\n self.vol_drv.disconnect_volume(self.adpt, 'host_uuid', 'vm_uuid',\\n inst, mock.MagicMock())\\n\\n # Verify\\n self.assertEqual(0, mock_remove_p_maps.call_count)\",\n \"def destroy_node(self):\\n driver = self.driver\\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\\n driver.destroy_node(self.node)\\n sleep(15)\\n for volume in self.volumes:\\n driver.destroy_volume(volume)\",\n \"def testAPICleanup(self):\\n\\n api = API({})\\n api.pool = ThreadPool()\\n\\n # pylint: disable=C2801\\n api.__del__()\\n\\n self.assertIsNone(api.pool)\",\n \"async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 5,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.current.pool_url == \\\"\\\"\\n assert status.current.relative_lock_height == 0\\n assert status.current.state == 1\\n assert status.current.version == 1\\n\\n assert status.target\\n assert status.target.pool_url == \\\"https://pool.example.com\\\"\\n assert status.target.relative_lock_height == 5\\n assert status.target.state == 3\\n assert status.target.version == 1\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\\n assert leave_pool_tx[\\\"transaction\\\"].wallet_id == wallet_id\\n assert leave_pool_tx[\\\"transaction\\\"].amount == 1\\n\\n async def status_is_leaving():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\\n\\n async def status_is_self_pooling():\\n # Farm enough blocks to wait for relative_lock_height\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_networking_project_network_delete(self):\\n pass\",\n \"def delete_entity(self, context, pool):\\n resource_path = \\\"%s/%s/%s\\\" % (RESOURCE_PREFIX, POOLS_RESOURCE,\\n pool.id)\\n msg = _(\\\"NetScaler driver pool removal: %s\\\") % pool.id\\n LOG.debug(msg)\\n self.client.remove_resource(context.tenant_id, resource_path)\",\n \"def test_sync_clear_mempool(self):\\n logging.info(\\\">>> Entered : test_sync_clear_mempool \\\\n\\\")\\n try:\\n # clear out the mempool\\n mostly_sync_mempools(self.nodes)\\n for index1, n in enumerate(self.nodes):\\n n.generate(2)\\n sync_blocks(self.nodes)\\n for index2, n in enumerate(self.nodes):\\n while len(n.getrawmempool()):\\n n.generate(1)\\n sync_blocks(self.nodes)\\n logging.info(\\\"cleared mempool: %s\\\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\\n base = [x.getrawmempool() for x in self.nodes]\\n assert_equal(base, [base[0]] * 4)\\n except (Exception, JSONRPCException) as e1:\\n logging.info(e1)\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\\n raise TestAssertionError({\\\"file_name\\\": fname, \\\"line_num\\\": exc_tb.tb_lineno, \\\\\\n \\\"error_type\\\": exc_type.__name__, \\\"error_msg\\\": str( e1 ), \\\\\\n \\\"n1\\\" : self.bins[index1], \\\"n2\\\" : self.bins[index2], \\\"amount\\\" : \\\"N/A\\\", \\\"numsig\\\" : \\\"N/A\\\"})\",\n \"def network_cleanup(self, args):\\n pass\",\n \"def test_delete_underscore():\\n pytest.raises(SaltInvocationError, mac_group.delete, \\\"_Test\\\")\",\n \"def test_remove_provider_from_inst_alloc_no_source(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n # Act like the allocations already did not include the source host\\n # for some reason\\n {\\n 'allocations': {\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n self.ks_adap_mock.get.assert_called()\\n self.ks_adap_mock.put.assert_not_called()\\n\\n self.assertTrue(res)\",\n \"def test_cleanup_filesystem(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar', 'filesystem':\\n {'source_path': '/bar',\\n 'target_path': '/baz'}})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, '/bar/foo')\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_deallocate_virt_realm(self):\\n pass\",\n \"def test_ipam_vlan_groups_delete(self):\\n pass\",\n \"def resources_cleanup(namespace, image_uuids=None):\\n resources = [\\n constants.DEPLOYMENT,\\n constants.POD,\\n constants.VOLUME_REPLICATION_GROUP,\\n constants.VOLUME_REPLICATION,\\n constants.PVC,\\n constants.PV,\\n ]\\n log.info(\\\"Cleaning up leftover resources in managed clusters\\\")\\n for cluster in get_non_acm_cluster_config():\\n config.switch_ctx(cluster.MULTICLUSTER[\\\"multicluster_index\\\"])\\n for resource in resources:\\n sleep(10) # Wait 10 seconds before getting the list of items\\n log.info(f\\\"Cleaning up {resource} resources\\\")\\n ocp_obj = ocp.OCP(kind=resource, namespace=namespace)\\n item_list = ocp_obj.get()[\\\"items\\\"]\\n for item in item_list:\\n resource_name = item[\\\"metadata\\\"][\\\"name\\\"]\\n try:\\n if resource == constants.PV:\\n if item[\\\"spec\\\"][\\\"claimRef\\\"][\\\"namespace\\\"] != namespace:\\n continue\\n ocp_obj.delete(resource_name=resource_name)\\n ocp_obj.wait_for_delete(resource_name=resource_name)\\n else:\\n ocp_obj.delete(resource_name=resource_name, wait=False)\\n ocp_obj.patch(\\n resource_name=resource_name,\\n params='{\\\"metadata\\\": {\\\"finalizers\\\":null}}',\\n format_type=\\\"merge\\\",\\n )\\n ocp_obj.wait_for_delete(resource_name=resource_name)\\n\\n except CommandFailed as ex:\\n if \\\"NotFound\\\" in str(ex):\\n log.info(\\n f\\\"{resource} {resource_name} got deleted successfully\\\"\\n )\\n else:\\n raise ex\\n\\n for cluster in get_non_acm_cluster_config():\\n config.switch_ctx(cluster.MULTICLUSTER[\\\"multicluster_index\\\"])\\n for image_uuid in image_uuids:\\n delete_volume_in_backend(\\n img_uuid=image_uuid,\\n pool_name=constants.DEFAULT_CEPHBLOCKPOOL,\\n disable_mirroring=True,\\n )\",\n \"def test_delete_collection_cluster_policy(self):\\n pass\",\n \"def test_remove_vm(self, instance_name):\\n self.instances.pop(instance_name)\",\n \"def _delete_network_vm(args):\\n libvirtConn = libvirt.openReadOnly(None)\\n if libvirtConn is None:\\n print('Cannot contact hypervisor', file=sys.stderr)\\n return 1\\n net = None\\n try:\\n net = libvirtConn.networkLookupByName(args.network_name)\\n except libvirt.libvirtError:\\n print('Cannot find network named [%s]' % args.network_name, file=sys.stderr)\\n return 1\\n print('Network found:\\\\n')\\n print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=\\\" \\\", newl=''))\\n print('')\\n\\n if not args.yes:\\n if not input('Really destroy this network ?').strip().lower() in ('y', 'yes'):\\n return 1\\n return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name)\",\n \"def test_aws_service_api_vm_delete(self):\\n pass\",\n \"def test_delete_collection_host_subnet(self):\\n pass\",\n \"def SafeBridgeDestroy(bridge):\\n #try:\\n # bridge.destroy()\\n #except requests.HTTPError as e:\\n # if e.response.status_code != requests.codes.not_found:\\n # print e.response.status_code\\n try:\\n bridge.destroy()\\n except:\\n return\",\n \"def cleanup(self, context, instance, network_info, block_device_info=None,\\n destroy_disks=True):\\n pass\",\n \"def task(ctx, config):\\n if config is None:\\n config = {}\\n assert isinstance(config, dict), \\\\\\n 'Resolve stuck peering only accepts a dict for config'\\n\\n manager = ctx.managers['ceph']\\n\\n while len(manager.get_osd_status()['up']) < 3:\\n time.sleep(10)\\n\\n\\n manager.wait_for_clean()\\n\\n dummyfile = '/etc/fstab'\\n dummyfile1 = '/etc/resolv.conf'\\n\\n #create 1 PG pool\\n pool='foo'\\n log.info('creating pool foo')\\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\\n\\n #set min_size of the pool to 1\\n #so that we can continue with I/O\\n #when 2 osds are down\\n manager.set_pool_property(pool, \\\"min_size\\\", 1)\\n\\n osds = [0, 1, 2]\\n\\n primary = manager.get_pg_primary('foo', 0)\\n log.info(\\\"primary osd is %d\\\", primary)\\n\\n others = list(osds)\\n others.remove(primary)\\n\\n log.info('writing initial objects')\\n first_mon = teuthology.get_first_mon(ctx, config)\\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\\n #create few objects\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\\n\\n manager.wait_for_clean()\\n\\n #kill other osds except primary\\n log.info('killing other osds except primary')\\n for i in others:\\n manager.kill_osd(i)\\n for i in others:\\n manager.mark_down_osd(i)\\n\\n\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\\n\\n #kill primary osd\\n manager.kill_osd(primary)\\n manager.mark_down_osd(primary)\\n\\n #revive other 2 osds\\n for i in others:\\n manager.revive_osd(i)\\n\\n #make sure that pg is down\\n #Assuming pg number for single pg pool will start from 0\\n pgnum=0\\n pgstr = manager.get_pgid(pool, pgnum)\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=60\\n start=time.time()\\n\\n while 'down' not in stats['state']:\\n assert time.time() - start < timeout, \\\\\\n 'failed to reach down state before timeout expired'\\n stats = manager.get_single_pg_stats(pgstr)\\n\\n #mark primary as lost\\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\\\\n '--yes-i-really-mean-it')\\n\\n\\n #expect the pg status to be active+undersized+degraded\\n #pg should recover and become active+clean within timeout\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=10\\n start=time.time()\\n\\n while manager.get_num_down():\\n assert time.time() - start < timeout, \\\\\\n 'failed to recover before timeout expired'\\n\\n manager.revive_osd(primary)\",\n \"def deletePool(self,ippool_name): \\n self.__deletePoolCheckInput(ippool_name)\\n ippool_obj=ippool_main.getLoader().getIPpoolByName(ippool_name)\\n self.__deletePoolDB(ippool_obj.getIPpoolID())\\n ippool_main.getLoader().unloadIPpoolByID(ippool_obj.getIPpoolID())\",\n \"def delete_share(self, context, share, share_server=None):\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n if not volume_uuid:\\n LOG.warning(\\\"No volume found for \\\"\\n \\\"share %(project_id)s/%(name)s\\\",\\n {\\\"project_id\\\": share['project_id'],\\n \\\"name\\\": share['name']})\\n return\\n\\n if self.configuration.quobyte_delete_shares:\\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\\n else:\\n self.rpc.call('exportVolume', {\\\"volume_uuid\\\": volume_uuid,\\n \\\"remove_export\\\": True,\\n })\",\n \"def test_unshare_template_registration(self):\\n pass\",\n \"def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\\n wallet = tt.Wallet(attach_to=node)\\n\\n wallet.create_account(\\\"goku1\\\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\\n wallet.create_account(\\\"steem\\\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\\n\\n with wallet.in_single_transaction():\\n wallet.api.delegate_vesting_shares(\\\"goku1\\\", \\\"steem\\\", tt.Asset.Vest(5))\\n wallet.api.delegate_vesting_shares(\\\"steem\\\", \\\"goku1\\\", tt.Asset.Vest(10))\\n\\n assert get_hardfork_version(node) == \\\"0.22.0\\\"\\n assert_account_resources(node, \\\"goku1\\\", operator.gt)\\n assert_account_resources(node, \\\"steem\\\", operator.gt)\\n\\n __wait_for_hardfork_23_application(node)\\n assert get_hardfork_version(node) == \\\"0.23.0\\\"\\n\\n assert_account_resources(node, \\\"goku1\\\", operator.eq)\\n assert_account_resources(node, \\\"steem\\\", operator.eq)\\n\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"goku1\\\")\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"steem\\\")\",\n \"def clearPool(self):\\n return self.request('clearPool')\",\n \"def _unprovision_node(self, conn):\\n conn.run(f\\\"rm -rf {EXPORTER_HOME}\\\")\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def remove_pool(ctx, pool_name):\\n \\n entryFound = False\\n table = \\\"NAT_POOL\\\"\\n key = pool_name\\n\\n if len(pool_name) > 32:\\n ctx.fail(\\\"Invalid pool name. Maximum allowed pool name is 32 characters !!\\\")\\n\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n\\n data = config_db.get_entry(table, key)\\n if not data:\\n click.echo(\\\"Trying to delete pool, which is not present.\\\")\\n entryFound = True\\n\\n binding_dict = config_db.get_table('NAT_BINDINGS')\\n if binding_dict and entryFound == False: \\n for binding_name, binding_values in binding_dict.items():\\n if binding_values['nat_pool'] == pool_name:\\n click.echo(\\\"Pool is not removed, as it is mapped to Binding {}, remove the pool binding first !!\\\".format(binding_name))\\n entryFound = True\\n break\\n\\n if entryFound == False:\\n config_db.set_entry(table, key, None)\",\n \"def test_aws_service_api_vm_security_group_delete(self):\\n pass\",\n \"def test_delete_bios_policy(self):\\n pass\",\n \"def test_delete_resource_group(self):\\n pass\",\n \"def clean_up(self):\\n dist.destroy_process_group()\",\n \"def destroy():\\n pass\",\n \"def destroy():\\n pass\",\n \"def rm_network(c):\\n print('Stopping local test network and removing containers')\\n with c.cd('images'):\\n c.run('sudo docker-compose down -v', hide='stderr')\\n\\n c.run('sudo rm -rf volumes/stellar-core/opt/stellar-core/buckets')\\n c.run('sudo rm -f volumes/stellar-core/opt/stellar-core/*.log')\\n c.run('sudo rm -rf volumes/stellar-core/tmp')\",\n \"def test_004_delete(self):\\n ret = svcmgr.main(argv=[\\\"delete\\\", \\\"-s\\\", SVCNAME, \\\"--local\\\"])\\n assert ret == 0\",\n \"def test_delete_hyperflex_node_profile(self):\\n pass\",\n \"def test_rebuild_with_wrong_shared_storage(self, mock_remove_allocs):\\n with mock.patch.object(self.compute.driver, 'instance_on_disk',\\n side_effect=lambda x: True) as mock_inst:\\n self.assertRaises(exception.InvalidSharedStorage,\\n lambda: self._rebuild(on_shared_storage=False))\\n\\n # Should remain on original host\\n instance = db.instance_get(self.context, self.inst.id)\\n self.assertEqual(instance['host'], 'fake_host_2')\\n self.assertTrue(mock_inst.called)\\n mock_remove_allocs.assert_called_once_with(\\n mock.ANY, instance.uuid, self.rt.compute_nodes[NODENAME].uuid)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.87827253","0.87459147","0.7914171","0.76246","0.75718844","0.7118149","0.7093812","0.708217","0.68163544","0.6781625","0.67124707","0.66831726","0.6607139","0.65762645","0.6470638","0.64604396","0.6458959","0.64408374","0.6336116","0.62824637","0.62496793","0.6249455","0.6209863","0.6171632","0.61274266","0.6114037","0.61016345","0.6067925","0.606319","0.6055822","0.6026736","0.5993281","0.59608537","0.59399694","0.59279466","0.58841914","0.58703434","0.58524776","0.5851875","0.58495826","0.58495295","0.5827854","0.58250654","0.5817522","0.57964677","0.5789457","0.5764167","0.5756763","0.57563573","0.5754726","0.5746677","0.5746276","0.57235473","0.5711256","0.56989783","0.56842905","0.56802005","0.5661017","0.56330645","0.5632502","0.5625052","0.562359","0.56154054","0.5606574","0.5580843","0.5564775","0.5554285","0.55284274","0.5527499","0.5524869","0.55208135","0.5516702","0.5508204","0.5503069","0.5497968","0.5489817","0.5484566","0.5477199","0.54694474","0.54681754","0.54681313","0.5465672","0.546389","0.5459115","0.5454363","0.5452217","0.54489344","0.5443235","0.54350644","0.54317045","0.54256725","0.5425481","0.5424819","0.5413349","0.54096615","0.54096615","0.54061395","0.5400989","0.5387665","0.53843284"],"string":"[\n \"0.87827253\",\n \"0.87459147\",\n \"0.7914171\",\n \"0.76246\",\n \"0.75718844\",\n \"0.7118149\",\n \"0.7093812\",\n \"0.708217\",\n \"0.68163544\",\n \"0.6781625\",\n \"0.67124707\",\n \"0.66831726\",\n \"0.6607139\",\n \"0.65762645\",\n \"0.6470638\",\n \"0.64604396\",\n \"0.6458959\",\n \"0.64408374\",\n \"0.6336116\",\n \"0.62824637\",\n \"0.62496793\",\n \"0.6249455\",\n \"0.6209863\",\n \"0.6171632\",\n \"0.61274266\",\n \"0.6114037\",\n \"0.61016345\",\n \"0.6067925\",\n \"0.606319\",\n \"0.6055822\",\n \"0.6026736\",\n \"0.5993281\",\n \"0.59608537\",\n \"0.59399694\",\n \"0.59279466\",\n \"0.58841914\",\n \"0.58703434\",\n \"0.58524776\",\n \"0.5851875\",\n \"0.58495826\",\n \"0.58495295\",\n \"0.5827854\",\n \"0.58250654\",\n \"0.5817522\",\n \"0.57964677\",\n \"0.5789457\",\n \"0.5764167\",\n \"0.5756763\",\n \"0.57563573\",\n \"0.5754726\",\n \"0.5746677\",\n \"0.5746276\",\n \"0.57235473\",\n \"0.5711256\",\n \"0.56989783\",\n \"0.56842905\",\n \"0.56802005\",\n \"0.5661017\",\n \"0.56330645\",\n \"0.5632502\",\n \"0.5625052\",\n \"0.562359\",\n \"0.56154054\",\n \"0.5606574\",\n \"0.5580843\",\n \"0.5564775\",\n \"0.5554285\",\n \"0.55284274\",\n \"0.5527499\",\n \"0.5524869\",\n \"0.55208135\",\n \"0.5516702\",\n \"0.5508204\",\n \"0.5503069\",\n \"0.5497968\",\n \"0.5489817\",\n \"0.5484566\",\n \"0.5477199\",\n \"0.54694474\",\n \"0.54681754\",\n \"0.54681313\",\n \"0.5465672\",\n \"0.546389\",\n \"0.5459115\",\n \"0.5454363\",\n \"0.5452217\",\n \"0.54489344\",\n \"0.5443235\",\n \"0.54350644\",\n \"0.54317045\",\n \"0.54256725\",\n \"0.5425481\",\n \"0.5424819\",\n \"0.5413349\",\n \"0.54096615\",\n \"0.54096615\",\n \"0.54061395\",\n \"0.5400989\",\n \"0.5387665\",\n \"0.53843284\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9630253"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81376,"cells":{"query":{"kind":"string","value":"Test case for index_nas_shares"},"document":{"kind":"string","value":"def test_index_nas_shares(self):\n pass"},"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_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_test_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_dashboards_v2_share(self):\n pass","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def test_kyc_put_legal_share_holder(self):\n pass","def test_index_containers(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\n ingest_shares = \"\"\"\n UNWIND $shares_list as s\n MERGE (share:AzureStorageFileShare{id: s.id})\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\n SET share.name = s.name,\n share.lastupdated = $azure_update_tag,\n share.lastmodifiedtime = s.last_modified_time,\n share.sharequota = s.share_quota,\n share.accesstier = s.access_tier,\n share.deleted = s.deleted,\n share.accesstierchangetime = s.access_tier_change_time,\n share.accesstierstatus = s.access_tier_status,\n share.deletedtime = s.deleted_time,\n share.enabledprotocols = s.enabled_protocols,\n share.remainingretentiondays = s.remaining_retention_days,\n share.shareusagebytes = s.share_usage_bytes,\n share.version = s.version\n WITH share, s\n MATCH (fs:AzureStorageFileService{id: s.service_id})\n MERGE (fs)-[r:CONTAINS]->(share)\n ON CREATE SET r.firstseen = timestamp()\n SET r.lastupdated = $azure_update_tag\n \"\"\"\n\n neo4j_session.run(\n ingest_shares,\n shares_list=shares,\n azure_update_tag=update_tag,\n )","def test_index(self):","def test_index_availability(client):\n response = client.get('/')\n assert response.status_code == 200","def test_index(client):\n ind = client.get('/')\n ind2 = client.get('/index/')\n assert ind.status_code == 200\n assert ind2.status_code == 200","def test_export_index(self):","def test_index_repositories(self):\n self.Mokes.add_repo_to_pi()\n with self.logged_in(access_token=\"nbiousndegoijubdognlksdngndsgmngds\"):\n index = self.client.get(\"/\").data.decode()\n self.assertIn('href=\"/repo/PerseusDl/canonical-greekLit\"', index, \"GreekLit link should be there\")\n self.assertIn('href=\"/repo/PerseusDl/canonical-greekLit\"', index, \"LatinLit link should be there\")","def test_stock_index(self):\n response = self.client.get(reverse('stock-index'))\n self.assertEqual(response.status_code, 200)","async def test_endpoint_delete_container_shares_correct(self):\n with self.patch_json_dump:\n resp = await delete_container_shares_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_kyc_post_legal_share_holder(self):\n pass","def test_index_stats(self):\n #Create Index\n self.run_multi_operations(buckets = self.buckets,\n query_definitions = self.query_definitions,\n create_index = True, drop_index = False)\n #Check Index Stats\n self.sleep(30)\n index_map = self.get_index_stats()\n self.log.info(index_map)\n for query_definition in self.query_definitions:\n index_name = query_definition.index_name\n for bucket in self.buckets:\n bucket_name = bucket.name\n check_keys = ['items_count', 'total_scan_duration', 'num_docs_queued',\n 'num_requests', 'num_rows_returned', 'num_docs_queued',\n 'num_docs_pending','delete_bytes' ]\n map = self._create_stats_map(items_count=2016)\n self._verify_index_stats(index_map, index_name, bucket_name, map, check_keys)","def test_read_cluster_resource_quota(self):\n pass","def test_kyc_get_legal_share_holders(self):\n pass","def get_shares_count(self):\n\t\treturn call_sdk_function('PrlVmCfg_GetSharesCount', self.handle)","def test_read_cluster_network(self):\n pass","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def get_correct_num_of_shares(shares):\n threshold = shares[0].threshold\n if len(shares) < threshold:\n raise('Not enough shares for decryption.')\n used_shares = [sk_share for sk_share in shares]\n # remove unnecessary shares\n while len(used_shares) > threshold:\n # remove share at random\n used_shares.remove(choice(used_shares))\n return used_shares","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_assign_clusters_nonsparse(self, new_data, filename):\n\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\n elif self.split_type == 'date':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\n \n averages_seg['exists'] = 1\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\n test_exists = test_data_exists[test_data_exists['exists']==1]\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\n \n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\n test_matrix = test_matrix.fillna(0)\n \n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\n\n print('clustering new data...')\n cluster_model = joblib.load(filename)\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\n \n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\n keydf = test_matrix[['segment_id','date','time']].reset_index()\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\n \n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]","def test_index_container_privileges(self):\n pass","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def test_add_asset_share_feed(self):\n pass","def test_create_cluster_network(self):\n pass","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def test_stochatreat_no_probs(n_treats, block_cols, df):\n treats = stochatreat(\n data=df, block_cols=block_cols, treats=n_treats, idx_col=\"id\", random_state=42\n )\n\n treatment_shares = treats.groupby([\"treat\"])[\"id\"].count() / treats.shape[0]\n\n np.testing.assert_almost_equal(\n treatment_shares, np.array([1 / n_treats] * n_treats), decimal=3\n )","def test_create_cluster_resource_quota(self):\n pass","def test_get_site_scans(self):\n pass","def test_read_namespaced_applied_cluster_resource_quota(self):\n pass","def test_wrong_config_shares1(self):\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\n\n for i in config:\n k = config\n k[i] = ''\n print k\n self.app.post_json(url=\"/config/shares\", params=k, status=400)\n return config","def test_kyc_get_legal_share_holder_natural(self):\n pass","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def testnbasis(self):\r\n count = sum([self.nbasisdict[n] for n in self.data.atomnos])\r\n assert self.data.nbasis == count","def test_smoker_get(self):\n pass","def test_creating_index_type(self):","def test_replace_cluster_resource_quota(self):\n pass","def test_list_cluster_network(self):\n pass","def test_data_source_soaps_count_get(self):\n pass","def test_news_index_no_perm(self):\n self.assertStatusCode(self.url, 403)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_extreme_neighborhoods(self):\n\n ## Radius = 0 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Min_neighbors > 30 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=31,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Radius very large ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=100.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)\n\n ## Min_neighbors = 0 ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.5,\n min_core_neighbors=0,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_atom_index_cache(self):\n # First make OH-\n mol = Molecule()\n mol.add_atom(8, -1, False, None)\n mol.add_atom(1, 0, False, None)\n mol.add_bond(0, 1, 1, False)\n assert mol.atom(0).molecule_atom_index == 0\n assert mol.atom(1).molecule_atom_index == 1\n\n # Now convert it to H2O and ask for atom indices again\n mol.add_atom(1, 0, False, None)\n mol.add_bond(1, 2, 1, False)\n mol.atom(0).formal_charge = 0\n assert mol.atom(0).molecule_atom_index == 0\n assert mol.atom(1).molecule_atom_index == 1\n assert mol.atom(2).molecule_atom_index == 2","def test_read_cluster_resource_quota_status(self):\n pass","def test_shared_albums(self):\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n t = (\n TestAccount.album_image_count\n + TestAccount.album_shared_image_count\n + TestAccount.shared_album_image_count\n + TestAccount.shared_album_shared_image_count\n )\n\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums including shared\".format(t),\n )\n\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\", \"--skip-shared-albums\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n # note that unless we use --no-album-index the shared files in the\n # visible album will show up here\n t = (\n TestAccount.album_image_count + TestAccount.album_shared_image_count\n ) # see above\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums excluding shared\".format(t),\n )","def test_news_index_has_perm(self):\n self.assertStatusCode(self.url, 200)","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def public_clb_shodan_check(cache: dict, session, awsAccountId: str, awsRegion: str, awsPartition: str) -> dict:\n shodanApiKey = get_shodan_api_key(cache)\n # ISO Time\n iso8601time = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).isoformat() \n for lb in describe_clbs(cache, session):\n if shodanApiKey is None:\n continue\n # B64 encode all of the details for the Asset\n assetJson = json.dumps(lb,default=str).encode(\"utf-8\")\n assetB64 = base64.b64encode(assetJson)\n clbName = lb[\"LoadBalancerName\"]\n clbArn = f\"arn:{awsPartition}:elasticloadbalancing:{awsRegion}:{awsAccountId}:loadbalancer/{clbName}\"\n dnsName = lb[\"DNSName\"]\n lbSgs = lb[\"SecurityGroups\"]\n lbSubnets = lb[\"Subnets\"]\n lbAzs = lb[\"AvailabilityZones\"]\n lbVpc = lb[\"VPCId\"]\n clbScheme = lb[\"Scheme\"]\n if clbScheme == \"internet-facing\":\n # Use Google DNS to resolve\n clbIp = google_dns_resolver(dnsName)\n if clbIp is None:\n continue\n # check if IP indexed by Shodan\n r = requests.get(url=f\"{SHODAN_HOSTS_URL}{clbIp}?key={shodanApiKey}\").json()\n if str(r) == \"{'error': 'No information available for that IP.'}\":\n # this is a passing check\n finding = {\n \"SchemaVersion\": \"2018-10-08\",\n \"Id\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"ProductArn\": f\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\",\n \"GeneratorId\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"AwsAccountId\": awsAccountId,\n \"Types\": [\"Effects/Data Exposure\"],\n \"CreatedAt\": iso8601time,\n \"UpdatedAt\": iso8601time,\n \"Severity\": {\"Label\": \"INFORMATIONAL\"},\n \"Title\": \"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\",\n \"Description\": f\"Classic Load Balancer {clbName} has not been indexed by Shodan.\",\n \"Remediation\": {\n \"Recommendation\": {\n \"Text\": \"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\",\n \"Url\": SHODAN_HOSTS_URL\n }\n },\n \"ProductFields\": {\n \"ProductName\": \"ElectricEye\",\n \"Provider\": \"AWS\",\n \"ProviderType\": \"CSP\",\n \"ProviderAccountId\": awsAccountId,\n \"AssetRegion\": awsRegion,\n \"AssetDetails\": assetB64,\n \"AssetClass\": \"Networking\",\n \"AssetService\": \"AWS Elastic Load Balancer\",\n \"AssetComponent\": \"Classic Load Balancer\"\n },\n \"Resources\": [\n {\n \"Type\": \"AwsElbLoadBalancer\",\n \"Id\": clbArn,\n \"Partition\": awsPartition,\n \"Region\": awsRegion,\n \"Details\": {\n \"AwsElbLoadBalancer\": {\n \"DnsName\": dnsName,\n \"Scheme\": clbScheme,\n \"SecurityGroups\": lbSgs,\n \"Subnets\": lbSubnets,\n \"VpcId\": lbVpc,\n \"AvailabilityZones\": lbAzs,\n \"LoadBalancerName\": clbName\n }\n }\n }\n ],\n \"Compliance\": {\n \"Status\": \"PASSED\",\n \"RelatedRequirements\": [\n \"NIST CSF V1.1 ID.RA-2\",\n \"NIST CSF V1.1 DE.AE-2\",\n \"NIST SP 800-53 Rev. 4 AU-6\",\n \"NIST SP 800-53 Rev. 4 CA-7\",\n \"NIST SP 800-53 Rev. 4 IR-4\",\n \"NIST SP 800-53 Rev. 4 PM-15\",\n \"NIST SP 800-53 Rev. 4 PM-16\",\n \"NIST SP 800-53 Rev. 4 SI-4\",\n \"NIST SP 800-53 Rev. 4 SI-5\",\n \"AIPCA TSC CC3.2\",\n \"AIPCA TSC CC7.2\",\n \"ISO 27001:2013 A.6.1.4\",\n \"ISO 27001:2013 A.12.4.1\",\n \"ISO 27001:2013 A.16.1.1\",\n \"ISO 27001:2013 A.16.1.4\",\n \"MITRE ATT&CK T1040\",\n \"MITRE ATT&CK T1046\",\n \"MITRE ATT&CK T1580\",\n \"MITRE ATT&CK T1590\",\n \"MITRE ATT&CK T1592\",\n \"MITRE ATT&CK T1595\"\n ]\n },\n \"Workflow\": {\"Status\": \"RESOLVED\"},\n \"RecordState\": \"ARCHIVED\"\n }\n yield finding\n else:\n assetPayload = {\n \"LoadBalancer\": lb,\n \"Shodan\": r\n }\n assetJson = json.dumps(assetPayload,default=str).encode(\"utf-8\")\n assetB64 = base64.b64encode(assetJson)\n finding = {\n \"SchemaVersion\": \"2018-10-08\",\n \"Id\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"ProductArn\": f\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\",\n \"GeneratorId\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"AwsAccountId\": awsAccountId,\n \"Types\": [\"Effects/Data Exposure\"],\n \"CreatedAt\": iso8601time,\n \"UpdatedAt\": iso8601time,\n \"Severity\": {\"Label\": \"MEDIUM\"},\n \"Title\": \"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\",\n \"Description\": f\"Classic Load Balancer {clbName} has been indexed by Shodan on IP address {clbIp} - resolved from DNS name {dnsName}. Shodan is an 'internet search engine' which continuously crawls and scans across the entire internet to capture host, geolocation, TLS, and running service information. Shodan is a popular tool used by blue teams, security researchers and adversaries alike. Having your asset indexed on Shodan, depending on its configuration, may increase its risk of unauthorized access and further compromise. Review your configuration and refer to the Shodan URL in the remediation section to take action to reduce your exposure and harden your host.\",\n \"Remediation\": {\n \"Recommendation\": {\n \"Text\": \"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\",\n \"Url\": f\"{SHODAN_HOSTS_URL}{clbIp}\"\n }\n },\n \"ProductFields\": {\n \"ProductName\": \"ElectricEye\",\n \"Provider\": \"AWS\",\n \"ProviderType\": \"CSP\",\n \"ProviderAccountId\": awsAccountId,\n \"AssetRegion\": awsRegion,\n \"AssetDetails\": assetB64,\n \"AssetClass\": \"Networking\",\n \"AssetService\": \"AWS Elastic Load Balancer\",\n \"AssetComponent\": \"Classic Load Balancer\"\n },\n \"Resources\": [\n {\n \"Type\": \"AwsElbLoadBalancer\",\n \"Id\": clbArn,\n \"Partition\": awsPartition,\n \"Region\": awsRegion,\n \"Details\": {\n \"AwsElbLoadBalancer\": {\n \"DnsName\": dnsName,\n \"Scheme\": clbScheme,\n \"SecurityGroups\": lbSgs,\n \"Subnets\": lbSubnets,\n \"VpcId\": lbVpc,\n \"AvailabilityZones\": lbAzs,\n \"LoadBalancerName\": clbName\n }\n }\n }\n ],\n \"Compliance\": {\n \"Status\": \"FAILED\",\n \"RelatedRequirements\": [\n \"NIST CSF V1.1 ID.RA-2\",\n \"NIST CSF V1.1 DE.AE-2\",\n \"NIST SP 800-53 Rev. 4 AU-6\",\n \"NIST SP 800-53 Rev. 4 CA-7\",\n \"NIST SP 800-53 Rev. 4 IR-4\",\n \"NIST SP 800-53 Rev. 4 PM-15\",\n \"NIST SP 800-53 Rev. 4 PM-16\",\n \"NIST SP 800-53 Rev. 4 SI-4\",\n \"NIST SP 800-53 Rev. 4 SI-5\",\n \"AIPCA TSC CC3.2\",\n \"AIPCA TSC CC7.2\",\n \"ISO 27001:2013 A.6.1.4\",\n \"ISO 27001:2013 A.12.4.1\",\n \"ISO 27001:2013 A.16.1.1\",\n \"ISO 27001:2013 A.16.1.4\",\n \"MITRE ATT&CK T1040\",\n \"MITRE ATT&CK T1046\",\n \"MITRE ATT&CK T1580\",\n \"MITRE ATT&CK T1590\",\n \"MITRE ATT&CK T1592\",\n \"MITRE ATT&CK T1595\"\n ]\n },\n \"Workflow\": {\"Status\": \"NEW\"},\n \"RecordState\": \"ACTIVE\"\n }\n yield finding","def share():\n return True","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_index_loads_properly(self):\n response = self.client.get('http://3.85.22.38:8080/books/')\n self.assertEqual(response.status_code, 200)","def testnatom(self):\r\n assert self.data.natom == 20","def test_geo_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_geo_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\n\t)","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_list_cluster_resource_quota(self):\n pass","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_stochatreat_no_misfits(probs):\n N = 10_000\n blocksize = 10\n df = pd.DataFrame(\n data={\n \"id\": np.arange(N),\n \"block\": np.repeat(np.arange(N / blocksize), repeats=blocksize),\n }\n )\n\n treats = stochatreat(\n data=df,\n block_cols=[\"block\"],\n treats=len(probs),\n idx_col=\"id\",\n probs=probs,\n random_state=42,\n )\n treatment_shares = treats.groupby([\"treat\"])[\"id\"].count() / treats.shape[0]\n\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\n if minimum_shares > 255 or nof_shares > 255:\n raise ValueError(\"Can only create up to 255 shares\")\n secret, shares = make_random_shares(\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\n )\n secret_bits = bits_in_number(secret)\n mnemonic_secret = number_to_mnemonic(secret)\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\n return mnemonic_secret, secret_bits, mnemonic_shares,","def create_new_index(self, index_name, value, is_cluster, check=False):\n print(f\"Creating {index_name} index started \\n\")\n add_index = \"/html//i[@id='addIndex']\"\n self.locator_finder_by_xpath(add_index).click()\n time.sleep(2)\n\n print(f\"selecting {index_name} from the list\\n\")\n self.locator_finder_by_select(self.select_index_type_id, value)\n\n if index_name == \"Persistent\":\n self.select_persistent_fields_id = self.locator_finder_by_hover_item_id(self.select_persistent_fields_id)\n time.sleep(1)\n self.select_persistent_fields_id.send_keys(\"pfields\").perform()\n self.select_persistent_name_id = self.locator_finder_by_hover_item_id(self.select_persistent_name_id)\n self.select_persistent_fields_id.send_keys(\"Persistent\").perform()\n time.sleep(1)\n\n if not is_cluster:\n self.select_persistent_unique_id = self.locator_finder_by_hover_item_id(\n self.select_persistent_unique_id\n )\n\n self.select_persistent_sparse_id = self.locator_finder_by_hover_item_id(self.select_persistent_sparse_id)\n self.select_persistent_duplicate_id = self.locator_finder_by_hover_item_id(\n self.select_persistent_duplicate_id\n )\n self.select_persistent_background_id = self.locator_finder_by_hover_item_id(self.select_persistent_background_id)\n time.sleep(1)\n\n elif index_name == \"Geo\":\n self.select_geo_fields_id = self.locator_finder_by_hover_item_id(self.select_geo_fields_id)\n self.select_geo_fields_id.send_keys(\"gfields\").perform()\n time.sleep(1)\n self.select_geo_name_id = self.locator_finder_by_hover_item_id(self.select_geo_name_id)\n self.select_geo_name_id.send_keys(\"Geo\").perform()\n time.sleep(1)\n self.select_geo_json_id = self.locator_finder_by_hover_item_id(self.select_geo_json_id)\n self.select_geo_background_id = self.locator_finder_by_hover_item_id(self.select_geo_background_id)\n time.sleep(1)\n self.wait_for_ajax()\n\n elif index_name == \"Fulltext\":\n self.select_fulltext_field_id = self.locator_finder_by_hover_item_id(self.select_fulltext_field_id)\n self.select_fulltext_field_id.send_keys(\"ffields\").perform()\n time.sleep(1)\n self.select_fulltext_name_id = self.locator_finder_by_hover_item_id(self.select_fulltext_name_id)\n self.select_fulltext_name_id.send_keys(\"Fulltext\").perform()\n time.sleep(1)\n self.select_fulltext_length_id = self.locator_finder_by_hover_item_id(self.select_fulltext_length_id)\n self.select_fulltext_length_id.send_keys(100)\n self.select_fulltext_background_id = self.locator_finder_by_hover_item_id(\n self.select_fulltext_background_id\n )\n time.sleep(1)\n self.wait_for_ajax()\n\n elif index_name == \"TTL\":\n self.select_ttl_field_id = self.locator_finder_by_hover_item_id(self.select_ttl_field_id)\n self.select_ttl_field_id.send_keys(\"tfields\").perform()\n time.sleep(1)\n self.select_ttl_name_id = self.locator_finder_by_hover_item_id(self.select_ttl_name_id)\n self.select_ttl_name_id.send_keys(\"TTL\").perform()\n time.sleep(1)\n self.select_ttl_expiry_id = self.locator_finder_by_hover_item_id(self.select_ttl_expiry_id)\n self.select_ttl_expiry_id.send_keys(1000)\n self.select_ttl_background_id = self.locator_finder_by_hover_item_id(self.select_ttl_background_id)\n time.sleep(1)\n self.wait_for_ajax()\n\n # experimental feature\n elif index_name == 'ZKD':\n if check:\n self.navbar_goto(\"collections\")\n print(\"Selecting computed values collections. \\n\")\n col = '//*[@id=\"collection_ComputedValueCol\"]/div/h5'\n self.locator_finder_by_xpath(col).click()\n self.select_index_menu()\n\n print(f\"Creating {index_name} index started \\n\")\n self.locator_finder_by_xpath(add_index).click()\n time.sleep(2)\n\n print(f\"selecting {index_name} from the list\\n\")\n self.locator_finder_by_select(self.select_index_type_id, 5)\n\n time.sleep(1)\n\n select_zkd_field_sitem = self.locator_finder_by_id('newZkdFields')\n select_zkd_field_sitem.click()\n select_zkd_field_sitem.clear()\n select_zkd_field_sitem.send_keys('x,y')\n time.sleep(1)\n else:\n select_zkd_field_sitem = self.locator_finder_by_id('newZkdFields')\n select_zkd_field_sitem.click()\n select_zkd_field_sitem.clear()\n select_zkd_field_sitem.send_keys('zkdfileds')\n time.sleep(1)\n\n select_zkd_name_sitem = self.locator_finder_by_id('newZkdName')\n select_zkd_name_sitem.click()\n select_zkd_name_sitem.clear()\n select_zkd_name_sitem.send_keys('ZKD')\n time.sleep(1)\n\n select_create_index_btn_id = \"createIndex\"\n self.locator_finder_by_id(select_create_index_btn_id).click()\n time.sleep(10)\n self.webdriver.refresh()\n\n if check:\n self.navbar_goto(\"collections\")\n self.select_collection(\"TestDoc\")\n self.select_index_menu()\n\n print(f\"Creating {index_name} index completed \\n\")","def get_shares_in_recycle_bin_by_network(\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\n if filters is None:\n filters = {}\n filters[\"share_network_id\"] = share_network_id\n filters[\"is_soft_deleted\"] = True\n query = _share_get_all_with_filters(context, filters=filters,\n sort_key=sort_key, sort_dir=sort_dir)\n return query","def cluster(self,\r\n indexlist=None,\r\n iterate_over=True,\r\n keycount=100,\r\n usepurge=True):\r\n if indexlist is None:\r\n indexlist = self.indexes()\r\n\r\n if iterate_over:\r\n self.reset_iterators()\r\n\r\n keysetlist = []\r\n\r\n if keycount == 100:\r\n for i_temp in indexlist:\r\n keysetlist.append(set(self.get_keys_from_note(i_temp)))\r\n\r\n #form a list of the keysets\r\n\r\n else:\r\n for i_temp in indexlist:\r\n keysetlist.append(set(self.return_least_keys\r\n (set(self.get_keys_from_note(i_temp)),\r\n numberof=keycount, no_allcaps=False)))\r\n\r\n #form a list of the keysets\r\n if not usepurge:\r\n clusteredsetlist = nformat.purgesets(consolidate.consolidate(keysetlist),\r\n self.all_cap_purge,\r\n self.first_cap_purge,\r\n self.lower_case_purge,\r\n self.purgelist)\r\n else:\r\n newkeysetlist = []\r\n for s_temp in keysetlist:\r\n newkeysetlist.append(self.default_dict['purge'].apply(s_temp))\r\n clusteredsetlist = consolidate.consolidate(newkeysetlist)\r\n counter = 1\r\n for csl in clusteredsetlist:\r\n\r\n t_temp = EMPTYCHAR\r\n for cs_temp in sorted(csl):\r\n t_temp += cs_temp + COMMA + BLANK\r\n display.noteprint((labels.CLUSTER + BLANK + POUND\r\n +str(counter),\r\n t_temp[:-2]))\r\n q_temp = EMPTYCHAR\r\n for cs_temp in list(csl):\r\n q_temp += VERTLINE+LEFTNOTE+cs_temp+RIGHTNOTE+VERTLINE\r\n\r\n q_temp = q_temp[1:-1].strip()\r\n\r\n counter += 1\r\n if iterate_over:\r\n tl_temp = new_search(q_temp,\r\n defaultdictionaryobject=self.default_dict,\r\n db_cursor=db_cursor,\r\n self=self)[1]\r\n tl_temp = [a_temp for a_temp in tl_temp\r\n if Index(a_temp) > Index(0)]\r\n if tl_temp:\r\n self.add_iterator(tl_temp, csl)","def test_calculate_count(request):\n print(\"\\n--Starting:\", request.node.name)\n\n net = ModelRoadwayNetwork.read(\n link_file=STPAUL_LINK_FILE,\n node_file=STPAUL_NODE_FILE,\n shape_file=STPAUL_SHAPE_FILE,\n fast=True,\n )\n\n net.add_counts()\n assert \"AADT\" in net.links_df.columns\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\n ## todo write an assert that actually tests something"],"string":"[\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_index_containers(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\\n ingest_shares = \\\"\\\"\\\"\\n UNWIND $shares_list as s\\n MERGE (share:AzureStorageFileShare{id: s.id})\\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\\n SET share.name = s.name,\\n share.lastupdated = $azure_update_tag,\\n share.lastmodifiedtime = s.last_modified_time,\\n share.sharequota = s.share_quota,\\n share.accesstier = s.access_tier,\\n share.deleted = s.deleted,\\n share.accesstierchangetime = s.access_tier_change_time,\\n share.accesstierstatus = s.access_tier_status,\\n share.deletedtime = s.deleted_time,\\n share.enabledprotocols = s.enabled_protocols,\\n share.remainingretentiondays = s.remaining_retention_days,\\n share.shareusagebytes = s.share_usage_bytes,\\n share.version = s.version\\n WITH share, s\\n MATCH (fs:AzureStorageFileService{id: s.service_id})\\n MERGE (fs)-[r:CONTAINS]->(share)\\n ON CREATE SET r.firstseen = timestamp()\\n SET r.lastupdated = $azure_update_tag\\n \\\"\\\"\\\"\\n\\n neo4j_session.run(\\n ingest_shares,\\n shares_list=shares,\\n azure_update_tag=update_tag,\\n )\",\n \"def test_index(self):\",\n \"def test_index_availability(client):\\n response = client.get('/')\\n assert response.status_code == 200\",\n \"def test_index(client):\\n ind = client.get('/')\\n ind2 = client.get('/index/')\\n assert ind.status_code == 200\\n assert ind2.status_code == 200\",\n \"def test_export_index(self):\",\n \"def test_index_repositories(self):\\n self.Mokes.add_repo_to_pi()\\n with self.logged_in(access_token=\\\"nbiousndegoijubdognlksdngndsgmngds\\\"):\\n index = self.client.get(\\\"/\\\").data.decode()\\n self.assertIn('href=\\\"/repo/PerseusDl/canonical-greekLit\\\"', index, \\\"GreekLit link should be there\\\")\\n self.assertIn('href=\\\"/repo/PerseusDl/canonical-greekLit\\\"', index, \\\"LatinLit link should be there\\\")\",\n \"def test_stock_index(self):\\n response = self.client.get(reverse('stock-index'))\\n self.assertEqual(response.status_code, 200)\",\n \"async def test_endpoint_delete_container_shares_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_container_shares_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_index_stats(self):\\n #Create Index\\n self.run_multi_operations(buckets = self.buckets,\\n query_definitions = self.query_definitions,\\n create_index = True, drop_index = False)\\n #Check Index Stats\\n self.sleep(30)\\n index_map = self.get_index_stats()\\n self.log.info(index_map)\\n for query_definition in self.query_definitions:\\n index_name = query_definition.index_name\\n for bucket in self.buckets:\\n bucket_name = bucket.name\\n check_keys = ['items_count', 'total_scan_duration', 'num_docs_queued',\\n 'num_requests', 'num_rows_returned', 'num_docs_queued',\\n 'num_docs_pending','delete_bytes' ]\\n map = self._create_stats_map(items_count=2016)\\n self._verify_index_stats(index_map, index_name, bucket_name, map, check_keys)\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def get_shares_count(self):\\n\\t\\treturn call_sdk_function('PrlVmCfg_GetSharesCount', self.handle)\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def get_correct_num_of_shares(shares):\\n threshold = shares[0].threshold\\n if len(shares) < threshold:\\n raise('Not enough shares for decryption.')\\n used_shares = [sk_share for sk_share in shares]\\n # remove unnecessary shares\\n while len(used_shares) > threshold:\\n # remove share at random\\n used_shares.remove(choice(used_shares))\\n return used_shares\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_assign_clusters_nonsparse(self, new_data, filename):\\n\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\\n elif self.split_type == 'date':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\\n \\n averages_seg['exists'] = 1\\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\\n test_exists = test_data_exists[test_data_exists['exists']==1]\\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\\n \\n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\\n test_matrix = test_matrix.fillna(0)\\n \\n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\\n\\n print('clustering new data...')\\n cluster_model = joblib.load(filename)\\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\\n \\n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\\n keydf = test_matrix[['segment_id','date','time']].reset_index()\\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\\n \\n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]\",\n \"def test_index_container_privileges(self):\\n pass\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def test_stochatreat_no_probs(n_treats, block_cols, df):\\n treats = stochatreat(\\n data=df, block_cols=block_cols, treats=n_treats, idx_col=\\\"id\\\", random_state=42\\n )\\n\\n treatment_shares = treats.groupby([\\\"treat\\\"])[\\\"id\\\"].count() / treats.shape[0]\\n\\n np.testing.assert_almost_equal(\\n treatment_shares, np.array([1 / n_treats] * n_treats), decimal=3\\n )\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def test_get_site_scans(self):\\n pass\",\n \"def test_read_namespaced_applied_cluster_resource_quota(self):\\n pass\",\n \"def test_wrong_config_shares1(self):\\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\\n\\n for i in config:\\n k = config\\n k[i] = ''\\n print k\\n self.app.post_json(url=\\\"/config/shares\\\", params=k, status=400)\\n return config\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def testnbasis(self):\\r\\n count = sum([self.nbasisdict[n] for n in self.data.atomnos])\\r\\n assert self.data.nbasis == count\",\n \"def test_smoker_get(self):\\n pass\",\n \"def test_creating_index_type(self):\",\n \"def test_replace_cluster_resource_quota(self):\\n pass\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def test_data_source_soaps_count_get(self):\\n pass\",\n \"def test_news_index_no_perm(self):\\n self.assertStatusCode(self.url, 403)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_extreme_neighborhoods(self):\\n\\n ## Radius = 0 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Min_neighbors > 30 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=31,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Radius very large ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=100.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\\n\\n ## Min_neighbors = 0 ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.5,\\n min_core_neighbors=0,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_atom_index_cache(self):\\n # First make OH-\\n mol = Molecule()\\n mol.add_atom(8, -1, False, None)\\n mol.add_atom(1, 0, False, None)\\n mol.add_bond(0, 1, 1, False)\\n assert mol.atom(0).molecule_atom_index == 0\\n assert mol.atom(1).molecule_atom_index == 1\\n\\n # Now convert it to H2O and ask for atom indices again\\n mol.add_atom(1, 0, False, None)\\n mol.add_bond(1, 2, 1, False)\\n mol.atom(0).formal_charge = 0\\n assert mol.atom(0).molecule_atom_index == 0\\n assert mol.atom(1).molecule_atom_index == 1\\n assert mol.atom(2).molecule_atom_index == 2\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def test_shared_albums(self):\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n t = (\\n TestAccount.album_image_count\\n + TestAccount.album_shared_image_count\\n + TestAccount.shared_album_image_count\\n + TestAccount.shared_album_shared_image_count\\n )\\n\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums including shared\\\".format(t),\\n )\\n\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\", \\\"--skip-shared-albums\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n # note that unless we use --no-album-index the shared files in the\\n # visible album will show up here\\n t = (\\n TestAccount.album_image_count + TestAccount.album_shared_image_count\\n ) # see above\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums excluding shared\\\".format(t),\\n )\",\n \"def test_news_index_has_perm(self):\\n self.assertStatusCode(self.url, 200)\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def public_clb_shodan_check(cache: dict, session, awsAccountId: str, awsRegion: str, awsPartition: str) -> dict:\\n shodanApiKey = get_shodan_api_key(cache)\\n # ISO Time\\n iso8601time = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).isoformat() \\n for lb in describe_clbs(cache, session):\\n if shodanApiKey is None:\\n continue\\n # B64 encode all of the details for the Asset\\n assetJson = json.dumps(lb,default=str).encode(\\\"utf-8\\\")\\n assetB64 = base64.b64encode(assetJson)\\n clbName = lb[\\\"LoadBalancerName\\\"]\\n clbArn = f\\\"arn:{awsPartition}:elasticloadbalancing:{awsRegion}:{awsAccountId}:loadbalancer/{clbName}\\\"\\n dnsName = lb[\\\"DNSName\\\"]\\n lbSgs = lb[\\\"SecurityGroups\\\"]\\n lbSubnets = lb[\\\"Subnets\\\"]\\n lbAzs = lb[\\\"AvailabilityZones\\\"]\\n lbVpc = lb[\\\"VPCId\\\"]\\n clbScheme = lb[\\\"Scheme\\\"]\\n if clbScheme == \\\"internet-facing\\\":\\n # Use Google DNS to resolve\\n clbIp = google_dns_resolver(dnsName)\\n if clbIp is None:\\n continue\\n # check if IP indexed by Shodan\\n r = requests.get(url=f\\\"{SHODAN_HOSTS_URL}{clbIp}?key={shodanApiKey}\\\").json()\\n if str(r) == \\\"{'error': 'No information available for that IP.'}\\\":\\n # this is a passing check\\n finding = {\\n \\\"SchemaVersion\\\": \\\"2018-10-08\\\",\\n \\\"Id\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"ProductArn\\\": f\\\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\\\",\\n \\\"GeneratorId\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"AwsAccountId\\\": awsAccountId,\\n \\\"Types\\\": [\\\"Effects/Data Exposure\\\"],\\n \\\"CreatedAt\\\": iso8601time,\\n \\\"UpdatedAt\\\": iso8601time,\\n \\\"Severity\\\": {\\\"Label\\\": \\\"INFORMATIONAL\\\"},\\n \\\"Title\\\": \\\"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\\\",\\n \\\"Description\\\": f\\\"Classic Load Balancer {clbName} has not been indexed by Shodan.\\\",\\n \\\"Remediation\\\": {\\n \\\"Recommendation\\\": {\\n \\\"Text\\\": \\\"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\\\",\\n \\\"Url\\\": SHODAN_HOSTS_URL\\n }\\n },\\n \\\"ProductFields\\\": {\\n \\\"ProductName\\\": \\\"ElectricEye\\\",\\n \\\"Provider\\\": \\\"AWS\\\",\\n \\\"ProviderType\\\": \\\"CSP\\\",\\n \\\"ProviderAccountId\\\": awsAccountId,\\n \\\"AssetRegion\\\": awsRegion,\\n \\\"AssetDetails\\\": assetB64,\\n \\\"AssetClass\\\": \\\"Networking\\\",\\n \\\"AssetService\\\": \\\"AWS Elastic Load Balancer\\\",\\n \\\"AssetComponent\\\": \\\"Classic Load Balancer\\\"\\n },\\n \\\"Resources\\\": [\\n {\\n \\\"Type\\\": \\\"AwsElbLoadBalancer\\\",\\n \\\"Id\\\": clbArn,\\n \\\"Partition\\\": awsPartition,\\n \\\"Region\\\": awsRegion,\\n \\\"Details\\\": {\\n \\\"AwsElbLoadBalancer\\\": {\\n \\\"DnsName\\\": dnsName,\\n \\\"Scheme\\\": clbScheme,\\n \\\"SecurityGroups\\\": lbSgs,\\n \\\"Subnets\\\": lbSubnets,\\n \\\"VpcId\\\": lbVpc,\\n \\\"AvailabilityZones\\\": lbAzs,\\n \\\"LoadBalancerName\\\": clbName\\n }\\n }\\n }\\n ],\\n \\\"Compliance\\\": {\\n \\\"Status\\\": \\\"PASSED\\\",\\n \\\"RelatedRequirements\\\": [\\n \\\"NIST CSF V1.1 ID.RA-2\\\",\\n \\\"NIST CSF V1.1 DE.AE-2\\\",\\n \\\"NIST SP 800-53 Rev. 4 AU-6\\\",\\n \\\"NIST SP 800-53 Rev. 4 CA-7\\\",\\n \\\"NIST SP 800-53 Rev. 4 IR-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-15\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-16\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-5\\\",\\n \\\"AIPCA TSC CC3.2\\\",\\n \\\"AIPCA TSC CC7.2\\\",\\n \\\"ISO 27001:2013 A.6.1.4\\\",\\n \\\"ISO 27001:2013 A.12.4.1\\\",\\n \\\"ISO 27001:2013 A.16.1.1\\\",\\n \\\"ISO 27001:2013 A.16.1.4\\\",\\n \\\"MITRE ATT&CK T1040\\\",\\n \\\"MITRE ATT&CK T1046\\\",\\n \\\"MITRE ATT&CK T1580\\\",\\n \\\"MITRE ATT&CK T1590\\\",\\n \\\"MITRE ATT&CK T1592\\\",\\n \\\"MITRE ATT&CK T1595\\\"\\n ]\\n },\\n \\\"Workflow\\\": {\\\"Status\\\": \\\"RESOLVED\\\"},\\n \\\"RecordState\\\": \\\"ARCHIVED\\\"\\n }\\n yield finding\\n else:\\n assetPayload = {\\n \\\"LoadBalancer\\\": lb,\\n \\\"Shodan\\\": r\\n }\\n assetJson = json.dumps(assetPayload,default=str).encode(\\\"utf-8\\\")\\n assetB64 = base64.b64encode(assetJson)\\n finding = {\\n \\\"SchemaVersion\\\": \\\"2018-10-08\\\",\\n \\\"Id\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"ProductArn\\\": f\\\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\\\",\\n \\\"GeneratorId\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"AwsAccountId\\\": awsAccountId,\\n \\\"Types\\\": [\\\"Effects/Data Exposure\\\"],\\n \\\"CreatedAt\\\": iso8601time,\\n \\\"UpdatedAt\\\": iso8601time,\\n \\\"Severity\\\": {\\\"Label\\\": \\\"MEDIUM\\\"},\\n \\\"Title\\\": \\\"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\\\",\\n \\\"Description\\\": f\\\"Classic Load Balancer {clbName} has been indexed by Shodan on IP address {clbIp} - resolved from DNS name {dnsName}. Shodan is an 'internet search engine' which continuously crawls and scans across the entire internet to capture host, geolocation, TLS, and running service information. Shodan is a popular tool used by blue teams, security researchers and adversaries alike. Having your asset indexed on Shodan, depending on its configuration, may increase its risk of unauthorized access and further compromise. Review your configuration and refer to the Shodan URL in the remediation section to take action to reduce your exposure and harden your host.\\\",\\n \\\"Remediation\\\": {\\n \\\"Recommendation\\\": {\\n \\\"Text\\\": \\\"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\\\",\\n \\\"Url\\\": f\\\"{SHODAN_HOSTS_URL}{clbIp}\\\"\\n }\\n },\\n \\\"ProductFields\\\": {\\n \\\"ProductName\\\": \\\"ElectricEye\\\",\\n \\\"Provider\\\": \\\"AWS\\\",\\n \\\"ProviderType\\\": \\\"CSP\\\",\\n \\\"ProviderAccountId\\\": awsAccountId,\\n \\\"AssetRegion\\\": awsRegion,\\n \\\"AssetDetails\\\": assetB64,\\n \\\"AssetClass\\\": \\\"Networking\\\",\\n \\\"AssetService\\\": \\\"AWS Elastic Load Balancer\\\",\\n \\\"AssetComponent\\\": \\\"Classic Load Balancer\\\"\\n },\\n \\\"Resources\\\": [\\n {\\n \\\"Type\\\": \\\"AwsElbLoadBalancer\\\",\\n \\\"Id\\\": clbArn,\\n \\\"Partition\\\": awsPartition,\\n \\\"Region\\\": awsRegion,\\n \\\"Details\\\": {\\n \\\"AwsElbLoadBalancer\\\": {\\n \\\"DnsName\\\": dnsName,\\n \\\"Scheme\\\": clbScheme,\\n \\\"SecurityGroups\\\": lbSgs,\\n \\\"Subnets\\\": lbSubnets,\\n \\\"VpcId\\\": lbVpc,\\n \\\"AvailabilityZones\\\": lbAzs,\\n \\\"LoadBalancerName\\\": clbName\\n }\\n }\\n }\\n ],\\n \\\"Compliance\\\": {\\n \\\"Status\\\": \\\"FAILED\\\",\\n \\\"RelatedRequirements\\\": [\\n \\\"NIST CSF V1.1 ID.RA-2\\\",\\n \\\"NIST CSF V1.1 DE.AE-2\\\",\\n \\\"NIST SP 800-53 Rev. 4 AU-6\\\",\\n \\\"NIST SP 800-53 Rev. 4 CA-7\\\",\\n \\\"NIST SP 800-53 Rev. 4 IR-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-15\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-16\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-5\\\",\\n \\\"AIPCA TSC CC3.2\\\",\\n \\\"AIPCA TSC CC7.2\\\",\\n \\\"ISO 27001:2013 A.6.1.4\\\",\\n \\\"ISO 27001:2013 A.12.4.1\\\",\\n \\\"ISO 27001:2013 A.16.1.1\\\",\\n \\\"ISO 27001:2013 A.16.1.4\\\",\\n \\\"MITRE ATT&CK T1040\\\",\\n \\\"MITRE ATT&CK T1046\\\",\\n \\\"MITRE ATT&CK T1580\\\",\\n \\\"MITRE ATT&CK T1590\\\",\\n \\\"MITRE ATT&CK T1592\\\",\\n \\\"MITRE ATT&CK T1595\\\"\\n ]\\n },\\n \\\"Workflow\\\": {\\\"Status\\\": \\\"NEW\\\"},\\n \\\"RecordState\\\": \\\"ACTIVE\\\"\\n }\\n yield finding\",\n \"def share():\\n return True\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_index_loads_properly(self):\\n response = self.client.get('http://3.85.22.38:8080/books/')\\n self.assertEqual(response.status_code, 200)\",\n \"def testnatom(self):\\r\\n assert self.data.natom == 20\",\n \"def test_geo_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_geo_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\\n\\t)\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_list_cluster_resource_quota(self):\\n pass\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_stochatreat_no_misfits(probs):\\n N = 10_000\\n blocksize = 10\\n df = pd.DataFrame(\\n data={\\n \\\"id\\\": np.arange(N),\\n \\\"block\\\": np.repeat(np.arange(N / blocksize), repeats=blocksize),\\n }\\n )\\n\\n treats = stochatreat(\\n data=df,\\n block_cols=[\\\"block\\\"],\\n treats=len(probs),\\n idx_col=\\\"id\\\",\\n probs=probs,\\n random_state=42,\\n )\\n treatment_shares = treats.groupby([\\\"treat\\\"])[\\\"id\\\"].count() / treats.shape[0]\\n\\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\\n if minimum_shares > 255 or nof_shares > 255:\\n raise ValueError(\\\"Can only create up to 255 shares\\\")\\n secret, shares = make_random_shares(\\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\\n )\\n secret_bits = bits_in_number(secret)\\n mnemonic_secret = number_to_mnemonic(secret)\\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\\n return mnemonic_secret, secret_bits, mnemonic_shares,\",\n \"def create_new_index(self, index_name, value, is_cluster, check=False):\\n print(f\\\"Creating {index_name} index started \\\\n\\\")\\n add_index = \\\"/html//i[@id='addIndex']\\\"\\n self.locator_finder_by_xpath(add_index).click()\\n time.sleep(2)\\n\\n print(f\\\"selecting {index_name} from the list\\\\n\\\")\\n self.locator_finder_by_select(self.select_index_type_id, value)\\n\\n if index_name == \\\"Persistent\\\":\\n self.select_persistent_fields_id = self.locator_finder_by_hover_item_id(self.select_persistent_fields_id)\\n time.sleep(1)\\n self.select_persistent_fields_id.send_keys(\\\"pfields\\\").perform()\\n self.select_persistent_name_id = self.locator_finder_by_hover_item_id(self.select_persistent_name_id)\\n self.select_persistent_fields_id.send_keys(\\\"Persistent\\\").perform()\\n time.sleep(1)\\n\\n if not is_cluster:\\n self.select_persistent_unique_id = self.locator_finder_by_hover_item_id(\\n self.select_persistent_unique_id\\n )\\n\\n self.select_persistent_sparse_id = self.locator_finder_by_hover_item_id(self.select_persistent_sparse_id)\\n self.select_persistent_duplicate_id = self.locator_finder_by_hover_item_id(\\n self.select_persistent_duplicate_id\\n )\\n self.select_persistent_background_id = self.locator_finder_by_hover_item_id(self.select_persistent_background_id)\\n time.sleep(1)\\n\\n elif index_name == \\\"Geo\\\":\\n self.select_geo_fields_id = self.locator_finder_by_hover_item_id(self.select_geo_fields_id)\\n self.select_geo_fields_id.send_keys(\\\"gfields\\\").perform()\\n time.sleep(1)\\n self.select_geo_name_id = self.locator_finder_by_hover_item_id(self.select_geo_name_id)\\n self.select_geo_name_id.send_keys(\\\"Geo\\\").perform()\\n time.sleep(1)\\n self.select_geo_json_id = self.locator_finder_by_hover_item_id(self.select_geo_json_id)\\n self.select_geo_background_id = self.locator_finder_by_hover_item_id(self.select_geo_background_id)\\n time.sleep(1)\\n self.wait_for_ajax()\\n\\n elif index_name == \\\"Fulltext\\\":\\n self.select_fulltext_field_id = self.locator_finder_by_hover_item_id(self.select_fulltext_field_id)\\n self.select_fulltext_field_id.send_keys(\\\"ffields\\\").perform()\\n time.sleep(1)\\n self.select_fulltext_name_id = self.locator_finder_by_hover_item_id(self.select_fulltext_name_id)\\n self.select_fulltext_name_id.send_keys(\\\"Fulltext\\\").perform()\\n time.sleep(1)\\n self.select_fulltext_length_id = self.locator_finder_by_hover_item_id(self.select_fulltext_length_id)\\n self.select_fulltext_length_id.send_keys(100)\\n self.select_fulltext_background_id = self.locator_finder_by_hover_item_id(\\n self.select_fulltext_background_id\\n )\\n time.sleep(1)\\n self.wait_for_ajax()\\n\\n elif index_name == \\\"TTL\\\":\\n self.select_ttl_field_id = self.locator_finder_by_hover_item_id(self.select_ttl_field_id)\\n self.select_ttl_field_id.send_keys(\\\"tfields\\\").perform()\\n time.sleep(1)\\n self.select_ttl_name_id = self.locator_finder_by_hover_item_id(self.select_ttl_name_id)\\n self.select_ttl_name_id.send_keys(\\\"TTL\\\").perform()\\n time.sleep(1)\\n self.select_ttl_expiry_id = self.locator_finder_by_hover_item_id(self.select_ttl_expiry_id)\\n self.select_ttl_expiry_id.send_keys(1000)\\n self.select_ttl_background_id = self.locator_finder_by_hover_item_id(self.select_ttl_background_id)\\n time.sleep(1)\\n self.wait_for_ajax()\\n\\n # experimental feature\\n elif index_name == 'ZKD':\\n if check:\\n self.navbar_goto(\\\"collections\\\")\\n print(\\\"Selecting computed values collections. \\\\n\\\")\\n col = '//*[@id=\\\"collection_ComputedValueCol\\\"]/div/h5'\\n self.locator_finder_by_xpath(col).click()\\n self.select_index_menu()\\n\\n print(f\\\"Creating {index_name} index started \\\\n\\\")\\n self.locator_finder_by_xpath(add_index).click()\\n time.sleep(2)\\n\\n print(f\\\"selecting {index_name} from the list\\\\n\\\")\\n self.locator_finder_by_select(self.select_index_type_id, 5)\\n\\n time.sleep(1)\\n\\n select_zkd_field_sitem = self.locator_finder_by_id('newZkdFields')\\n select_zkd_field_sitem.click()\\n select_zkd_field_sitem.clear()\\n select_zkd_field_sitem.send_keys('x,y')\\n time.sleep(1)\\n else:\\n select_zkd_field_sitem = self.locator_finder_by_id('newZkdFields')\\n select_zkd_field_sitem.click()\\n select_zkd_field_sitem.clear()\\n select_zkd_field_sitem.send_keys('zkdfileds')\\n time.sleep(1)\\n\\n select_zkd_name_sitem = self.locator_finder_by_id('newZkdName')\\n select_zkd_name_sitem.click()\\n select_zkd_name_sitem.clear()\\n select_zkd_name_sitem.send_keys('ZKD')\\n time.sleep(1)\\n\\n select_create_index_btn_id = \\\"createIndex\\\"\\n self.locator_finder_by_id(select_create_index_btn_id).click()\\n time.sleep(10)\\n self.webdriver.refresh()\\n\\n if check:\\n self.navbar_goto(\\\"collections\\\")\\n self.select_collection(\\\"TestDoc\\\")\\n self.select_index_menu()\\n\\n print(f\\\"Creating {index_name} index completed \\\\n\\\")\",\n \"def get_shares_in_recycle_bin_by_network(\\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\\n if filters is None:\\n filters = {}\\n filters[\\\"share_network_id\\\"] = share_network_id\\n filters[\\\"is_soft_deleted\\\"] = True\\n query = _share_get_all_with_filters(context, filters=filters,\\n sort_key=sort_key, sort_dir=sort_dir)\\n return query\",\n \"def cluster(self,\\r\\n indexlist=None,\\r\\n iterate_over=True,\\r\\n keycount=100,\\r\\n usepurge=True):\\r\\n if indexlist is None:\\r\\n indexlist = self.indexes()\\r\\n\\r\\n if iterate_over:\\r\\n self.reset_iterators()\\r\\n\\r\\n keysetlist = []\\r\\n\\r\\n if keycount == 100:\\r\\n for i_temp in indexlist:\\r\\n keysetlist.append(set(self.get_keys_from_note(i_temp)))\\r\\n\\r\\n #form a list of the keysets\\r\\n\\r\\n else:\\r\\n for i_temp in indexlist:\\r\\n keysetlist.append(set(self.return_least_keys\\r\\n (set(self.get_keys_from_note(i_temp)),\\r\\n numberof=keycount, no_allcaps=False)))\\r\\n\\r\\n #form a list of the keysets\\r\\n if not usepurge:\\r\\n clusteredsetlist = nformat.purgesets(consolidate.consolidate(keysetlist),\\r\\n self.all_cap_purge,\\r\\n self.first_cap_purge,\\r\\n self.lower_case_purge,\\r\\n self.purgelist)\\r\\n else:\\r\\n newkeysetlist = []\\r\\n for s_temp in keysetlist:\\r\\n newkeysetlist.append(self.default_dict['purge'].apply(s_temp))\\r\\n clusteredsetlist = consolidate.consolidate(newkeysetlist)\\r\\n counter = 1\\r\\n for csl in clusteredsetlist:\\r\\n\\r\\n t_temp = EMPTYCHAR\\r\\n for cs_temp in sorted(csl):\\r\\n t_temp += cs_temp + COMMA + BLANK\\r\\n display.noteprint((labels.CLUSTER + BLANK + POUND\\r\\n +str(counter),\\r\\n t_temp[:-2]))\\r\\n q_temp = EMPTYCHAR\\r\\n for cs_temp in list(csl):\\r\\n q_temp += VERTLINE+LEFTNOTE+cs_temp+RIGHTNOTE+VERTLINE\\r\\n\\r\\n q_temp = q_temp[1:-1].strip()\\r\\n\\r\\n counter += 1\\r\\n if iterate_over:\\r\\n tl_temp = new_search(q_temp,\\r\\n defaultdictionaryobject=self.default_dict,\\r\\n db_cursor=db_cursor,\\r\\n self=self)[1]\\r\\n tl_temp = [a_temp for a_temp in tl_temp\\r\\n if Index(a_temp) > Index(0)]\\r\\n if tl_temp:\\r\\n self.add_iterator(tl_temp, csl)\",\n \"def test_calculate_count(request):\\n print(\\\"\\\\n--Starting:\\\", request.node.name)\\n\\n net = ModelRoadwayNetwork.read(\\n link_file=STPAUL_LINK_FILE,\\n node_file=STPAUL_NODE_FILE,\\n shape_file=STPAUL_SHAPE_FILE,\\n fast=True,\\n )\\n\\n net.add_counts()\\n assert \\\"AADT\\\" in net.links_df.columns\\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\\n ## todo write an assert that actually tests something\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9408521","0.8480369","0.7828743","0.77089137","0.76689196","0.7658634","0.7639658","0.7374224","0.73682296","0.71836025","0.70449203","0.69670975","0.677711","0.675877","0.670886","0.6664895","0.6502741","0.6135646","0.60962385","0.5956307","0.5926037","0.5799074","0.56415457","0.5495783","0.5483802","0.54495466","0.5408182","0.5391498","0.53852993","0.5371935","0.53576213","0.5327559","0.532407","0.5300565","0.5298329","0.5267913","0.52539706","0.52429533","0.52286184","0.52232575","0.51981616","0.51924664","0.5187783","0.5184086","0.517927","0.51719606","0.5148949","0.5146661","0.51455224","0.51455224","0.513262","0.5129734","0.5119832","0.5117486","0.5109328","0.5073933","0.5063459","0.50633496","0.50586545","0.50518626","0.5051258","0.5048796","0.5045715","0.50402075","0.50289553","0.50282323","0.50044125","0.49838603","0.49710783","0.49678326","0.49665913","0.49642965","0.49584153","0.49492815","0.4939866","0.49392995","0.49311364","0.49186125","0.49185976","0.4901167","0.49004605","0.4891383","0.4887265","0.4881289","0.4873537","0.4868641","0.48651567","0.48580503","0.4848415","0.4845574","0.48450312","0.48393598","0.48386502","0.48367387","0.48311836","0.483014","0.48156935","0.4813044","0.48104697","0.48097733"],"string":"[\n \"0.9408521\",\n \"0.8480369\",\n \"0.7828743\",\n \"0.77089137\",\n \"0.76689196\",\n \"0.7658634\",\n \"0.7639658\",\n \"0.7374224\",\n \"0.73682296\",\n \"0.71836025\",\n \"0.70449203\",\n \"0.69670975\",\n \"0.677711\",\n \"0.675877\",\n \"0.670886\",\n \"0.6664895\",\n \"0.6502741\",\n \"0.6135646\",\n \"0.60962385\",\n \"0.5956307\",\n \"0.5926037\",\n \"0.5799074\",\n \"0.56415457\",\n \"0.5495783\",\n \"0.5483802\",\n \"0.54495466\",\n \"0.5408182\",\n \"0.5391498\",\n \"0.53852993\",\n \"0.5371935\",\n \"0.53576213\",\n \"0.5327559\",\n \"0.532407\",\n \"0.5300565\",\n \"0.5298329\",\n \"0.5267913\",\n \"0.52539706\",\n \"0.52429533\",\n \"0.52286184\",\n \"0.52232575\",\n \"0.51981616\",\n \"0.51924664\",\n \"0.5187783\",\n \"0.5184086\",\n \"0.517927\",\n \"0.51719606\",\n \"0.5148949\",\n \"0.5146661\",\n \"0.51455224\",\n \"0.51455224\",\n \"0.513262\",\n \"0.5129734\",\n \"0.5119832\",\n \"0.5117486\",\n \"0.5109328\",\n \"0.5073933\",\n \"0.5063459\",\n \"0.50633496\",\n \"0.50586545\",\n \"0.50518626\",\n \"0.5051258\",\n \"0.5048796\",\n \"0.5045715\",\n \"0.50402075\",\n \"0.50289553\",\n \"0.50282323\",\n \"0.50044125\",\n \"0.49838603\",\n \"0.49710783\",\n \"0.49678326\",\n \"0.49665913\",\n \"0.49642965\",\n \"0.49584153\",\n \"0.49492815\",\n \"0.4939866\",\n \"0.49392995\",\n \"0.49311364\",\n \"0.49186125\",\n \"0.49185976\",\n \"0.4901167\",\n \"0.49004605\",\n \"0.4891383\",\n \"0.4887265\",\n \"0.4881289\",\n \"0.4873537\",\n \"0.4868641\",\n \"0.48651567\",\n \"0.48580503\",\n \"0.4848415\",\n \"0.4845574\",\n \"0.48450312\",\n \"0.48393598\",\n \"0.48386502\",\n \"0.48367387\",\n \"0.48311836\",\n \"0.483014\",\n \"0.48156935\",\n \"0.4813044\",\n \"0.48104697\",\n \"0.48097733\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.93974316"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":81377,"cells":{"query":{"kind":"string","value":"Test case for index_nas_shares_by_nas"},"document":{"kind":"string","value":"def test_index_nas_shares_by_nas(self):\n pass"},"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_index_nas_shares(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_test_nas_share(self):\n pass","def test_update_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_destroy_nas_share_by_pool(self):\n pass","def test_dashboards_v2_share(self):\n pass","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\n ingest_shares = \"\"\"\n UNWIND $shares_list as s\n MERGE (share:AzureStorageFileShare{id: s.id})\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\n SET share.name = s.name,\n share.lastupdated = $azure_update_tag,\n share.lastmodifiedtime = s.last_modified_time,\n share.sharequota = s.share_quota,\n share.accesstier = s.access_tier,\n share.deleted = s.deleted,\n share.accesstierchangetime = s.access_tier_change_time,\n share.accesstierstatus = s.access_tier_status,\n share.deletedtime = s.deleted_time,\n share.enabledprotocols = s.enabled_protocols,\n share.remainingretentiondays = s.remaining_retention_days,\n share.shareusagebytes = s.share_usage_bytes,\n share.version = s.version\n WITH share, s\n MATCH (fs:AzureStorageFileService{id: s.service_id})\n MERGE (fs)-[r:CONTAINS]->(share)\n ON CREATE SET r.firstseen = timestamp()\n SET r.lastupdated = $azure_update_tag\n \"\"\"\n\n neo4j_session.run(\n ingest_shares,\n shares_list=shares,\n azure_update_tag=update_tag,\n )","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_stochatreat_no_probs(n_treats, block_cols, df):\n treats = stochatreat(\n data=df, block_cols=block_cols, treats=n_treats, idx_col=\"id\", random_state=42\n )\n\n treatment_shares = treats.groupby([\"treat\"])[\"id\"].count() / treats.shape[0]\n\n np.testing.assert_almost_equal(\n treatment_shares, np.array([1 / n_treats] * n_treats), decimal=3\n )","def get_shares_in_recycle_bin_by_network(\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\n if filters is None:\n filters = {}\n filters[\"share_network_id\"] = share_network_id\n filters[\"is_soft_deleted\"] = True\n query = _share_get_all_with_filters(context, filters=filters,\n sort_key=sort_key, sort_dir=sort_dir)\n return query","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def test_read_cluster_network(self):\n pass","def test_sqpp_distributed_ands_equivalent(self):\n self.assertEqual(sorted(perform_request_search(p='ellis and (kaluza-klein or r-parity)')),\n sorted(perform_request_search(p='ellis and (r-parity or kaluza-klein)')))","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def test_extreme_neighborhoods(self):\n\n ## Radius = 0 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Min_neighbors > 30 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=31,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Radius very large ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=100.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)\n\n ## Min_neighbors = 0 ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.5,\n min_core_neighbors=0,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)","def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.cluster_lists[longer_index]) \n # build the noeds for shorter cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[shorter_index]:\n len_spectra = len(cluster.get_spectra())\n star = ClusterNode(cluster.id, len_spectra) \n self.stars[cluster.id] = star\n\n self.cluster_spectra_num[shorter_index] += len_spectra\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\n # build the noeds for longer cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[longer_index]:\n len_spectra = len(cluster.get_spectra())\n starlet = ClusterNode(cluster.id, len_spectra) \n self.starlets[cluster.id] = starlet\n\n self.cluster_spectra_num[longer_index] += len_spectra\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\n # do the comparing, and network building\n for i in range (0, len(self.cluster_lists[shorter_index])):\n cluster0 = self.cluster_lists[shorter_index][i] \n for j in range (i, len(self.cluster_lists[longer_index])):\n cluster1 = self.cluster_lists[longer_index][j] \n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\n if similarity == 0:\n continue\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\n self.shared_spec_num += shared_spec_num\n\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\n\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length","def test_assign_clusters_nonsparse(self, new_data, filename):\n\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\n elif self.split_type == 'date':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\n \n averages_seg['exists'] = 1\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\n test_exists = test_data_exists[test_data_exists['exists']==1]\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\n \n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\n test_matrix = test_matrix.fillna(0)\n \n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\n\n print('clustering new data...')\n cluster_model = joblib.load(filename)\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\n \n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\n keydf = test_matrix[['segment_id','date','time']].reset_index()\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\n \n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]","def get_shares_count(self):\n\t\treturn call_sdk_function('PrlVmCfg_GetSharesCount', self.handle)","def test_dashboards_v2_delete_share(self):\n pass","def test_kyc_get_legal_share_holders(self):\n pass","def test_create_cluster_network(self):\n pass","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def test_atom_index_cache(self):\n # First make OH-\n mol = Molecule()\n mol.add_atom(8, -1, False, None)\n mol.add_atom(1, 0, False, None)\n mol.add_bond(0, 1, 1, False)\n assert mol.atom(0).molecule_atom_index == 0\n assert mol.atom(1).molecule_atom_index == 1\n\n # Now convert it to H2O and ask for atom indices again\n mol.add_atom(1, 0, False, None)\n mol.add_bond(1, 2, 1, False)\n mol.atom(0).formal_charge = 0\n assert mol.atom(0).molecule_atom_index == 0\n assert mol.atom(1).molecule_atom_index == 1\n assert mol.atom(2).molecule_atom_index == 2","def test_kyc_put_legal_share_holder(self):\n pass","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def test_calculate_count(request):\n print(\"\\n--Starting:\", request.node.name)\n\n net = ModelRoadwayNetwork.read(\n link_file=STPAUL_LINK_FILE,\n node_file=STPAUL_NODE_FILE,\n shape_file=STPAUL_SHAPE_FILE,\n fast=True,\n )\n\n net.add_counts()\n assert \"AADT\" in net.links_df.columns\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\n ## todo write an assert that actually tests something","def test_list_cluster_network(self):\n pass","def get_correct_num_of_shares(shares):\n threshold = shares[0].threshold\n if len(shares) < threshold:\n raise('Not enough shares for decryption.')\n used_shares = [sk_share for sk_share in shares]\n # remove unnecessary shares\n while len(used_shares) > threshold:\n # remove share at random\n used_shares.remove(choice(used_shares))\n return used_shares","def test(shipment):\n shipment.unload_ships()\n ships = shipment.ships.values()\n\n zookeepers = build_zookeeper_cluster(filter_quorum_ships(ships))\n\n elasticsearches = []\n for ship in ships:\n elasticsearch = create_elasticsearch(clustername='testcluster', version='1.4.1')\n kibana = create_kibana()\n nginx = create_nginx_proxy()\n\n # Place all containers on the same ship\n ship.place(elasticsearch)\n ship.place(kibana)\n ship.place(nginx)\n\n # Adjust memory to prevent OOM when running on the laptop\n elasticsearch.memory = min(ship.memory, 128*1024*1024)\n\n # We will use Zookeeper for master discovery\n attach_zookeepers_to_elasticsearch(elasticsearch, zookeepers)\n\n # Nginx will terminate https and proxy requests to Elasticsearch and Kibana\n attach_upstreams_to_nginx(nginx, upstreams=[\n (elasticsearch.doors['http'], 9200, 9443),\n (kibana.doors['http'], 8080, 8443),\n ])\n\n # Expose nginx ports before attaching it to Kibana\n nginx.expose_ports(list(range(2000, 4000)))\n\n # Kibana should use the same origin and just change port to access Elasticsearch\n attach_elasticsearch_to_kibana(kibana, httpdoor=nginx.doors['elasticsearch.http'],\n httpsdoor=nginx.doors['elasticsearch.https'])\n\n # Save elasticsearches to clusterize them later\n elasticsearches.append(elasticsearch)\n\n # Let Elasticsearches know about each other\n clusterize_elasticsearches(elasticsearches)\n\n # Expose all unexposed ports\n shipment.expose_ports(list(range(51000, 51100)))","def test_index(self):","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_read_cluster_resource_quota(self):\n pass","def test_data_source_soaps_count_get(self):\n pass","def get_shares_in_recycle_bin_by_share_server(\n context, share_server_id, filters=None, sort_key=None, sort_dir=None):\n if filters is None:\n filters = {}\n filters[\"is_soft_deleted\"] = True\n query = _share_get_all_with_filters(\n context, share_server_id=share_server_id, filters=filters,\n sort_key=sort_key, sort_dir=sort_dir)\n return query","def submit_key_share(self, recovered_node_idx=None, sync=False):\n if recovered_node_idx is None:\n issuer = self.address\n key_share_G1, key_share_G1_correctness_proof, key_share_G2 = (\n super().compute_key_share()\n )\n else:\n issuer = self.addresses[recovered_node_idx]\n key_share_G1, key_share_G2 = self.key_shares[recovered_node_idx]\n key_share_G1_correctness_proof = crypto.dleq(\n H1,\n key_share_G1,\n G1,\n self.commitments[recovered_node_idx][0],\n self.recovered_key_share_secrets[recovered_node_idx],\n )\n\n key_share_G1 = point_to_eth(key_share_G1)\n key_share_G2 = point_G2_to_eth(key_share_G2)\n\n self.logger.info(f\" keyshare (G1): {key_share_G1}\")\n self.logger.info(f\" keyshare (G2): {key_share_G2}\")\n self.logger.info(f\" correctess proof: {key_share_G1_correctness_proof}\")\n\n return self.contract.submit_key_share(\n issuer, key_share_G1, key_share_G1_correctness_proof, key_share_G2\n ).call(self.address, sync)","def simsearch_non_exist(self, input_ts, n):\n\n\t\tinput_ts = standardize(input_ts)\n\t\t# calc dist from input_ts to vantage points\n\t\tdist = []\n\t\tfor (vt, id) in self.vantage_pts:\n\t\t\tdist.append((calcDist(vt, input_ts), str(id)))\n\t\t# sort vantage points by distance\n\t\tdist.sort(key=lambda kv: kv[0])\n\n\t\t# print(dist)\n\t\tid_set = set()\n\t\tsimilar_ts_pQ = []\n\t\tfor i in range(n):\n\t\t\tcur_dist = dist[i][0]\n\t\t\tcur_vt_id = dist[i][1]\n\t\t\tcur_db = connect('simsearch/ts_db_index/ts_' + cur_vt_id + '.db')\n\t\t\t# find ts in current circle\n\t\t\tradius = 2 * cur_dist\n\t\t\tdist_ids = cur_db.get_smaller_than(radius)\n\t\t\tcur_db.close()\n\t\t\t# calc distance from input ts to ts in current circle\n\t\t\tfor (ds, Id) in dist_ids:\n\t\t\t\tif Id not in id_set:\n\t\t\t\t\tid_set.add(Id)\n\t\t\t\t\tcur_ts = pickle.load(open('simsearch/ts_data/ts_' + Id + '.dat', 'rb'))\n\t\t\t\t\tds_to_input = calcDist(input_ts, cur_ts)\n\t\t\t\t\theapq.heappush(similar_ts_pQ, (-ds_to_input, Id))\n\t\t\t\t\tif len(similar_ts_pQ) > n:\n\t\t\t\t\t\t\theapq.heappop(similar_ts_pQ)\n\t\tsim_ts = sorted([(-ds, Id) for (ds, Id) in similar_ts_pQ])\n\t\treturn sim_ts","def test_export_index(self):","def test_index_repositories(self):\n self.Mokes.add_repo_to_pi()\n with self.logged_in(access_token=\"nbiousndegoijubdognlksdngndsgmngds\"):\n index = self.client.get(\"/\").data.decode()\n self.assertIn('href=\"/repo/PerseusDl/canonical-greekLit\"', index, \"GreekLit link should be there\")\n self.assertIn('href=\"/repo/PerseusDl/canonical-greekLit\"', index, \"LatinLit link should be there\")","def test_kyc_get_legal_share_holder_natural(self):\n pass","async def test_endpoint_delete_container_shares_correct(self):\n with self.patch_json_dump:\n resp = await delete_container_shares_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def public_clb_shodan_check(cache: dict, session, awsAccountId: str, awsRegion: str, awsPartition: str) -> dict:\n shodanApiKey = get_shodan_api_key(cache)\n # ISO Time\n iso8601time = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).isoformat() \n for lb in describe_clbs(cache, session):\n if shodanApiKey is None:\n continue\n # B64 encode all of the details for the Asset\n assetJson = json.dumps(lb,default=str).encode(\"utf-8\")\n assetB64 = base64.b64encode(assetJson)\n clbName = lb[\"LoadBalancerName\"]\n clbArn = f\"arn:{awsPartition}:elasticloadbalancing:{awsRegion}:{awsAccountId}:loadbalancer/{clbName}\"\n dnsName = lb[\"DNSName\"]\n lbSgs = lb[\"SecurityGroups\"]\n lbSubnets = lb[\"Subnets\"]\n lbAzs = lb[\"AvailabilityZones\"]\n lbVpc = lb[\"VPCId\"]\n clbScheme = lb[\"Scheme\"]\n if clbScheme == \"internet-facing\":\n # Use Google DNS to resolve\n clbIp = google_dns_resolver(dnsName)\n if clbIp is None:\n continue\n # check if IP indexed by Shodan\n r = requests.get(url=f\"{SHODAN_HOSTS_URL}{clbIp}?key={shodanApiKey}\").json()\n if str(r) == \"{'error': 'No information available for that IP.'}\":\n # this is a passing check\n finding = {\n \"SchemaVersion\": \"2018-10-08\",\n \"Id\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"ProductArn\": f\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\",\n \"GeneratorId\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"AwsAccountId\": awsAccountId,\n \"Types\": [\"Effects/Data Exposure\"],\n \"CreatedAt\": iso8601time,\n \"UpdatedAt\": iso8601time,\n \"Severity\": {\"Label\": \"INFORMATIONAL\"},\n \"Title\": \"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\",\n \"Description\": f\"Classic Load Balancer {clbName} has not been indexed by Shodan.\",\n \"Remediation\": {\n \"Recommendation\": {\n \"Text\": \"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\",\n \"Url\": SHODAN_HOSTS_URL\n }\n },\n \"ProductFields\": {\n \"ProductName\": \"ElectricEye\",\n \"Provider\": \"AWS\",\n \"ProviderType\": \"CSP\",\n \"ProviderAccountId\": awsAccountId,\n \"AssetRegion\": awsRegion,\n \"AssetDetails\": assetB64,\n \"AssetClass\": \"Networking\",\n \"AssetService\": \"AWS Elastic Load Balancer\",\n \"AssetComponent\": \"Classic Load Balancer\"\n },\n \"Resources\": [\n {\n \"Type\": \"AwsElbLoadBalancer\",\n \"Id\": clbArn,\n \"Partition\": awsPartition,\n \"Region\": awsRegion,\n \"Details\": {\n \"AwsElbLoadBalancer\": {\n \"DnsName\": dnsName,\n \"Scheme\": clbScheme,\n \"SecurityGroups\": lbSgs,\n \"Subnets\": lbSubnets,\n \"VpcId\": lbVpc,\n \"AvailabilityZones\": lbAzs,\n \"LoadBalancerName\": clbName\n }\n }\n }\n ],\n \"Compliance\": {\n \"Status\": \"PASSED\",\n \"RelatedRequirements\": [\n \"NIST CSF V1.1 ID.RA-2\",\n \"NIST CSF V1.1 DE.AE-2\",\n \"NIST SP 800-53 Rev. 4 AU-6\",\n \"NIST SP 800-53 Rev. 4 CA-7\",\n \"NIST SP 800-53 Rev. 4 IR-4\",\n \"NIST SP 800-53 Rev. 4 PM-15\",\n \"NIST SP 800-53 Rev. 4 PM-16\",\n \"NIST SP 800-53 Rev. 4 SI-4\",\n \"NIST SP 800-53 Rev. 4 SI-5\",\n \"AIPCA TSC CC3.2\",\n \"AIPCA TSC CC7.2\",\n \"ISO 27001:2013 A.6.1.4\",\n \"ISO 27001:2013 A.12.4.1\",\n \"ISO 27001:2013 A.16.1.1\",\n \"ISO 27001:2013 A.16.1.4\",\n \"MITRE ATT&CK T1040\",\n \"MITRE ATT&CK T1046\",\n \"MITRE ATT&CK T1580\",\n \"MITRE ATT&CK T1590\",\n \"MITRE ATT&CK T1592\",\n \"MITRE ATT&CK T1595\"\n ]\n },\n \"Workflow\": {\"Status\": \"RESOLVED\"},\n \"RecordState\": \"ARCHIVED\"\n }\n yield finding\n else:\n assetPayload = {\n \"LoadBalancer\": lb,\n \"Shodan\": r\n }\n assetJson = json.dumps(assetPayload,default=str).encode(\"utf-8\")\n assetB64 = base64.b64encode(assetJson)\n finding = {\n \"SchemaVersion\": \"2018-10-08\",\n \"Id\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"ProductArn\": f\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\",\n \"GeneratorId\": f\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\",\n \"AwsAccountId\": awsAccountId,\n \"Types\": [\"Effects/Data Exposure\"],\n \"CreatedAt\": iso8601time,\n \"UpdatedAt\": iso8601time,\n \"Severity\": {\"Label\": \"MEDIUM\"},\n \"Title\": \"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\",\n \"Description\": f\"Classic Load Balancer {clbName} has been indexed by Shodan on IP address {clbIp} - resolved from DNS name {dnsName}. Shodan is an 'internet search engine' which continuously crawls and scans across the entire internet to capture host, geolocation, TLS, and running service information. Shodan is a popular tool used by blue teams, security researchers and adversaries alike. Having your asset indexed on Shodan, depending on its configuration, may increase its risk of unauthorized access and further compromise. Review your configuration and refer to the Shodan URL in the remediation section to take action to reduce your exposure and harden your host.\",\n \"Remediation\": {\n \"Recommendation\": {\n \"Text\": \"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\",\n \"Url\": f\"{SHODAN_HOSTS_URL}{clbIp}\"\n }\n },\n \"ProductFields\": {\n \"ProductName\": \"ElectricEye\",\n \"Provider\": \"AWS\",\n \"ProviderType\": \"CSP\",\n \"ProviderAccountId\": awsAccountId,\n \"AssetRegion\": awsRegion,\n \"AssetDetails\": assetB64,\n \"AssetClass\": \"Networking\",\n \"AssetService\": \"AWS Elastic Load Balancer\",\n \"AssetComponent\": \"Classic Load Balancer\"\n },\n \"Resources\": [\n {\n \"Type\": \"AwsElbLoadBalancer\",\n \"Id\": clbArn,\n \"Partition\": awsPartition,\n \"Region\": awsRegion,\n \"Details\": {\n \"AwsElbLoadBalancer\": {\n \"DnsName\": dnsName,\n \"Scheme\": clbScheme,\n \"SecurityGroups\": lbSgs,\n \"Subnets\": lbSubnets,\n \"VpcId\": lbVpc,\n \"AvailabilityZones\": lbAzs,\n \"LoadBalancerName\": clbName\n }\n }\n }\n ],\n \"Compliance\": {\n \"Status\": \"FAILED\",\n \"RelatedRequirements\": [\n \"NIST CSF V1.1 ID.RA-2\",\n \"NIST CSF V1.1 DE.AE-2\",\n \"NIST SP 800-53 Rev. 4 AU-6\",\n \"NIST SP 800-53 Rev. 4 CA-7\",\n \"NIST SP 800-53 Rev. 4 IR-4\",\n \"NIST SP 800-53 Rev. 4 PM-15\",\n \"NIST SP 800-53 Rev. 4 PM-16\",\n \"NIST SP 800-53 Rev. 4 SI-4\",\n \"NIST SP 800-53 Rev. 4 SI-5\",\n \"AIPCA TSC CC3.2\",\n \"AIPCA TSC CC7.2\",\n \"ISO 27001:2013 A.6.1.4\",\n \"ISO 27001:2013 A.12.4.1\",\n \"ISO 27001:2013 A.16.1.1\",\n \"ISO 27001:2013 A.16.1.4\",\n \"MITRE ATT&CK T1040\",\n \"MITRE ATT&CK T1046\",\n \"MITRE ATT&CK T1580\",\n \"MITRE ATT&CK T1590\",\n \"MITRE ATT&CK T1592\",\n \"MITRE ATT&CK T1595\"\n ]\n },\n \"Workflow\": {\"Status\": \"NEW\"},\n \"RecordState\": \"ACTIVE\"\n }\n yield finding","def test_add_asset_share_feed(self):\n pass","def shares(self, unit=None, units=None, timezone=None,\r\n rollup=None, limit=None, unit_reference_ts=None):\r\n params = base.get_params(None, locals())\r\n return self._get('shares', params)","def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\n if minimum_shares > 255 or nof_shares > 255:\n raise ValueError(\"Can only create up to 255 shares\")\n secret, shares = make_random_shares(\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\n )\n secret_bits = bits_in_number(secret)\n mnemonic_secret = number_to_mnemonic(secret)\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\n return mnemonic_secret, secret_bits, mnemonic_shares,","def test_ocean_assets_search(publisher_ocean_instance, metadata):\n identifier = str(uuid.uuid1()).replace(\"-\", \"\")\n metadata_copy = metadata.copy()\n metadata_copy[\"main\"][\"name\"] = identifier\n assert len(publisher_ocean_instance.assets.search(identifier)) == 0\n\n publisher = get_publisher_wallet()\n ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)\n wait_for_ddo(publisher_ocean_instance, ddo.did)\n time.sleep(1) # apparently changes are not instantaneous\n assert len(publisher_ocean_instance.assets.search(identifier)) == 1\n assert len(publisher_ocean_instance.assets.search(\"Gorilla\")) == 0","def test_stochatreat_no_misfits(probs):\n N = 10_000\n blocksize = 10\n df = pd.DataFrame(\n data={\n \"id\": np.arange(N),\n \"block\": np.repeat(np.arange(N / blocksize), repeats=blocksize),\n }\n )\n\n treats = stochatreat(\n data=df,\n block_cols=[\"block\"],\n treats=len(probs),\n idx_col=\"id\",\n probs=probs,\n random_state=42,\n )\n treatment_shares = treats.groupby([\"treat\"])[\"id\"].count() / treats.shape[0]\n\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)","def test_eventualConsistencyStar(self) :\n\t\tstarSize = self.STARSIZE\n\t\tprint str(starSize) + \" Nodes arranged in star topology\"\n\n\t\tnodeList = self.createNodes(starSize)\n\t\tself.addAppRecordDiff(nodeList)\n\t\tsessIDlist = self.sessionsStar(nodeList)\n\n\t\tfor j in range (2) :\n \t\tfor i in range(starSize-1) :\n\t\t\t\tself.fullDBReplication(nodeList[sessIDlist[i][0]], sessIDlist[i][2])\n\n\t\t\t\t# Print statements\n\t\t\t\tprint \"Sync data between \" + nodeList[i].instanceID + \" and \" + nodeList[starSize-1].instanceID\n\n\t\t# Asserts to show that all the nodes have the same data\n\t\tself.assertEqual(self.endConditionData(nodeList) , False)","def testnbasis(self):\r\n count = sum([self.nbasisdict[n] for n in self.data.atomnos])\r\n assert self.data.nbasis == count","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def test_read_namespaced_applied_cluster_resource_quota(self):\n pass","def test_index_stats(self):\n #Create Index\n self.run_multi_operations(buckets = self.buckets,\n query_definitions = self.query_definitions,\n create_index = True, drop_index = False)\n #Check Index Stats\n self.sleep(30)\n index_map = self.get_index_stats()\n self.log.info(index_map)\n for query_definition in self.query_definitions:\n index_name = query_definition.index_name\n for bucket in self.buckets:\n bucket_name = bucket.name\n check_keys = ['items_count', 'total_scan_duration', 'num_docs_queued',\n 'num_requests', 'num_rows_returned', 'num_docs_queued',\n 'num_docs_pending','delete_bytes' ]\n map = self._create_stats_map(items_count=2016)\n self._verify_index_stats(index_map, index_name, bucket_name, map, check_keys)","def test_9_node_positional_itegrity(self):\n ring = ConsistentHashRing([])\n for n in range(9):\n ring.add_node((\"192.168.10.%s\" % str(10+n),\"%s\" % str(10+n)))\n self.assertEqual(\n len([n[0] for n in ring.ring]),\n len(set([n[0] for n in ring.ring])))","def test_index_containers(self):\n pass","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def _test_node_spacing_non_sym(\n endpoint, unique_theta_count, unique_zeta_count, NFP\n ):\n nrho = 1\n sym = False\n\n def test(grid):\n if not endpoint:\n # if no duplicates\n np.testing.assert_allclose(grid.weights, grid.spacing.prod(axis=1))\n is_theta_dupe = (endpoint and unique_theta_count > 0 and not sym) & (\n grid.nodes[:, 1] % (2 * np.pi) == 0\n )\n is_zeta_dupe = (endpoint and unique_zeta_count > 0) & (\n grid.nodes[:, 2] % (2 * np.pi / NFP) == 0\n )\n\n def test_surface(surface_label, actual_ds, desired_ds):\n for index, ds in enumerate(actual_ds):\n if is_theta_dupe[index] and is_zeta_dupe[index]:\n # the grid has 4 of these nodes\n np.testing.assert_allclose(\n ds, desired_ds / 4, err_msg=surface_label\n )\n elif is_theta_dupe[index] or is_zeta_dupe[index]:\n # the grid has 2 of these nodes\n np.testing.assert_allclose(\n ds, desired_ds / 2, err_msg=surface_label\n )\n else:\n # unique node\n np.testing.assert_allclose(\n ds, desired_ds, err_msg=surface_label\n )\n\n test_surface(\n \"rho\",\n grid.spacing[:, 1:].prod(axis=1),\n (2 * np.pi / max(unique_theta_count, 1))\n * (2 * np.pi / max(unique_zeta_count, 1)),\n )\n test_surface(\n \"theta\",\n grid.spacing[:, [0, 2]].prod(axis=1),\n (1 / nrho) * (2 * np.pi / max(unique_zeta_count, 1)),\n )\n test_surface(\n \"zeta\",\n grid.spacing[:, :2].prod(axis=1),\n (1 / nrho) * (2 * np.pi / max(unique_theta_count, 1)),\n )\n\n lg_1 = LinearGrid(\n rho=nrho,\n theta=unique_theta_count + endpoint,\n zeta=unique_zeta_count + endpoint,\n NFP=NFP,\n sym=sym,\n endpoint=endpoint,\n )\n rho = np.linspace(1, 0, nrho)[::-1]\n theta = np.linspace(\n 0, 2 * np.pi, unique_theta_count + endpoint, endpoint=endpoint\n )\n zeta = np.linspace(\n 0, 2 * np.pi / NFP, unique_zeta_count + endpoint, endpoint=endpoint\n )\n lg_2 = LinearGrid(\n rho=rho, theta=theta, zeta=zeta, NFP=NFP, sym=sym, endpoint=endpoint\n )\n lg_3 = LinearGrid(\n rho=rho,\n theta=theta,\n zeta=zeta,\n NFP=NFP,\n sym=sym,\n endpoint=not endpoint, # incorrect marker should have no effect\n )\n assert lg_3.endpoint == endpoint\n test(lg_1)\n # The test below might fail for theta and zeta surfaces only if nrho > 1.\n # This is unrelated to how duplicate node spacing is handled.\n # The cause is because grid construction does not always\n # compute drho as constant (even when the rho nodes are linearly spaced),\n # and this test assumes drho to be a constant for grids without duplicates.\n test(lg_2)\n test(lg_3)","def test_index(client):\n ind = client.get('/')\n ind2 = client.get('/index/')\n assert ind.status_code == 200\n assert ind2.status_code == 200","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_create_cluster_resource_quota(self):\n pass","def test_kyc_post_legal_share_holder(self):\n pass","def test_get_site_scans(self):\n pass","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_stochatreat_only_misfits(probs):\n N = 1_000\n df = pd.DataFrame(\n data={\n \"id\": np.arange(N),\n \"block\": np.arange(N),\n }\n )\n treats = stochatreat(\n data=df,\n block_cols=[\"block\"],\n treats=len(probs),\n idx_col=\"id\",\n probs=probs,\n random_state=42,\n )\n treatment_shares = treats.groupby([\"treat\"])[\"id\"].count() / treats.shape[0]\n\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)","def test_dbscan_similarity():\n # Parameters chosen specifically for this task.\n eps = 0.15\n min_samples = 10\n # Compute similarities\n D = distance.squareform(distance.pdist(X))\n D /= np.max(D)\n # Compute DBSCAN\n core_samples, labels = dbscan(D, metric=\"precomputed\",\n eps=eps, min_samples=min_samples)\n # number of clusters, ignoring noise if present\n n_clusters_1 = len(set(labels)) - (1 if -1 in labels else 0)\n\n assert_equal(n_clusters_1, n_clusters)\n\n db = DBSCAN(metric=\"precomputed\")\n labels = db.fit(D, eps=eps, min_samples=min_samples).labels_\n\n n_clusters_2 = len(set(labels)) - int(-1 in labels)\n assert_equal(n_clusters_2, n_clusters)","def get_smarts(prefix, atom_idxs):\n\n offmol = Molecule.from_file(prefix + '.mol2')\n fix_carboxylate_bond_orders(offmol)\n remove_charge_and_bond_order_from_guanidinium(offmol)\n remove_charge_and_bond_order_from_imidazole(offmol)\n if prefix in prefix2pmd_struct:\n pmd_struct = prefix2pmd_struct[prefix]\n else: \n pmd_struct = ParmEd.load_file(prefix + '.prmtop')\n prefix2pmd_struct[prefix] = pmd_struct\n oemol = offmol.to_openeye()\n residues_of_interest = set()\n atom_indices_of_interest = set()\n for atom_idx in atom_idxs:\n residues_of_interest.add(pmd_struct.atoms[atom_idx].residue.idx)\n for oeatom, pmd_atom in zip(oemol.GetAtoms(), pmd_struct.atoms):\n\n # Delete all non-residue-of-interest atoms\n if (pmd_atom.residue.idx in residues_of_interest):\n atom_indices_of_interest.add(pmd_atom.idx)\n\n # Assign tags to atoms of interest\n if (oeatom.GetIdx() in atom_idxs):\n map_index = atom_idxs.index(oeatom.GetIdx()) + 1\n oeatom.SetMapIdx(map_index)\n\n # Make a \"Subset\" molecule, so that we don't get weird charges\n # around where we cleave the residues\n subsetmol = OEChem.OEGraphMol()\n oepred = OEChem.PyAtomPredicate(lambda x:x.GetIdx() in atom_indices_of_interest)\n OEChem.OESubsetMol(subsetmol, oemol, oepred)\n #OEAssignAromaticFlags(subsetmol, \n smiles_options = (OEChem.OESMILESFlag_Canonical | OEChem.OESMILESFlag_Isotopes |\n OEChem.OESMILESFlag_RGroups)\n # Add the atom and bond stereo flags\n smiles_options |= OEChem.OESMILESFlag_AtomStereo | OEChem.OESMILESFlag_BondStereo\n\n # Add the hydrogen flag\n smiles_options |= OEChem.OESMILESFlag_Hydrogens\n smiles_options |= OEChem.OESMILESFlag_AtomMaps\n smiles = OEChem.OECreateSmiString(subsetmol, smiles_options)\n\n # Replace \"$\" characters (bond order 4) with \"~\" (wildcard bond)\n smiles = smiles.replace('$', '~')\n return smiles","def test_index_availability(client):\n response = client.get('/')\n assert response.status_code == 200","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def cluster(self,\r\n indexlist=None,\r\n iterate_over=True,\r\n keycount=100,\r\n usepurge=True):\r\n if indexlist is None:\r\n indexlist = self.indexes()\r\n\r\n if iterate_over:\r\n self.reset_iterators()\r\n\r\n keysetlist = []\r\n\r\n if keycount == 100:\r\n for i_temp in indexlist:\r\n keysetlist.append(set(self.get_keys_from_note(i_temp)))\r\n\r\n #form a list of the keysets\r\n\r\n else:\r\n for i_temp in indexlist:\r\n keysetlist.append(set(self.return_least_keys\r\n (set(self.get_keys_from_note(i_temp)),\r\n numberof=keycount, no_allcaps=False)))\r\n\r\n #form a list of the keysets\r\n if not usepurge:\r\n clusteredsetlist = nformat.purgesets(consolidate.consolidate(keysetlist),\r\n self.all_cap_purge,\r\n self.first_cap_purge,\r\n self.lower_case_purge,\r\n self.purgelist)\r\n else:\r\n newkeysetlist = []\r\n for s_temp in keysetlist:\r\n newkeysetlist.append(self.default_dict['purge'].apply(s_temp))\r\n clusteredsetlist = consolidate.consolidate(newkeysetlist)\r\n counter = 1\r\n for csl in clusteredsetlist:\r\n\r\n t_temp = EMPTYCHAR\r\n for cs_temp in sorted(csl):\r\n t_temp += cs_temp + COMMA + BLANK\r\n display.noteprint((labels.CLUSTER + BLANK + POUND\r\n +str(counter),\r\n t_temp[:-2]))\r\n q_temp = EMPTYCHAR\r\n for cs_temp in list(csl):\r\n q_temp += VERTLINE+LEFTNOTE+cs_temp+RIGHTNOTE+VERTLINE\r\n\r\n q_temp = q_temp[1:-1].strip()\r\n\r\n counter += 1\r\n if iterate_over:\r\n tl_temp = new_search(q_temp,\r\n defaultdictionaryobject=self.default_dict,\r\n db_cursor=db_cursor,\r\n self=self)[1]\r\n tl_temp = [a_temp for a_temp in tl_temp\r\n if Index(a_temp) > Index(0)]\r\n if tl_temp:\r\n self.add_iterator(tl_temp, csl)","def test_wrong_config_shares1(self):\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\n\n for i in config:\n k = config\n k[i] = ''\n print k\n self.app.post_json(url=\"/config/shares\", params=k, status=400)\n return config","def share_with_neighbourhood(self, neighbourhood):\n # Loop through the agents in self.agents .\n for agent in self.agents:\n # Calculate the distance between self and the current other agent:\n distance = self.distance_between(agent)\n # If distance is less than or equal to the neighbourhood\n if distance <= neighbourhood:\n # Sum self.store and agent.store .\n sum = self.store + agent.store\n # Divide sum by two to calculate average.\n average = sum /2\n # self.store = average\n self.store = average\n # agent.store = average\n agent.store = average\n #test code print below\n #print(\"sharing \" + str(distance) + \" \" + str(average))","def testNanotecSharedMemory():\n\t\n\tmemoryClient = NanotecSharedMemoryClient()\n\t\n\t\n\t\n\tserialPort1 = memoryClient.sendInstruction(\"NanotecMotor,/dev/ttyACM0,17\")\n\t\n\tID1 = memoryClient.sendInstruction(\"getID,\" + serialPort1)\n\tprint(\"ID1 (actual): \" + ID1 + \", expected: 17\")\n\tprint(\"\")\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tID1 = memoryClient.sendInstruction(\"getSerialPort,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"ID Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tposition = memoryClient.sendInstruction(\"getAbsoluteAngularPosition,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"Position Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\treturn","def test_creating_index_type(self):","def calculate_items(ret_o,snaps, min_neigh=4, cutoff=1.5, MAXnb=100,\n nbins=2000, nbinsq=50, Pe=10, rho_0=0.60,\n spatial_correlation_flag = True,\n cluster_flag = False, CG_flag = True):\n\n ts = len(snaps)\n \n for t1 in range(0,ts):\n\n snap1 = snaps[t1]\n print(t1,ts)\n # for each snapshot in the dump file data\n\n box=snap1['box']\n ref_coords = snap1['ucoords']\n mus = snap1['mus']\n\n # compute (normalized) mean polarisation\n polarisation = np.linalg.norm(np.mean(mus,axis=0))\n\n p6re = np.mean(snap1['c_psi6[1]'])\n p6im = np.mean(snap1['c_psi6[2]'])\n p6 = np.absolute(np.complex(p6re, p6im))\n\n mux = np.mean(snap1['mux'])\n mux2 = np.mean(np.array(snap1['mux'])**2)\n muy = np.mean(snap1['muy'])\n muy2 = np.mean(np.array(snap1['muy'])**2)\n \n theta_Ns = np.arctan2(snap1['muy'], snap1['mux'])\n theta = np.mean(theta_Ns)\n theta2 = np.mean(theta_Ns**2)\n \n nematic_Ns = (2.*np.cos(theta)**2 - 1.)\n nematic = np.mean(nematic_Ns)\n nematic2 = np.mean(nematic_Ns**2)\n \n # compute time averages\n ret_o['g_cnt'] = ret_o.get('g_cnt',0) + 1\n ret_o['sum_psi6'] = ret_o.get('sum_psi6',0) + p6\n ret_o['sum_psi62'] = ret_o.get('sum_psi62',0) + p6*p6\n ret_o['sum_psi6_re'] = ret_o.get('sum_psi6_re',0) + p6re\n ret_o['sum_psi6_im'] = ret_o.get('sum_psi6_im',0) + p6im\n ret_o['sum_mux'] = ret_o.get('sum_mux',0) + mux\n ret_o['sum_mux2'] = ret_o.get('sum_mux2',0) + mux2\n ret_o['sum_muy'] = ret_o.get('sum_muy',0) + muy\n ret_o['sum_muy2'] = ret_o.get('sum_muy2',0) + muy2\n\n \n ret_o['sum_theta'] = ret_o.get('sum_theta',0) + theta\n ret_o['sum_theta2'] = ret_o.get('sum_theta2',0) + theta2\n\n\n ret_o['sum_nematic'] = ret_o.get('sum_nematic',0) + nematic\n ret_o['sum_nematic2'] = ret_o.get('sum_nematic2',0) + nematic2\n ret_o['polarisation'] = ret_o.get('polarisation',0) + polarisation\n\n \n if spatial_correlation_flag:\n \n tmp_list = spatial_correlations(t1,snap1, ret_o,min_neigh=4,\n cutoff=1.5,MAXnb=100,nbins=2000,\n nbinsq=50,Pe=10, rho_0=0.60)\n\n # distance matrix between particle pairs\n ref_distance, ref_dis_x, ref_dis_y = tmp_list[:3]\n # number of neighbours for all particles\n ref_num_nb, ref_list_nb = tmp_list[3:5]\n \n # correlation functions and structure functions\n g, g6, g6re, g6im, sq = tmp_list[5:10]\n g_ori, g_dp, g_dp_tr, g_pr, s_pr = tmp_list[10:]\n\n\n # compute time averages\n\n g_mat = np.matrix(g)\n g6_mat = np.matrix(g6)\n g6re_mat = np.matrix(g6re)\n g6im_mat = np.matrix(g6im)\n sq_mat = np.array(sq)\n\n ret_o['sum_g'] = ret_o.get('sum_g',0*g_mat)+g_mat\n ret_o['sum_g6'] = ret_o.get('sum_g6',0*g6_mat)+g6_mat\n ret_o['sum_g6re'] = ret_o.get('sum_g6re',0*g6re_mat)+g6re_mat \n ret_o['sum_g6im'] = ret_o.get('sum_g6im',0*g6im_mat)+g6im_mat\n\n ret_o['sum_sq'] = ret_o.get('sum_sq',0*sq_mat)+sq_mat\n\n g_ori_mat = np.array(g_ori)\n g_dp_mat = np.array(g_dp)\n g_dp_tr_mat = np.array(g_dp_tr)\n g_pr_mat = np.array(g_pr)\n pij_rij_mat = s_pr\n\n\n ret_o['sum_g_ori'] = (ret_o.get('sum_g_ori',0*g_ori_mat)\n + g_ori_mat)\n ret_o['sum_g_dp'] = (ret_o.get('sum_g_dp',0*g_dp_mat)\n + g_dp_mat)\n ret_o['sum_g_dp_tr'] = (ret_o.get('sum_g_dp_tr',0*g_dp_tr_mat)\n +g_dp_tr_mat)\n ret_o['sum_g_pr'] = (ret_o.get('sum_g_pr',0*g_pr_mat)\n +g_pr_mat)\n ret_o['sum_pij_rij'] = (ret_o.get('sum_pij_rij',0*pij_rij_mat)\n + pij_rij_mat)\n\n\n\n \n if cluster_flag:\n\n tmp_list = cluster_momenta(t1,snap1,\n min_cluster_size=min_cluster_size,\n CG_flag=CG_flag)\n\n RMS_AngMom,RMS_AngMom2 = tmp_list[:2]\n RMS_LinMom,RMS_LinMom2,cluster_size = tmp_list[2:]\n\n\n # beginning of time averages\n\n ret_o['sum_RMS_AngMom'] = (ret_o.get('sum_RMS_AngMom',0)\n + RMS_AngMom)\n ret_o['sum_RMS_AngMom2'] = (ret_o.get('sum_RMS_AngMom2',0)\n + RMS_AngMom2)\n ret_o['sum_RMS_LinMom'] = (ret_o.get('sum_RMS_LinMom',0)\n + RMS_LinMom)\n ret_o['sum_RMS_LinMom2'] = (ret_o.get('sum_RMS_LinMom2',0)\n + RMS_LinMom2)\n ret_o['sum_cluster_size'] = (ret_o.get('sum_cluster_size',0)\n +cluster_size)\n\n\n return ret_o","def run_star(job, r1_id, r2_id, star_index_url, wiggle=False, sort=False, save_aligned_bam=False):\n # Download and untar STAR index file\n download_url(url=star_index_url, name='starIndex.tar.gz', work_dir=job.tempDir)\n subprocess.check_call(['tar', '-xvf', os.path.join(job.tempDir, 'starIndex.tar.gz'), '-C', job.tempDir])\n os.remove(os.path.join(job.tempDir, 'starIndex.tar.gz'))\n star_index = os.path.join('/data', os.listdir(job.tempDir)[0]) if len(os.listdir(job.tempDir)) == 1 else '/data'\n\n # Define parameters\n parameters = ['--runThreadN', str(job.cores),\n '--genomeDir', star_index,\n '--outFileNamePrefix', 'rna',\n '--outSAMunmapped', 'Within',\n '--quantMode', 'TranscriptomeSAM',\n '--outSAMattributes', 'NH', 'HI', 'AS', 'NM', 'MD',\n '--outFilterType', 'BySJout',\n '--outFilterMultimapNmax', '20',\n '--outFilterMismatchNmax', '999',\n '--outFilterMismatchNoverReadLmax', '0.04',\n '--alignIntronMin', '20',\n '--alignIntronMax', '1000000',\n '--alignMatesGapMax', '1000000',\n '--alignSJoverhangMin', '8',\n '--alignSJDBoverhangMin', '1',\n '--sjdbScore', '1']\n\n # Modify parameters based on function arguments\n if sort:\n parameters.extend(['--outSAMtype', 'BAM', 'SortedByCoordinate', '--limitBAMsortRAM', '49268954168'])\n aligned_bam = 'rnaAligned.sortedByCoord.out.bam'\n else:\n parameters.extend(['--outSAMtype', 'BAM', 'Unsorted'])\n aligned_bam = 'rnaAligned.out.bam'\n if wiggle:\n parameters.extend(['--outWigType', 'bedGraph',\n '--outWigStrand', 'Unstranded',\n '--outWigReferencesPrefix', 'chr'])\n\n # Read in fastq(s) and modify parameters based on\n job.fileStore.readGlobalFile(r1_id, os.path.join(job.tempDir, 'R1.fastq'))\n if r1_id and r2_id:\n job.fileStore.readGlobalFile(r2_id, os.path.join(job.tempDir, 'R2.fastq'))\n parameters.extend(['--readFilesIn', '/data/R1.fastq', '/data/R2.fastq'])\n else:\n parameters.extend(['--readFilesIn', '/data/R1.fastq'])\n\n # Call: STAR\n dockerCall(job=job, tool=star_version, workDir=job.tempDir, parameters=parameters)\n\n # Check output bam isnt size zero if sorted\n aligned_bam_path = os.path.join(job.tempDir, aligned_bam)\n if sort:\n assert os.stat(aligned_bam_path).st_size > 0, 'Aligned bam failed to sort. Ensure sufficient memory is free.'\n\n # Write files to fileStore\n transcriptome_id = job.fileStore.writeGlobalFile(os.path.join(job.tempDir, 'rnaAligned.toTranscriptome.out.bam'))\n aligned_id = job.fileStore.writeGlobalFile(aligned_bam_path) if save_aligned_bam else None\n wiggle_path = os.path.join(job.tempDir, 'rnaSignal.UniqueMultiple.str1.out.bg')\n wiggle_id = job.fileStore.writeGlobalFile(wiggle_path) if wiggle else None\n\n # Tar output files, store in fileStore, and return FileStoreIDs\n output_files = [os.path.join(job.tempDir, x) for x in ['rnaLog.final.out', 'rnaSJ.out.tab']]\n tarball_files('star.tar.gz', file_paths=output_files, output_dir=job.tempDir)\n star_id = job.fileStore.writeGlobalFile(os.path.join(job.tempDir, 'star.tar.gz'))\n\n return transcriptome_id, star_id, aligned_id, wiggle_id","def test_openshift_node_with_cluster_and_node_access_view(self):\n with schema_context(self.schema_name):\n expected = (\n OCPCostSummaryByNodeP.objects.annotate(**{\"value\": F(\"node\")})\n .values(\"value\")\n .distinct()\n .filter(node__in=[RBAC_NODE], cluster_id__in=[\"OCP-on-AWS\"])\n .count()\n )\n self.assertTrue(expected)\n url = reverse(\"openshift-nodes\")\n response = self.client.get(url, **self.headers)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n json_result = response.json()\n self.assertIsNotNone(json_result.get(\"data\"))\n self.assertIsInstance(json_result.get(\"data\"), list)\n self.assertEqual(len(json_result.get(\"data\")), expected)","def test_replace_cluster_network(self):\n pass"],"string":"[\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\\n ingest_shares = \\\"\\\"\\\"\\n UNWIND $shares_list as s\\n MERGE (share:AzureStorageFileShare{id: s.id})\\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\\n SET share.name = s.name,\\n share.lastupdated = $azure_update_tag,\\n share.lastmodifiedtime = s.last_modified_time,\\n share.sharequota = s.share_quota,\\n share.accesstier = s.access_tier,\\n share.deleted = s.deleted,\\n share.accesstierchangetime = s.access_tier_change_time,\\n share.accesstierstatus = s.access_tier_status,\\n share.deletedtime = s.deleted_time,\\n share.enabledprotocols = s.enabled_protocols,\\n share.remainingretentiondays = s.remaining_retention_days,\\n share.shareusagebytes = s.share_usage_bytes,\\n share.version = s.version\\n WITH share, s\\n MATCH (fs:AzureStorageFileService{id: s.service_id})\\n MERGE (fs)-[r:CONTAINS]->(share)\\n ON CREATE SET r.firstseen = timestamp()\\n SET r.lastupdated = $azure_update_tag\\n \\\"\\\"\\\"\\n\\n neo4j_session.run(\\n ingest_shares,\\n shares_list=shares,\\n azure_update_tag=update_tag,\\n )\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_stochatreat_no_probs(n_treats, block_cols, df):\\n treats = stochatreat(\\n data=df, block_cols=block_cols, treats=n_treats, idx_col=\\\"id\\\", random_state=42\\n )\\n\\n treatment_shares = treats.groupby([\\\"treat\\\"])[\\\"id\\\"].count() / treats.shape[0]\\n\\n np.testing.assert_almost_equal(\\n treatment_shares, np.array([1 / n_treats] * n_treats), decimal=3\\n )\",\n \"def get_shares_in_recycle_bin_by_network(\\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\\n if filters is None:\\n filters = {}\\n filters[\\\"share_network_id\\\"] = share_network_id\\n filters[\\\"is_soft_deleted\\\"] = True\\n query = _share_get_all_with_filters(context, filters=filters,\\n sort_key=sort_key, sort_dir=sort_dir)\\n return query\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def test_sqpp_distributed_ands_equivalent(self):\\n self.assertEqual(sorted(perform_request_search(p='ellis and (kaluza-klein or r-parity)')),\\n sorted(perform_request_search(p='ellis and (r-parity or kaluza-klein)')))\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def test_extreme_neighborhoods(self):\\n\\n ## Radius = 0 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Min_neighbors > 30 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=31,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Radius very large ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=100.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\\n\\n ## Min_neighbors = 0 ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.5,\\n min_core_neighbors=0,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\",\n \"def compare(self):\\n len0 = len(self.cluster_lists[0])\\n len1 = len(self.cluster_lists[1])\\n longer_index = 0 if len0 >= len1 else 1\\n shorter_index = 1 if len1 <= len0 else 0\\n self.stars_length = len(self.cluster_lists[shorter_index]) \\n self.starlets_length = len(self.cluster_lists[longer_index]) \\n # build the noeds for shorter cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[shorter_index]:\\n len_spectra = len(cluster.get_spectra())\\n star = ClusterNode(cluster.id, len_spectra) \\n self.stars[cluster.id] = star\\n\\n self.cluster_spectra_num[shorter_index] += len_spectra\\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\\n # build the noeds for longer cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[longer_index]:\\n len_spectra = len(cluster.get_spectra())\\n starlet = ClusterNode(cluster.id, len_spectra) \\n self.starlets[cluster.id] = starlet\\n\\n self.cluster_spectra_num[longer_index] += len_spectra\\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\\n # do the comparing, and network building\\n for i in range (0, len(self.cluster_lists[shorter_index])):\\n cluster0 = self.cluster_lists[shorter_index][i] \\n for j in range (i, len(self.cluster_lists[longer_index])):\\n cluster1 = self.cluster_lists[longer_index][j] \\n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\\n if similarity == 0:\\n continue\\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\\n self.shared_spec_num += shared_spec_num\\n\\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\\n\\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length\",\n \"def test_assign_clusters_nonsparse(self, new_data, filename):\\n\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\\n elif self.split_type == 'date':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\\n \\n averages_seg['exists'] = 1\\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\\n test_exists = test_data_exists[test_data_exists['exists']==1]\\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\\n \\n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\\n test_matrix = test_matrix.fillna(0)\\n \\n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\\n\\n print('clustering new data...')\\n cluster_model = joblib.load(filename)\\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\\n \\n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\\n keydf = test_matrix[['segment_id','date','time']].reset_index()\\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\\n \\n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]\",\n \"def get_shares_count(self):\\n\\t\\treturn call_sdk_function('PrlVmCfg_GetSharesCount', self.handle)\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def test_atom_index_cache(self):\\n # First make OH-\\n mol = Molecule()\\n mol.add_atom(8, -1, False, None)\\n mol.add_atom(1, 0, False, None)\\n mol.add_bond(0, 1, 1, False)\\n assert mol.atom(0).molecule_atom_index == 0\\n assert mol.atom(1).molecule_atom_index == 1\\n\\n # Now convert it to H2O and ask for atom indices again\\n mol.add_atom(1, 0, False, None)\\n mol.add_bond(1, 2, 1, False)\\n mol.atom(0).formal_charge = 0\\n assert mol.atom(0).molecule_atom_index == 0\\n assert mol.atom(1).molecule_atom_index == 1\\n assert mol.atom(2).molecule_atom_index == 2\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def test_calculate_count(request):\\n print(\\\"\\\\n--Starting:\\\", request.node.name)\\n\\n net = ModelRoadwayNetwork.read(\\n link_file=STPAUL_LINK_FILE,\\n node_file=STPAUL_NODE_FILE,\\n shape_file=STPAUL_SHAPE_FILE,\\n fast=True,\\n )\\n\\n net.add_counts()\\n assert \\\"AADT\\\" in net.links_df.columns\\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\\n ## todo write an assert that actually tests something\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def get_correct_num_of_shares(shares):\\n threshold = shares[0].threshold\\n if len(shares) < threshold:\\n raise('Not enough shares for decryption.')\\n used_shares = [sk_share for sk_share in shares]\\n # remove unnecessary shares\\n while len(used_shares) > threshold:\\n # remove share at random\\n used_shares.remove(choice(used_shares))\\n return used_shares\",\n \"def test(shipment):\\n shipment.unload_ships()\\n ships = shipment.ships.values()\\n\\n zookeepers = build_zookeeper_cluster(filter_quorum_ships(ships))\\n\\n elasticsearches = []\\n for ship in ships:\\n elasticsearch = create_elasticsearch(clustername='testcluster', version='1.4.1')\\n kibana = create_kibana()\\n nginx = create_nginx_proxy()\\n\\n # Place all containers on the same ship\\n ship.place(elasticsearch)\\n ship.place(kibana)\\n ship.place(nginx)\\n\\n # Adjust memory to prevent OOM when running on the laptop\\n elasticsearch.memory = min(ship.memory, 128*1024*1024)\\n\\n # We will use Zookeeper for master discovery\\n attach_zookeepers_to_elasticsearch(elasticsearch, zookeepers)\\n\\n # Nginx will terminate https and proxy requests to Elasticsearch and Kibana\\n attach_upstreams_to_nginx(nginx, upstreams=[\\n (elasticsearch.doors['http'], 9200, 9443),\\n (kibana.doors['http'], 8080, 8443),\\n ])\\n\\n # Expose nginx ports before attaching it to Kibana\\n nginx.expose_ports(list(range(2000, 4000)))\\n\\n # Kibana should use the same origin and just change port to access Elasticsearch\\n attach_elasticsearch_to_kibana(kibana, httpdoor=nginx.doors['elasticsearch.http'],\\n httpsdoor=nginx.doors['elasticsearch.https'])\\n\\n # Save elasticsearches to clusterize them later\\n elasticsearches.append(elasticsearch)\\n\\n # Let Elasticsearches know about each other\\n clusterize_elasticsearches(elasticsearches)\\n\\n # Expose all unexposed ports\\n shipment.expose_ports(list(range(51000, 51100)))\",\n \"def test_index(self):\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def test_data_source_soaps_count_get(self):\\n pass\",\n \"def get_shares_in_recycle_bin_by_share_server(\\n context, share_server_id, filters=None, sort_key=None, sort_dir=None):\\n if filters is None:\\n filters = {}\\n filters[\\\"is_soft_deleted\\\"] = True\\n query = _share_get_all_with_filters(\\n context, share_server_id=share_server_id, filters=filters,\\n sort_key=sort_key, sort_dir=sort_dir)\\n return query\",\n \"def submit_key_share(self, recovered_node_idx=None, sync=False):\\n if recovered_node_idx is None:\\n issuer = self.address\\n key_share_G1, key_share_G1_correctness_proof, key_share_G2 = (\\n super().compute_key_share()\\n )\\n else:\\n issuer = self.addresses[recovered_node_idx]\\n key_share_G1, key_share_G2 = self.key_shares[recovered_node_idx]\\n key_share_G1_correctness_proof = crypto.dleq(\\n H1,\\n key_share_G1,\\n G1,\\n self.commitments[recovered_node_idx][0],\\n self.recovered_key_share_secrets[recovered_node_idx],\\n )\\n\\n key_share_G1 = point_to_eth(key_share_G1)\\n key_share_G2 = point_G2_to_eth(key_share_G2)\\n\\n self.logger.info(f\\\" keyshare (G1): {key_share_G1}\\\")\\n self.logger.info(f\\\" keyshare (G2): {key_share_G2}\\\")\\n self.logger.info(f\\\" correctess proof: {key_share_G1_correctness_proof}\\\")\\n\\n return self.contract.submit_key_share(\\n issuer, key_share_G1, key_share_G1_correctness_proof, key_share_G2\\n ).call(self.address, sync)\",\n \"def simsearch_non_exist(self, input_ts, n):\\n\\n\\t\\tinput_ts = standardize(input_ts)\\n\\t\\t# calc dist from input_ts to vantage points\\n\\t\\tdist = []\\n\\t\\tfor (vt, id) in self.vantage_pts:\\n\\t\\t\\tdist.append((calcDist(vt, input_ts), str(id)))\\n\\t\\t# sort vantage points by distance\\n\\t\\tdist.sort(key=lambda kv: kv[0])\\n\\n\\t\\t# print(dist)\\n\\t\\tid_set = set()\\n\\t\\tsimilar_ts_pQ = []\\n\\t\\tfor i in range(n):\\n\\t\\t\\tcur_dist = dist[i][0]\\n\\t\\t\\tcur_vt_id = dist[i][1]\\n\\t\\t\\tcur_db = connect('simsearch/ts_db_index/ts_' + cur_vt_id + '.db')\\n\\t\\t\\t# find ts in current circle\\n\\t\\t\\tradius = 2 * cur_dist\\n\\t\\t\\tdist_ids = cur_db.get_smaller_than(radius)\\n\\t\\t\\tcur_db.close()\\n\\t\\t\\t# calc distance from input ts to ts in current circle\\n\\t\\t\\tfor (ds, Id) in dist_ids:\\n\\t\\t\\t\\tif Id not in id_set:\\n\\t\\t\\t\\t\\tid_set.add(Id)\\n\\t\\t\\t\\t\\tcur_ts = pickle.load(open('simsearch/ts_data/ts_' + Id + '.dat', 'rb'))\\n\\t\\t\\t\\t\\tds_to_input = calcDist(input_ts, cur_ts)\\n\\t\\t\\t\\t\\theapq.heappush(similar_ts_pQ, (-ds_to_input, Id))\\n\\t\\t\\t\\t\\tif len(similar_ts_pQ) > n:\\n\\t\\t\\t\\t\\t\\t\\theapq.heappop(similar_ts_pQ)\\n\\t\\tsim_ts = sorted([(-ds, Id) for (ds, Id) in similar_ts_pQ])\\n\\t\\treturn sim_ts\",\n \"def test_export_index(self):\",\n \"def test_index_repositories(self):\\n self.Mokes.add_repo_to_pi()\\n with self.logged_in(access_token=\\\"nbiousndegoijubdognlksdngndsgmngds\\\"):\\n index = self.client.get(\\\"/\\\").data.decode()\\n self.assertIn('href=\\\"/repo/PerseusDl/canonical-greekLit\\\"', index, \\\"GreekLit link should be there\\\")\\n self.assertIn('href=\\\"/repo/PerseusDl/canonical-greekLit\\\"', index, \\\"LatinLit link should be there\\\")\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"async def test_endpoint_delete_container_shares_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_container_shares_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def public_clb_shodan_check(cache: dict, session, awsAccountId: str, awsRegion: str, awsPartition: str) -> dict:\\n shodanApiKey = get_shodan_api_key(cache)\\n # ISO Time\\n iso8601time = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).isoformat() \\n for lb in describe_clbs(cache, session):\\n if shodanApiKey is None:\\n continue\\n # B64 encode all of the details for the Asset\\n assetJson = json.dumps(lb,default=str).encode(\\\"utf-8\\\")\\n assetB64 = base64.b64encode(assetJson)\\n clbName = lb[\\\"LoadBalancerName\\\"]\\n clbArn = f\\\"arn:{awsPartition}:elasticloadbalancing:{awsRegion}:{awsAccountId}:loadbalancer/{clbName}\\\"\\n dnsName = lb[\\\"DNSName\\\"]\\n lbSgs = lb[\\\"SecurityGroups\\\"]\\n lbSubnets = lb[\\\"Subnets\\\"]\\n lbAzs = lb[\\\"AvailabilityZones\\\"]\\n lbVpc = lb[\\\"VPCId\\\"]\\n clbScheme = lb[\\\"Scheme\\\"]\\n if clbScheme == \\\"internet-facing\\\":\\n # Use Google DNS to resolve\\n clbIp = google_dns_resolver(dnsName)\\n if clbIp is None:\\n continue\\n # check if IP indexed by Shodan\\n r = requests.get(url=f\\\"{SHODAN_HOSTS_URL}{clbIp}?key={shodanApiKey}\\\").json()\\n if str(r) == \\\"{'error': 'No information available for that IP.'}\\\":\\n # this is a passing check\\n finding = {\\n \\\"SchemaVersion\\\": \\\"2018-10-08\\\",\\n \\\"Id\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"ProductArn\\\": f\\\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\\\",\\n \\\"GeneratorId\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"AwsAccountId\\\": awsAccountId,\\n \\\"Types\\\": [\\\"Effects/Data Exposure\\\"],\\n \\\"CreatedAt\\\": iso8601time,\\n \\\"UpdatedAt\\\": iso8601time,\\n \\\"Severity\\\": {\\\"Label\\\": \\\"INFORMATIONAL\\\"},\\n \\\"Title\\\": \\\"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\\\",\\n \\\"Description\\\": f\\\"Classic Load Balancer {clbName} has not been indexed by Shodan.\\\",\\n \\\"Remediation\\\": {\\n \\\"Recommendation\\\": {\\n \\\"Text\\\": \\\"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\\\",\\n \\\"Url\\\": SHODAN_HOSTS_URL\\n }\\n },\\n \\\"ProductFields\\\": {\\n \\\"ProductName\\\": \\\"ElectricEye\\\",\\n \\\"Provider\\\": \\\"AWS\\\",\\n \\\"ProviderType\\\": \\\"CSP\\\",\\n \\\"ProviderAccountId\\\": awsAccountId,\\n \\\"AssetRegion\\\": awsRegion,\\n \\\"AssetDetails\\\": assetB64,\\n \\\"AssetClass\\\": \\\"Networking\\\",\\n \\\"AssetService\\\": \\\"AWS Elastic Load Balancer\\\",\\n \\\"AssetComponent\\\": \\\"Classic Load Balancer\\\"\\n },\\n \\\"Resources\\\": [\\n {\\n \\\"Type\\\": \\\"AwsElbLoadBalancer\\\",\\n \\\"Id\\\": clbArn,\\n \\\"Partition\\\": awsPartition,\\n \\\"Region\\\": awsRegion,\\n \\\"Details\\\": {\\n \\\"AwsElbLoadBalancer\\\": {\\n \\\"DnsName\\\": dnsName,\\n \\\"Scheme\\\": clbScheme,\\n \\\"SecurityGroups\\\": lbSgs,\\n \\\"Subnets\\\": lbSubnets,\\n \\\"VpcId\\\": lbVpc,\\n \\\"AvailabilityZones\\\": lbAzs,\\n \\\"LoadBalancerName\\\": clbName\\n }\\n }\\n }\\n ],\\n \\\"Compliance\\\": {\\n \\\"Status\\\": \\\"PASSED\\\",\\n \\\"RelatedRequirements\\\": [\\n \\\"NIST CSF V1.1 ID.RA-2\\\",\\n \\\"NIST CSF V1.1 DE.AE-2\\\",\\n \\\"NIST SP 800-53 Rev. 4 AU-6\\\",\\n \\\"NIST SP 800-53 Rev. 4 CA-7\\\",\\n \\\"NIST SP 800-53 Rev. 4 IR-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-15\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-16\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-5\\\",\\n \\\"AIPCA TSC CC3.2\\\",\\n \\\"AIPCA TSC CC7.2\\\",\\n \\\"ISO 27001:2013 A.6.1.4\\\",\\n \\\"ISO 27001:2013 A.12.4.1\\\",\\n \\\"ISO 27001:2013 A.16.1.1\\\",\\n \\\"ISO 27001:2013 A.16.1.4\\\",\\n \\\"MITRE ATT&CK T1040\\\",\\n \\\"MITRE ATT&CK T1046\\\",\\n \\\"MITRE ATT&CK T1580\\\",\\n \\\"MITRE ATT&CK T1590\\\",\\n \\\"MITRE ATT&CK T1592\\\",\\n \\\"MITRE ATT&CK T1595\\\"\\n ]\\n },\\n \\\"Workflow\\\": {\\\"Status\\\": \\\"RESOLVED\\\"},\\n \\\"RecordState\\\": \\\"ARCHIVED\\\"\\n }\\n yield finding\\n else:\\n assetPayload = {\\n \\\"LoadBalancer\\\": lb,\\n \\\"Shodan\\\": r\\n }\\n assetJson = json.dumps(assetPayload,default=str).encode(\\\"utf-8\\\")\\n assetB64 = base64.b64encode(assetJson)\\n finding = {\\n \\\"SchemaVersion\\\": \\\"2018-10-08\\\",\\n \\\"Id\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"ProductArn\\\": f\\\"arn:{awsPartition}:securityhub:{awsRegion}:{awsAccountId}:product/{awsAccountId}/default\\\",\\n \\\"GeneratorId\\\": f\\\"{clbArn}/{dnsName}/classic-load-balancer-shodan-index-check\\\",\\n \\\"AwsAccountId\\\": awsAccountId,\\n \\\"Types\\\": [\\\"Effects/Data Exposure\\\"],\\n \\\"CreatedAt\\\": iso8601time,\\n \\\"UpdatedAt\\\": iso8601time,\\n \\\"Severity\\\": {\\\"Label\\\": \\\"MEDIUM\\\"},\\n \\\"Title\\\": \\\"[ELB.6] Internet-facing Classic Load Balancers should be monitored for being indexed by Shodan\\\",\\n \\\"Description\\\": f\\\"Classic Load Balancer {clbName} has been indexed by Shodan on IP address {clbIp} - resolved from DNS name {dnsName}. Shodan is an 'internet search engine' which continuously crawls and scans across the entire internet to capture host, geolocation, TLS, and running service information. Shodan is a popular tool used by blue teams, security researchers and adversaries alike. Having your asset indexed on Shodan, depending on its configuration, may increase its risk of unauthorized access and further compromise. Review your configuration and refer to the Shodan URL in the remediation section to take action to reduce your exposure and harden your host.\\\",\\n \\\"Remediation\\\": {\\n \\\"Recommendation\\\": {\\n \\\"Text\\\": \\\"To learn more about the information that Shodan indexed on your host refer to the URL in the remediation section.\\\",\\n \\\"Url\\\": f\\\"{SHODAN_HOSTS_URL}{clbIp}\\\"\\n }\\n },\\n \\\"ProductFields\\\": {\\n \\\"ProductName\\\": \\\"ElectricEye\\\",\\n \\\"Provider\\\": \\\"AWS\\\",\\n \\\"ProviderType\\\": \\\"CSP\\\",\\n \\\"ProviderAccountId\\\": awsAccountId,\\n \\\"AssetRegion\\\": awsRegion,\\n \\\"AssetDetails\\\": assetB64,\\n \\\"AssetClass\\\": \\\"Networking\\\",\\n \\\"AssetService\\\": \\\"AWS Elastic Load Balancer\\\",\\n \\\"AssetComponent\\\": \\\"Classic Load Balancer\\\"\\n },\\n \\\"Resources\\\": [\\n {\\n \\\"Type\\\": \\\"AwsElbLoadBalancer\\\",\\n \\\"Id\\\": clbArn,\\n \\\"Partition\\\": awsPartition,\\n \\\"Region\\\": awsRegion,\\n \\\"Details\\\": {\\n \\\"AwsElbLoadBalancer\\\": {\\n \\\"DnsName\\\": dnsName,\\n \\\"Scheme\\\": clbScheme,\\n \\\"SecurityGroups\\\": lbSgs,\\n \\\"Subnets\\\": lbSubnets,\\n \\\"VpcId\\\": lbVpc,\\n \\\"AvailabilityZones\\\": lbAzs,\\n \\\"LoadBalancerName\\\": clbName\\n }\\n }\\n }\\n ],\\n \\\"Compliance\\\": {\\n \\\"Status\\\": \\\"FAILED\\\",\\n \\\"RelatedRequirements\\\": [\\n \\\"NIST CSF V1.1 ID.RA-2\\\",\\n \\\"NIST CSF V1.1 DE.AE-2\\\",\\n \\\"NIST SP 800-53 Rev. 4 AU-6\\\",\\n \\\"NIST SP 800-53 Rev. 4 CA-7\\\",\\n \\\"NIST SP 800-53 Rev. 4 IR-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-15\\\",\\n \\\"NIST SP 800-53 Rev. 4 PM-16\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-4\\\",\\n \\\"NIST SP 800-53 Rev. 4 SI-5\\\",\\n \\\"AIPCA TSC CC3.2\\\",\\n \\\"AIPCA TSC CC7.2\\\",\\n \\\"ISO 27001:2013 A.6.1.4\\\",\\n \\\"ISO 27001:2013 A.12.4.1\\\",\\n \\\"ISO 27001:2013 A.16.1.1\\\",\\n \\\"ISO 27001:2013 A.16.1.4\\\",\\n \\\"MITRE ATT&CK T1040\\\",\\n \\\"MITRE ATT&CK T1046\\\",\\n \\\"MITRE ATT&CK T1580\\\",\\n \\\"MITRE ATT&CK T1590\\\",\\n \\\"MITRE ATT&CK T1592\\\",\\n \\\"MITRE ATT&CK T1595\\\"\\n ]\\n },\\n \\\"Workflow\\\": {\\\"Status\\\": \\\"NEW\\\"},\\n \\\"RecordState\\\": \\\"ACTIVE\\\"\\n }\\n yield finding\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def shares(self, unit=None, units=None, timezone=None,\\r\\n rollup=None, limit=None, unit_reference_ts=None):\\r\\n params = base.get_params(None, locals())\\r\\n return self._get('shares', params)\",\n \"def make_random_mnemonic_shares(minimum_shares, nof_shares, prime=PRIME_12TH_MERSENNE):\\n if minimum_shares > 255 or nof_shares > 255:\\n raise ValueError(\\\"Can only create up to 255 shares\\\")\\n secret, shares = make_random_shares(\\n minimum=minimum_shares, shares=int(nof_shares), prime=prime\\n )\\n secret_bits = bits_in_number(secret)\\n mnemonic_secret = number_to_mnemonic(secret)\\n mnemonic_shares = [number_to_mnemonic(pad_number(s, minimum_shares, i)) for i, s in shares]\\n return mnemonic_secret, secret_bits, mnemonic_shares,\",\n \"def test_ocean_assets_search(publisher_ocean_instance, metadata):\\n identifier = str(uuid.uuid1()).replace(\\\"-\\\", \\\"\\\")\\n metadata_copy = metadata.copy()\\n metadata_copy[\\\"main\\\"][\\\"name\\\"] = identifier\\n assert len(publisher_ocean_instance.assets.search(identifier)) == 0\\n\\n publisher = get_publisher_wallet()\\n ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)\\n wait_for_ddo(publisher_ocean_instance, ddo.did)\\n time.sleep(1) # apparently changes are not instantaneous\\n assert len(publisher_ocean_instance.assets.search(identifier)) == 1\\n assert len(publisher_ocean_instance.assets.search(\\\"Gorilla\\\")) == 0\",\n \"def test_stochatreat_no_misfits(probs):\\n N = 10_000\\n blocksize = 10\\n df = pd.DataFrame(\\n data={\\n \\\"id\\\": np.arange(N),\\n \\\"block\\\": np.repeat(np.arange(N / blocksize), repeats=blocksize),\\n }\\n )\\n\\n treats = stochatreat(\\n data=df,\\n block_cols=[\\\"block\\\"],\\n treats=len(probs),\\n idx_col=\\\"id\\\",\\n probs=probs,\\n random_state=42,\\n )\\n treatment_shares = treats.groupby([\\\"treat\\\"])[\\\"id\\\"].count() / treats.shape[0]\\n\\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)\",\n \"def test_eventualConsistencyStar(self) :\\n\\t\\tstarSize = self.STARSIZE\\n\\t\\tprint str(starSize) + \\\" Nodes arranged in star topology\\\"\\n\\n\\t\\tnodeList = self.createNodes(starSize)\\n\\t\\tself.addAppRecordDiff(nodeList)\\n\\t\\tsessIDlist = self.sessionsStar(nodeList)\\n\\n\\t\\tfor j in range (2) :\\n \\t\\tfor i in range(starSize-1) :\\n\\t\\t\\t\\tself.fullDBReplication(nodeList[sessIDlist[i][0]], sessIDlist[i][2])\\n\\n\\t\\t\\t\\t# Print statements\\n\\t\\t\\t\\tprint \\\"Sync data between \\\" + nodeList[i].instanceID + \\\" and \\\" + nodeList[starSize-1].instanceID\\n\\n\\t\\t# Asserts to show that all the nodes have the same data\\n\\t\\tself.assertEqual(self.endConditionData(nodeList) , False)\",\n \"def testnbasis(self):\\r\\n count = sum([self.nbasisdict[n] for n in self.data.atomnos])\\r\\n assert self.data.nbasis == count\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_read_namespaced_applied_cluster_resource_quota(self):\\n pass\",\n \"def test_index_stats(self):\\n #Create Index\\n self.run_multi_operations(buckets = self.buckets,\\n query_definitions = self.query_definitions,\\n create_index = True, drop_index = False)\\n #Check Index Stats\\n self.sleep(30)\\n index_map = self.get_index_stats()\\n self.log.info(index_map)\\n for query_definition in self.query_definitions:\\n index_name = query_definition.index_name\\n for bucket in self.buckets:\\n bucket_name = bucket.name\\n check_keys = ['items_count', 'total_scan_duration', 'num_docs_queued',\\n 'num_requests', 'num_rows_returned', 'num_docs_queued',\\n 'num_docs_pending','delete_bytes' ]\\n map = self._create_stats_map(items_count=2016)\\n self._verify_index_stats(index_map, index_name, bucket_name, map, check_keys)\",\n \"def test_9_node_positional_itegrity(self):\\n ring = ConsistentHashRing([])\\n for n in range(9):\\n ring.add_node((\\\"192.168.10.%s\\\" % str(10+n),\\\"%s\\\" % str(10+n)))\\n self.assertEqual(\\n len([n[0] for n in ring.ring]),\\n len(set([n[0] for n in ring.ring])))\",\n \"def test_index_containers(self):\\n pass\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def _test_node_spacing_non_sym(\\n endpoint, unique_theta_count, unique_zeta_count, NFP\\n ):\\n nrho = 1\\n sym = False\\n\\n def test(grid):\\n if not endpoint:\\n # if no duplicates\\n np.testing.assert_allclose(grid.weights, grid.spacing.prod(axis=1))\\n is_theta_dupe = (endpoint and unique_theta_count > 0 and not sym) & (\\n grid.nodes[:, 1] % (2 * np.pi) == 0\\n )\\n is_zeta_dupe = (endpoint and unique_zeta_count > 0) & (\\n grid.nodes[:, 2] % (2 * np.pi / NFP) == 0\\n )\\n\\n def test_surface(surface_label, actual_ds, desired_ds):\\n for index, ds in enumerate(actual_ds):\\n if is_theta_dupe[index] and is_zeta_dupe[index]:\\n # the grid has 4 of these nodes\\n np.testing.assert_allclose(\\n ds, desired_ds / 4, err_msg=surface_label\\n )\\n elif is_theta_dupe[index] or is_zeta_dupe[index]:\\n # the grid has 2 of these nodes\\n np.testing.assert_allclose(\\n ds, desired_ds / 2, err_msg=surface_label\\n )\\n else:\\n # unique node\\n np.testing.assert_allclose(\\n ds, desired_ds, err_msg=surface_label\\n )\\n\\n test_surface(\\n \\\"rho\\\",\\n grid.spacing[:, 1:].prod(axis=1),\\n (2 * np.pi / max(unique_theta_count, 1))\\n * (2 * np.pi / max(unique_zeta_count, 1)),\\n )\\n test_surface(\\n \\\"theta\\\",\\n grid.spacing[:, [0, 2]].prod(axis=1),\\n (1 / nrho) * (2 * np.pi / max(unique_zeta_count, 1)),\\n )\\n test_surface(\\n \\\"zeta\\\",\\n grid.spacing[:, :2].prod(axis=1),\\n (1 / nrho) * (2 * np.pi / max(unique_theta_count, 1)),\\n )\\n\\n lg_1 = LinearGrid(\\n rho=nrho,\\n theta=unique_theta_count + endpoint,\\n zeta=unique_zeta_count + endpoint,\\n NFP=NFP,\\n sym=sym,\\n endpoint=endpoint,\\n )\\n rho = np.linspace(1, 0, nrho)[::-1]\\n theta = np.linspace(\\n 0, 2 * np.pi, unique_theta_count + endpoint, endpoint=endpoint\\n )\\n zeta = np.linspace(\\n 0, 2 * np.pi / NFP, unique_zeta_count + endpoint, endpoint=endpoint\\n )\\n lg_2 = LinearGrid(\\n rho=rho, theta=theta, zeta=zeta, NFP=NFP, sym=sym, endpoint=endpoint\\n )\\n lg_3 = LinearGrid(\\n rho=rho,\\n theta=theta,\\n zeta=zeta,\\n NFP=NFP,\\n sym=sym,\\n endpoint=not endpoint, # incorrect marker should have no effect\\n )\\n assert lg_3.endpoint == endpoint\\n test(lg_1)\\n # The test below might fail for theta and zeta surfaces only if nrho > 1.\\n # This is unrelated to how duplicate node spacing is handled.\\n # The cause is because grid construction does not always\\n # compute drho as constant (even when the rho nodes are linearly spaced),\\n # and this test assumes drho to be a constant for grids without duplicates.\\n test(lg_2)\\n test(lg_3)\",\n \"def test_index(client):\\n ind = client.get('/')\\n ind2 = client.get('/index/')\\n assert ind.status_code == 200\\n assert ind2.status_code == 200\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_get_site_scans(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_stochatreat_only_misfits(probs):\\n N = 1_000\\n df = pd.DataFrame(\\n data={\\n \\\"id\\\": np.arange(N),\\n \\\"block\\\": np.arange(N),\\n }\\n )\\n treats = stochatreat(\\n data=df,\\n block_cols=[\\\"block\\\"],\\n treats=len(probs),\\n idx_col=\\\"id\\\",\\n probs=probs,\\n random_state=42,\\n )\\n treatment_shares = treats.groupby([\\\"treat\\\"])[\\\"id\\\"].count() / treats.shape[0]\\n\\n np.testing.assert_almost_equal(treatment_shares, np.array(probs), decimal=3)\",\n \"def test_dbscan_similarity():\\n # Parameters chosen specifically for this task.\\n eps = 0.15\\n min_samples = 10\\n # Compute similarities\\n D = distance.squareform(distance.pdist(X))\\n D /= np.max(D)\\n # Compute DBSCAN\\n core_samples, labels = dbscan(D, metric=\\\"precomputed\\\",\\n eps=eps, min_samples=min_samples)\\n # number of clusters, ignoring noise if present\\n n_clusters_1 = len(set(labels)) - (1 if -1 in labels else 0)\\n\\n assert_equal(n_clusters_1, n_clusters)\\n\\n db = DBSCAN(metric=\\\"precomputed\\\")\\n labels = db.fit(D, eps=eps, min_samples=min_samples).labels_\\n\\n n_clusters_2 = len(set(labels)) - int(-1 in labels)\\n assert_equal(n_clusters_2, n_clusters)\",\n \"def get_smarts(prefix, atom_idxs):\\n\\n offmol = Molecule.from_file(prefix + '.mol2')\\n fix_carboxylate_bond_orders(offmol)\\n remove_charge_and_bond_order_from_guanidinium(offmol)\\n remove_charge_and_bond_order_from_imidazole(offmol)\\n if prefix in prefix2pmd_struct:\\n pmd_struct = prefix2pmd_struct[prefix]\\n else: \\n pmd_struct = ParmEd.load_file(prefix + '.prmtop')\\n prefix2pmd_struct[prefix] = pmd_struct\\n oemol = offmol.to_openeye()\\n residues_of_interest = set()\\n atom_indices_of_interest = set()\\n for atom_idx in atom_idxs:\\n residues_of_interest.add(pmd_struct.atoms[atom_idx].residue.idx)\\n for oeatom, pmd_atom in zip(oemol.GetAtoms(), pmd_struct.atoms):\\n\\n # Delete all non-residue-of-interest atoms\\n if (pmd_atom.residue.idx in residues_of_interest):\\n atom_indices_of_interest.add(pmd_atom.idx)\\n\\n # Assign tags to atoms of interest\\n if (oeatom.GetIdx() in atom_idxs):\\n map_index = atom_idxs.index(oeatom.GetIdx()) + 1\\n oeatom.SetMapIdx(map_index)\\n\\n # Make a \\\"Subset\\\" molecule, so that we don't get weird charges\\n # around where we cleave the residues\\n subsetmol = OEChem.OEGraphMol()\\n oepred = OEChem.PyAtomPredicate(lambda x:x.GetIdx() in atom_indices_of_interest)\\n OEChem.OESubsetMol(subsetmol, oemol, oepred)\\n #OEAssignAromaticFlags(subsetmol, \\n smiles_options = (OEChem.OESMILESFlag_Canonical | OEChem.OESMILESFlag_Isotopes |\\n OEChem.OESMILESFlag_RGroups)\\n # Add the atom and bond stereo flags\\n smiles_options |= OEChem.OESMILESFlag_AtomStereo | OEChem.OESMILESFlag_BondStereo\\n\\n # Add the hydrogen flag\\n smiles_options |= OEChem.OESMILESFlag_Hydrogens\\n smiles_options |= OEChem.OESMILESFlag_AtomMaps\\n smiles = OEChem.OECreateSmiString(subsetmol, smiles_options)\\n\\n # Replace \\\"$\\\" characters (bond order 4) with \\\"~\\\" (wildcard bond)\\n smiles = smiles.replace('$', '~')\\n return smiles\",\n \"def test_index_availability(client):\\n response = client.get('/')\\n assert response.status_code == 200\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def cluster(self,\\r\\n indexlist=None,\\r\\n iterate_over=True,\\r\\n keycount=100,\\r\\n usepurge=True):\\r\\n if indexlist is None:\\r\\n indexlist = self.indexes()\\r\\n\\r\\n if iterate_over:\\r\\n self.reset_iterators()\\r\\n\\r\\n keysetlist = []\\r\\n\\r\\n if keycount == 100:\\r\\n for i_temp in indexlist:\\r\\n keysetlist.append(set(self.get_keys_from_note(i_temp)))\\r\\n\\r\\n #form a list of the keysets\\r\\n\\r\\n else:\\r\\n for i_temp in indexlist:\\r\\n keysetlist.append(set(self.return_least_keys\\r\\n (set(self.get_keys_from_note(i_temp)),\\r\\n numberof=keycount, no_allcaps=False)))\\r\\n\\r\\n #form a list of the keysets\\r\\n if not usepurge:\\r\\n clusteredsetlist = nformat.purgesets(consolidate.consolidate(keysetlist),\\r\\n self.all_cap_purge,\\r\\n self.first_cap_purge,\\r\\n self.lower_case_purge,\\r\\n self.purgelist)\\r\\n else:\\r\\n newkeysetlist = []\\r\\n for s_temp in keysetlist:\\r\\n newkeysetlist.append(self.default_dict['purge'].apply(s_temp))\\r\\n clusteredsetlist = consolidate.consolidate(newkeysetlist)\\r\\n counter = 1\\r\\n for csl in clusteredsetlist:\\r\\n\\r\\n t_temp = EMPTYCHAR\\r\\n for cs_temp in sorted(csl):\\r\\n t_temp += cs_temp + COMMA + BLANK\\r\\n display.noteprint((labels.CLUSTER + BLANK + POUND\\r\\n +str(counter),\\r\\n t_temp[:-2]))\\r\\n q_temp = EMPTYCHAR\\r\\n for cs_temp in list(csl):\\r\\n q_temp += VERTLINE+LEFTNOTE+cs_temp+RIGHTNOTE+VERTLINE\\r\\n\\r\\n q_temp = q_temp[1:-1].strip()\\r\\n\\r\\n counter += 1\\r\\n if iterate_over:\\r\\n tl_temp = new_search(q_temp,\\r\\n defaultdictionaryobject=self.default_dict,\\r\\n db_cursor=db_cursor,\\r\\n self=self)[1]\\r\\n tl_temp = [a_temp for a_temp in tl_temp\\r\\n if Index(a_temp) > Index(0)]\\r\\n if tl_temp:\\r\\n self.add_iterator(tl_temp, csl)\",\n \"def test_wrong_config_shares1(self):\\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\\n\\n for i in config:\\n k = config\\n k[i] = ''\\n print k\\n self.app.post_json(url=\\\"/config/shares\\\", params=k, status=400)\\n return config\",\n \"def share_with_neighbourhood(self, neighbourhood):\\n # Loop through the agents in self.agents .\\n for agent in self.agents:\\n # Calculate the distance between self and the current other agent:\\n distance = self.distance_between(agent)\\n # If distance is less than or equal to the neighbourhood\\n if distance <= neighbourhood:\\n # Sum self.store and agent.store .\\n sum = self.store + agent.store\\n # Divide sum by two to calculate average.\\n average = sum /2\\n # self.store = average\\n self.store = average\\n # agent.store = average\\n agent.store = average\\n #test code print below\\n #print(\\\"sharing \\\" + str(distance) + \\\" \\\" + str(average))\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\",\n \"def test_creating_index_type(self):\",\n \"def calculate_items(ret_o,snaps, min_neigh=4, cutoff=1.5, MAXnb=100,\\n nbins=2000, nbinsq=50, Pe=10, rho_0=0.60,\\n spatial_correlation_flag = True,\\n cluster_flag = False, CG_flag = True):\\n\\n ts = len(snaps)\\n \\n for t1 in range(0,ts):\\n\\n snap1 = snaps[t1]\\n print(t1,ts)\\n # for each snapshot in the dump file data\\n\\n box=snap1['box']\\n ref_coords = snap1['ucoords']\\n mus = snap1['mus']\\n\\n # compute (normalized) mean polarisation\\n polarisation = np.linalg.norm(np.mean(mus,axis=0))\\n\\n p6re = np.mean(snap1['c_psi6[1]'])\\n p6im = np.mean(snap1['c_psi6[2]'])\\n p6 = np.absolute(np.complex(p6re, p6im))\\n\\n mux = np.mean(snap1['mux'])\\n mux2 = np.mean(np.array(snap1['mux'])**2)\\n muy = np.mean(snap1['muy'])\\n muy2 = np.mean(np.array(snap1['muy'])**2)\\n \\n theta_Ns = np.arctan2(snap1['muy'], snap1['mux'])\\n theta = np.mean(theta_Ns)\\n theta2 = np.mean(theta_Ns**2)\\n \\n nematic_Ns = (2.*np.cos(theta)**2 - 1.)\\n nematic = np.mean(nematic_Ns)\\n nematic2 = np.mean(nematic_Ns**2)\\n \\n # compute time averages\\n ret_o['g_cnt'] = ret_o.get('g_cnt',0) + 1\\n ret_o['sum_psi6'] = ret_o.get('sum_psi6',0) + p6\\n ret_o['sum_psi62'] = ret_o.get('sum_psi62',0) + p6*p6\\n ret_o['sum_psi6_re'] = ret_o.get('sum_psi6_re',0) + p6re\\n ret_o['sum_psi6_im'] = ret_o.get('sum_psi6_im',0) + p6im\\n ret_o['sum_mux'] = ret_o.get('sum_mux',0) + mux\\n ret_o['sum_mux2'] = ret_o.get('sum_mux2',0) + mux2\\n ret_o['sum_muy'] = ret_o.get('sum_muy',0) + muy\\n ret_o['sum_muy2'] = ret_o.get('sum_muy2',0) + muy2\\n\\n \\n ret_o['sum_theta'] = ret_o.get('sum_theta',0) + theta\\n ret_o['sum_theta2'] = ret_o.get('sum_theta2',0) + theta2\\n\\n\\n ret_o['sum_nematic'] = ret_o.get('sum_nematic',0) + nematic\\n ret_o['sum_nematic2'] = ret_o.get('sum_nematic2',0) + nematic2\\n ret_o['polarisation'] = ret_o.get('polarisation',0) + polarisation\\n\\n \\n if spatial_correlation_flag:\\n \\n tmp_list = spatial_correlations(t1,snap1, ret_o,min_neigh=4,\\n cutoff=1.5,MAXnb=100,nbins=2000,\\n nbinsq=50,Pe=10, rho_0=0.60)\\n\\n # distance matrix between particle pairs\\n ref_distance, ref_dis_x, ref_dis_y = tmp_list[:3]\\n # number of neighbours for all particles\\n ref_num_nb, ref_list_nb = tmp_list[3:5]\\n \\n # correlation functions and structure functions\\n g, g6, g6re, g6im, sq = tmp_list[5:10]\\n g_ori, g_dp, g_dp_tr, g_pr, s_pr = tmp_list[10:]\\n\\n\\n # compute time averages\\n\\n g_mat = np.matrix(g)\\n g6_mat = np.matrix(g6)\\n g6re_mat = np.matrix(g6re)\\n g6im_mat = np.matrix(g6im)\\n sq_mat = np.array(sq)\\n\\n ret_o['sum_g'] = ret_o.get('sum_g',0*g_mat)+g_mat\\n ret_o['sum_g6'] = ret_o.get('sum_g6',0*g6_mat)+g6_mat\\n ret_o['sum_g6re'] = ret_o.get('sum_g6re',0*g6re_mat)+g6re_mat \\n ret_o['sum_g6im'] = ret_o.get('sum_g6im',0*g6im_mat)+g6im_mat\\n\\n ret_o['sum_sq'] = ret_o.get('sum_sq',0*sq_mat)+sq_mat\\n\\n g_ori_mat = np.array(g_ori)\\n g_dp_mat = np.array(g_dp)\\n g_dp_tr_mat = np.array(g_dp_tr)\\n g_pr_mat = np.array(g_pr)\\n pij_rij_mat = s_pr\\n\\n\\n ret_o['sum_g_ori'] = (ret_o.get('sum_g_ori',0*g_ori_mat)\\n + g_ori_mat)\\n ret_o['sum_g_dp'] = (ret_o.get('sum_g_dp',0*g_dp_mat)\\n + g_dp_mat)\\n ret_o['sum_g_dp_tr'] = (ret_o.get('sum_g_dp_tr',0*g_dp_tr_mat)\\n +g_dp_tr_mat)\\n ret_o['sum_g_pr'] = (ret_o.get('sum_g_pr',0*g_pr_mat)\\n +g_pr_mat)\\n ret_o['sum_pij_rij'] = (ret_o.get('sum_pij_rij',0*pij_rij_mat)\\n + pij_rij_mat)\\n\\n\\n\\n \\n if cluster_flag:\\n\\n tmp_list = cluster_momenta(t1,snap1,\\n min_cluster_size=min_cluster_size,\\n CG_flag=CG_flag)\\n\\n RMS_AngMom,RMS_AngMom2 = tmp_list[:2]\\n RMS_LinMom,RMS_LinMom2,cluster_size = tmp_list[2:]\\n\\n\\n # beginning of time averages\\n\\n ret_o['sum_RMS_AngMom'] = (ret_o.get('sum_RMS_AngMom',0)\\n + RMS_AngMom)\\n ret_o['sum_RMS_AngMom2'] = (ret_o.get('sum_RMS_AngMom2',0)\\n + RMS_AngMom2)\\n ret_o['sum_RMS_LinMom'] = (ret_o.get('sum_RMS_LinMom',0)\\n + RMS_LinMom)\\n ret_o['sum_RMS_LinMom2'] = (ret_o.get('sum_RMS_LinMom2',0)\\n + RMS_LinMom2)\\n ret_o['sum_cluster_size'] = (ret_o.get('sum_cluster_size',0)\\n +cluster_size)\\n\\n\\n return ret_o\",\n \"def run_star(job, r1_id, r2_id, star_index_url, wiggle=False, sort=False, save_aligned_bam=False):\\n # Download and untar STAR index file\\n download_url(url=star_index_url, name='starIndex.tar.gz', work_dir=job.tempDir)\\n subprocess.check_call(['tar', '-xvf', os.path.join(job.tempDir, 'starIndex.tar.gz'), '-C', job.tempDir])\\n os.remove(os.path.join(job.tempDir, 'starIndex.tar.gz'))\\n star_index = os.path.join('/data', os.listdir(job.tempDir)[0]) if len(os.listdir(job.tempDir)) == 1 else '/data'\\n\\n # Define parameters\\n parameters = ['--runThreadN', str(job.cores),\\n '--genomeDir', star_index,\\n '--outFileNamePrefix', 'rna',\\n '--outSAMunmapped', 'Within',\\n '--quantMode', 'TranscriptomeSAM',\\n '--outSAMattributes', 'NH', 'HI', 'AS', 'NM', 'MD',\\n '--outFilterType', 'BySJout',\\n '--outFilterMultimapNmax', '20',\\n '--outFilterMismatchNmax', '999',\\n '--outFilterMismatchNoverReadLmax', '0.04',\\n '--alignIntronMin', '20',\\n '--alignIntronMax', '1000000',\\n '--alignMatesGapMax', '1000000',\\n '--alignSJoverhangMin', '8',\\n '--alignSJDBoverhangMin', '1',\\n '--sjdbScore', '1']\\n\\n # Modify parameters based on function arguments\\n if sort:\\n parameters.extend(['--outSAMtype', 'BAM', 'SortedByCoordinate', '--limitBAMsortRAM', '49268954168'])\\n aligned_bam = 'rnaAligned.sortedByCoord.out.bam'\\n else:\\n parameters.extend(['--outSAMtype', 'BAM', 'Unsorted'])\\n aligned_bam = 'rnaAligned.out.bam'\\n if wiggle:\\n parameters.extend(['--outWigType', 'bedGraph',\\n '--outWigStrand', 'Unstranded',\\n '--outWigReferencesPrefix', 'chr'])\\n\\n # Read in fastq(s) and modify parameters based on\\n job.fileStore.readGlobalFile(r1_id, os.path.join(job.tempDir, 'R1.fastq'))\\n if r1_id and r2_id:\\n job.fileStore.readGlobalFile(r2_id, os.path.join(job.tempDir, 'R2.fastq'))\\n parameters.extend(['--readFilesIn', '/data/R1.fastq', '/data/R2.fastq'])\\n else:\\n parameters.extend(['--readFilesIn', '/data/R1.fastq'])\\n\\n # Call: STAR\\n dockerCall(job=job, tool=star_version, workDir=job.tempDir, parameters=parameters)\\n\\n # Check output bam isnt size zero if sorted\\n aligned_bam_path = os.path.join(job.tempDir, aligned_bam)\\n if sort:\\n assert os.stat(aligned_bam_path).st_size > 0, 'Aligned bam failed to sort. Ensure sufficient memory is free.'\\n\\n # Write files to fileStore\\n transcriptome_id = job.fileStore.writeGlobalFile(os.path.join(job.tempDir, 'rnaAligned.toTranscriptome.out.bam'))\\n aligned_id = job.fileStore.writeGlobalFile(aligned_bam_path) if save_aligned_bam else None\\n wiggle_path = os.path.join(job.tempDir, 'rnaSignal.UniqueMultiple.str1.out.bg')\\n wiggle_id = job.fileStore.writeGlobalFile(wiggle_path) if wiggle else None\\n\\n # Tar output files, store in fileStore, and return FileStoreIDs\\n output_files = [os.path.join(job.tempDir, x) for x in ['rnaLog.final.out', 'rnaSJ.out.tab']]\\n tarball_files('star.tar.gz', file_paths=output_files, output_dir=job.tempDir)\\n star_id = job.fileStore.writeGlobalFile(os.path.join(job.tempDir, 'star.tar.gz'))\\n\\n return transcriptome_id, star_id, aligned_id, wiggle_id\",\n \"def test_openshift_node_with_cluster_and_node_access_view(self):\\n with schema_context(self.schema_name):\\n expected = (\\n OCPCostSummaryByNodeP.objects.annotate(**{\\\"value\\\": F(\\\"node\\\")})\\n .values(\\\"value\\\")\\n .distinct()\\n .filter(node__in=[RBAC_NODE], cluster_id__in=[\\\"OCP-on-AWS\\\"])\\n .count()\\n )\\n self.assertTrue(expected)\\n url = reverse(\\\"openshift-nodes\\\")\\n response = self.client.get(url, **self.headers)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n json_result = response.json()\\n self.assertIsNotNone(json_result.get(\\\"data\\\"))\\n self.assertIsInstance(json_result.get(\\\"data\\\"), list)\\n self.assertEqual(len(json_result.get(\\\"data\\\")), expected)\",\n \"def test_replace_cluster_network(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.91021","0.85721266","0.7744076","0.7691755","0.7667866","0.766065","0.7447273","0.71588457","0.7131582","0.70934236","0.7039851","0.6991671","0.67114615","0.65478647","0.6541465","0.63235873","0.62416536","0.6241281","0.60786486","0.607121","0.5646648","0.5584896","0.54764915","0.54153967","0.53797764","0.53322566","0.5319372","0.5312099","0.5257952","0.524838","0.51762706","0.5156424","0.5151239","0.51466846","0.5120512","0.5100292","0.5100292","0.50968117","0.5089575","0.5081106","0.50668234","0.5066241","0.50525355","0.50494516","0.50327915","0.5029002","0.5027613","0.5002831","0.49965894","0.49956757","0.4990346","0.49894172","0.49808314","0.49784452","0.4971207","0.49676883","0.49539784","0.495042","0.49411145","0.49399605","0.49353528","0.493313","0.4930099","0.4927806","0.49237928","0.49200705","0.49097264","0.49089682","0.49012154","0.48911074","0.48874983","0.48702547","0.48647654","0.48549482","0.48539698","0.48533297","0.48515874","0.48470724","0.4846552","0.4837767","0.48307565","0.48262742","0.4816493","0.47926468","0.47910938","0.4784907","0.47843388","0.47607592","0.47561803","0.475092","0.47394368","0.47366256","0.47241062","0.4718001","0.47112677","0.470687","0.47060087","0.47056937","0.46950293","0.46946263"],"string":"[\n \"0.91021\",\n \"0.85721266\",\n \"0.7744076\",\n \"0.7691755\",\n \"0.7667866\",\n \"0.766065\",\n \"0.7447273\",\n \"0.71588457\",\n \"0.7131582\",\n \"0.70934236\",\n \"0.7039851\",\n \"0.6991671\",\n \"0.67114615\",\n \"0.65478647\",\n \"0.6541465\",\n \"0.63235873\",\n \"0.62416536\",\n \"0.6241281\",\n \"0.60786486\",\n \"0.607121\",\n \"0.5646648\",\n \"0.5584896\",\n \"0.54764915\",\n \"0.54153967\",\n \"0.53797764\",\n \"0.53322566\",\n \"0.5319372\",\n \"0.5312099\",\n \"0.5257952\",\n \"0.524838\",\n \"0.51762706\",\n \"0.5156424\",\n \"0.5151239\",\n \"0.51466846\",\n \"0.5120512\",\n \"0.5100292\",\n \"0.5100292\",\n \"0.50968117\",\n \"0.5089575\",\n \"0.5081106\",\n \"0.50668234\",\n \"0.5066241\",\n \"0.50525355\",\n \"0.50494516\",\n \"0.50327915\",\n \"0.5029002\",\n \"0.5027613\",\n \"0.5002831\",\n \"0.49965894\",\n \"0.49956757\",\n \"0.4990346\",\n \"0.49894172\",\n \"0.49808314\",\n \"0.49784452\",\n \"0.4971207\",\n \"0.49676883\",\n \"0.49539784\",\n \"0.495042\",\n \"0.49411145\",\n \"0.49399605\",\n \"0.49353528\",\n \"0.493313\",\n \"0.4930099\",\n \"0.4927806\",\n \"0.49237928\",\n \"0.49200705\",\n \"0.49097264\",\n \"0.49089682\",\n \"0.49012154\",\n \"0.48911074\",\n \"0.48874983\",\n \"0.48702547\",\n \"0.48647654\",\n \"0.48549482\",\n \"0.48539698\",\n \"0.48533297\",\n \"0.48515874\",\n \"0.48470724\",\n \"0.4846552\",\n \"0.4837767\",\n \"0.48307565\",\n \"0.48262742\",\n \"0.4816493\",\n \"0.47926468\",\n \"0.47910938\",\n \"0.4784907\",\n \"0.47843388\",\n \"0.47607592\",\n \"0.47561803\",\n \"0.475092\",\n \"0.47394368\",\n \"0.47366256\",\n \"0.47241062\",\n \"0.4718001\",\n \"0.47112677\",\n \"0.470687\",\n \"0.47060087\",\n \"0.47056937\",\n \"0.46950293\",\n \"0.46946263\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.95178986"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81378,"cells":{"query":{"kind":"string","value":"Test case for index_nas_shares_by_pool"},"document":{"kind":"string","value":"def test_index_nas_shares_by_pool(self):\n pass"},"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_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_destroy_nas_share_by_nas(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_read_cluster_resource_quota(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_create_cluster_resource_quota(self):\n pass","def pool_snps(parent1, parent2):","def test_autocreate_licensepool(self):\n identifier = self._identifier()\n assert [] == identifier.licensed_through\n provider = AlwaysSuccessfulCollectionCoverageProvider(\n self._default_collection\n )\n pool = provider.license_pool(identifier)\n assert [pool] == identifier.licensed_through\n assert pool.data_source == provider.data_source\n assert pool.identifier == identifier\n assert pool.collection == provider.collection\n\n # Calling license_pool again finds the same LicensePool\n # as before.\n pool2 = provider.license_pool(identifier)\n assert pool == pool2\n\n # It's possible for a CollectionCoverageProvider to create a\n # LicensePool for a different DataSource than the one\n # associated with the Collection. Only the metadata wrangler\n # needs to do this -- it's so a CoverageProvider for a\n # third-party DataSource can create an 'Internal Processing'\n # LicensePool when some other part of the metadata wrangler\n # failed to do this earlier.\n\n # If a working pool already exists, it's returned and no new\n # pool is created.\n same_pool = provider.license_pool(\n identifier, DataSource.INTERNAL_PROCESSING\n )\n assert same_pool == pool2\n assert provider.data_source == same_pool.data_source\n\n # A new pool is only created if no working pool can be found.\n identifier2 = self._identifier()\n new_pool = provider.license_pool(\n identifier2, DataSource.INTERNAL_PROCESSING\n )\n assert new_pool.data_source.name == DataSource.INTERNAL_PROCESSING\n assert new_pool.identifier == identifier2\n assert new_pool.collection == provider.collection","def test_replace_cluster_resource_quota(self):\n pass","def test_list_cluster_resource_quota(self):\n pass","def csAddPool(self,pool,creatorid,nas=None):\n\n logger.debug(\"Attempting to create pool '\"+pool+\"'.\")\n\n localpath = \"/.\"+pool\n\n url = self.csurl + \"/polcentral/v1_0/pools/\"\n\n if nas == None:\n logger.debug(\"No NAS object provided, will create pool '\"+pool+\"' type 'MW'.\")\n pooltype = 'MW'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n else:\n logger.debug(\"NAS object provided, will create pool '\"+pool+\"' type 'PS'.\")\n pooltype = 'PS'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n\n payload = {\n \"name\": pool,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath\n }\n \"\"\"\n payload = {\n \"name\": poolname,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath,\n \"subscribedevices\":subscribedevices,\n \"deviceid\": deviceid,\n \"pathinpool\": pathinpool,\n \"servername\": servername,\n \"sharename\": sharename,\n \"sharepath\": sharepath,\n \"credsetname\": creditname,\n \"overridewarnings\": overridewarnings\n }\n \"\"\"\n\n try:\n r = requests.post(url, data=json.dumps(payload))\n except Exception:\n logger.error(\"Exception during api call to add pool.\")\n return 'Error'\n\n if r.status_code == 200:\n logger.debug(\"Pool '\"+pool+\"' was successfully created.\")\n poolid = r.json()['_id']\n return poolid['$id']\n else:\n logger.error(\"Pool '\"+pool+\"' was not created. Error code is \"+str(r.status_code)+\".\")\n return 'Error'","def test_create_cluster_network(self):\n pass","def test_read_cluster_network(self):\n pass","def test_list_cluster_network(self):\n pass","def test_pooling(self):\n for width in range(2, 5):\n for width2 in range(1, width):\n matrix_size = (4, 5, width)\n matrix = get_random_test_tensor(size=matrix_size)\n pool_size = width2\n for stride in range(1, width2):\n for padding in range(2):\n reference = torch.nn.functional.avg_pool2d(\n matrix.unsqueeze(0), pool_size,\n stride=stride, padding=padding\n )\n\n encrypted_matrix = SharedTensor(matrix)\n encrypted_pool = encrypted_matrix.avg_pool2d(\n pool_size, stride=stride, padding=padding)\n self._check(\n encrypted_pool, reference[0], 'avg_pool2d failed')","def testExcessiveSigops(self):\n NUM_ADDRS = 50\n logging.info(\"testExcessiveSigops: Cleaning up node state\")\n\n # We are not testing excessively sized blocks so make these large\n self.nodes[0].set(\"net.excessiveBlock=5000000\")\n self.nodes[1].set(\"net.excessiveBlock=5000000\")\n self.nodes[2].set(\"net.excessiveBlock=5000000\")\n self.nodes[3].set(\"net.excessiveBlock=5000000\")\n self.nodes[0].setminingmaxblock(FIVE_MB)\n self.nodes[1].setminingmaxblock(FIVE_MB)\n self.nodes[2].setminingmaxblock(FIVE_MB)\n self.nodes[3].setminingmaxblock(FIVE_MB)\n # Stagger the accept depths so we can see the block accepted stepwise\n self.nodes[0].set(\"net.excessiveAcceptDepth=0\")\n self.nodes[1].set(\"net.excessiveAcceptDepth=1\")\n self.nodes[2].set(\"net.excessiveAcceptDepth=2\")\n self.nodes[3].set(\"net.excessiveAcceptDepth=3\")\n\n for n in self.nodes:\n n.generate(10)\n self.sync_blocks()\n\n self.nodes[0].generate(100) # create a lot of BTC for spending\n self.sync_all()\n\n self.nodes[0].set(\"net.excessiveSigopsPerMb=100\") # Set low so txns will fail if its used\n self.nodes[1].set(\"net.excessiveSigopsPerMb=5000\")\n self.nodes[2].set(\"net.excessiveSigopsPerMb=1000\")\n self.nodes[3].set(\"net.excessiveSigopsPerMb=100\")\n\n logging.info(\"Creating addresses...\")\n self.nodes[0].keypoolrefill(NUM_ADDRS)\n addrs = [self.nodes[0].getnewaddress() for _ in range(NUM_ADDRS)]\n\n # test that a < 1MB block ignores the sigops parameter\n self.nodes[0].setminingmaxblock(ONE_MB)\n # if excessive Sigops was heeded, this txn would not make it into the block\n self.createUtxos(self.nodes[0], addrs, NUM_ADDRS)\n mpool = self.nodes[0].getmempoolinfo()\n assert_equal(mpool[\"size\"], 0)\n\n # test that a < 1MB block ignores the sigops parameter, even if the max block size is less\n self.nodes[0].setminingmaxblock(FIVE_MB)\n # if excessive Sigops was heeded, this txn would not make it into the block\n self.createUtxos(self.nodes[0], addrs, NUM_ADDRS)\n mpool = self.nodes[0].getmempoolinfo()\n assert_equal(mpool[\"size\"], 0)\n\n if self.extended: # creating 1MB+ blocks is too slow for travis due to the signing cost\n self.createUtxos(self.nodes[0], addrs, 10000) # we need a lot to generate 1MB+ blocks\n\n wallet = self.nodes[0].listunspent()\n wallet.sort(key=lambda x: x[\"amount\"], reverse=True)\n self.nodes[0].set(\"net.excessiveSigopsPerMb=100000\") # Set this huge so all txns are accepted by this node\n\n logging.info(\"Generate > 1MB block with excessive sigops\")\n generateTx(self.nodes[0], 1100000, addrs)\n\n counts = [x.getblockcount() for x in self.nodes]\n base = counts[0]\n\n self.nodes[0].generate(1)\n assert_equal(True, self.expectHeights([base + 1, base, base, base], 30))\n\n logging.info(\"Test excessive block propagation to nodes with different AD\")\n self.nodes[0].generate(1)\n # it takes a while to sync all the txns\n assert_equal(True, self.expectHeights([base + 2, base + 2, base, base], 500))\n\n self.nodes[0].generate(1)\n assert_equal(True, self.expectHeights([base + 3, base + 3, base + 3, base], 90))\n\n self.nodes[0].generate(1)\n assert_equal(True, self.expectHeights([base + 4, base + 4, base + 4, base + 4], 90))\n\n logging.info(\"Excessive sigops test completed\")\n\n # set it all back to defaults\n for n in self.nodes:\n n.generate(150)\n self.sync_blocks()\n\n self.nodes[0].set(\"net.excessiveSigopsPerMb=20000\") # Set low so txns will fail if its used\n self.nodes[1].set(\"net.excessiveSigopsPerMb=20000\")\n self.nodes[2].set(\"net.excessiveSigopsPerMb=20000\")\n self.nodes[3].set(\"net.excessiveSigopsPerMb=20000\")\n\n self.nodes[0].setminingmaxblock(ONE_MB)\n self.nodes[1].setminingmaxblock(ONE_MB)\n self.nodes[2].setminingmaxblock(ONE_MB)\n self.nodes[3].setminingmaxblock(ONE_MB)\n self.nodes[0].set(\"net.excessiveBlock=1000000\")\n self.nodes[1].set(\"net.excessiveBlock=1000000\")\n self.nodes[2].set(\"net.excessiveBlock=1000000\")\n self.nodes[3].set(\"net.excessiveBlock=1000000\")","def _create_volume_pool(self, pool_name):\n osd_map = self._rados_command('osd dump', {})\n\n existing_id = self._get_pool_id(osd_map, pool_name)\n if existing_id is not None:\n log.info(\"Pool {0} already exists\".format(pool_name))\n return existing_id\n\n osd_count = len(osd_map['osds'])\n\n # We can't query the actual cluster config remotely, but since this is\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\n # that in use in the rest of the cluster.\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\n\n other_pgs = 0\n for pool in osd_map['pools']:\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\n other_pgs += pool['pg_num']\n\n # A basic heuristic for picking pg_num: work out the max number of\n # PGs we can have without tripping a warning, then subtract the number\n # of PGs already created by non-manila pools, then divide by ten. That'll\n # give you a reasonable result on a system where you have \"a few\" manila\n # shares.\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\n # TODO Alternatively, respect an override set by the user.\n\n self._rados_command(\n 'osd pool create',\n {\n 'pool': pool_name,\n 'pg_num': int(pg_num),\n }\n )\n\n osd_map = self._rados_command('osd dump', {})\n pool_id = self._get_pool_id(osd_map, pool_name)\n\n if pool_id is None:\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\n # removing it right after we created it.\n log.error(\"OSD map doesn't contain expected pool '{0}':\\n{1}\".format(\n pool_name, json.dumps(osd_map, indent=2)\n ))\n raise RuntimeError(\"Pool '{0}' not present in map after creation\".format(pool_name))\n else:\n return pool_id","def test_read_cluster_resource_quota_status(self):\n pass","def verify_pool(self, pool):\n svc = self.pool_path % pool\n self.rest_get(svc, restclient.Status.OK)","def test_thread_pool(self):\n self.assertIdentical(self.tx_client._pool, self.pool)","def test_get_hyperflex_cluster_storage_policy_by_moid(self):\n pass","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_object = RadosOrchestrator(node=cephadm)\n mon_obj = MonConfigMethods(rados_obj=rados_object)\n ceph_nodes = kw.get(\"ceph_nodes\")\n osd_list = []\n total_osd_app_mem = {}\n\n for node in ceph_nodes:\n if node.role == \"osd\":\n node_osds = rados_object.collect_osd_daemon_ids(node)\n osd_list = osd_list + node_osds\n\n target_configs = config[\"cache_trim_max_skip_pinned\"][\"configurations\"]\n max_skip_pinned_value = int(\n mon_obj.get_config(section=\"osd\", param=\"bluestore_cache_trim_max_skip_pinned\")\n )\n\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\n if max_skip_pinned_value != 1000:\n log.error(\n \"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\"\n )\n raise Exception(\n \"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\"\n )\n\n # Creating pools and starting the test\n for entry in target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n if entry.get(\"pool_type\", \"replicated\") == \"erasure\":\n method_should_succeed(\n rados_object.create_erasure_pool, name=entry[\"pool_name\"], **entry\n )\n else:\n method_should_succeed(\n rados_object.create_pool,\n **entry,\n )\n\n if not rados_object.bench_write(**entry):\n log.error(\"Failed to write objects into the EC Pool\")\n return 1\n rados_object.bench_read(**entry)\n log.info(\"Finished writing data into the pool\")\n\n # performing scrub and deep-scrub\n rados_object.run_scrub()\n rados_object.run_deep_scrub()\n time.sleep(10)\n\n rados_object.change_heap_profiler_state(osd_list, \"start\")\n # Executing tests for 45 minutes\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\n while datetime.datetime.now() < time_execution:\n # Get all OSDs heap dump\n heap_dump = rados_object.get_heap_dump(osd_list)\n # get the osd application used memory\n osd_app_mem = get_bytes_used_by_app(heap_dump)\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\n # wait for 10 seconds and collecting the memory\n time.sleep(10)\n for osd_id, mem_list in total_osd_app_mem.items():\n mem_growth = is_what_percent_mem(mem_list)\n if mem_growth > 80:\n log.error(\n f\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\"\n )\n raise Exception(\"No warning generated by PG Autoscaler\")\n log.info(f\"The relative memory growth for the osd.{osd_id} is {mem_growth} \")\n\n rados_object.change_heap_profiler_state(osd_list, \"stop\")\n\n # check fo the crashes in the cluster\n crash_list = rados_object.do_crash_ls()\n if not crash_list:\n return 0\n else:\n return 1","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def test_no_impact_between_tenants(self):\n field = 'body'\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=self.index_count,\n field=field, sync=False)\n for taskInstance in createIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n self.log.debug(\"Getting initial RR values\")\n stat_obj_list = self.create_Stats_Obj_list()\n stat_field = 'resident_ratio'\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n\n bucket_list = []\n bucket_list.append(self.cluster.buckets[0])\n\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\n limit=self.query_limit)\n for taskInstance in query_tasks_info:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\n replica=self.index_replicas,\n defer=False,\n number_of_indexes_per_coll=2 * self.index_count,\n count=self.index_count,\n field=field, sync=False)\n for taskInstance in newcreateIndexTasklist:\n self.task.jython_task_manager.get_task_result(taskInstance)\n\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\n self.compareRR(initial_rr_value_map, final_rr_value_map)","def test_list_cluster_policy(self):\n pass","def test_dashboards_v2_share(self):\n pass","def pool_search(self,**kwargs):\n\t\treturn self.DA.pool_search(self,**kwargs)","def test_get_buckets(self):\n pass","def test_read_namespaced_applied_cluster_resource_quota(self):\n pass","def test_create_hyperflex_cluster_network_policy(self):\n pass","def test_get_hyperflex_cluster_by_moid(self):\n pass","def test_pool_dependence(self):\n ok_(id(CSVarPool.pool) == id(VarPool.pool), 'mem address of pools should be the same')\n\n var = 'foo'\n app = 'test'\n VarPool(app=app).set(var, 'bar')\n eq_(CSVarPool.get(var, app=app), 'bar')\n CSVarPool(app=app).set(var, 'foo')\n eq_(VarPool.get(var, app=app), 'foo')","def test_read_cluster_policy(self):\n pass","def test_index_containers(self):\n pass","def verify_avail_space(self, pool, project, share, size):\n self.verify_project(pool, project)\n avail = self.get_project_stats(pool, project)\n if avail < size:\n exception_msg = (_('Error creating '\n 'share: %(share)s on '\n 'pool: %(pool)s. '\n 'Not enough space.')\n % {'share': share,\n 'pool': pool})\n raise exception.ShareBackendException(msg=exception_msg)","def test_sync_clear_mempool(self):\n logging.info(\">>> Entered : test_sync_clear_mempool \\n\")\n try:\n # clear out the mempool\n mostly_sync_mempools(self.nodes)\n for index1, n in enumerate(self.nodes):\n n.generate(2)\n sync_blocks(self.nodes)\n for index2, n in enumerate(self.nodes):\n while len(n.getrawmempool()):\n n.generate(1)\n sync_blocks(self.nodes)\n logging.info(\"cleared mempool: %s\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\n base = [x.getrawmempool() for x in self.nodes]\n assert_equal(base, [base[0]] * 4)\n except (Exception, JSONRPCException) as e1:\n logging.info(e1)\n exc_type, exc_obj, exc_tb = sys.exc_info()\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\n raise TestAssertionError({\"file_name\": fname, \"line_num\": exc_tb.tb_lineno, \\\n \"error_type\": exc_type.__name__, \"error_msg\": str( e1 ), \\\n \"n1\" : self.bins[index1], \"n2\" : self.bins[index2], \"amount\" : \"N/A\", \"numsig\" : \"N/A\"})","def cluster_credsets(hpo_data, block_merge_dist=200000, kmeans_subclustering=False):\n\n # Pool credible sets, tagged with block ID\n pooled_creds_str = ''\n for hdat in hpo_data.values():\n for bid, binfo in hdat['blocks'].items():\n for ci in binfo['credset_bt']:\n pooled_creds_str += '\\t'.join([ci.chrom, str(ci.start), \n str(ci.end), bid]) + '\\n'\n pooled_creds_bt = pbt.BedTool(pooled_creds_str, from_string=True).sort().saveas()\n merged_creds_bt = pooled_creds_bt.merge(c=4, o='distinct', d=block_merge_dist)\n\n # Build nx.Graph() of credible sets to be clustered\n G = nx.Graph()\n csids = \\\n list(set([e for s in [x.split(',') for x in merged_creds_bt.to_dataframe().\\\n iloc[:, 3].tolist()] for e in s]))\n G.add_nodes_from(csids)\n for x in merged_creds_bt:\n creds = x[3].split(',')\n if len(creds) > 1:\n G.add_edges_from(list(combinations(creds, 2)))\n\n # If optioned, attempt to split subgraphs containing multiple blocks from the same HPO\n # This corrects for daisy chaining between distinct clumps identified\n # earlier using split_blocks_by_cov()\n if kmeans_subclustering:\n v1_clusters = list(nx.connected_components(G))\n for g in v1_clusters:\n\n # Only need to correct clusters containing >1 independent block from the same HPO\n hpo_counts = Counter([x.split('_')[0] for x in g])\n if any(np.array(list(hpo_counts.values())) > 1):\n\n # Get info on all blocks in cluster\n all_bids = list(g)\n block_bt = pooled_creds_bt.filter(lambda x: x[3] in all_bids).saveas()\n\n # Compute matrix of coverage between all blocks\n block_cov = pd.DataFrame(columns=all_bids)\n for bid in all_bids:\n bid_bt = block_bt.filter(lambda x: x[3] == bid).saveas()\n cvals = {}\n for x in block_bt.coverage(bid_bt):\n ovr_bp = int(x[5])\n union = bid_bt.cat(pbt.BedTool('\\t'.join(x[:4]), \n from_string=True))\n union_bp = np.sum([len(x) for x in union])\n cvals[x[3]] = ovr_bp / union_bp\n block_cov.loc[bid] = block_cov.columns.map(cvals)\n\n # Initial hierarchical clustering such that k clusters are obtained,\n # where k is the max number of independent blocks from any one HPO\n kmeans = KMeans(n_clusters=max(hpo_counts.values()), random_state=2021).fit(block_cov)\n newclusters = {k : set() for k in range(max(hpo_counts.values()))}\n for k, bid in zip(kmeans.labels_, block_cov.index):\n newclusters[k].add(bid)\n\n # Prune all edges between new subclusters\n for members in newclusters.values():\n for bid in members:\n for other_id in [x for x in all_bids if x not in members]:\n if G.has_edge(bid, other_id):\n G.remove_edge(bid, other_id)\n\n # Format each cluster in the graph of credsets\n clustered_credsets = \\\n { 'clustered_region_' + str(i) : x for i, x \\\n in enumerate(nx.connected_components(G))}\n \n return clustered_credsets","def test_delete_cluster_resource_quota(self):\n pass","def test_volume_service_pool(self):\n self.assertEqual(\n ChangeStateScript()._deployer._volume_service._pool,\n StoragePool(reactor, b\"flocker\", FilePath(b\"/flocker\")))","def test_pool_consistency(self) -> None:\n x = Constant(\n 'const1',\n Float32(),\n np.zeros([1, 3, 3, 3])\n )\n input_ops = {'X': cast(Operator, x)}\n\n MaxPool(\n 'max_pool1',\n [1, 2, 2, 3],\n Float32(),\n input_ops,\n kernel_shape=[3, 3],\n pads=[1, 1, 1, 1],\n strides=[2, 2]\n )\n\n print(\"Consistency test for pooling operator passed!\")","def test_n_minus_f_pool_processes_attrib(looper, nodeSet,\n sdk_pool_handle,\n sdk_wallet_steward):\n make_pool_n_minus_f_nodes(looper, nodeSet)\n\n sdk_add_raw_attribute(looper, sdk_pool_handle, sdk_wallet_steward, 'foo', 'bar')","def test_list_pools(mocker, api: API, account: Account, raw_pools):\n api.candlepin.get_pools.return_value = raw_pools\n\n apply_mapping_spy = mocker.patch(\n \"ethel.account.apply_mapping\", side_effect=apply_mapping\n )\n pools = account.list_pools()\n assert len(pools) == len(raw_pools)\n\n expected_call_count = len(account.POOL_ATTRIBUTES_MAPPING) * len(raw_pools)\n\n assert apply_mapping_spy.call_count == expected_call_count","def test_list_pools_no_filter(api: API, account: Account, raw_pools):\n api.candlepin.get_pools.return_value = raw_pools\n pools = account.list_pools(filter_attributes={})\n assert pools == raw_pools","def test_update_hyperflex_cluster_network_policy(self):\n pass","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def test_patch_cluster_resource_quota(self):\n pass","def calc_pool(players):\n players = [str(x) for x in players]\n n = len(players)\n for player in players:\n nopool = payoff_nopool(p=percentages[player])\n print(nopool)\n p = {i: percentages[key] for i, key in zip([x for x in range(2, n+1)],\n [x for x in players if x != player])}\n p[1] = percentages[player]\n pool = payoff_n_p(p=p, n=n)\n print(pool)","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def test_assign_clusters_nonsparse(self, new_data, filename):\n\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\n elif self.split_type == 'date':\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\n \n averages_seg['exists'] = 1\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\n test_exists = test_data_exists[test_data_exists['exists']==1]\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\n \n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\n test_matrix = test_matrix.fillna(0)\n \n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\n\n print('clustering new data...')\n cluster_model = joblib.load(filename)\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\n \n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\n keydf = test_matrix[['segment_id','date','time']].reset_index()\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\n \n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]","def test_allocation_strategy_opt_allocs():\n prices = np.array([[10, 10], [11, 15], [12, 5], [13, 10]])\n allocs = AllocationStrategy.opt_allocs(prices, neg_sharpe_ratio)\n np.testing.assert_almost_equal(allocs, [1, 0])","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_allocator_single_confilicting_sets():\n indexSets = [set([1]), set([1])]\n allocator = Allocator(indexSets)\n assert len(allocator.slots) == 2\n allocation = allocator.allocate()\n assert not allocation","def test_replace_cluster_network(self):\n pass","def pool_list(mnode):\n cmd = \"gluster pool list\"\n return g.run(mnode, cmd)","def test_kyc_put_legal_share_holder(self):\n pass","def test_get_hyperflex_cluster_network_policy_by_moid(self):\n pass","async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\n\n trusted, fee = trusted_and_fee\n num_blocks = 4 # Num blocks to farm at a time\n total_blocks = 0 # Total blocks farmed so far\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n wallet_node_0 = wallet_nodes[0]\n our_ph = receive_address[0]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_node_0.config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_node_0.config[\"trusted_peers\"] = {}\n\n await wallet_node_0.server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\n total_block_rewards = await get_total_block_rewards(total_blocks)\n\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n assert total_block_rewards > 0\n\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5001\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx_2.spend_bundle,\n creation_tx_2.name,\n )\n\n for r in creation_tx.removals:\n assert r not in creation_tx_2.removals\n\n await farm_blocks(full_node_api, our_ph, 1)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 2\n wallet_id: int = summaries_response[0][\"id\"]\n wallet_id_2: int = summaries_response[1][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n assert status_2.target is None\n\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\n return fetched is not None and fetched.is_in_mempool()\n\n join_pool: Dict = await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 10,\n fee,\n )\n assert join_pool[\"success\"]\n join_pool_tx: TransactionRecord = join_pool[\"transaction\"]\n assert join_pool_tx is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\n\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \"https://pool.example.com\", 10, fee)\n assert join_pool_2[\"success\"]\n join_pool_tx_2: TransactionRecord = join_pool_2[\"transaction\"]\n for r in join_pool_tx.removals:\n assert r not in join_pool_tx_2.removals\n assert join_pool_tx_2 is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is not None\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.target is not None\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await farm_blocks(full_node_api, our_ph, 1)\n\n async def status_is_farming_to_pool(w_id: int):\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_index_container_privileges(self):\n pass","def _is_pool_owned(self, pdata):\n svc = '/api/system/v1/version'\n ret = self.rest_get(svc, restclient.Status.OK)\n vdata = jsonutils.loads(ret.data)\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\n vdata['version']['nodename'] == pdata['pool']['owner'])","def test_delete_cluster_network(self):\n pass","def test_kyc_get_legal_share_holders(self):\n pass","def testSubset(df, fullIndex, indexCol, members, gbCol='Stimulus', gbValues=None, countCol='Cells', min_count=7, nsamps=None, rseed=110820):\n\n if gbValues is None:\n gbValues = sorted(df[gbCol].unique())\n cnts = df.groupby([indexCol, gbCol])[countCol].agg(np.sum).unstack(gbCol, fill_value=0)[gbValues]\n cnts = cnts.reindex(fullIndex, axis=0, fill_value=0)\n resDf = testHClusters(cnts, members, gbValues, min_count=min_count)\n \n if not nsamps is None:\n \"\"\"Preliminarily, permutation-based p-values have correlated perfectly\n with the analytic p-values\"\"\"\n np.random.seed(rseed)\n rtmp = df.copy()\n rchi2 = np.zeros((resDf.shape[0], nsamps))\n rpvalue = np.zeros((resDf.shape[0], nsamps))\n for sampi in range(nsamps):\n rtmp.loc[:, gbCol] = rtmp[gbCol].values[np.random.permutation(rtmp.shape[0])]\n rcnts = rtmp.groupby([indexCol, gbCol])['Cells'].agg(np.sum).unstack(gbCol, fill_value=0)\n rcnts = rcnts.reindex(fullIndex, axis=0, fill_value=0)\n rres = testHClusters(rcnts, members, gbValues, min_count=min_count)\n rchi2[:, sampi] = rres['chi2']\n rpvalue[:, sampi] = rres['pvalue']\n ppvalue = ((rpvalue <= resDf['pvalue'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\n pchi2 = ((rchi2 <= resDf['chi2'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\n ppvalue[np.isnan(resDf['chi2'].values)] = np.nan\n pchi2[np.isnan(resDf['chi2'].values)] = np.nan\n resDf = resDf.assign(**{'Perm P-pvalue':ppvalue, 'Perm Chi2-pvalue':pchi2})\n\n return resDf","def test_create_cluster_policy(self):\n pass","def test_replace_cluster_resource_quota_status(self):\n pass","def test_sqpp_distributed_ands_equivalent(self):\n self.assertEqual(sorted(perform_request_search(p='ellis and (kaluza-klein or r-parity)')),\n sorted(perform_request_search(p='ellis and (r-parity or kaluza-klein)')))","def test_get_resource_license_resource_count_by_moid(self):\n pass","def test_delete_collection_cluster_network(self):\n pass","def test_extreme_neighborhoods(self):\n\n ## Radius = 0 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Min_neighbors > 30 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=31,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Radius very large ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=100.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)\n\n ## Min_neighbors = 0 ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.5,\n min_core_neighbors=0,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)","def createBucketsWithNetworks(trainer, path):\n # Here a list with the model and the corresponding \"address\" (table/bucket) is indexed.\n trainer.trainable_buckets = {\"model\": [], \"table\": [], \"bucketName\": []}\n\n # this list will hold dictionaries with numbers of trainable buckets and utilized buckets.\n trainer.estimators_num_of_table = []\n\n for num, ith_table in enumerate(trainer.lsh.hash_tables):\n print(\"\\nPost-LSH training for buckets in table no. {} of {}...\".format(num + 1, trainer.lsh.num_hashtables))\n # below a set is used to avoid duplicate counting\n table_estimators = {\"buckets_used\": set(), \"trainable_buckets\": 0}\n for jth_hashcode in ith_table.storage.items():\n graphs_in_bucket = [i[1] for i in jth_hashcode[1]]\n\n if len(graphs_in_bucket) >= trainer.lsh.min_bucket_size: # If it's a trainable bucket.\n table_estimators[\"trainable_buckets\"] += 1\n # Turn the bucket into a Dataset\n x = ListDataset(data_list=graphs_in_bucket)\n\n # Create a model for this bucket.\n bucket_model = SimGNN(trainer.args, trainer.number_of_node_labels, trainer.number_of_edge_labels)\n bucket_optimizer = torch.optim.Adam(bucket_model.parameters(), lr=trainer.args.learning_rate,\n weight_decay=trainer.args.weight_decay)\n checkpoint = torch.load(path)\n bucket_model.load_state_dict(checkpoint['model_state_dict'])\n bucket_optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n\n # Save the model's address.\n trainer.trainable_buckets[\"table\"].append(num)\n trainer.trainable_buckets[\"bucketName\"].append(jth_hashcode[0])\n\n # Train the model and save it to the index.\n trainer.fit(lsh_bucket=x, modelToUse=(bucket_model, bucket_optimizer))\n trainer.trainable_buckets[\"model\"].append(bucket_model)\n\n # Add the estimators' counts to the list before moving to the next table.\n trainer.estimators_num_of_table.append(table_estimators)\n\n pass\n print(\"\\nPost-LSH training completed.\")","def pool_test_dataset_dir(obs_dir_fp,exp_dir_fp,file_name_delimiter=\"--\",\\\n file_name_field_order=\\\n {'file_type':0,\"prediction_method\":1,\"weighting_method\":2,\"holdout_method\":3,\\\n \"distance\":4,\"organism\":5},strict=False, verbose=True,pool_by=['distance']):\n trials = defaultdict(list)\n #We'll want a quick unzip fn for converting points to trials\n #TODO: separate out into a 'get_paired_data_from_dirs' function\n\n pooled_observations = {}\n pooled_expectations = {}\n pairs = iter_prediction_expectation_pairs(obs_dir_fp,exp_dir_fp,file_name_field_order,file_name_delimiter,verbose=verbose)\n file_number = 0\n for obs_table,exp_table,filename in pairs:\n #print \"analyzing filename:\",filename \n filename_metadata= get_metadata_from_filename(filename,file_name_field_order,\\\n file_name_delimiter,verbose=verbose)\n \n #base_tag = '%s\\t%s\\t' %(filename_metadata['holdout_method'],filename_metadata['prediction_method'])\n #tags = [base_tag+'all_results']\n if 'file_type' in pool_by:\n pool_by.remove('file_type') #we do this manually at the end\n combined_tag = ['all']*len(file_name_field_order.keys())\n for field in file_name_field_order.keys():\n #print combined_tag\n #print file_name_field_order\n idx = file_name_field_order[field]\n #print idx\n if field in pool_by:\n combined_tag[idx] = filename_metadata[field]\n tags=[file_name_delimiter.join(combined_tag)]\n \n if verbose:\n print \"Pooling by:\", pool_by\n print \"Combined tags:\",tags\n \n pooled_observations,pooled_expectations =\\\n update_pooled_data(obs_table,exp_table,tags,pooled_observations,\\\n pooled_expectations,str(file_number),verbose=verbose)\n file_number += 1\n\n return pooled_observations,pooled_expectations","def test_update_hyperflex_cluster(self):\n pass","def test_add_node_to_pool_with_large_ppseqno_diff_views(do_view_change, looper, txnPoolNodeSet, tconf, sdk_pool_handle,\n sdk_wallet_steward, tdir, allPluginsPath):\n\n ensure_several_view_change(looper, txnPoolNodeSet, do_view_change, custom_timeout=tconf.NEW_VIEW_TIMEOUT)\n\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\n big_ppseqno = cur_ppseqno + tconf.LOG_SIZE * 2 + 2300\n assert (big_ppseqno > cur_ppseqno)\n\n # ensure pool is working properly\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\n\n _set_ppseqno(txnPoolNodeSet, big_ppseqno)\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\n assert (big_ppseqno == cur_ppseqno)\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\n\n\n\n # Disable view change after adding new node as it will not be able to finish due to fake ppSeqNo set\n for n in txnPoolNodeSet:\n n.write_manager.node_reg_handler.internal_bus = None\n\n new_steward_name = \"testClientSteward\" + randomString(4)\n new_node_name = \"TestTheta\" + randomString(4)\n new_steward_wallet_handle, new_node = sdk_add_new_steward_and_node(\n looper, sdk_pool_handle, sdk_wallet_steward,\n new_steward_name, new_node_name, tdir, tconf,\n allPluginsPath=allPluginsPath)\n txnPoolNodeSet.append(new_node)\n looper.run(checkNodesConnected(txnPoolNodeSet))\n\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n new_steward_wallet_handle,\n sdk_pool_handle)\n\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\n\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])","def test(shipment):\n shipment.unload_ships()\n ships = shipment.ships.values()\n\n zookeepers = build_zookeeper_cluster(filter_quorum_ships(ships))\n\n elasticsearches = []\n for ship in ships:\n elasticsearch = create_elasticsearch(clustername='testcluster', version='1.4.1')\n kibana = create_kibana()\n nginx = create_nginx_proxy()\n\n # Place all containers on the same ship\n ship.place(elasticsearch)\n ship.place(kibana)\n ship.place(nginx)\n\n # Adjust memory to prevent OOM when running on the laptop\n elasticsearch.memory = min(ship.memory, 128*1024*1024)\n\n # We will use Zookeeper for master discovery\n attach_zookeepers_to_elasticsearch(elasticsearch, zookeepers)\n\n # Nginx will terminate https and proxy requests to Elasticsearch and Kibana\n attach_upstreams_to_nginx(nginx, upstreams=[\n (elasticsearch.doors['http'], 9200, 9443),\n (kibana.doors['http'], 8080, 8443),\n ])\n\n # Expose nginx ports before attaching it to Kibana\n nginx.expose_ports(list(range(2000, 4000)))\n\n # Kibana should use the same origin and just change port to access Elasticsearch\n attach_elasticsearch_to_kibana(kibana, httpdoor=nginx.doors['elasticsearch.http'],\n httpsdoor=nginx.doors['elasticsearch.https'])\n\n # Save elasticsearches to clusterize them later\n elasticsearches.append(elasticsearch)\n\n # Let Elasticsearches know about each other\n clusterize_elasticsearches(elasticsearches)\n\n # Expose all unexposed ports\n shipment.expose_ports(list(range(51000, 51100)))","def _check_bam_index_and_copy(\n samtools_exe,singularity_image,bam_file,list_of_analysis,\n use_ephemeral_space=True,threads=1,dry_run=False):\n try:\n output_temp_dirs = dict()\n check_file_path(bam_file)\n if not isinstance(list_of_analysis,list) or \\\n len(list_of_analysis)==0:\n raise TypeError('Expecing a list of analysis names for copy bam')\n bai_file = '{0}.bai'.format(bam_file) # check bam index path\n if not os.path.exists(bai_file): # create index in not found\n _ = \\\n index_bam_or_cram(\n samtools_exe=samtools_exe,\n input_path=bam_file,\n threads=threads,\n singularity_image=singularity_image,\n dry_run=dry_run)\n if not dry_run:\n check_file_path(bai_file) # check final bam index\n for analysis_name in list_of_analysis:\n temp_dir = \\\n get_temp_dir(use_ephemeral_space=use_ephemeral_space)\n temp_bam = \\\n os.path.join(temp_dir,os.path.basename(bam_file))\n temp_bai = \\\n os.path.join(temp_dir,os.path.basename(bai_file))\n copy_local_file(\n bam_file,temp_bam)\n if not dry_run:\n copy_local_file(\n bai_file,temp_bai)\n output_temp_dirs.\\\n update({analysis_name:temp_bam})\n if len(output_temp_dirs.keys())==0:\n raise ValueError(\n 'No output temp bam path found for input {0}'\\\n .format(bam_file))\n return output_temp_dirs\n except Exception as e:\n raise ValueError(\n 'Failed to copy bam and index, error: {0}'.format(e))","def test_9_node_positional_itegrity(self):\n ring = ConsistentHashRing([])\n for n in range(9):\n ring.add_node((\"192.168.10.%s\" % str(10+n),\"%s\" % str(10+n)))\n self.assertEqual(\n len([n[0] for n in ring.ring]),\n len(set([n[0] for n in ring.ring])))","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_data_source_soaps_count_get(self):\n pass","def test_delete_collection_cluster_resource_quota(self):\n pass","async def test_change_pools(self, setup, trusted_and_fee, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n pool_a_ph = receive_address[1]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_b_ph = await wallets[1].get_new_puzzlehash()\n full_node_api = full_nodes[0]\n\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n WAIT_SECS = 200\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n pool_a_ph, \"https://pool-a.org\", 5, f\"{self_hostname}:5000\", \"new\", \"FARMING_TO_POOL\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status.target is None\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n assert pw_info.current.pool_url == \"https://pool-a.org\"\n assert pw_info.current.relative_lock_height == 5\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_b_ph,\n \"https://pool-b.org\",\n 10,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n\n async def status_is_leaving():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving)\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n assert pw_info.current.pool_url == \"https://pool-b.org\"\n assert pw_info.current.relative_lock_height == 10\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_index_stability(self, example_staypoints):\n sp = example_staypoints\n sp2, locs = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=10, num_samples=2, distance_metric=\"haversine\", agg_level=\"user\"\n )\n assert sp.index.equals(sp2.index)","def show_pool(self, pool, **_params):\r\n return self.get(self.pool_path % (pool), params=_params)","def test_get_placement_w_exception(self, mock__get_nslcmop,\n mock__get_nsd,\n mock__get_vim_accounts,\n mock_create_ns_placement_data,\n mock_do_placement_computation):\n server = self.serverSetup()\n\n server.msgBus.aiowrite = _async_mock()\n mock__get_nsd.return_value = nsd_from_db\n mock__get_nsd.side_effect = RuntimeError('kaboom!')\n mock__get_vim_accounts.return_value = list_of_vims\n mock_do_placement_computation.return_value = \\\n [{'vimAccountId': 'bbbbbbbb-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '1'},\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '2'},\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '3'}]\n\n _run(server.get_placement(nslcmop_record_w_pinning['id']))\n self.assertTrue(server.msgBus.aiowrite.mock.called)\n args, kwargs = server.msgBus.aiowrite.mock.call_args\n rsp_payload = args[2]\n expected_keys = {'placement'}\n self.assertEqual(expected_keys, set(rsp_payload.keys()), \"placement response missing keys\")\n self.assertIs(type(rsp_payload['placement']['vnf']), list, 'vnf not a list')\n self.assertEqual([], rsp_payload['placement']['vnf'], 'vnf list not empty')\n self.assertEqual(nslcmop_record_w_pinning['id'], rsp_payload['placement']['nslcmopId'], \"nslcmopId invalid\")","def test_replace_cluster_policy(self):\n pass"],"string":"[\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def pool_snps(parent1, parent2):\",\n \"def test_autocreate_licensepool(self):\\n identifier = self._identifier()\\n assert [] == identifier.licensed_through\\n provider = AlwaysSuccessfulCollectionCoverageProvider(\\n self._default_collection\\n )\\n pool = provider.license_pool(identifier)\\n assert [pool] == identifier.licensed_through\\n assert pool.data_source == provider.data_source\\n assert pool.identifier == identifier\\n assert pool.collection == provider.collection\\n\\n # Calling license_pool again finds the same LicensePool\\n # as before.\\n pool2 = provider.license_pool(identifier)\\n assert pool == pool2\\n\\n # It's possible for a CollectionCoverageProvider to create a\\n # LicensePool for a different DataSource than the one\\n # associated with the Collection. Only the metadata wrangler\\n # needs to do this -- it's so a CoverageProvider for a\\n # third-party DataSource can create an 'Internal Processing'\\n # LicensePool when some other part of the metadata wrangler\\n # failed to do this earlier.\\n\\n # If a working pool already exists, it's returned and no new\\n # pool is created.\\n same_pool = provider.license_pool(\\n identifier, DataSource.INTERNAL_PROCESSING\\n )\\n assert same_pool == pool2\\n assert provider.data_source == same_pool.data_source\\n\\n # A new pool is only created if no working pool can be found.\\n identifier2 = self._identifier()\\n new_pool = provider.license_pool(\\n identifier2, DataSource.INTERNAL_PROCESSING\\n )\\n assert new_pool.data_source.name == DataSource.INTERNAL_PROCESSING\\n assert new_pool.identifier == identifier2\\n assert new_pool.collection == provider.collection\",\n \"def test_replace_cluster_resource_quota(self):\\n pass\",\n \"def test_list_cluster_resource_quota(self):\\n pass\",\n \"def csAddPool(self,pool,creatorid,nas=None):\\n\\n logger.debug(\\\"Attempting to create pool '\\\"+pool+\\\"'.\\\")\\n\\n localpath = \\\"/.\\\"+pool\\n\\n url = self.csurl + \\\"/polcentral/v1_0/pools/\\\"\\n\\n if nas == None:\\n logger.debug(\\\"No NAS object provided, will create pool '\\\"+pool+\\\"' type 'MW'.\\\")\\n pooltype = 'MW'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n else:\\n logger.debug(\\\"NAS object provided, will create pool '\\\"+pool+\\\"' type 'PS'.\\\")\\n pooltype = 'PS'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n\\n payload = {\\n \\\"name\\\": pool,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath\\n }\\n \\\"\\\"\\\"\\n payload = {\\n \\\"name\\\": poolname,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath,\\n \\\"subscribedevices\\\":subscribedevices,\\n \\\"deviceid\\\": deviceid,\\n \\\"pathinpool\\\": pathinpool,\\n \\\"servername\\\": servername,\\n \\\"sharename\\\": sharename,\\n \\\"sharepath\\\": sharepath,\\n \\\"credsetname\\\": creditname,\\n \\\"overridewarnings\\\": overridewarnings\\n }\\n \\\"\\\"\\\"\\n\\n try:\\n r = requests.post(url, data=json.dumps(payload))\\n except Exception:\\n logger.error(\\\"Exception during api call to add pool.\\\")\\n return 'Error'\\n\\n if r.status_code == 200:\\n logger.debug(\\\"Pool '\\\"+pool+\\\"' was successfully created.\\\")\\n poolid = r.json()['_id']\\n return poolid['$id']\\n else:\\n logger.error(\\\"Pool '\\\"+pool+\\\"' was not created. Error code is \\\"+str(r.status_code)+\\\".\\\")\\n return 'Error'\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def test_pooling(self):\\n for width in range(2, 5):\\n for width2 in range(1, width):\\n matrix_size = (4, 5, width)\\n matrix = get_random_test_tensor(size=matrix_size)\\n pool_size = width2\\n for stride in range(1, width2):\\n for padding in range(2):\\n reference = torch.nn.functional.avg_pool2d(\\n matrix.unsqueeze(0), pool_size,\\n stride=stride, padding=padding\\n )\\n\\n encrypted_matrix = SharedTensor(matrix)\\n encrypted_pool = encrypted_matrix.avg_pool2d(\\n pool_size, stride=stride, padding=padding)\\n self._check(\\n encrypted_pool, reference[0], 'avg_pool2d failed')\",\n \"def testExcessiveSigops(self):\\n NUM_ADDRS = 50\\n logging.info(\\\"testExcessiveSigops: Cleaning up node state\\\")\\n\\n # We are not testing excessively sized blocks so make these large\\n self.nodes[0].set(\\\"net.excessiveBlock=5000000\\\")\\n self.nodes[1].set(\\\"net.excessiveBlock=5000000\\\")\\n self.nodes[2].set(\\\"net.excessiveBlock=5000000\\\")\\n self.nodes[3].set(\\\"net.excessiveBlock=5000000\\\")\\n self.nodes[0].setminingmaxblock(FIVE_MB)\\n self.nodes[1].setminingmaxblock(FIVE_MB)\\n self.nodes[2].setminingmaxblock(FIVE_MB)\\n self.nodes[3].setminingmaxblock(FIVE_MB)\\n # Stagger the accept depths so we can see the block accepted stepwise\\n self.nodes[0].set(\\\"net.excessiveAcceptDepth=0\\\")\\n self.nodes[1].set(\\\"net.excessiveAcceptDepth=1\\\")\\n self.nodes[2].set(\\\"net.excessiveAcceptDepth=2\\\")\\n self.nodes[3].set(\\\"net.excessiveAcceptDepth=3\\\")\\n\\n for n in self.nodes:\\n n.generate(10)\\n self.sync_blocks()\\n\\n self.nodes[0].generate(100) # create a lot of BTC for spending\\n self.sync_all()\\n\\n self.nodes[0].set(\\\"net.excessiveSigopsPerMb=100\\\") # Set low so txns will fail if its used\\n self.nodes[1].set(\\\"net.excessiveSigopsPerMb=5000\\\")\\n self.nodes[2].set(\\\"net.excessiveSigopsPerMb=1000\\\")\\n self.nodes[3].set(\\\"net.excessiveSigopsPerMb=100\\\")\\n\\n logging.info(\\\"Creating addresses...\\\")\\n self.nodes[0].keypoolrefill(NUM_ADDRS)\\n addrs = [self.nodes[0].getnewaddress() for _ in range(NUM_ADDRS)]\\n\\n # test that a < 1MB block ignores the sigops parameter\\n self.nodes[0].setminingmaxblock(ONE_MB)\\n # if excessive Sigops was heeded, this txn would not make it into the block\\n self.createUtxos(self.nodes[0], addrs, NUM_ADDRS)\\n mpool = self.nodes[0].getmempoolinfo()\\n assert_equal(mpool[\\\"size\\\"], 0)\\n\\n # test that a < 1MB block ignores the sigops parameter, even if the max block size is less\\n self.nodes[0].setminingmaxblock(FIVE_MB)\\n # if excessive Sigops was heeded, this txn would not make it into the block\\n self.createUtxos(self.nodes[0], addrs, NUM_ADDRS)\\n mpool = self.nodes[0].getmempoolinfo()\\n assert_equal(mpool[\\\"size\\\"], 0)\\n\\n if self.extended: # creating 1MB+ blocks is too slow for travis due to the signing cost\\n self.createUtxos(self.nodes[0], addrs, 10000) # we need a lot to generate 1MB+ blocks\\n\\n wallet = self.nodes[0].listunspent()\\n wallet.sort(key=lambda x: x[\\\"amount\\\"], reverse=True)\\n self.nodes[0].set(\\\"net.excessiveSigopsPerMb=100000\\\") # Set this huge so all txns are accepted by this node\\n\\n logging.info(\\\"Generate > 1MB block with excessive sigops\\\")\\n generateTx(self.nodes[0], 1100000, addrs)\\n\\n counts = [x.getblockcount() for x in self.nodes]\\n base = counts[0]\\n\\n self.nodes[0].generate(1)\\n assert_equal(True, self.expectHeights([base + 1, base, base, base], 30))\\n\\n logging.info(\\\"Test excessive block propagation to nodes with different AD\\\")\\n self.nodes[0].generate(1)\\n # it takes a while to sync all the txns\\n assert_equal(True, self.expectHeights([base + 2, base + 2, base, base], 500))\\n\\n self.nodes[0].generate(1)\\n assert_equal(True, self.expectHeights([base + 3, base + 3, base + 3, base], 90))\\n\\n self.nodes[0].generate(1)\\n assert_equal(True, self.expectHeights([base + 4, base + 4, base + 4, base + 4], 90))\\n\\n logging.info(\\\"Excessive sigops test completed\\\")\\n\\n # set it all back to defaults\\n for n in self.nodes:\\n n.generate(150)\\n self.sync_blocks()\\n\\n self.nodes[0].set(\\\"net.excessiveSigopsPerMb=20000\\\") # Set low so txns will fail if its used\\n self.nodes[1].set(\\\"net.excessiveSigopsPerMb=20000\\\")\\n self.nodes[2].set(\\\"net.excessiveSigopsPerMb=20000\\\")\\n self.nodes[3].set(\\\"net.excessiveSigopsPerMb=20000\\\")\\n\\n self.nodes[0].setminingmaxblock(ONE_MB)\\n self.nodes[1].setminingmaxblock(ONE_MB)\\n self.nodes[2].setminingmaxblock(ONE_MB)\\n self.nodes[3].setminingmaxblock(ONE_MB)\\n self.nodes[0].set(\\\"net.excessiveBlock=1000000\\\")\\n self.nodes[1].set(\\\"net.excessiveBlock=1000000\\\")\\n self.nodes[2].set(\\\"net.excessiveBlock=1000000\\\")\\n self.nodes[3].set(\\\"net.excessiveBlock=1000000\\\")\",\n \"def _create_volume_pool(self, pool_name):\\n osd_map = self._rados_command('osd dump', {})\\n\\n existing_id = self._get_pool_id(osd_map, pool_name)\\n if existing_id is not None:\\n log.info(\\\"Pool {0} already exists\\\".format(pool_name))\\n return existing_id\\n\\n osd_count = len(osd_map['osds'])\\n\\n # We can't query the actual cluster config remotely, but since this is\\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\\n # that in use in the rest of the cluster.\\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\\n\\n other_pgs = 0\\n for pool in osd_map['pools']:\\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\\n other_pgs += pool['pg_num']\\n\\n # A basic heuristic for picking pg_num: work out the max number of\\n # PGs we can have without tripping a warning, then subtract the number\\n # of PGs already created by non-manila pools, then divide by ten. That'll\\n # give you a reasonable result on a system where you have \\\"a few\\\" manila\\n # shares.\\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\\n # TODO Alternatively, respect an override set by the user.\\n\\n self._rados_command(\\n 'osd pool create',\\n {\\n 'pool': pool_name,\\n 'pg_num': int(pg_num),\\n }\\n )\\n\\n osd_map = self._rados_command('osd dump', {})\\n pool_id = self._get_pool_id(osd_map, pool_name)\\n\\n if pool_id is None:\\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\\n # removing it right after we created it.\\n log.error(\\\"OSD map doesn't contain expected pool '{0}':\\\\n{1}\\\".format(\\n pool_name, json.dumps(osd_map, indent=2)\\n ))\\n raise RuntimeError(\\\"Pool '{0}' not present in map after creation\\\".format(pool_name))\\n else:\\n return pool_id\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def verify_pool(self, pool):\\n svc = self.pool_path % pool\\n self.rest_get(svc, restclient.Status.OK)\",\n \"def test_thread_pool(self):\\n self.assertIdentical(self.tx_client._pool, self.pool)\",\n \"def test_get_hyperflex_cluster_storage_policy_by_moid(self):\\n pass\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_object = RadosOrchestrator(node=cephadm)\\n mon_obj = MonConfigMethods(rados_obj=rados_object)\\n ceph_nodes = kw.get(\\\"ceph_nodes\\\")\\n osd_list = []\\n total_osd_app_mem = {}\\n\\n for node in ceph_nodes:\\n if node.role == \\\"osd\\\":\\n node_osds = rados_object.collect_osd_daemon_ids(node)\\n osd_list = osd_list + node_osds\\n\\n target_configs = config[\\\"cache_trim_max_skip_pinned\\\"][\\\"configurations\\\"]\\n max_skip_pinned_value = int(\\n mon_obj.get_config(section=\\\"osd\\\", param=\\\"bluestore_cache_trim_max_skip_pinned\\\")\\n )\\n\\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\\n if max_skip_pinned_value != 1000:\\n log.error(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\\\"\\n )\\n raise Exception(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\\\"\\n )\\n\\n # Creating pools and starting the test\\n for entry in target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n if entry.get(\\\"pool_type\\\", \\\"replicated\\\") == \\\"erasure\\\":\\n method_should_succeed(\\n rados_object.create_erasure_pool, name=entry[\\\"pool_name\\\"], **entry\\n )\\n else:\\n method_should_succeed(\\n rados_object.create_pool,\\n **entry,\\n )\\n\\n if not rados_object.bench_write(**entry):\\n log.error(\\\"Failed to write objects into the EC Pool\\\")\\n return 1\\n rados_object.bench_read(**entry)\\n log.info(\\\"Finished writing data into the pool\\\")\\n\\n # performing scrub and deep-scrub\\n rados_object.run_scrub()\\n rados_object.run_deep_scrub()\\n time.sleep(10)\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"start\\\")\\n # Executing tests for 45 minutes\\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\\n while datetime.datetime.now() < time_execution:\\n # Get all OSDs heap dump\\n heap_dump = rados_object.get_heap_dump(osd_list)\\n # get the osd application used memory\\n osd_app_mem = get_bytes_used_by_app(heap_dump)\\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\\n # wait for 10 seconds and collecting the memory\\n time.sleep(10)\\n for osd_id, mem_list in total_osd_app_mem.items():\\n mem_growth = is_what_percent_mem(mem_list)\\n if mem_growth > 80:\\n log.error(\\n f\\\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\\\"\\n )\\n raise Exception(\\\"No warning generated by PG Autoscaler\\\")\\n log.info(f\\\"The relative memory growth for the osd.{osd_id} is {mem_growth} \\\")\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"stop\\\")\\n\\n # check fo the crashes in the cluster\\n crash_list = rados_object.do_crash_ls()\\n if not crash_list:\\n return 0\\n else:\\n return 1\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def test_no_impact_between_tenants(self):\\n field = 'body'\\n indexMap, createIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=self.index_count,\\n field=field, sync=False)\\n for taskInstance in createIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n self.log.debug(\\\"Getting initial RR values\\\")\\n stat_obj_list = self.create_Stats_Obj_list()\\n stat_field = 'resident_ratio'\\n initial_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n\\n bucket_list = []\\n bucket_list.append(self.cluster.buckets[0])\\n\\n query_tasks_info = self.indexUtil.run_full_scan(self.cluster, indexMap, key='body', totalCount=self.init_items_per_collection,\\n limit=self.query_limit)\\n for taskInstance in query_tasks_info:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n newIndexMap, newcreateIndexTasklist = self.indexUtil.create_gsi_on_each_collection(self.cluster,buckets=bucket_list,\\n replica=self.index_replicas,\\n defer=False,\\n number_of_indexes_per_coll=2 * self.index_count,\\n count=self.index_count,\\n field=field, sync=False)\\n for taskInstance in newcreateIndexTasklist:\\n self.task.jython_task_manager.get_task_result(taskInstance)\\n\\n final_rr_value_map = self.get_plasma_index_stat_value(stat_field, stat_obj_list)\\n self.compareRR(initial_rr_value_map, final_rr_value_map)\",\n \"def test_list_cluster_policy(self):\\n pass\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def pool_search(self,**kwargs):\\n\\t\\treturn self.DA.pool_search(self,**kwargs)\",\n \"def test_get_buckets(self):\\n pass\",\n \"def test_read_namespaced_applied_cluster_resource_quota(self):\\n pass\",\n \"def test_create_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def test_get_hyperflex_cluster_by_moid(self):\\n pass\",\n \"def test_pool_dependence(self):\\n ok_(id(CSVarPool.pool) == id(VarPool.pool), 'mem address of pools should be the same')\\n\\n var = 'foo'\\n app = 'test'\\n VarPool(app=app).set(var, 'bar')\\n eq_(CSVarPool.get(var, app=app), 'bar')\\n CSVarPool(app=app).set(var, 'foo')\\n eq_(VarPool.get(var, app=app), 'foo')\",\n \"def test_read_cluster_policy(self):\\n pass\",\n \"def test_index_containers(self):\\n pass\",\n \"def verify_avail_space(self, pool, project, share, size):\\n self.verify_project(pool, project)\\n avail = self.get_project_stats(pool, project)\\n if avail < size:\\n exception_msg = (_('Error creating '\\n 'share: %(share)s on '\\n 'pool: %(pool)s. '\\n 'Not enough space.')\\n % {'share': share,\\n 'pool': pool})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_sync_clear_mempool(self):\\n logging.info(\\\">>> Entered : test_sync_clear_mempool \\\\n\\\")\\n try:\\n # clear out the mempool\\n mostly_sync_mempools(self.nodes)\\n for index1, n in enumerate(self.nodes):\\n n.generate(2)\\n sync_blocks(self.nodes)\\n for index2, n in enumerate(self.nodes):\\n while len(n.getrawmempool()):\\n n.generate(1)\\n sync_blocks(self.nodes)\\n logging.info(\\\"cleared mempool: %s\\\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\\n base = [x.getrawmempool() for x in self.nodes]\\n assert_equal(base, [base[0]] * 4)\\n except (Exception, JSONRPCException) as e1:\\n logging.info(e1)\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\\n raise TestAssertionError({\\\"file_name\\\": fname, \\\"line_num\\\": exc_tb.tb_lineno, \\\\\\n \\\"error_type\\\": exc_type.__name__, \\\"error_msg\\\": str( e1 ), \\\\\\n \\\"n1\\\" : self.bins[index1], \\\"n2\\\" : self.bins[index2], \\\"amount\\\" : \\\"N/A\\\", \\\"numsig\\\" : \\\"N/A\\\"})\",\n \"def cluster_credsets(hpo_data, block_merge_dist=200000, kmeans_subclustering=False):\\n\\n # Pool credible sets, tagged with block ID\\n pooled_creds_str = ''\\n for hdat in hpo_data.values():\\n for bid, binfo in hdat['blocks'].items():\\n for ci in binfo['credset_bt']:\\n pooled_creds_str += '\\\\t'.join([ci.chrom, str(ci.start), \\n str(ci.end), bid]) + '\\\\n'\\n pooled_creds_bt = pbt.BedTool(pooled_creds_str, from_string=True).sort().saveas()\\n merged_creds_bt = pooled_creds_bt.merge(c=4, o='distinct', d=block_merge_dist)\\n\\n # Build nx.Graph() of credible sets to be clustered\\n G = nx.Graph()\\n csids = \\\\\\n list(set([e for s in [x.split(',') for x in merged_creds_bt.to_dataframe().\\\\\\n iloc[:, 3].tolist()] for e in s]))\\n G.add_nodes_from(csids)\\n for x in merged_creds_bt:\\n creds = x[3].split(',')\\n if len(creds) > 1:\\n G.add_edges_from(list(combinations(creds, 2)))\\n\\n # If optioned, attempt to split subgraphs containing multiple blocks from the same HPO\\n # This corrects for daisy chaining between distinct clumps identified\\n # earlier using split_blocks_by_cov()\\n if kmeans_subclustering:\\n v1_clusters = list(nx.connected_components(G))\\n for g in v1_clusters:\\n\\n # Only need to correct clusters containing >1 independent block from the same HPO\\n hpo_counts = Counter([x.split('_')[0] for x in g])\\n if any(np.array(list(hpo_counts.values())) > 1):\\n\\n # Get info on all blocks in cluster\\n all_bids = list(g)\\n block_bt = pooled_creds_bt.filter(lambda x: x[3] in all_bids).saveas()\\n\\n # Compute matrix of coverage between all blocks\\n block_cov = pd.DataFrame(columns=all_bids)\\n for bid in all_bids:\\n bid_bt = block_bt.filter(lambda x: x[3] == bid).saveas()\\n cvals = {}\\n for x in block_bt.coverage(bid_bt):\\n ovr_bp = int(x[5])\\n union = bid_bt.cat(pbt.BedTool('\\\\t'.join(x[:4]), \\n from_string=True))\\n union_bp = np.sum([len(x) for x in union])\\n cvals[x[3]] = ovr_bp / union_bp\\n block_cov.loc[bid] = block_cov.columns.map(cvals)\\n\\n # Initial hierarchical clustering such that k clusters are obtained,\\n # where k is the max number of independent blocks from any one HPO\\n kmeans = KMeans(n_clusters=max(hpo_counts.values()), random_state=2021).fit(block_cov)\\n newclusters = {k : set() for k in range(max(hpo_counts.values()))}\\n for k, bid in zip(kmeans.labels_, block_cov.index):\\n newclusters[k].add(bid)\\n\\n # Prune all edges between new subclusters\\n for members in newclusters.values():\\n for bid in members:\\n for other_id in [x for x in all_bids if x not in members]:\\n if G.has_edge(bid, other_id):\\n G.remove_edge(bid, other_id)\\n\\n # Format each cluster in the graph of credsets\\n clustered_credsets = \\\\\\n { 'clustered_region_' + str(i) : x for i, x \\\\\\n in enumerate(nx.connected_components(G))}\\n \\n return clustered_credsets\",\n \"def test_delete_cluster_resource_quota(self):\\n pass\",\n \"def test_volume_service_pool(self):\\n self.assertEqual(\\n ChangeStateScript()._deployer._volume_service._pool,\\n StoragePool(reactor, b\\\"flocker\\\", FilePath(b\\\"/flocker\\\")))\",\n \"def test_pool_consistency(self) -> None:\\n x = Constant(\\n 'const1',\\n Float32(),\\n np.zeros([1, 3, 3, 3])\\n )\\n input_ops = {'X': cast(Operator, x)}\\n\\n MaxPool(\\n 'max_pool1',\\n [1, 2, 2, 3],\\n Float32(),\\n input_ops,\\n kernel_shape=[3, 3],\\n pads=[1, 1, 1, 1],\\n strides=[2, 2]\\n )\\n\\n print(\\\"Consistency test for pooling operator passed!\\\")\",\n \"def test_n_minus_f_pool_processes_attrib(looper, nodeSet,\\n sdk_pool_handle,\\n sdk_wallet_steward):\\n make_pool_n_minus_f_nodes(looper, nodeSet)\\n\\n sdk_add_raw_attribute(looper, sdk_pool_handle, sdk_wallet_steward, 'foo', 'bar')\",\n \"def test_list_pools(mocker, api: API, account: Account, raw_pools):\\n api.candlepin.get_pools.return_value = raw_pools\\n\\n apply_mapping_spy = mocker.patch(\\n \\\"ethel.account.apply_mapping\\\", side_effect=apply_mapping\\n )\\n pools = account.list_pools()\\n assert len(pools) == len(raw_pools)\\n\\n expected_call_count = len(account.POOL_ATTRIBUTES_MAPPING) * len(raw_pools)\\n\\n assert apply_mapping_spy.call_count == expected_call_count\",\n \"def test_list_pools_no_filter(api: API, account: Account, raw_pools):\\n api.candlepin.get_pools.return_value = raw_pools\\n pools = account.list_pools(filter_attributes={})\\n assert pools == raw_pools\",\n \"def test_update_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_patch_cluster_resource_quota(self):\\n pass\",\n \"def calc_pool(players):\\n players = [str(x) for x in players]\\n n = len(players)\\n for player in players:\\n nopool = payoff_nopool(p=percentages[player])\\n print(nopool)\\n p = {i: percentages[key] for i, key in zip([x for x in range(2, n+1)],\\n [x for x in players if x != player])}\\n p[1] = percentages[player]\\n pool = payoff_n_p(p=p, n=n)\\n print(pool)\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def test_assign_clusters_nonsparse(self, new_data, filename):\\n\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_random',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_random',con=engine)\\n elif self.split_type == 'date':\\n averages_seg = pd.read_sql('SELECT * FROM clust_nonsparse_avebysegment_date',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_nonsparse_avebyrt_date',con=engine)\\n \\n averages_seg['exists'] = 1\\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'day_of_week', 'time_idx', 'exists']], on=['segment_id', 'day_of_week', 'time_idx'])\\n test_exists = test_data_exists[test_data_exists['exists']==1]\\n test_notexists = test_data_exists[test_data_exists['exists']!=1]\\n \\n test_exists_tmp = test_exists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_notexists_tmp = test_notexists[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2']]\\n test_matrix_exists = pd.merge(test_exists_tmp, averages_seg, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\\n test_matrix_notexists = pd.merge(test_notexists_tmp, averages_rt, how='left', on=['road_type', 'day_of_week', 'time_idx'])\\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\\n test_matrix = test_matrix.fillna(0)\\n \\n test_nonsparse_matrix = test_matrix[['segment_id','date','time','date_idx', 'time_idx', 'day_of_week', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_binary', 'level_min', 'level_max', 'level_mean', 'level_count']]\\n test_nonsparse_matrix = self.scale_matrix(test_nonsparse_matrix)\\n\\n print('clustering new data...')\\n cluster_model = joblib.load(filename)\\n cluster_predictions = cluster_model.predict(test_nonsparse_matrix.drop(columns = ['segment_id','date','time']))\\n \\n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_nonsparse']).reset_index()\\n keydf = test_matrix[['segment_id','date','time']].reset_index()\\n test_cluster_df_sparse = pd.merge(clusterdf, keydf, on=['index'])\\n \\n return test_cluster_df_sparse[['segment_id','date','time','cluster_nonsparse']]\",\n \"def test_allocation_strategy_opt_allocs():\\n prices = np.array([[10, 10], [11, 15], [12, 5], [13, 10]])\\n allocs = AllocationStrategy.opt_allocs(prices, neg_sharpe_ratio)\\n np.testing.assert_almost_equal(allocs, [1, 0])\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_allocator_single_confilicting_sets():\\n indexSets = [set([1]), set([1])]\\n allocator = Allocator(indexSets)\\n assert len(allocator.slots) == 2\\n allocation = allocator.allocate()\\n assert not allocation\",\n \"def test_replace_cluster_network(self):\\n pass\",\n \"def pool_list(mnode):\\n cmd = \\\"gluster pool list\\\"\\n return g.run(mnode, cmd)\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_get_hyperflex_cluster_network_policy_by_moid(self):\\n pass\",\n \"async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\\n\\n trusted, fee = trusted_and_fee\\n num_blocks = 4 # Num blocks to farm at a time\\n total_blocks = 0 # Total blocks farmed so far\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n wallet_node_0 = wallet_nodes[0]\\n our_ph = receive_address[0]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_node_0.server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\\n total_block_rewards = await get_total_block_rewards(total_blocks)\\n\\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n assert total_block_rewards > 0\\n\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5001\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx_2.spend_bundle,\\n creation_tx_2.name,\\n )\\n\\n for r in creation_tx.removals:\\n assert r not in creation_tx_2.removals\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 2\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n wallet_id_2: int = summaries_response[1][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n assert status_2.target is None\\n\\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\\n return fetched is not None and fetched.is_in_mempool()\\n\\n join_pool: Dict = await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 10,\\n fee,\\n )\\n assert join_pool[\\\"success\\\"]\\n join_pool_tx: TransactionRecord = join_pool[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\\n\\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \\\"https://pool.example.com\\\", 10, fee)\\n assert join_pool_2[\\\"success\\\"]\\n join_pool_tx_2: TransactionRecord = join_pool_2[\\\"transaction\\\"]\\n for r in join_pool_tx.removals:\\n assert r not in join_pool_tx_2.removals\\n assert join_pool_tx_2 is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is not None\\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.target is not None\\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n\\n async def status_is_farming_to_pool(w_id: int):\\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_index_container_privileges(self):\\n pass\",\n \"def _is_pool_owned(self, pdata):\\n svc = '/api/system/v1/version'\\n ret = self.rest_get(svc, restclient.Status.OK)\\n vdata = jsonutils.loads(ret.data)\\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\\n vdata['version']['nodename'] == pdata['pool']['owner'])\",\n \"def test_delete_cluster_network(self):\\n pass\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def testSubset(df, fullIndex, indexCol, members, gbCol='Stimulus', gbValues=None, countCol='Cells', min_count=7, nsamps=None, rseed=110820):\\n\\n if gbValues is None:\\n gbValues = sorted(df[gbCol].unique())\\n cnts = df.groupby([indexCol, gbCol])[countCol].agg(np.sum).unstack(gbCol, fill_value=0)[gbValues]\\n cnts = cnts.reindex(fullIndex, axis=0, fill_value=0)\\n resDf = testHClusters(cnts, members, gbValues, min_count=min_count)\\n \\n if not nsamps is None:\\n \\\"\\\"\\\"Preliminarily, permutation-based p-values have correlated perfectly\\n with the analytic p-values\\\"\\\"\\\"\\n np.random.seed(rseed)\\n rtmp = df.copy()\\n rchi2 = np.zeros((resDf.shape[0], nsamps))\\n rpvalue = np.zeros((resDf.shape[0], nsamps))\\n for sampi in range(nsamps):\\n rtmp.loc[:, gbCol] = rtmp[gbCol].values[np.random.permutation(rtmp.shape[0])]\\n rcnts = rtmp.groupby([indexCol, gbCol])['Cells'].agg(np.sum).unstack(gbCol, fill_value=0)\\n rcnts = rcnts.reindex(fullIndex, axis=0, fill_value=0)\\n rres = testHClusters(rcnts, members, gbValues, min_count=min_count)\\n rchi2[:, sampi] = rres['chi2']\\n rpvalue[:, sampi] = rres['pvalue']\\n ppvalue = ((rpvalue <= resDf['pvalue'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\\n pchi2 = ((rchi2 <= resDf['chi2'].values[:, None]).sum(axis=1) + 1) / (nsamps + 1)\\n ppvalue[np.isnan(resDf['chi2'].values)] = np.nan\\n pchi2[np.isnan(resDf['chi2'].values)] = np.nan\\n resDf = resDf.assign(**{'Perm P-pvalue':ppvalue, 'Perm Chi2-pvalue':pchi2})\\n\\n return resDf\",\n \"def test_create_cluster_policy(self):\\n pass\",\n \"def test_replace_cluster_resource_quota_status(self):\\n pass\",\n \"def test_sqpp_distributed_ands_equivalent(self):\\n self.assertEqual(sorted(perform_request_search(p='ellis and (kaluza-klein or r-parity)')),\\n sorted(perform_request_search(p='ellis and (r-parity or kaluza-klein)')))\",\n \"def test_get_resource_license_resource_count_by_moid(self):\\n pass\",\n \"def test_delete_collection_cluster_network(self):\\n pass\",\n \"def test_extreme_neighborhoods(self):\\n\\n ## Radius = 0 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Min_neighbors > 30 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=31,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Radius very large ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=100.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\\n\\n ## Min_neighbors = 0 ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.5,\\n min_core_neighbors=0,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\",\n \"def createBucketsWithNetworks(trainer, path):\\n # Here a list with the model and the corresponding \\\"address\\\" (table/bucket) is indexed.\\n trainer.trainable_buckets = {\\\"model\\\": [], \\\"table\\\": [], \\\"bucketName\\\": []}\\n\\n # this list will hold dictionaries with numbers of trainable buckets and utilized buckets.\\n trainer.estimators_num_of_table = []\\n\\n for num, ith_table in enumerate(trainer.lsh.hash_tables):\\n print(\\\"\\\\nPost-LSH training for buckets in table no. {} of {}...\\\".format(num + 1, trainer.lsh.num_hashtables))\\n # below a set is used to avoid duplicate counting\\n table_estimators = {\\\"buckets_used\\\": set(), \\\"trainable_buckets\\\": 0}\\n for jth_hashcode in ith_table.storage.items():\\n graphs_in_bucket = [i[1] for i in jth_hashcode[1]]\\n\\n if len(graphs_in_bucket) >= trainer.lsh.min_bucket_size: # If it's a trainable bucket.\\n table_estimators[\\\"trainable_buckets\\\"] += 1\\n # Turn the bucket into a Dataset\\n x = ListDataset(data_list=graphs_in_bucket)\\n\\n # Create a model for this bucket.\\n bucket_model = SimGNN(trainer.args, trainer.number_of_node_labels, trainer.number_of_edge_labels)\\n bucket_optimizer = torch.optim.Adam(bucket_model.parameters(), lr=trainer.args.learning_rate,\\n weight_decay=trainer.args.weight_decay)\\n checkpoint = torch.load(path)\\n bucket_model.load_state_dict(checkpoint['model_state_dict'])\\n bucket_optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\n\\n # Save the model's address.\\n trainer.trainable_buckets[\\\"table\\\"].append(num)\\n trainer.trainable_buckets[\\\"bucketName\\\"].append(jth_hashcode[0])\\n\\n # Train the model and save it to the index.\\n trainer.fit(lsh_bucket=x, modelToUse=(bucket_model, bucket_optimizer))\\n trainer.trainable_buckets[\\\"model\\\"].append(bucket_model)\\n\\n # Add the estimators' counts to the list before moving to the next table.\\n trainer.estimators_num_of_table.append(table_estimators)\\n\\n pass\\n print(\\\"\\\\nPost-LSH training completed.\\\")\",\n \"def pool_test_dataset_dir(obs_dir_fp,exp_dir_fp,file_name_delimiter=\\\"--\\\",\\\\\\n file_name_field_order=\\\\\\n {'file_type':0,\\\"prediction_method\\\":1,\\\"weighting_method\\\":2,\\\"holdout_method\\\":3,\\\\\\n \\\"distance\\\":4,\\\"organism\\\":5},strict=False, verbose=True,pool_by=['distance']):\\n trials = defaultdict(list)\\n #We'll want a quick unzip fn for converting points to trials\\n #TODO: separate out into a 'get_paired_data_from_dirs' function\\n\\n pooled_observations = {}\\n pooled_expectations = {}\\n pairs = iter_prediction_expectation_pairs(obs_dir_fp,exp_dir_fp,file_name_field_order,file_name_delimiter,verbose=verbose)\\n file_number = 0\\n for obs_table,exp_table,filename in pairs:\\n #print \\\"analyzing filename:\\\",filename \\n filename_metadata= get_metadata_from_filename(filename,file_name_field_order,\\\\\\n file_name_delimiter,verbose=verbose)\\n \\n #base_tag = '%s\\\\t%s\\\\t' %(filename_metadata['holdout_method'],filename_metadata['prediction_method'])\\n #tags = [base_tag+'all_results']\\n if 'file_type' in pool_by:\\n pool_by.remove('file_type') #we do this manually at the end\\n combined_tag = ['all']*len(file_name_field_order.keys())\\n for field in file_name_field_order.keys():\\n #print combined_tag\\n #print file_name_field_order\\n idx = file_name_field_order[field]\\n #print idx\\n if field in pool_by:\\n combined_tag[idx] = filename_metadata[field]\\n tags=[file_name_delimiter.join(combined_tag)]\\n \\n if verbose:\\n print \\\"Pooling by:\\\", pool_by\\n print \\\"Combined tags:\\\",tags\\n \\n pooled_observations,pooled_expectations =\\\\\\n update_pooled_data(obs_table,exp_table,tags,pooled_observations,\\\\\\n pooled_expectations,str(file_number),verbose=verbose)\\n file_number += 1\\n\\n return pooled_observations,pooled_expectations\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def test_add_node_to_pool_with_large_ppseqno_diff_views(do_view_change, looper, txnPoolNodeSet, tconf, sdk_pool_handle,\\n sdk_wallet_steward, tdir, allPluginsPath):\\n\\n ensure_several_view_change(looper, txnPoolNodeSet, do_view_change, custom_timeout=tconf.NEW_VIEW_TIMEOUT)\\n\\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\\n big_ppseqno = cur_ppseqno + tconf.LOG_SIZE * 2 + 2300\\n assert (big_ppseqno > cur_ppseqno)\\n\\n # ensure pool is working properly\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\\n\\n _set_ppseqno(txnPoolNodeSet, big_ppseqno)\\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\\n assert (big_ppseqno == cur_ppseqno)\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n\\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\\n\\n\\n\\n # Disable view change after adding new node as it will not be able to finish due to fake ppSeqNo set\\n for n in txnPoolNodeSet:\\n n.write_manager.node_reg_handler.internal_bus = None\\n\\n new_steward_name = \\\"testClientSteward\\\" + randomString(4)\\n new_node_name = \\\"TestTheta\\\" + randomString(4)\\n new_steward_wallet_handle, new_node = sdk_add_new_steward_and_node(\\n looper, sdk_pool_handle, sdk_wallet_steward,\\n new_steward_name, new_node_name, tdir, tconf,\\n allPluginsPath=allPluginsPath)\\n txnPoolNodeSet.append(new_node)\\n looper.run(checkNodesConnected(txnPoolNodeSet))\\n\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n new_steward_wallet_handle,\\n sdk_pool_handle)\\n\\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\\n\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n\\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\",\n \"def test(shipment):\\n shipment.unload_ships()\\n ships = shipment.ships.values()\\n\\n zookeepers = build_zookeeper_cluster(filter_quorum_ships(ships))\\n\\n elasticsearches = []\\n for ship in ships:\\n elasticsearch = create_elasticsearch(clustername='testcluster', version='1.4.1')\\n kibana = create_kibana()\\n nginx = create_nginx_proxy()\\n\\n # Place all containers on the same ship\\n ship.place(elasticsearch)\\n ship.place(kibana)\\n ship.place(nginx)\\n\\n # Adjust memory to prevent OOM when running on the laptop\\n elasticsearch.memory = min(ship.memory, 128*1024*1024)\\n\\n # We will use Zookeeper for master discovery\\n attach_zookeepers_to_elasticsearch(elasticsearch, zookeepers)\\n\\n # Nginx will terminate https and proxy requests to Elasticsearch and Kibana\\n attach_upstreams_to_nginx(nginx, upstreams=[\\n (elasticsearch.doors['http'], 9200, 9443),\\n (kibana.doors['http'], 8080, 8443),\\n ])\\n\\n # Expose nginx ports before attaching it to Kibana\\n nginx.expose_ports(list(range(2000, 4000)))\\n\\n # Kibana should use the same origin and just change port to access Elasticsearch\\n attach_elasticsearch_to_kibana(kibana, httpdoor=nginx.doors['elasticsearch.http'],\\n httpsdoor=nginx.doors['elasticsearch.https'])\\n\\n # Save elasticsearches to clusterize them later\\n elasticsearches.append(elasticsearch)\\n\\n # Let Elasticsearches know about each other\\n clusterize_elasticsearches(elasticsearches)\\n\\n # Expose all unexposed ports\\n shipment.expose_ports(list(range(51000, 51100)))\",\n \"def _check_bam_index_and_copy(\\n samtools_exe,singularity_image,bam_file,list_of_analysis,\\n use_ephemeral_space=True,threads=1,dry_run=False):\\n try:\\n output_temp_dirs = dict()\\n check_file_path(bam_file)\\n if not isinstance(list_of_analysis,list) or \\\\\\n len(list_of_analysis)==0:\\n raise TypeError('Expecing a list of analysis names for copy bam')\\n bai_file = '{0}.bai'.format(bam_file) # check bam index path\\n if not os.path.exists(bai_file): # create index in not found\\n _ = \\\\\\n index_bam_or_cram(\\n samtools_exe=samtools_exe,\\n input_path=bam_file,\\n threads=threads,\\n singularity_image=singularity_image,\\n dry_run=dry_run)\\n if not dry_run:\\n check_file_path(bai_file) # check final bam index\\n for analysis_name in list_of_analysis:\\n temp_dir = \\\\\\n get_temp_dir(use_ephemeral_space=use_ephemeral_space)\\n temp_bam = \\\\\\n os.path.join(temp_dir,os.path.basename(bam_file))\\n temp_bai = \\\\\\n os.path.join(temp_dir,os.path.basename(bai_file))\\n copy_local_file(\\n bam_file,temp_bam)\\n if not dry_run:\\n copy_local_file(\\n bai_file,temp_bai)\\n output_temp_dirs.\\\\\\n update({analysis_name:temp_bam})\\n if len(output_temp_dirs.keys())==0:\\n raise ValueError(\\n 'No output temp bam path found for input {0}'\\\\\\n .format(bam_file))\\n return output_temp_dirs\\n except Exception as e:\\n raise ValueError(\\n 'Failed to copy bam and index, error: {0}'.format(e))\",\n \"def test_9_node_positional_itegrity(self):\\n ring = ConsistentHashRing([])\\n for n in range(9):\\n ring.add_node((\\\"192.168.10.%s\\\" % str(10+n),\\\"%s\\\" % str(10+n)))\\n self.assertEqual(\\n len([n[0] for n in ring.ring]),\\n len(set([n[0] for n in ring.ring])))\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_data_source_soaps_count_get(self):\\n pass\",\n \"def test_delete_collection_cluster_resource_quota(self):\\n pass\",\n \"async def test_change_pools(self, setup, trusted_and_fee, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n pool_a_ph = receive_address[1]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_b_ph = await wallets[1].get_new_puzzlehash()\\n full_node_api = full_nodes[0]\\n\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n WAIT_SECS = 200\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n pool_a_ph, \\\"https://pool-a.org\\\", 5, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"FARMING_TO_POOL\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status.target is None\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n assert pw_info.current.pool_url == \\\"https://pool-a.org\\\"\\n assert pw_info.current.relative_lock_height == 5\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_b_ph,\\n \\\"https://pool-b.org\\\",\\n 10,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n\\n async def status_is_leaving():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving)\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n assert pw_info.current.pool_url == \\\"https://pool-b.org\\\"\\n assert pw_info.current.relative_lock_height == 10\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_index_stability(self, example_staypoints):\\n sp = example_staypoints\\n sp2, locs = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=10, num_samples=2, distance_metric=\\\"haversine\\\", agg_level=\\\"user\\\"\\n )\\n assert sp.index.equals(sp2.index)\",\n \"def show_pool(self, pool, **_params):\\r\\n return self.get(self.pool_path % (pool), params=_params)\",\n \"def test_get_placement_w_exception(self, mock__get_nslcmop,\\n mock__get_nsd,\\n mock__get_vim_accounts,\\n mock_create_ns_placement_data,\\n mock_do_placement_computation):\\n server = self.serverSetup()\\n\\n server.msgBus.aiowrite = _async_mock()\\n mock__get_nsd.return_value = nsd_from_db\\n mock__get_nsd.side_effect = RuntimeError('kaboom!')\\n mock__get_vim_accounts.return_value = list_of_vims\\n mock_do_placement_computation.return_value = \\\\\\n [{'vimAccountId': 'bbbbbbbb-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '1'},\\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '2'},\\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '3'}]\\n\\n _run(server.get_placement(nslcmop_record_w_pinning['id']))\\n self.assertTrue(server.msgBus.aiowrite.mock.called)\\n args, kwargs = server.msgBus.aiowrite.mock.call_args\\n rsp_payload = args[2]\\n expected_keys = {'placement'}\\n self.assertEqual(expected_keys, set(rsp_payload.keys()), \\\"placement response missing keys\\\")\\n self.assertIs(type(rsp_payload['placement']['vnf']), list, 'vnf not a list')\\n self.assertEqual([], rsp_payload['placement']['vnf'], 'vnf list not empty')\\n self.assertEqual(nslcmop_record_w_pinning['id'], rsp_payload['placement']['nslcmopId'], \\\"nslcmopId invalid\\\")\",\n \"def test_replace_cluster_policy(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84751886","0.8132446","0.80617833","0.80411273","0.74651307","0.707621","0.6979327","0.68828","0.6788973","0.6761283","0.6760841","0.6421319","0.6332053","0.6197863","0.601423","0.59699273","0.578675","0.5785175","0.5685915","0.56655633","0.5647678","0.55837846","0.55596685","0.5473192","0.547152","0.5449656","0.5410674","0.53838277","0.5369926","0.536226","0.53157747","0.52717286","0.52676886","0.5257613","0.5257598","0.5255412","0.5254403","0.5248712","0.5238985","0.52256495","0.52256495","0.5225593","0.52192765","0.52018607","0.51947325","0.5188591","0.51774806","0.517728","0.51703966","0.5168805","0.5159214","0.5089136","0.50799733","0.50751525","0.5071313","0.5071158","0.5068024","0.50674474","0.50634277","0.5060016","0.5047723","0.5042286","0.50339913","0.50324607","0.50317997","0.5027146","0.5020918","0.5019704","0.5018197","0.5012512","0.49988255","0.4995307","0.4994538","0.49808455","0.49804062","0.49802643","0.4975587","0.4974198","0.49682522","0.49660605","0.49584806","0.49530345","0.49399596","0.49335605","0.49205965","0.49195746","0.49165937","0.4899252","0.48968366","0.4892567","0.4891403","0.48860955","0.48742288","0.4873007","0.48638338","0.48624507","0.48514092","0.48409197","0.4838934","0.48329258"],"string":"[\n \"0.84751886\",\n \"0.8132446\",\n \"0.80617833\",\n \"0.80411273\",\n \"0.74651307\",\n \"0.707621\",\n \"0.6979327\",\n \"0.68828\",\n \"0.6788973\",\n \"0.6761283\",\n \"0.6760841\",\n \"0.6421319\",\n \"0.6332053\",\n \"0.6197863\",\n \"0.601423\",\n \"0.59699273\",\n \"0.578675\",\n \"0.5785175\",\n \"0.5685915\",\n \"0.56655633\",\n \"0.5647678\",\n \"0.55837846\",\n \"0.55596685\",\n \"0.5473192\",\n \"0.547152\",\n \"0.5449656\",\n \"0.5410674\",\n \"0.53838277\",\n \"0.5369926\",\n \"0.536226\",\n \"0.53157747\",\n \"0.52717286\",\n \"0.52676886\",\n \"0.5257613\",\n \"0.5257598\",\n \"0.5255412\",\n \"0.5254403\",\n \"0.5248712\",\n \"0.5238985\",\n \"0.52256495\",\n \"0.52256495\",\n \"0.5225593\",\n \"0.52192765\",\n \"0.52018607\",\n \"0.51947325\",\n \"0.5188591\",\n \"0.51774806\",\n \"0.517728\",\n \"0.51703966\",\n \"0.5168805\",\n \"0.5159214\",\n \"0.5089136\",\n \"0.50799733\",\n \"0.50751525\",\n \"0.5071313\",\n \"0.5071158\",\n \"0.5068024\",\n \"0.50674474\",\n \"0.50634277\",\n \"0.5060016\",\n \"0.5047723\",\n \"0.5042286\",\n \"0.50339913\",\n \"0.50324607\",\n \"0.50317997\",\n \"0.5027146\",\n \"0.5020918\",\n \"0.5019704\",\n \"0.5018197\",\n \"0.5012512\",\n \"0.49988255\",\n \"0.4995307\",\n \"0.4994538\",\n \"0.49808455\",\n \"0.49804062\",\n \"0.49802643\",\n \"0.4975587\",\n \"0.4974198\",\n \"0.49682522\",\n \"0.49660605\",\n \"0.49584806\",\n \"0.49530345\",\n \"0.49399596\",\n \"0.49335605\",\n \"0.49205965\",\n \"0.49195746\",\n \"0.49165937\",\n \"0.4899252\",\n \"0.48968366\",\n \"0.4892567\",\n \"0.4891403\",\n \"0.48860955\",\n \"0.48742288\",\n \"0.4873007\",\n \"0.48638338\",\n \"0.48624507\",\n \"0.48514092\",\n \"0.48409197\",\n \"0.4838934\",\n \"0.48329258\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9608631"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81379,"cells":{"query":{"kind":"string","value":"Test case for mount_status_nas_share"},"document":{"kind":"string","value":"def test_mount_status_nas_share(self):\n pass"},"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_mount_status_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_destroy_nas_share_by_pool(self):\n pass","def test_get_drive_mount_point_name_unique_id_exists(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n gfs._unique_id = 0\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n gfs._unique_id = None\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_index_nas_shares_by_pool(self):\n pass","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def _ensure_share_mounted(self, nfs_share, mount_path=None):\n mnt_flags = []\n if self.shares.get(nfs_share) is not None:\n mnt_flags = self.shares[nfs_share].split()\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\n for attempt in range(num_attempts):\n try:\n if mount_path is None:\n self._remotefsclient.mount(nfs_share, mnt_flags)\n else:\n if mount_path in self._remotefsclient._read_mounts():\n LOG.info('Already mounted: %s', mount_path)\n return\n\n fileutils.ensure_tree(mount_path)\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\n mnt_flags)\n return\n except Exception as e:\n if attempt == (num_attempts - 1):\n LOG.error('Mount failure for %(share)s after '\n '%(count)d attempts.',\n {'share': nfs_share,\n 'count': num_attempts})\n raise exception.NfsException(six.text_type(e))\n LOG.warning(\n 'Mount attempt %(attempt)d failed: %(error)s. '\n 'Retrying mount ...',\n {'attempt': attempt, 'error': e})\n greenthread.sleep(1)","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def __init__(self, win_server, share_folder, mount_point, user, password):\n \n share_folder = share_folder.replace(\"/\", \"\\\\\")\n network_folder = r'//%s/%s' %(win_server, share_folder)\n\n print('Mount_point - %s' %(mount_point))\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\n self.mount_point = mount_point\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\n self.success = []\n self.error = []\n\n mount_cmd = \"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\"\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\n mount_point=mount_point,\n user=user,\n password=password)\n self.umount_cmd = \"umount {mount_point}\".format(mount_point=mount_point)","def fs_ok(fs_info):\n if fs_info.mountpoint == '/':\n return True\n\n if (fs_info.device == fs_info.fstype or fs_info.fstype == 'nullfs' or\n '/docker' in fs_info.mountpoint or\n fs_info.mountpoint.startswith('/etc') or\n fs_info.mountpoint.startswith('/lib/modules')):\n return False\n\n if fs_info.device.startswith('/dev/'):\n return True\n\n return False","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def mount_cifs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n share_name = share_config.get('share_name')\n remote_host = share_config.get('remote_host')\n if remote_host and share_name and mount_point:\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\n self.cmd(command)","def testMountCommand(self):\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\n mountPath = tempfile.mkdtemp()\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\n File().getLocalFilePath(self.file))\n self.assertTrue(os.path.exists(filePath))\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if not os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n self.assertFalse(os.path.exists(filePath))\n os.rmdir(mountPath)\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)","def test_HYD965(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpBadRequest(response)","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def _mount_point_exists(self, mountpoint):\n cmd = ['dir', mountpoint]\n logger.debug('running command: %s' % (' '.join(cmd)))\n stdout, stderr, retval = self._run_cli_process(cmd)\n\n if not retval:\n logger.debug(\"mountpoint %s ready\" % mountpoint)\n else:\n logger.debug(\"mountpoint %s reported not ready with error '%s'\" %\n (mountpoint, stderr.strip()))\n\n return not retval","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_get_drive_mount_point_name_unique_id_None(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_empty(self):\n mount_fs = MountFS()\n self.assertEqual(mount_fs.getinfo(''), {})\n self.assertEqual(mount_fs.getxattr('', 'yo'), None)\n self.assertEqual(mount_fs.listdir(), [])\n self.assertEqual(list(mount_fs.ilistdir()), [])","def _check_mounted_system(self):\n res = self.su_cmd('touch /system/.dwarf_check')\n if res == '':\n res = self._do_adb_command('shell ls -la /system')\n if '.dwarf_check' in res:\n res = self.su_cmd('rm /system/.dwarf_check')\n if res == '':\n return True\n elif res == 'Read-only file system':\n return False\n\n return False","def test_mountfile(self):\n quote = b\"\"\"If you wish to make an apple pie from scratch, you must first invent the universe.\"\"\"\n mem_fs = MemoryFS()\n mem_fs.makedir('foo')\n mem_fs.setcontents('foo/bar.txt', quote)\n foo_dir = mem_fs.opendir('foo')\n\n mount_fs = MountFS()\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\n\n self.assertTrue(mount_fs.isdir('/'))\n self.assertTrue(mount_fs.isdir('./'))\n self.assertTrue(mount_fs.isdir(''))\n\n # Check we can see the mounted file in the dir list\n self.assertEqual(mount_fs.listdir(), [\"bar.txt\"])\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\n self.assertTrue(mount_fs.exists('bar.txt'))\n self.assertTrue(mount_fs.isfile('bar.txt'))\n self.assertTrue(not mount_fs.isdir('bar.txt'))\n\n # Check open and getinfo callables\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\n\n # Check changes are written back\n mem_fs.setcontents('foo/bar.txt', 'baz')\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\n\n # Check changes are written to the original fs\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\n\n # Check unmount\n self.assertTrue(mount_fs.unmount(\"bar.txt\"))\n self.assertEqual(mount_fs.listdir(), [])\n self.assertTrue(not mount_fs.exists('bar.txt'))\n\n # Check unount a second time is a null op, and returns False\n self.assertFalse(mount_fs.unmount(\"bar.txt\"))","def test_set_state_full(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n mgt_uri = \"/api/target/%s/\" % self.mgt.id\n with mock.patch(\"chroma_core.models.Command.set_state\", mock.Mock(return_value=None)):\n self.api_set_state_full(mgt_uri, \"unmounted\")\n Command.set_state.assert_called_once()","def test_format():\n device = \"/dev/sdX1\"\n mock = MagicMock(return_value=0)\n with patch.dict(disk.__salt__, {\"cmd.retcode\": mock}), patch(\n \"salt.utils.path.which\", MagicMock(return_value=True)\n ):\n assert disk.format_(device) is True","def test_mount_failure(self):\n with prepared_image_file(create_filesystem=False):\n program = RsyncSystemBackup(\n crypto_device=CRYPTO_NAME,\n destination=os.path.join(MOUNT_POINT, 'latest'),\n mount_point=MOUNT_POINT,\n )\n # When `mount' fails it should exit with a nonzero exit code,\n # thereby causing executor to raise an ExternalCommandFailed\n # exception that obscures the FailedToMountError exception that\n # we're interested in. The check=False option enables our\n # `last resort error handling' code path to be reached.\n program.destination_context.options['check'] = False\n self.assertRaises(FailedToMountError, program.execute)","def check_filesystem(ssh_connection, disk_fmt, disk):\n if disk_fmt == \"squashfs\":\n return\n cmd = \"fsck.{} -n {}\".format(disk_fmt, disk)\n exit_code, _, stderr = ssh_connection.run(cmd)\n assert exit_code == 0, stderr","def _get_mount_status(self, vm=None):\n result = Shell.run(f\"multipass info {vm} --format=json\")\n\n if f'instance \"{vm}\" does not exist' in result:\n dict_result = {\n 'name': vm,\n 'status': \"instance does not exist\"\n }\n else:\n result = json.loads(result)\n dict_result = {\n 'name': vm,\n 'status': result[\"info\"][vm]['state'],\n 'mounts': result[\"info\"][vm]['mounts']\n }\n return dict_result","def test_items_are_mounted(self):\n response2 = self.client.get(\"/importer/design26/models.py\")\n self.assertEquals(response2.status_code, 200)","def is_afs_mounted():\n return afs_mountpoint() is not None","def test_verify_ssh_access_with_root_works(driver):","def check_mount_state(self, nodes=None):\n state = {\n \"mounted\": NodeSet(),\n \"unmounted\": NodeSet(),\n \"nodirectory\": NodeSet()\n }\n if not nodes:\n nodes = NodeSet.fromlist(self.hosts)\n check_mounted = NodeSet()\n\n # Detect which hosts have mount point directories defined\n command = \"test -d {0} -a ! -L {0}\".format(self.mount_dir.value)\n retcodes = pcmd(nodes, command, expect_rc=None)\n for retcode, hosts in list(retcodes.items()):\n if retcode == 0:\n check_mounted.add(hosts)\n else:\n command = \"grep 'dfuse {}' /proc/mounts\" .format(self.mount_dir.value)\n retcodes = pcmd(hosts, command, expect_rc=None)\n for ret_code, host_names in list(retcodes.items()):\n if ret_code == 0:\n check_mounted.add(host_names)\n else:\n state[\"nodirectory\"].add(host_names)\n\n if check_mounted:\n # Detect which hosts with mount point directories have it mounted as a fuseblk device\n command = \"stat -c %T -f {0} | grep -v fuseblk\".format(self.mount_dir.value)\n retcodes = pcmd(check_mounted, command, expect_rc=None)\n for retcode, hosts in list(retcodes.items()):\n if retcode == 1:\n state[\"mounted\"].add(hosts)\n else:\n state[\"unmounted\"].add(hosts)\n\n return state","def test_dashboards_v2_share(self):\n pass","def testSupported2(t, env):\n c = env.c1.new_client(env.testname(t))\n sess = c.create_session()\n\n # GETFH after do a SECINFO_NO_NAME should get error NFS4ERR_NOFILEHANDLE\n res = sess.compound([op.putrootfh(), op.secinfo_no_name(0), op.getfh()])\n print res\n check(res, NFS4ERR_NOFILEHANDLE)","def test_update_volume_stats_error(self):\n self._fail_host_storage = True\n actual = self.driver.get_volume_stats(True)\n self.assertEqual('HGST', actual['vendor_name'])\n self.assertEqual('hgst', actual['storage_protocol'])\n self.assertEqual('unknown', actual['total_capacity_gb'])\n self.assertEqual('unknown', actual['free_capacity_gb'])\n self.assertEqual(0, actual['reserved_percentage'])","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_least_busy_host_gets_volume(self):\n volume1 = self.start_service('volume', host='host1')\n volume2 = self.start_service('volume', host='host2')\n volume_id1 = self._create_volume()\n volume1.create_volume(self.context, volume_id1)\n volume_id2 = self._create_volume()\n host = self.scheduler.driver.schedule_create_volume(self.context,\n volume_id2)\n self.assertEqual(host, 'host2')\n volume1.delete_volume(self.context, volume_id1)\n db.volume_destroy(self.context, volume_id2)\n volume1.kill()\n volume2.kill()","def test_update_volume_stats_cached(self):\n self._fail_host_storage = True\n actual = self.driver.get_volume_stats(False)\n self.assertEqual('HGST', actual['vendor_name'])\n self.assertEqual('hgst', actual['storage_protocol'])\n self.assertEqual(90, actual['total_capacity_gb'])\n self.assertEqual(87, actual['free_capacity_gb'])\n self.assertEqual(0, actual['reserved_percentage'])","def test_check_disk_space_sufficient(self):\n self.assertTrue(self.command.check_disk_space(1, self.temp_dir))\n self.assertTrue(self.command.check_disk_space(\n 1, self.temp_dir,\n label=\"Hello\", context=\"Contextual detail\", die=True))","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def is_mounted(self):\n try:\n _ = openmediavault.subprocess.check_output(\n [\n 'findmnt',\n '--canonicalize',\n '--first-only',\n '--noheadings',\n '--raw',\n '--nofsroot',\n self.canonical_device_file,\n ]\n )\n return True\n except subprocess.CalledProcessError:\n pass\n return False","def is_guest_sharing_auto_mount(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))","def test_ls_no_shareddir():\n\n with bad_fixture() as root:\n assert next(pipeline.ls(root=root), None) is None","def _fsal_hook(self, base, share, access):\n return {\"Hostname\": self.gluster_manager.host,\n \"Volume\": self.gluster_manager.volume,\n \"Volpath\": \"/\" + share['name']}","def ensure_share(self, context, share, share_server=None):\n pass","def nases(statusdb):\n disk_space = status.get_nases_disk_space()\n if statusdb:\n status.update_status_db(disk_space, server_type='nas')","def share():\n return True","def test_ucs_get_rackmount(self):\n api_data = request(\"get\", \"/rackmount\")\n self.assertEqual(api_data['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\n self.assertGreater(len(api_data[\"json\"]), 0, \"Found zero Rackmounts\")\n # TO DO more in depth testing for the returned content such as mac validation, etc...","def mount(self, fstype, export, vol_name, mountpoint, instance, options):\n\n # NOTE(mdbooth): mount() may currently be called multiple times for a\n # single attachment. Any operation which calls\n # LibvirtDriver._hard_reboot will re-attach volumes which are probably\n # already attached, resulting in multiple mount calls.\n\n LOG.debug('_HostMountState.mount(fstype=%(fstype)s, '\n 'export=%(export)s, vol_name=%(vol_name)s, %(mountpoint)s, '\n 'options=%(options)s) generation %(gen)s',\n {'fstype': fstype, 'export': export, 'vol_name': vol_name,\n 'mountpoint': mountpoint, 'options': options,\n 'gen': self.generation}, instance=instance)\n with self._get_locked(mountpoint) as mount:\n if os.path.ismount(mountpoint):\n LOG.debug(('Mounting %(mountpoint)s generation %(gen)s, '\n 'mountpoint already mounted'),\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)\n else:\n LOG.debug('Mounting %(mountpoint)s generation %(gen)s',\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)\n\n fileutils.ensure_tree(mountpoint)\n\n try:\n nova.privsep.fs.mount(fstype, export, mountpoint, options)\n except processutils.ProcessExecutionError:\n # Check to see if mountpoint is mounted despite the error\n # eg it was already mounted\n if os.path.ismount(mountpoint):\n # We're not going to raise the exception because we're\n # in the desired state anyway. However, this is still\n # unusual so we'll log it.\n LOG.exception(\n 'Error mounting %(fstypes export %(export)s on '\n '%(mountpoint)s. Continuing because mountpount is '\n 'mounted despite this.',\n {'fstype': fstype, 'export': export,\n 'mountpoint': mountpoint}, instance=instance)\n else:\n # If the mount failed there's no reason for us to keep\n # a record of it. It will be created again if the\n # caller retries.\n\n # Delete while holding lock\n del self.mountpoints[mountpoint]\n\n raise\n\n mount.add_attachment(vol_name, instance.uuid)\n\n LOG.debug('_HostMountState.mount() for %(mountpoint)s '\n 'generation %(gen)s completed successfully',\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_format_():\n device = \"/dev/sdX1\"\n mock = MagicMock(return_value=0)\n with patch.dict(disk.__salt__, {\"cmd.retcode\": mock}):\n disk.format_(device=device)\n mock.assert_any_call([\"mkfs\", \"-t\", \"ext4\", device], ignore_retcode=True)","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def _update_volume_stats(self):\n LOG.debug('Updating volume stats')\n total_space = 0\n free_space = 0\n share = None\n for _share in self._mounted_shares:\n if self.shares_with_capacities[_share]['free'] > free_space:\n free_space = self.shares_with_capacities[_share]['free']\n total_space = self.shares_with_capacities[_share]['total']\n share = _share\n\n location_info = '%(driver)s:%(share)s' % {\n 'driver': self.__class__.__name__,\n 'share': share\n }\n nms_url = self.share2nms[share].url\n self._stats = {\n 'vendor_name': 'Nexenta',\n 'dedup': self.volume_deduplication,\n 'compression': self.volume_compression,\n 'description': self.volume_description,\n 'nms_url': nms_url,\n 'ns_shares': self.shares_with_capacities,\n 'driver_version': self.VERSION,\n 'storage_protocol': constants.NFS,\n 'total_capacity_gb': total_space,\n 'free_capacity_gb': free_space,\n 'reserved_percentage': self.configuration.reserved_percentage,\n 'QoS_support': False,\n 'location_info': location_info,\n 'volume_backend_name': self.backend_name,\n 'nfs_mount_point_base': self.nfs_mount_point_base\n }","def test_read_cluster_resource_quota_status(self):\n pass","def umount_cifs_share(self, **kwargs):\n mount_point = kwargs.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def umount_nfs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def step_impl(context):\n log.info(\"====> verify the NSA files are not placed under container_nsa directory\")\n\n nsa_container = get_nsa_container_string(context)\n container_nsa_path = \"/tmp/cme/local/GFD/{nsa_container}/container_nsa\".format(nsa_container=nsa_container)\n log.info(\" ****> DEBUG: nsa container path is: {container_nsa_path}\".format(container_nsa_path=container_nsa_path))\n\n command = \"cd {container_nsa_path}; ls -a | wc -l\".format(container_nsa_path=container_nsa_path)\n if \"2\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\n log.info(\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\")\n else:\n assert False, \" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\"","def loadMountData(self, status):\n\n if status and not self.mountUp:\n self.mount.getFW()\n self.mount.getLocation()\n self.mount.cycleSetting()\n self.mainW.refreshName()\n self.mainW.refreshModel()\n self.mount.getTLE()\n self.mountUp = True\n return True\n elif not status and self.mountUp:\n location = self.mount.obsSite.location\n self.mount.resetData()\n self.mount.obsSite.location = location\n self.mountUp = False\n return False\n\n return status","def generate_cifs_table(cls) -> ty.List[ty.Tuple[str, str]]:\n exit_code, output = sp.getstatusoutput(\"mount\")\n return cls.parse_mount_table(exit_code, output)","def snap_status(mnode, snapname=\"\", volname=\"\"):\n\n if snapname != \"\" and volname != \"\":\n g.log.error(\"Incorrect cmd. snap status cli accepts either \"\n \"snapname or volname\")\n return (-1, None, None)\n\n if volname != '':\n volname = \"volume %s\" % volname\n\n cmd = \"gluster snapshot status %s %s\" % (snapname, volname)\n return g.run(mnode, cmd)","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_dashboards_v2_list_shares(self):\n pass","def testMakeMountCommands(self):\n self.maxDiff = None\n container_obj = self.explorer_object.GetContainer(\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(x) for x in commands]\n expected_commands = [\n (\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\n 'docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '-init=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\n '=ro+wh none /mnt'),\n (\n '/bin/mount --bind -o ro test_data/docker/volumes/'\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\n '_data /mnt/var/jenkins_home')\n ]\n self.assertEqual(expected_commands, commands)"],"string":"[\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_get_drive_mount_point_name_unique_id_exists(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n gfs._unique_id = 0\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n gfs._unique_id = None\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def _ensure_share_mounted(self, nfs_share, mount_path=None):\\n mnt_flags = []\\n if self.shares.get(nfs_share) is not None:\\n mnt_flags = self.shares[nfs_share].split()\\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\\n for attempt in range(num_attempts):\\n try:\\n if mount_path is None:\\n self._remotefsclient.mount(nfs_share, mnt_flags)\\n else:\\n if mount_path in self._remotefsclient._read_mounts():\\n LOG.info('Already mounted: %s', mount_path)\\n return\\n\\n fileutils.ensure_tree(mount_path)\\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\\n mnt_flags)\\n return\\n except Exception as e:\\n if attempt == (num_attempts - 1):\\n LOG.error('Mount failure for %(share)s after '\\n '%(count)d attempts.',\\n {'share': nfs_share,\\n 'count': num_attempts})\\n raise exception.NfsException(six.text_type(e))\\n LOG.warning(\\n 'Mount attempt %(attempt)d failed: %(error)s. '\\n 'Retrying mount ...',\\n {'attempt': attempt, 'error': e})\\n greenthread.sleep(1)\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def __init__(self, win_server, share_folder, mount_point, user, password):\\n \\n share_folder = share_folder.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n network_folder = r'//%s/%s' %(win_server, share_folder)\\n\\n print('Mount_point - %s' %(mount_point))\\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\\n self.mount_point = mount_point\\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\\n self.success = []\\n self.error = []\\n\\n mount_cmd = \\\"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\\\"\\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\\n mount_point=mount_point,\\n user=user,\\n password=password)\\n self.umount_cmd = \\\"umount {mount_point}\\\".format(mount_point=mount_point)\",\n \"def fs_ok(fs_info):\\n if fs_info.mountpoint == '/':\\n return True\\n\\n if (fs_info.device == fs_info.fstype or fs_info.fstype == 'nullfs' or\\n '/docker' in fs_info.mountpoint or\\n fs_info.mountpoint.startswith('/etc') or\\n fs_info.mountpoint.startswith('/lib/modules')):\\n return False\\n\\n if fs_info.device.startswith('/dev/'):\\n return True\\n\\n return False\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def mount_cifs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n share_name = share_config.get('share_name')\\n remote_host = share_config.get('remote_host')\\n if remote_host and share_name and mount_point:\\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\\n self.cmd(command)\",\n \"def testMountCommand(self):\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\\n mountPath = tempfile.mkdtemp()\\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\\n File().getLocalFilePath(self.file))\\n self.assertTrue(os.path.exists(filePath))\\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if not os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n self.assertFalse(os.path.exists(filePath))\\n os.rmdir(mountPath)\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\",\n \"def test_HYD965(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpBadRequest(response)\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def _mount_point_exists(self, mountpoint):\\n cmd = ['dir', mountpoint]\\n logger.debug('running command: %s' % (' '.join(cmd)))\\n stdout, stderr, retval = self._run_cli_process(cmd)\\n\\n if not retval:\\n logger.debug(\\\"mountpoint %s ready\\\" % mountpoint)\\n else:\\n logger.debug(\\\"mountpoint %s reported not ready with error '%s'\\\" %\\n (mountpoint, stderr.strip()))\\n\\n return not retval\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_get_drive_mount_point_name_unique_id_None(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_empty(self):\\n mount_fs = MountFS()\\n self.assertEqual(mount_fs.getinfo(''), {})\\n self.assertEqual(mount_fs.getxattr('', 'yo'), None)\\n self.assertEqual(mount_fs.listdir(), [])\\n self.assertEqual(list(mount_fs.ilistdir()), [])\",\n \"def _check_mounted_system(self):\\n res = self.su_cmd('touch /system/.dwarf_check')\\n if res == '':\\n res = self._do_adb_command('shell ls -la /system')\\n if '.dwarf_check' in res:\\n res = self.su_cmd('rm /system/.dwarf_check')\\n if res == '':\\n return True\\n elif res == 'Read-only file system':\\n return False\\n\\n return False\",\n \"def test_mountfile(self):\\n quote = b\\\"\\\"\\\"If you wish to make an apple pie from scratch, you must first invent the universe.\\\"\\\"\\\"\\n mem_fs = MemoryFS()\\n mem_fs.makedir('foo')\\n mem_fs.setcontents('foo/bar.txt', quote)\\n foo_dir = mem_fs.opendir('foo')\\n\\n mount_fs = MountFS()\\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\\n\\n self.assertTrue(mount_fs.isdir('/'))\\n self.assertTrue(mount_fs.isdir('./'))\\n self.assertTrue(mount_fs.isdir(''))\\n\\n # Check we can see the mounted file in the dir list\\n self.assertEqual(mount_fs.listdir(), [\\\"bar.txt\\\"])\\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\\n self.assertTrue(mount_fs.exists('bar.txt'))\\n self.assertTrue(mount_fs.isfile('bar.txt'))\\n self.assertTrue(not mount_fs.isdir('bar.txt'))\\n\\n # Check open and getinfo callables\\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\\n\\n # Check changes are written back\\n mem_fs.setcontents('foo/bar.txt', 'baz')\\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\\n\\n # Check changes are written to the original fs\\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\\n\\n # Check unmount\\n self.assertTrue(mount_fs.unmount(\\\"bar.txt\\\"))\\n self.assertEqual(mount_fs.listdir(), [])\\n self.assertTrue(not mount_fs.exists('bar.txt'))\\n\\n # Check unount a second time is a null op, and returns False\\n self.assertFalse(mount_fs.unmount(\\\"bar.txt\\\"))\",\n \"def test_set_state_full(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n mgt_uri = \\\"/api/target/%s/\\\" % self.mgt.id\\n with mock.patch(\\\"chroma_core.models.Command.set_state\\\", mock.Mock(return_value=None)):\\n self.api_set_state_full(mgt_uri, \\\"unmounted\\\")\\n Command.set_state.assert_called_once()\",\n \"def test_format():\\n device = \\\"/dev/sdX1\\\"\\n mock = MagicMock(return_value=0)\\n with patch.dict(disk.__salt__, {\\\"cmd.retcode\\\": mock}), patch(\\n \\\"salt.utils.path.which\\\", MagicMock(return_value=True)\\n ):\\n assert disk.format_(device) is True\",\n \"def test_mount_failure(self):\\n with prepared_image_file(create_filesystem=False):\\n program = RsyncSystemBackup(\\n crypto_device=CRYPTO_NAME,\\n destination=os.path.join(MOUNT_POINT, 'latest'),\\n mount_point=MOUNT_POINT,\\n )\\n # When `mount' fails it should exit with a nonzero exit code,\\n # thereby causing executor to raise an ExternalCommandFailed\\n # exception that obscures the FailedToMountError exception that\\n # we're interested in. The check=False option enables our\\n # `last resort error handling' code path to be reached.\\n program.destination_context.options['check'] = False\\n self.assertRaises(FailedToMountError, program.execute)\",\n \"def check_filesystem(ssh_connection, disk_fmt, disk):\\n if disk_fmt == \\\"squashfs\\\":\\n return\\n cmd = \\\"fsck.{} -n {}\\\".format(disk_fmt, disk)\\n exit_code, _, stderr = ssh_connection.run(cmd)\\n assert exit_code == 0, stderr\",\n \"def _get_mount_status(self, vm=None):\\n result = Shell.run(f\\\"multipass info {vm} --format=json\\\")\\n\\n if f'instance \\\"{vm}\\\" does not exist' in result:\\n dict_result = {\\n 'name': vm,\\n 'status': \\\"instance does not exist\\\"\\n }\\n else:\\n result = json.loads(result)\\n dict_result = {\\n 'name': vm,\\n 'status': result[\\\"info\\\"][vm]['state'],\\n 'mounts': result[\\\"info\\\"][vm]['mounts']\\n }\\n return dict_result\",\n \"def test_items_are_mounted(self):\\n response2 = self.client.get(\\\"/importer/design26/models.py\\\")\\n self.assertEquals(response2.status_code, 200)\",\n \"def is_afs_mounted():\\n return afs_mountpoint() is not None\",\n \"def test_verify_ssh_access_with_root_works(driver):\",\n \"def check_mount_state(self, nodes=None):\\n state = {\\n \\\"mounted\\\": NodeSet(),\\n \\\"unmounted\\\": NodeSet(),\\n \\\"nodirectory\\\": NodeSet()\\n }\\n if not nodes:\\n nodes = NodeSet.fromlist(self.hosts)\\n check_mounted = NodeSet()\\n\\n # Detect which hosts have mount point directories defined\\n command = \\\"test -d {0} -a ! -L {0}\\\".format(self.mount_dir.value)\\n retcodes = pcmd(nodes, command, expect_rc=None)\\n for retcode, hosts in list(retcodes.items()):\\n if retcode == 0:\\n check_mounted.add(hosts)\\n else:\\n command = \\\"grep 'dfuse {}' /proc/mounts\\\" .format(self.mount_dir.value)\\n retcodes = pcmd(hosts, command, expect_rc=None)\\n for ret_code, host_names in list(retcodes.items()):\\n if ret_code == 0:\\n check_mounted.add(host_names)\\n else:\\n state[\\\"nodirectory\\\"].add(host_names)\\n\\n if check_mounted:\\n # Detect which hosts with mount point directories have it mounted as a fuseblk device\\n command = \\\"stat -c %T -f {0} | grep -v fuseblk\\\".format(self.mount_dir.value)\\n retcodes = pcmd(check_mounted, command, expect_rc=None)\\n for retcode, hosts in list(retcodes.items()):\\n if retcode == 1:\\n state[\\\"mounted\\\"].add(hosts)\\n else:\\n state[\\\"unmounted\\\"].add(hosts)\\n\\n return state\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def testSupported2(t, env):\\n c = env.c1.new_client(env.testname(t))\\n sess = c.create_session()\\n\\n # GETFH after do a SECINFO_NO_NAME should get error NFS4ERR_NOFILEHANDLE\\n res = sess.compound([op.putrootfh(), op.secinfo_no_name(0), op.getfh()])\\n print res\\n check(res, NFS4ERR_NOFILEHANDLE)\",\n \"def test_update_volume_stats_error(self):\\n self._fail_host_storage = True\\n actual = self.driver.get_volume_stats(True)\\n self.assertEqual('HGST', actual['vendor_name'])\\n self.assertEqual('hgst', actual['storage_protocol'])\\n self.assertEqual('unknown', actual['total_capacity_gb'])\\n self.assertEqual('unknown', actual['free_capacity_gb'])\\n self.assertEqual(0, actual['reserved_percentage'])\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_least_busy_host_gets_volume(self):\\n volume1 = self.start_service('volume', host='host1')\\n volume2 = self.start_service('volume', host='host2')\\n volume_id1 = self._create_volume()\\n volume1.create_volume(self.context, volume_id1)\\n volume_id2 = self._create_volume()\\n host = self.scheduler.driver.schedule_create_volume(self.context,\\n volume_id2)\\n self.assertEqual(host, 'host2')\\n volume1.delete_volume(self.context, volume_id1)\\n db.volume_destroy(self.context, volume_id2)\\n volume1.kill()\\n volume2.kill()\",\n \"def test_update_volume_stats_cached(self):\\n self._fail_host_storage = True\\n actual = self.driver.get_volume_stats(False)\\n self.assertEqual('HGST', actual['vendor_name'])\\n self.assertEqual('hgst', actual['storage_protocol'])\\n self.assertEqual(90, actual['total_capacity_gb'])\\n self.assertEqual(87, actual['free_capacity_gb'])\\n self.assertEqual(0, actual['reserved_percentage'])\",\n \"def test_check_disk_space_sufficient(self):\\n self.assertTrue(self.command.check_disk_space(1, self.temp_dir))\\n self.assertTrue(self.command.check_disk_space(\\n 1, self.temp_dir,\\n label=\\\"Hello\\\", context=\\\"Contextual detail\\\", die=True))\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def is_mounted(self):\\n try:\\n _ = openmediavault.subprocess.check_output(\\n [\\n 'findmnt',\\n '--canonicalize',\\n '--first-only',\\n '--noheadings',\\n '--raw',\\n '--nofsroot',\\n self.canonical_device_file,\\n ]\\n )\\n return True\\n except subprocess.CalledProcessError:\\n pass\\n return False\",\n \"def is_guest_sharing_auto_mount(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))\",\n \"def test_ls_no_shareddir():\\n\\n with bad_fixture() as root:\\n assert next(pipeline.ls(root=root), None) is None\",\n \"def _fsal_hook(self, base, share, access):\\n return {\\\"Hostname\\\": self.gluster_manager.host,\\n \\\"Volume\\\": self.gluster_manager.volume,\\n \\\"Volpath\\\": \\\"/\\\" + share['name']}\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def nases(statusdb):\\n disk_space = status.get_nases_disk_space()\\n if statusdb:\\n status.update_status_db(disk_space, server_type='nas')\",\n \"def share():\\n return True\",\n \"def test_ucs_get_rackmount(self):\\n api_data = request(\\\"get\\\", \\\"/rackmount\\\")\\n self.assertEqual(api_data['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\\n self.assertGreater(len(api_data[\\\"json\\\"]), 0, \\\"Found zero Rackmounts\\\")\\n # TO DO more in depth testing for the returned content such as mac validation, etc...\",\n \"def mount(self, fstype, export, vol_name, mountpoint, instance, options):\\n\\n # NOTE(mdbooth): mount() may currently be called multiple times for a\\n # single attachment. Any operation which calls\\n # LibvirtDriver._hard_reboot will re-attach volumes which are probably\\n # already attached, resulting in multiple mount calls.\\n\\n LOG.debug('_HostMountState.mount(fstype=%(fstype)s, '\\n 'export=%(export)s, vol_name=%(vol_name)s, %(mountpoint)s, '\\n 'options=%(options)s) generation %(gen)s',\\n {'fstype': fstype, 'export': export, 'vol_name': vol_name,\\n 'mountpoint': mountpoint, 'options': options,\\n 'gen': self.generation}, instance=instance)\\n with self._get_locked(mountpoint) as mount:\\n if os.path.ismount(mountpoint):\\n LOG.debug(('Mounting %(mountpoint)s generation %(gen)s, '\\n 'mountpoint already mounted'),\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\\n else:\\n LOG.debug('Mounting %(mountpoint)s generation %(gen)s',\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\\n\\n fileutils.ensure_tree(mountpoint)\\n\\n try:\\n nova.privsep.fs.mount(fstype, export, mountpoint, options)\\n except processutils.ProcessExecutionError:\\n # Check to see if mountpoint is mounted despite the error\\n # eg it was already mounted\\n if os.path.ismount(mountpoint):\\n # We're not going to raise the exception because we're\\n # in the desired state anyway. However, this is still\\n # unusual so we'll log it.\\n LOG.exception(\\n 'Error mounting %(fstypes export %(export)s on '\\n '%(mountpoint)s. Continuing because mountpount is '\\n 'mounted despite this.',\\n {'fstype': fstype, 'export': export,\\n 'mountpoint': mountpoint}, instance=instance)\\n else:\\n # If the mount failed there's no reason for us to keep\\n # a record of it. It will be created again if the\\n # caller retries.\\n\\n # Delete while holding lock\\n del self.mountpoints[mountpoint]\\n\\n raise\\n\\n mount.add_attachment(vol_name, instance.uuid)\\n\\n LOG.debug('_HostMountState.mount() for %(mountpoint)s '\\n 'generation %(gen)s completed successfully',\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_format_():\\n device = \\\"/dev/sdX1\\\"\\n mock = MagicMock(return_value=0)\\n with patch.dict(disk.__salt__, {\\\"cmd.retcode\\\": mock}):\\n disk.format_(device=device)\\n mock.assert_any_call([\\\"mkfs\\\", \\\"-t\\\", \\\"ext4\\\", device], ignore_retcode=True)\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def _update_volume_stats(self):\\n LOG.debug('Updating volume stats')\\n total_space = 0\\n free_space = 0\\n share = None\\n for _share in self._mounted_shares:\\n if self.shares_with_capacities[_share]['free'] > free_space:\\n free_space = self.shares_with_capacities[_share]['free']\\n total_space = self.shares_with_capacities[_share]['total']\\n share = _share\\n\\n location_info = '%(driver)s:%(share)s' % {\\n 'driver': self.__class__.__name__,\\n 'share': share\\n }\\n nms_url = self.share2nms[share].url\\n self._stats = {\\n 'vendor_name': 'Nexenta',\\n 'dedup': self.volume_deduplication,\\n 'compression': self.volume_compression,\\n 'description': self.volume_description,\\n 'nms_url': nms_url,\\n 'ns_shares': self.shares_with_capacities,\\n 'driver_version': self.VERSION,\\n 'storage_protocol': constants.NFS,\\n 'total_capacity_gb': total_space,\\n 'free_capacity_gb': free_space,\\n 'reserved_percentage': self.configuration.reserved_percentage,\\n 'QoS_support': False,\\n 'location_info': location_info,\\n 'volume_backend_name': self.backend_name,\\n 'nfs_mount_point_base': self.nfs_mount_point_base\\n }\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def umount_cifs_share(self, **kwargs):\\n mount_point = kwargs.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def umount_nfs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def step_impl(context):\\n log.info(\\\"====> verify the NSA files are not placed under container_nsa directory\\\")\\n\\n nsa_container = get_nsa_container_string(context)\\n container_nsa_path = \\\"/tmp/cme/local/GFD/{nsa_container}/container_nsa\\\".format(nsa_container=nsa_container)\\n log.info(\\\" ****> DEBUG: nsa container path is: {container_nsa_path}\\\".format(container_nsa_path=container_nsa_path))\\n\\n command = \\\"cd {container_nsa_path}; ls -a | wc -l\\\".format(container_nsa_path=container_nsa_path)\\n if \\\"2\\\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\\n log.info(\\\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\\\")\\n else:\\n assert False, \\\" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\\\"\",\n \"def loadMountData(self, status):\\n\\n if status and not self.mountUp:\\n self.mount.getFW()\\n self.mount.getLocation()\\n self.mount.cycleSetting()\\n self.mainW.refreshName()\\n self.mainW.refreshModel()\\n self.mount.getTLE()\\n self.mountUp = True\\n return True\\n elif not status and self.mountUp:\\n location = self.mount.obsSite.location\\n self.mount.resetData()\\n self.mount.obsSite.location = location\\n self.mountUp = False\\n return False\\n\\n return status\",\n \"def generate_cifs_table(cls) -> ty.List[ty.Tuple[str, str]]:\\n exit_code, output = sp.getstatusoutput(\\\"mount\\\")\\n return cls.parse_mount_table(exit_code, output)\",\n \"def snap_status(mnode, snapname=\\\"\\\", volname=\\\"\\\"):\\n\\n if snapname != \\\"\\\" and volname != \\\"\\\":\\n g.log.error(\\\"Incorrect cmd. snap status cli accepts either \\\"\\n \\\"snapname or volname\\\")\\n return (-1, None, None)\\n\\n if volname != '':\\n volname = \\\"volume %s\\\" % volname\\n\\n cmd = \\\"gluster snapshot status %s %s\\\" % (snapname, volname)\\n return g.run(mnode, cmd)\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def testMakeMountCommands(self):\\n self.maxDiff = None\\n container_obj = self.explorer_object.GetContainer(\\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(x) for x in commands]\\n expected_commands = [\\n (\\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\\n 'docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '-init=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount --bind -o ro test_data/docker/volumes/'\\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\\n '_data /mnt/var/jenkins_home')\\n ]\\n self.assertEqual(expected_commands, commands)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9339884","0.86251044","0.7847734","0.77573013","0.7702383","0.75028086","0.7351555","0.73283494","0.7200713","0.69585705","0.68284434","0.68067634","0.6647951","0.65063286","0.6441414","0.6424272","0.6211882","0.59345067","0.5869384","0.5858923","0.585648","0.5828026","0.5814331","0.5809202","0.5792276","0.5791175","0.57801557","0.5769963","0.57667005","0.574211","0.57373536","0.5726387","0.5713751","0.56885964","0.5684259","0.5677187","0.5676685","0.5671711","0.5668394","0.56544405","0.5647273","0.561165","0.5607016","0.5601972","0.5599905","0.5598966","0.5590905","0.5569387","0.5542334","0.5539422","0.5530967","0.55236316","0.55079406","0.54972","0.5463206","0.54597074","0.54592216","0.54578024","0.5455274","0.5454903","0.5449084","0.54351246","0.5433596","0.5431824","0.54177296","0.5410018","0.5399981","0.5394631","0.5358127","0.53564614","0.53539056","0.535361","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53395075","0.53329027","0.5326552","0.53237534","0.5316236","0.53161746","0.5305577","0.52934456","0.5270017","0.5261946","0.52619094","0.5254521","0.52491766"],"string":"[\n \"0.9339884\",\n \"0.86251044\",\n \"0.7847734\",\n \"0.77573013\",\n \"0.7702383\",\n \"0.75028086\",\n \"0.7351555\",\n \"0.73283494\",\n \"0.7200713\",\n \"0.69585705\",\n \"0.68284434\",\n \"0.68067634\",\n \"0.6647951\",\n \"0.65063286\",\n \"0.6441414\",\n \"0.6424272\",\n \"0.6211882\",\n \"0.59345067\",\n \"0.5869384\",\n \"0.5858923\",\n \"0.585648\",\n \"0.5828026\",\n \"0.5814331\",\n \"0.5809202\",\n \"0.5792276\",\n \"0.5791175\",\n \"0.57801557\",\n \"0.5769963\",\n \"0.57667005\",\n \"0.574211\",\n \"0.57373536\",\n \"0.5726387\",\n \"0.5713751\",\n \"0.56885964\",\n \"0.5684259\",\n \"0.5677187\",\n \"0.5676685\",\n \"0.5671711\",\n \"0.5668394\",\n \"0.56544405\",\n \"0.5647273\",\n \"0.561165\",\n \"0.5607016\",\n \"0.5601972\",\n \"0.5599905\",\n \"0.5598966\",\n \"0.5590905\",\n \"0.5569387\",\n \"0.5542334\",\n \"0.5539422\",\n \"0.5530967\",\n \"0.55236316\",\n \"0.55079406\",\n \"0.54972\",\n \"0.5463206\",\n \"0.54597074\",\n \"0.54592216\",\n \"0.54578024\",\n \"0.5455274\",\n \"0.5454903\",\n \"0.5449084\",\n \"0.54351246\",\n \"0.5433596\",\n \"0.5431824\",\n \"0.54177296\",\n \"0.5410018\",\n \"0.5399981\",\n \"0.5394631\",\n \"0.5358127\",\n \"0.53564614\",\n \"0.53539056\",\n \"0.535361\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53395075\",\n \"0.53329027\",\n \"0.5326552\",\n \"0.53237534\",\n \"0.5316236\",\n \"0.53161746\",\n \"0.5305577\",\n \"0.52934456\",\n \"0.5270017\",\n \"0.5261946\",\n \"0.52619094\",\n \"0.5254521\",\n \"0.52491766\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.94080406"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81380,"cells":{"query":{"kind":"string","value":"Test case for mount_status_nas_share_by_nas"},"document":{"kind":"string","value":"def test_mount_status_nas_share_by_nas(self):\n pass"},"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_mount_status_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_index_nas_shares(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_dashboards_v2_share(self):\n pass","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def test_get_drive_mount_point_name_unique_id_exists(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n gfs._unique_id = 0\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n gfs._unique_id = None\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_dashboards_v2_list_shares(self):\n pass","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def mount_cifs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n share_name = share_config.get('share_name')\n remote_host = share_config.get('remote_host')\n if remote_host and share_name and mount_point:\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\n self.cmd(command)","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def _ensure_share_mounted(self, nfs_share, mount_path=None):\n mnt_flags = []\n if self.shares.get(nfs_share) is not None:\n mnt_flags = self.shares[nfs_share].split()\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\n for attempt in range(num_attempts):\n try:\n if mount_path is None:\n self._remotefsclient.mount(nfs_share, mnt_flags)\n else:\n if mount_path in self._remotefsclient._read_mounts():\n LOG.info('Already mounted: %s', mount_path)\n return\n\n fileutils.ensure_tree(mount_path)\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\n mnt_flags)\n return\n except Exception as e:\n if attempt == (num_attempts - 1):\n LOG.error('Mount failure for %(share)s after '\n '%(count)d attempts.',\n {'share': nfs_share,\n 'count': num_attempts})\n raise exception.NfsException(six.text_type(e))\n LOG.warning(\n 'Mount attempt %(attempt)d failed: %(error)s. '\n 'Retrying mount ...',\n {'attempt': attempt, 'error': e})\n greenthread.sleep(1)","def share():\n return True","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_get_drive_mount_point_name_unique_id_None(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def __init__(self, win_server, share_folder, mount_point, user, password):\n \n share_folder = share_folder.replace(\"/\", \"\\\\\")\n network_folder = r'//%s/%s' %(win_server, share_folder)\n\n print('Mount_point - %s' %(mount_point))\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\n self.mount_point = mount_point\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\n self.success = []\n self.error = []\n\n mount_cmd = \"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\"\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\n mount_point=mount_point,\n user=user,\n password=password)\n self.umount_cmd = \"umount {mount_point}\".format(mount_point=mount_point)","def ensure_share(self, context, share, share_server=None):\n pass","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def test_HYD965(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpBadRequest(response)","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_verify_ssh_access_with_root_works(driver):","def is_guest_sharing_auto_mount(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_dashboards_v2_delete_share(self):\n pass","def fs_ok(fs_info):\n if fs_info.mountpoint == '/':\n return True\n\n if (fs_info.device == fs_info.fstype or fs_info.fstype == 'nullfs' or\n '/docker' in fs_info.mountpoint or\n fs_info.mountpoint.startswith('/etc') or\n fs_info.mountpoint.startswith('/lib/modules')):\n return False\n\n if fs_info.device.startswith('/dev/'):\n return True\n\n return False","def nases(statusdb):\n disk_space = status.get_nases_disk_space()\n if statusdb:\n status.update_status_db(disk_space, server_type='nas')","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def _mount_point_exists(self, mountpoint):\n cmd = ['dir', mountpoint]\n logger.debug('running command: %s' % (' '.join(cmd)))\n stdout, stderr, retval = self._run_cli_process(cmd)\n\n if not retval:\n logger.debug(\"mountpoint %s ready\" % mountpoint)\n else:\n logger.debug(\"mountpoint %s reported not ready with error '%s'\" %\n (mountpoint, stderr.strip()))\n\n return not retval","def _get_mount_point_for_share(self, nfs_share):\n nfs_share = nfs_share.encode('utf-8')\n return os.path.join(self.configuration.nexenta_mount_point_base,\n md5(nfs_share, usedforsecurity=False).hexdigest())","def testMountCommand(self):\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\n mountPath = tempfile.mkdtemp()\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\n File().getLocalFilePath(self.file))\n self.assertTrue(os.path.exists(filePath))\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if not os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n self.assertFalse(os.path.exists(filePath))\n os.rmdir(mountPath)\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)","def check_filesystem(ssh_connection, disk_fmt, disk):\n if disk_fmt == \"squashfs\":\n return\n cmd = \"fsck.{} -n {}\".format(disk_fmt, disk)\n exit_code, _, stderr = ssh_connection.run(cmd)\n assert exit_code == 0, stderr","def _update_volume_stats(self):\n LOG.debug('Updating volume stats')\n total_space = 0\n free_space = 0\n share = None\n for _share in self._mounted_shares:\n if self.shares_with_capacities[_share]['free'] > free_space:\n free_space = self.shares_with_capacities[_share]['free']\n total_space = self.shares_with_capacities[_share]['total']\n share = _share\n\n location_info = '%(driver)s:%(share)s' % {\n 'driver': self.__class__.__name__,\n 'share': share\n }\n nms_url = self.share2nms[share].url\n self._stats = {\n 'vendor_name': 'Nexenta',\n 'dedup': self.volume_deduplication,\n 'compression': self.volume_compression,\n 'description': self.volume_description,\n 'nms_url': nms_url,\n 'ns_shares': self.shares_with_capacities,\n 'driver_version': self.VERSION,\n 'storage_protocol': constants.NFS,\n 'total_capacity_gb': total_space,\n 'free_capacity_gb': free_space,\n 'reserved_percentage': self.configuration.reserved_percentage,\n 'QoS_support': False,\n 'location_info': location_info,\n 'volume_backend_name': self.backend_name,\n 'nfs_mount_point_base': self.nfs_mount_point_base\n }","def test_ls_no_shareddir():\n\n with bad_fixture() as root:\n assert next(pipeline.ls(root=root), None) is None","def umount_cifs_share(self, **kwargs):\n mount_point = kwargs.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def check_mount_state(self, nodes=None):\n state = {\n \"mounted\": NodeSet(),\n \"unmounted\": NodeSet(),\n \"nodirectory\": NodeSet()\n }\n if not nodes:\n nodes = NodeSet.fromlist(self.hosts)\n check_mounted = NodeSet()\n\n # Detect which hosts have mount point directories defined\n command = \"test -d {0} -a ! -L {0}\".format(self.mount_dir.value)\n retcodes = pcmd(nodes, command, expect_rc=None)\n for retcode, hosts in list(retcodes.items()):\n if retcode == 0:\n check_mounted.add(hosts)\n else:\n command = \"grep 'dfuse {}' /proc/mounts\" .format(self.mount_dir.value)\n retcodes = pcmd(hosts, command, expect_rc=None)\n for ret_code, host_names in list(retcodes.items()):\n if ret_code == 0:\n check_mounted.add(host_names)\n else:\n state[\"nodirectory\"].add(host_names)\n\n if check_mounted:\n # Detect which hosts with mount point directories have it mounted as a fuseblk device\n command = \"stat -c %T -f {0} | grep -v fuseblk\".format(self.mount_dir.value)\n retcodes = pcmd(check_mounted, command, expect_rc=None)\n for retcode, hosts in list(retcodes.items()):\n if retcode == 1:\n state[\"mounted\"].add(hosts)\n else:\n state[\"unmounted\"].add(hosts)\n\n return state","def match_nfs_export(exports_list, export_parent, nas_server, path):\n\n for export in exports_list:\n flag = True\n if nas_server and not is_nas_server_matched(nas_server, export):\n flag = False\n elif export_parent and not is_export_parent_matched(export_parent,\n export):\n flag = False\n elif path and not is_path_matched(path, export):\n flag = False\n if flag:\n return export\n return False","def test_items_are_mounted(self):\n response2 = self.client.get(\"/importer/design26/models.py\")\n self.assertEquals(response2.status_code, 200)","def test_format():\n device = \"/dev/sdX1\"\n mock = MagicMock(return_value=0)\n with patch.dict(disk.__salt__, {\"cmd.retcode\": mock}), patch(\n \"salt.utils.path.which\", MagicMock(return_value=True)\n ):\n assert disk.format_(device) is True","def is_afs_mounted():\n return afs_mountpoint() is not None","def umount_nfs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def step_impl(context):\n log.info(\"====> verify the NSA files are not placed under container_nsa directory\")\n\n nsa_container = get_nsa_container_string(context)\n container_nsa_path = \"/tmp/cme/local/GFD/{nsa_container}/container_nsa\".format(nsa_container=nsa_container)\n log.info(\" ****> DEBUG: nsa container path is: {container_nsa_path}\".format(container_nsa_path=container_nsa_path))\n\n command = \"cd {container_nsa_path}; ls -a | wc -l\".format(container_nsa_path=container_nsa_path)\n if \"2\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\n log.info(\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\")\n else:\n assert False, \" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\"","def test_least_busy_host_gets_volume(self):\n volume1 = self.start_service('volume', host='host1')\n volume2 = self.start_service('volume', host='host2')\n volume_id1 = self._create_volume()\n volume1.create_volume(self.context, volume_id1)\n volume_id2 = self._create_volume()\n host = self.scheduler.driver.schedule_create_volume(self.context,\n volume_id2)\n self.assertEqual(host, 'host2')\n volume1.delete_volume(self.context, volume_id1)\n db.volume_destroy(self.context, volume_id2)\n volume1.kill()\n volume2.kill()","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def is_share_all_host_disks(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def test_mountfile(self):\n quote = b\"\"\"If you wish to make an apple pie from scratch, you must first invent the universe.\"\"\"\n mem_fs = MemoryFS()\n mem_fs.makedir('foo')\n mem_fs.setcontents('foo/bar.txt', quote)\n foo_dir = mem_fs.opendir('foo')\n\n mount_fs = MountFS()\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\n\n self.assertTrue(mount_fs.isdir('/'))\n self.assertTrue(mount_fs.isdir('./'))\n self.assertTrue(mount_fs.isdir(''))\n\n # Check we can see the mounted file in the dir list\n self.assertEqual(mount_fs.listdir(), [\"bar.txt\"])\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\n self.assertTrue(mount_fs.exists('bar.txt'))\n self.assertTrue(mount_fs.isfile('bar.txt'))\n self.assertTrue(not mount_fs.isdir('bar.txt'))\n\n # Check open and getinfo callables\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\n\n # Check changes are written back\n mem_fs.setcontents('foo/bar.txt', 'baz')\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\n\n # Check changes are written to the original fs\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\n\n # Check unmount\n self.assertTrue(mount_fs.unmount(\"bar.txt\"))\n self.assertEqual(mount_fs.listdir(), [])\n self.assertTrue(not mount_fs.exists('bar.txt'))\n\n # Check unount a second time is a null op, and returns False\n self.assertFalse(mount_fs.unmount(\"bar.txt\"))","def dnt_share_app():\r\n msg, status = \"\", True\r\n try:\r\n\r\n 'Click on Do not share button'\r\n flag1 = ui_controls.button(get_obj_identifier('a'))\r\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\r\n \r\n \r\n\r\n status = False if not(flag1) else True\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def check_free_space():\n subprocess.run([\"ssh\",backup_host, \"du -h\", dest ]])\n # get output","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_read_cluster_resource_quota_status(self):\n pass","def _fsal_hook(self, base, share, access):\n return {\"Hostname\": self.gluster_manager.host,\n \"Volume\": self.gluster_manager.volume,\n \"Volpath\": \"/\" + share['name']}","def test_mount_failure(self):\n with prepared_image_file(create_filesystem=False):\n program = RsyncSystemBackup(\n crypto_device=CRYPTO_NAME,\n destination=os.path.join(MOUNT_POINT, 'latest'),\n mount_point=MOUNT_POINT,\n )\n # When `mount' fails it should exit with a nonzero exit code,\n # thereby causing executor to raise an ExternalCommandFailed\n # exception that obscures the FailedToMountError exception that\n # we're interested in. The check=False option enables our\n # `last resort error handling' code path to be reached.\n program.destination_context.options['check'] = False\n self.assertRaises(FailedToMountError, program.execute)","def test_update_volume_stats_cached(self):\n self._fail_host_storage = True\n actual = self.driver.get_volume_stats(False)\n self.assertEqual('HGST', actual['vendor_name'])\n self.assertEqual('hgst', actual['storage_protocol'])\n self.assertEqual(90, actual['total_capacity_gb'])\n self.assertEqual(87, actual['free_capacity_gb'])\n self.assertEqual(0, actual['reserved_percentage'])","def test_update_volume_stats_error(self):\n self._fail_host_storage = True\n actual = self.driver.get_volume_stats(True)\n self.assertEqual('HGST', actual['vendor_name'])\n self.assertEqual('hgst', actual['storage_protocol'])\n self.assertEqual('unknown', actual['total_capacity_gb'])\n self.assertEqual('unknown', actual['free_capacity_gb'])\n self.assertEqual(0, actual['reserved_percentage'])","def _get_capacity_info(self, nfs_share):\n nms = self.share2nms[nfs_share]\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\n ns_folder),\n 'used|available')\n free = utils.str2size(folder_props['available'])\n allocated = utils.str2size(folder_props['used'])\n self.shares_with_capacities[nfs_share] = {\n 'free': utils.str2gib_size(free),\n 'total': utils.str2gib_size(free + allocated)}\n return free + allocated, free, allocated","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def _get_mount_status(self, vm=None):\n result = Shell.run(f\"multipass info {vm} --format=json\")\n\n if f'instance \"{vm}\" does not exist' in result:\n dict_result = {\n 'name': vm,\n 'status': \"instance does not exist\"\n }\n else:\n result = json.loads(result)\n dict_result = {\n 'name': vm,\n 'status': result[\"info\"][vm]['state'],\n 'mounts': result[\"info\"][vm]['mounts']\n }\n return dict_result","def test_no_list_listings(self):\n pool_name = p_n()\n fs_name = fs_n()\n StratisCli.pool_create(pool_name, block_devices=DISKS)\n StratisCli.fs_create(pool_name, fs_name)\n\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\n self.assertEqual(StratisCli.blockdev_list(),\n StratisCli.blockdev_list(False))","def testMakeMountCommands(self):\n self.maxDiff = None\n container_obj = self.explorer_object.GetContainer(\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(x) for x in commands]\n expected_commands = [\n (\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\n 'docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '-init=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\n '=ro+wh none /mnt'),\n (\n '/bin/mount --bind -o ro test_data/docker/volumes/'\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\n '_data /mnt/var/jenkins_home')\n ]\n self.assertEqual(expected_commands, commands)","def test_set_state_full(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n mgt_uri = \"/api/target/%s/\" % self.mgt.id\n with mock.patch(\"chroma_core.models.Command.set_state\", mock.Mock(return_value=None)):\n self.api_set_state_full(mgt_uri, \"unmounted\")\n Command.set_state.assert_called_once()","def _check_mounted_system(self):\n res = self.su_cmd('touch /system/.dwarf_check')\n if res == '':\n res = self._do_adb_command('shell ls -la /system')\n if '.dwarf_check' in res:\n res = self.su_cmd('rm /system/.dwarf_check')\n if res == '':\n return True\n elif res == 'Read-only file system':\n return False\n\n return False","def test_create_snapshot(self, mock_ghn):\n # Now snapshot the volume and check commands\n snapshot = {'volume_name': 'volume10',\n 'volume_id': 'xxx', 'display_name': 'snap10',\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\n 'volume': {'provider_id': 'space10'}}\n ret = self.driver.create_snapshot(snapshot)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': snapshot['display_name'], 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'snap10'}\n self.assertDictMatch(expected_pid, ret)","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","def run_cmd_on_the_nas_with_ssh(driver, cmd):\n global results\n results = ssh_cmd(cmd, 'root', 'testing', host)\n assert results['result'], f'STDOUT: {results[\"output\"]}, STDERR: {results[\"stderr\"]}'","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_get_node_drive(self):\n pass","def allow_access_nfs(self, pool, project, share, access):\n if access['access_type'] != 'ip':\n reason = _('Only ip access type allowed.')\n raise exception.InvalidShareAccess(reason)\n\n ip = access['access_to']\n details = self.get_share(pool, project, share)\n sharenfs = details['sharenfs']\n\n if sharenfs == 'on' or sharenfs == 'rw':\n LOG.debug('Share %s has read/write permission '\n 'open to all.', share)\n return\n if sharenfs == 'off':\n sharenfs = 'sec=sys'\n if ip in sharenfs:\n LOG.debug('Access to share %(share)s via NFS '\n 'already granted to %(ip)s.',\n {'share': share,\n 'ip': ip})\n return\n\n entry = (',rw=@%s' % ip)\n if '/' not in ip:\n entry = \"%s/32\" % entry\n arg = {'sharenfs': sharenfs + entry}\n self.modify_share(pool, project, share, arg)","async def check_disks_availability(self, disks, allow_duplicate_serials):\n verrors = ValidationErrors()\n disks_cache = dict(map(lambda x: (x['devname'], x), await self.middleware.call('disk.query')))\n\n disks_set = set(disks)\n disks_not_in_cache = disks_set - set(disks_cache.keys())\n if disks_not_in_cache:\n verrors.add(\n 'topology',\n f'The following disks were not found in system: {\",\" .join(disks_not_in_cache)}.'\n )\n\n disks_reserved = await self.middleware.call('disk.get_reserved')\n already_used = disks_set - (disks_set - set(disks_reserved))\n if already_used:\n verrors.add(\n 'topology',\n f'The following disks are already in use: {\",\" .join(already_used)}.'\n )\n\n if not allow_duplicate_serials and not verrors:\n serial_to_disk = defaultdict(set)\n for disk in disks:\n serial_to_disk[(disks_cache[disk]['serial'], disks_cache[disk]['lunid'])].add(disk)\n for reserved_disk in disks_reserved:\n reserved_disk_cache = disks_cache.get(reserved_disk)\n if not reserved_disk_cache:\n continue\n\n serial_to_disk[(reserved_disk_cache['serial'], reserved_disk_cache['lunid'])].add(reserved_disk)\n\n if duplicate_serials := {serial for serial, serial_disks in serial_to_disk.items()\n if len(serial_disks) > 1}:\n error = ', '.join(map(lambda serial: f'{serial[0]!r} ({\", \".join(sorted(serial_to_disk[serial]))})',\n duplicate_serials))\n verrors.add('topology', f'Disks have duplicate serial numbers: {error}.')\n\n return verrors","async def test_endpoint_share_container_correct(self):\n self.json_mock.return_value.status = 204\n with self.patch_json_dump:\n resp = await share_container_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_empty(self):\n mount_fs = MountFS()\n self.assertEqual(mount_fs.getinfo(''), {})\n self.assertEqual(mount_fs.getxattr('', 'yo'), None)\n self.assertEqual(mount_fs.listdir(), [])\n self.assertEqual(list(mount_fs.ilistdir()), [])"],"string":"[\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def test_get_drive_mount_point_name_unique_id_exists(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n gfs._unique_id = 0\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n gfs._unique_id = None\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def mount_cifs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n share_name = share_config.get('share_name')\\n remote_host = share_config.get('remote_host')\\n if remote_host and share_name and mount_point:\\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\\n self.cmd(command)\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def _ensure_share_mounted(self, nfs_share, mount_path=None):\\n mnt_flags = []\\n if self.shares.get(nfs_share) is not None:\\n mnt_flags = self.shares[nfs_share].split()\\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\\n for attempt in range(num_attempts):\\n try:\\n if mount_path is None:\\n self._remotefsclient.mount(nfs_share, mnt_flags)\\n else:\\n if mount_path in self._remotefsclient._read_mounts():\\n LOG.info('Already mounted: %s', mount_path)\\n return\\n\\n fileutils.ensure_tree(mount_path)\\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\\n mnt_flags)\\n return\\n except Exception as e:\\n if attempt == (num_attempts - 1):\\n LOG.error('Mount failure for %(share)s after '\\n '%(count)d attempts.',\\n {'share': nfs_share,\\n 'count': num_attempts})\\n raise exception.NfsException(six.text_type(e))\\n LOG.warning(\\n 'Mount attempt %(attempt)d failed: %(error)s. '\\n 'Retrying mount ...',\\n {'attempt': attempt, 'error': e})\\n greenthread.sleep(1)\",\n \"def share():\\n return True\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_get_drive_mount_point_name_unique_id_None(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def __init__(self, win_server, share_folder, mount_point, user, password):\\n \\n share_folder = share_folder.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n network_folder = r'//%s/%s' %(win_server, share_folder)\\n\\n print('Mount_point - %s' %(mount_point))\\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\\n self.mount_point = mount_point\\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\\n self.success = []\\n self.error = []\\n\\n mount_cmd = \\\"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\\\"\\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\\n mount_point=mount_point,\\n user=user,\\n password=password)\\n self.umount_cmd = \\\"umount {mount_point}\\\".format(mount_point=mount_point)\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def test_HYD965(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpBadRequest(response)\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_verify_ssh_access_with_root_works(driver):\",\n \"def is_guest_sharing_auto_mount(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def fs_ok(fs_info):\\n if fs_info.mountpoint == '/':\\n return True\\n\\n if (fs_info.device == fs_info.fstype or fs_info.fstype == 'nullfs' or\\n '/docker' in fs_info.mountpoint or\\n fs_info.mountpoint.startswith('/etc') or\\n fs_info.mountpoint.startswith('/lib/modules')):\\n return False\\n\\n if fs_info.device.startswith('/dev/'):\\n return True\\n\\n return False\",\n \"def nases(statusdb):\\n disk_space = status.get_nases_disk_space()\\n if statusdb:\\n status.update_status_db(disk_space, server_type='nas')\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def _mount_point_exists(self, mountpoint):\\n cmd = ['dir', mountpoint]\\n logger.debug('running command: %s' % (' '.join(cmd)))\\n stdout, stderr, retval = self._run_cli_process(cmd)\\n\\n if not retval:\\n logger.debug(\\\"mountpoint %s ready\\\" % mountpoint)\\n else:\\n logger.debug(\\\"mountpoint %s reported not ready with error '%s'\\\" %\\n (mountpoint, stderr.strip()))\\n\\n return not retval\",\n \"def _get_mount_point_for_share(self, nfs_share):\\n nfs_share = nfs_share.encode('utf-8')\\n return os.path.join(self.configuration.nexenta_mount_point_base,\\n md5(nfs_share, usedforsecurity=False).hexdigest())\",\n \"def testMountCommand(self):\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\\n mountPath = tempfile.mkdtemp()\\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\\n File().getLocalFilePath(self.file))\\n self.assertTrue(os.path.exists(filePath))\\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if not os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n self.assertFalse(os.path.exists(filePath))\\n os.rmdir(mountPath)\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\",\n \"def check_filesystem(ssh_connection, disk_fmt, disk):\\n if disk_fmt == \\\"squashfs\\\":\\n return\\n cmd = \\\"fsck.{} -n {}\\\".format(disk_fmt, disk)\\n exit_code, _, stderr = ssh_connection.run(cmd)\\n assert exit_code == 0, stderr\",\n \"def _update_volume_stats(self):\\n LOG.debug('Updating volume stats')\\n total_space = 0\\n free_space = 0\\n share = None\\n for _share in self._mounted_shares:\\n if self.shares_with_capacities[_share]['free'] > free_space:\\n free_space = self.shares_with_capacities[_share]['free']\\n total_space = self.shares_with_capacities[_share]['total']\\n share = _share\\n\\n location_info = '%(driver)s:%(share)s' % {\\n 'driver': self.__class__.__name__,\\n 'share': share\\n }\\n nms_url = self.share2nms[share].url\\n self._stats = {\\n 'vendor_name': 'Nexenta',\\n 'dedup': self.volume_deduplication,\\n 'compression': self.volume_compression,\\n 'description': self.volume_description,\\n 'nms_url': nms_url,\\n 'ns_shares': self.shares_with_capacities,\\n 'driver_version': self.VERSION,\\n 'storage_protocol': constants.NFS,\\n 'total_capacity_gb': total_space,\\n 'free_capacity_gb': free_space,\\n 'reserved_percentage': self.configuration.reserved_percentage,\\n 'QoS_support': False,\\n 'location_info': location_info,\\n 'volume_backend_name': self.backend_name,\\n 'nfs_mount_point_base': self.nfs_mount_point_base\\n }\",\n \"def test_ls_no_shareddir():\\n\\n with bad_fixture() as root:\\n assert next(pipeline.ls(root=root), None) is None\",\n \"def umount_cifs_share(self, **kwargs):\\n mount_point = kwargs.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def check_mount_state(self, nodes=None):\\n state = {\\n \\\"mounted\\\": NodeSet(),\\n \\\"unmounted\\\": NodeSet(),\\n \\\"nodirectory\\\": NodeSet()\\n }\\n if not nodes:\\n nodes = NodeSet.fromlist(self.hosts)\\n check_mounted = NodeSet()\\n\\n # Detect which hosts have mount point directories defined\\n command = \\\"test -d {0} -a ! -L {0}\\\".format(self.mount_dir.value)\\n retcodes = pcmd(nodes, command, expect_rc=None)\\n for retcode, hosts in list(retcodes.items()):\\n if retcode == 0:\\n check_mounted.add(hosts)\\n else:\\n command = \\\"grep 'dfuse {}' /proc/mounts\\\" .format(self.mount_dir.value)\\n retcodes = pcmd(hosts, command, expect_rc=None)\\n for ret_code, host_names in list(retcodes.items()):\\n if ret_code == 0:\\n check_mounted.add(host_names)\\n else:\\n state[\\\"nodirectory\\\"].add(host_names)\\n\\n if check_mounted:\\n # Detect which hosts with mount point directories have it mounted as a fuseblk device\\n command = \\\"stat -c %T -f {0} | grep -v fuseblk\\\".format(self.mount_dir.value)\\n retcodes = pcmd(check_mounted, command, expect_rc=None)\\n for retcode, hosts in list(retcodes.items()):\\n if retcode == 1:\\n state[\\\"mounted\\\"].add(hosts)\\n else:\\n state[\\\"unmounted\\\"].add(hosts)\\n\\n return state\",\n \"def match_nfs_export(exports_list, export_parent, nas_server, path):\\n\\n for export in exports_list:\\n flag = True\\n if nas_server and not is_nas_server_matched(nas_server, export):\\n flag = False\\n elif export_parent and not is_export_parent_matched(export_parent,\\n export):\\n flag = False\\n elif path and not is_path_matched(path, export):\\n flag = False\\n if flag:\\n return export\\n return False\",\n \"def test_items_are_mounted(self):\\n response2 = self.client.get(\\\"/importer/design26/models.py\\\")\\n self.assertEquals(response2.status_code, 200)\",\n \"def test_format():\\n device = \\\"/dev/sdX1\\\"\\n mock = MagicMock(return_value=0)\\n with patch.dict(disk.__salt__, {\\\"cmd.retcode\\\": mock}), patch(\\n \\\"salt.utils.path.which\\\", MagicMock(return_value=True)\\n ):\\n assert disk.format_(device) is True\",\n \"def is_afs_mounted():\\n return afs_mountpoint() is not None\",\n \"def umount_nfs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def step_impl(context):\\n log.info(\\\"====> verify the NSA files are not placed under container_nsa directory\\\")\\n\\n nsa_container = get_nsa_container_string(context)\\n container_nsa_path = \\\"/tmp/cme/local/GFD/{nsa_container}/container_nsa\\\".format(nsa_container=nsa_container)\\n log.info(\\\" ****> DEBUG: nsa container path is: {container_nsa_path}\\\".format(container_nsa_path=container_nsa_path))\\n\\n command = \\\"cd {container_nsa_path}; ls -a | wc -l\\\".format(container_nsa_path=container_nsa_path)\\n if \\\"2\\\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\\n log.info(\\\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\\\")\\n else:\\n assert False, \\\" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\\\"\",\n \"def test_least_busy_host_gets_volume(self):\\n volume1 = self.start_service('volume', host='host1')\\n volume2 = self.start_service('volume', host='host2')\\n volume_id1 = self._create_volume()\\n volume1.create_volume(self.context, volume_id1)\\n volume_id2 = self._create_volume()\\n host = self.scheduler.driver.schedule_create_volume(self.context,\\n volume_id2)\\n self.assertEqual(host, 'host2')\\n volume1.delete_volume(self.context, volume_id1)\\n db.volume_destroy(self.context, volume_id2)\\n volume1.kill()\\n volume2.kill()\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def is_share_all_host_disks(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def test_mountfile(self):\\n quote = b\\\"\\\"\\\"If you wish to make an apple pie from scratch, you must first invent the universe.\\\"\\\"\\\"\\n mem_fs = MemoryFS()\\n mem_fs.makedir('foo')\\n mem_fs.setcontents('foo/bar.txt', quote)\\n foo_dir = mem_fs.opendir('foo')\\n\\n mount_fs = MountFS()\\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\\n\\n self.assertTrue(mount_fs.isdir('/'))\\n self.assertTrue(mount_fs.isdir('./'))\\n self.assertTrue(mount_fs.isdir(''))\\n\\n # Check we can see the mounted file in the dir list\\n self.assertEqual(mount_fs.listdir(), [\\\"bar.txt\\\"])\\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\\n self.assertTrue(mount_fs.exists('bar.txt'))\\n self.assertTrue(mount_fs.isfile('bar.txt'))\\n self.assertTrue(not mount_fs.isdir('bar.txt'))\\n\\n # Check open and getinfo callables\\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\\n\\n # Check changes are written back\\n mem_fs.setcontents('foo/bar.txt', 'baz')\\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\\n\\n # Check changes are written to the original fs\\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\\n\\n # Check unmount\\n self.assertTrue(mount_fs.unmount(\\\"bar.txt\\\"))\\n self.assertEqual(mount_fs.listdir(), [])\\n self.assertTrue(not mount_fs.exists('bar.txt'))\\n\\n # Check unount a second time is a null op, and returns False\\n self.assertFalse(mount_fs.unmount(\\\"bar.txt\\\"))\",\n \"def dnt_share_app():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n\\r\\n 'Click on Do not share button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('a'))\\r\\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not(flag1) else True\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def check_free_space():\\n subprocess.run([\\\"ssh\\\",backup_host, \\\"du -h\\\", dest ]])\\n # get output\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def _fsal_hook(self, base, share, access):\\n return {\\\"Hostname\\\": self.gluster_manager.host,\\n \\\"Volume\\\": self.gluster_manager.volume,\\n \\\"Volpath\\\": \\\"/\\\" + share['name']}\",\n \"def test_mount_failure(self):\\n with prepared_image_file(create_filesystem=False):\\n program = RsyncSystemBackup(\\n crypto_device=CRYPTO_NAME,\\n destination=os.path.join(MOUNT_POINT, 'latest'),\\n mount_point=MOUNT_POINT,\\n )\\n # When `mount' fails it should exit with a nonzero exit code,\\n # thereby causing executor to raise an ExternalCommandFailed\\n # exception that obscures the FailedToMountError exception that\\n # we're interested in. The check=False option enables our\\n # `last resort error handling' code path to be reached.\\n program.destination_context.options['check'] = False\\n self.assertRaises(FailedToMountError, program.execute)\",\n \"def test_update_volume_stats_cached(self):\\n self._fail_host_storage = True\\n actual = self.driver.get_volume_stats(False)\\n self.assertEqual('HGST', actual['vendor_name'])\\n self.assertEqual('hgst', actual['storage_protocol'])\\n self.assertEqual(90, actual['total_capacity_gb'])\\n self.assertEqual(87, actual['free_capacity_gb'])\\n self.assertEqual(0, actual['reserved_percentage'])\",\n \"def test_update_volume_stats_error(self):\\n self._fail_host_storage = True\\n actual = self.driver.get_volume_stats(True)\\n self.assertEqual('HGST', actual['vendor_name'])\\n self.assertEqual('hgst', actual['storage_protocol'])\\n self.assertEqual('unknown', actual['total_capacity_gb'])\\n self.assertEqual('unknown', actual['free_capacity_gb'])\\n self.assertEqual(0, actual['reserved_percentage'])\",\n \"def _get_capacity_info(self, nfs_share):\\n nms = self.share2nms[nfs_share]\\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\\n ns_folder),\\n 'used|available')\\n free = utils.str2size(folder_props['available'])\\n allocated = utils.str2size(folder_props['used'])\\n self.shares_with_capacities[nfs_share] = {\\n 'free': utils.str2gib_size(free),\\n 'total': utils.str2gib_size(free + allocated)}\\n return free + allocated, free, allocated\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def _get_mount_status(self, vm=None):\\n result = Shell.run(f\\\"multipass info {vm} --format=json\\\")\\n\\n if f'instance \\\"{vm}\\\" does not exist' in result:\\n dict_result = {\\n 'name': vm,\\n 'status': \\\"instance does not exist\\\"\\n }\\n else:\\n result = json.loads(result)\\n dict_result = {\\n 'name': vm,\\n 'status': result[\\\"info\\\"][vm]['state'],\\n 'mounts': result[\\\"info\\\"][vm]['mounts']\\n }\\n return dict_result\",\n \"def test_no_list_listings(self):\\n pool_name = p_n()\\n fs_name = fs_n()\\n StratisCli.pool_create(pool_name, block_devices=DISKS)\\n StratisCli.fs_create(pool_name, fs_name)\\n\\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\\n self.assertEqual(StratisCli.blockdev_list(),\\n StratisCli.blockdev_list(False))\",\n \"def testMakeMountCommands(self):\\n self.maxDiff = None\\n container_obj = self.explorer_object.GetContainer(\\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(x) for x in commands]\\n expected_commands = [\\n (\\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\\n 'docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '-init=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount --bind -o ro test_data/docker/volumes/'\\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\\n '_data /mnt/var/jenkins_home')\\n ]\\n self.assertEqual(expected_commands, commands)\",\n \"def test_set_state_full(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n mgt_uri = \\\"/api/target/%s/\\\" % self.mgt.id\\n with mock.patch(\\\"chroma_core.models.Command.set_state\\\", mock.Mock(return_value=None)):\\n self.api_set_state_full(mgt_uri, \\\"unmounted\\\")\\n Command.set_state.assert_called_once()\",\n \"def _check_mounted_system(self):\\n res = self.su_cmd('touch /system/.dwarf_check')\\n if res == '':\\n res = self._do_adb_command('shell ls -la /system')\\n if '.dwarf_check' in res:\\n res = self.su_cmd('rm /system/.dwarf_check')\\n if res == '':\\n return True\\n elif res == 'Read-only file system':\\n return False\\n\\n return False\",\n \"def test_create_snapshot(self, mock_ghn):\\n # Now snapshot the volume and check commands\\n snapshot = {'volume_name': 'volume10',\\n 'volume_id': 'xxx', 'display_name': 'snap10',\\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\\n 'volume': {'provider_id': 'space10'}}\\n ret = self.driver.create_snapshot(snapshot)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': snapshot['display_name'], 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'snap10'}\\n self.assertDictMatch(expected_pid, ret)\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"def run_cmd_on_the_nas_with_ssh(driver, cmd):\\n global results\\n results = ssh_cmd(cmd, 'root', 'testing', host)\\n assert results['result'], f'STDOUT: {results[\\\"output\\\"]}, STDERR: {results[\\\"stderr\\\"]}'\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_get_node_drive(self):\\n pass\",\n \"def allow_access_nfs(self, pool, project, share, access):\\n if access['access_type'] != 'ip':\\n reason = _('Only ip access type allowed.')\\n raise exception.InvalidShareAccess(reason)\\n\\n ip = access['access_to']\\n details = self.get_share(pool, project, share)\\n sharenfs = details['sharenfs']\\n\\n if sharenfs == 'on' or sharenfs == 'rw':\\n LOG.debug('Share %s has read/write permission '\\n 'open to all.', share)\\n return\\n if sharenfs == 'off':\\n sharenfs = 'sec=sys'\\n if ip in sharenfs:\\n LOG.debug('Access to share %(share)s via NFS '\\n 'already granted to %(ip)s.',\\n {'share': share,\\n 'ip': ip})\\n return\\n\\n entry = (',rw=@%s' % ip)\\n if '/' not in ip:\\n entry = \\\"%s/32\\\" % entry\\n arg = {'sharenfs': sharenfs + entry}\\n self.modify_share(pool, project, share, arg)\",\n \"async def check_disks_availability(self, disks, allow_duplicate_serials):\\n verrors = ValidationErrors()\\n disks_cache = dict(map(lambda x: (x['devname'], x), await self.middleware.call('disk.query')))\\n\\n disks_set = set(disks)\\n disks_not_in_cache = disks_set - set(disks_cache.keys())\\n if disks_not_in_cache:\\n verrors.add(\\n 'topology',\\n f'The following disks were not found in system: {\\\",\\\" .join(disks_not_in_cache)}.'\\n )\\n\\n disks_reserved = await self.middleware.call('disk.get_reserved')\\n already_used = disks_set - (disks_set - set(disks_reserved))\\n if already_used:\\n verrors.add(\\n 'topology',\\n f'The following disks are already in use: {\\\",\\\" .join(already_used)}.'\\n )\\n\\n if not allow_duplicate_serials and not verrors:\\n serial_to_disk = defaultdict(set)\\n for disk in disks:\\n serial_to_disk[(disks_cache[disk]['serial'], disks_cache[disk]['lunid'])].add(disk)\\n for reserved_disk in disks_reserved:\\n reserved_disk_cache = disks_cache.get(reserved_disk)\\n if not reserved_disk_cache:\\n continue\\n\\n serial_to_disk[(reserved_disk_cache['serial'], reserved_disk_cache['lunid'])].add(reserved_disk)\\n\\n if duplicate_serials := {serial for serial, serial_disks in serial_to_disk.items()\\n if len(serial_disks) > 1}:\\n error = ', '.join(map(lambda serial: f'{serial[0]!r} ({\\\", \\\".join(sorted(serial_to_disk[serial]))})',\\n duplicate_serials))\\n verrors.add('topology', f'Disks have duplicate serial numbers: {error}.')\\n\\n return verrors\",\n \"async def test_endpoint_share_container_correct(self):\\n self.json_mock.return_value.status = 204\\n with self.patch_json_dump:\\n resp = await share_container_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_empty(self):\\n mount_fs = MountFS()\\n self.assertEqual(mount_fs.getinfo(''), {})\\n self.assertEqual(mount_fs.getxattr('', 'yo'), None)\\n self.assertEqual(mount_fs.listdir(), [])\\n self.assertEqual(list(mount_fs.ilistdir()), [])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9223469","0.8762923","0.8201179","0.81886965","0.8143352","0.8128441","0.7978966","0.7839654","0.7666999","0.7568727","0.72756267","0.72689754","0.718854","0.70526314","0.70140773","0.6603129","0.6567966","0.64892024","0.62469953","0.6022947","0.5962818","0.59593135","0.5923996","0.5917267","0.5894529","0.58689535","0.5863176","0.5859191","0.58072716","0.5781444","0.57741934","0.5725025","0.5703175","0.5680433","0.56741756","0.5668273","0.5624026","0.5621917","0.56058276","0.55707705","0.5568029","0.5509774","0.5487018","0.5457667","0.54574054","0.5428507","0.5426311","0.5415179","0.5383684","0.5375075","0.537375","0.5357161","0.5349072","0.5342341","0.5335271","0.5328785","0.5320331","0.53029424","0.5294937","0.528555","0.5270036","0.52675414","0.5245536","0.524115","0.5233555","0.5226703","0.5225664","0.52242845","0.5203569","0.5201193","0.5197237","0.5187302","0.5179486","0.5174427","0.51728165","0.51630014","0.51603913","0.5153399","0.51447946","0.51432985","0.5142251","0.5138714","0.51263535","0.5125019","0.51078117","0.50971144","0.50937974","0.5090453","0.50765276","0.5074102","0.5070639","0.5049479","0.50477207","0.5045104","0.50433177","0.5042613","0.5040449","0.5035053","0.50330335","0.5026963"],"string":"[\n \"0.9223469\",\n \"0.8762923\",\n \"0.8201179\",\n \"0.81886965\",\n \"0.8143352\",\n \"0.8128441\",\n \"0.7978966\",\n \"0.7839654\",\n \"0.7666999\",\n \"0.7568727\",\n \"0.72756267\",\n \"0.72689754\",\n \"0.718854\",\n \"0.70526314\",\n \"0.70140773\",\n \"0.6603129\",\n \"0.6567966\",\n \"0.64892024\",\n \"0.62469953\",\n \"0.6022947\",\n \"0.5962818\",\n \"0.59593135\",\n \"0.5923996\",\n \"0.5917267\",\n \"0.5894529\",\n \"0.58689535\",\n \"0.5863176\",\n \"0.5859191\",\n \"0.58072716\",\n \"0.5781444\",\n \"0.57741934\",\n \"0.5725025\",\n \"0.5703175\",\n \"0.5680433\",\n \"0.56741756\",\n \"0.5668273\",\n \"0.5624026\",\n \"0.5621917\",\n \"0.56058276\",\n \"0.55707705\",\n \"0.5568029\",\n \"0.5509774\",\n \"0.5487018\",\n \"0.5457667\",\n \"0.54574054\",\n \"0.5428507\",\n \"0.5426311\",\n \"0.5415179\",\n \"0.5383684\",\n \"0.5375075\",\n \"0.537375\",\n \"0.5357161\",\n \"0.5349072\",\n \"0.5342341\",\n \"0.5335271\",\n \"0.5328785\",\n \"0.5320331\",\n \"0.53029424\",\n \"0.5294937\",\n \"0.528555\",\n \"0.5270036\",\n \"0.52675414\",\n \"0.5245536\",\n \"0.524115\",\n \"0.5233555\",\n \"0.5226703\",\n \"0.5225664\",\n \"0.52242845\",\n \"0.5203569\",\n \"0.5201193\",\n \"0.5197237\",\n \"0.5187302\",\n \"0.5179486\",\n \"0.5174427\",\n \"0.51728165\",\n \"0.51630014\",\n \"0.51603913\",\n \"0.5153399\",\n \"0.51447946\",\n \"0.51432985\",\n \"0.5142251\",\n \"0.5138714\",\n \"0.51263535\",\n \"0.5125019\",\n \"0.51078117\",\n \"0.50971144\",\n \"0.50937974\",\n \"0.5090453\",\n \"0.50765276\",\n \"0.5074102\",\n \"0.5070639\",\n \"0.5049479\",\n \"0.50477207\",\n \"0.5045104\",\n \"0.50433177\",\n \"0.5042613\",\n \"0.5040449\",\n \"0.5035053\",\n \"0.50330335\",\n \"0.5026963\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.94895434"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81381,"cells":{"query":{"kind":"string","value":"Test case for mount_status_nas_share_by_pool"},"document":{"kind":"string","value":"def test_mount_status_nas_share_by_pool(self):\n pass"},"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_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_index_nas_shares(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_volume_service_pool(self):\n self.assertEqual(\n ChangeStateScript()._deployer._volume_service._pool,\n StoragePool(reactor, b\"flocker\", FilePath(b\"/flocker\")))","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_get_drive_mount_point_name_unique_id_exists(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n gfs._unique_id = 0\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n gfs._unique_id = None\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def test_no_list_listings(self):\n pool_name = p_n()\n fs_name = fs_n()\n StratisCli.pool_create(pool_name, block_devices=DISKS)\n StratisCli.fs_create(pool_name, fs_name)\n\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\n self.assertEqual(StratisCli.blockdev_list(),\n StratisCli.blockdev_list(False))","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def test_dashboards_v2_share(self):\n pass","def check_free_space():\n subprocess.run([\"ssh\",backup_host, \"du -h\", dest ]])\n # get output","def verify_avail_space(self, pool, project, share, size):\n self.verify_project(pool, project)\n avail = self.get_project_stats(pool, project)\n if avail < size:\n exception_msg = (_('Error creating '\n 'share: %(share)s on '\n 'pool: %(pool)s. '\n 'Not enough space.')\n % {'share': share,\n 'pool': pool})\n raise exception.ShareBackendException(msg=exception_msg)","def test_get_drive_mount_point_name_unique_id_None(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_least_busy_host_gets_volume(self):\n volume1 = self.start_service('volume', host='host1')\n volume2 = self.start_service('volume', host='host2')\n volume_id1 = self._create_volume()\n volume1.create_volume(self.context, volume_id1)\n volume_id2 = self._create_volume()\n host = self.scheduler.driver.schedule_create_volume(self.context,\n volume_id2)\n self.assertEqual(host, 'host2')\n volume1.delete_volume(self.context, volume_id1)\n db.volume_destroy(self.context, volume_id2)\n volume1.kill()\n volume2.kill()","def _create_volume_pool(self, pool_name):\n osd_map = self._rados_command('osd dump', {})\n\n existing_id = self._get_pool_id(osd_map, pool_name)\n if existing_id is not None:\n log.info(\"Pool {0} already exists\".format(pool_name))\n return existing_id\n\n osd_count = len(osd_map['osds'])\n\n # We can't query the actual cluster config remotely, but since this is\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\n # that in use in the rest of the cluster.\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\n\n other_pgs = 0\n for pool in osd_map['pools']:\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\n other_pgs += pool['pg_num']\n\n # A basic heuristic for picking pg_num: work out the max number of\n # PGs we can have without tripping a warning, then subtract the number\n # of PGs already created by non-manila pools, then divide by ten. That'll\n # give you a reasonable result on a system where you have \"a few\" manila\n # shares.\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\n # TODO Alternatively, respect an override set by the user.\n\n self._rados_command(\n 'osd pool create',\n {\n 'pool': pool_name,\n 'pg_num': int(pg_num),\n }\n )\n\n osd_map = self._rados_command('osd dump', {})\n pool_id = self._get_pool_id(osd_map, pool_name)\n\n if pool_id is None:\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\n # removing it right after we created it.\n log.error(\"OSD map doesn't contain expected pool '{0}':\\n{1}\".format(\n pool_name, json.dumps(osd_map, indent=2)\n ))\n raise RuntimeError(\"Pool '{0}' not present in map after creation\".format(pool_name))\n else:\n return pool_id","def test_read_cluster_resource_quota_status(self):\n pass","def mount_cifs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n share_name = share_config.get('share_name')\n remote_host = share_config.get('remote_host')\n if remote_host and share_name and mount_point:\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\n self.cmd(command)","def _get_capacity_info(self, nfs_share):\n nms = self.share2nms[nfs_share]\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\n ns_folder),\n 'used|available')\n free = utils.str2size(folder_props['available'])\n allocated = utils.str2size(folder_props['used'])\n self.shares_with_capacities[nfs_share] = {\n 'free': utils.str2gib_size(free),\n 'total': utils.str2gib_size(free + allocated)}\n return free + allocated, free, allocated","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def umount_cifs_share(self, **kwargs):\n mount_point = kwargs.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def test_least_busy_host_gets_volume_no_queue(self):\n volume1 = service.Service('host1',\n 'nova-volume',\n 'volume',\n FLAGS.volume_manager)\n volume1.start()\n volume2 = service.Service('host2',\n 'nova-volume',\n 'volume',\n FLAGS.volume_manager)\n volume2.start()\n volume_id1 = self._create_volume()\n volume1.create_volume(self.context, volume_id1)\n volume_id2 = self._create_volume()\n host = self.scheduler.driver.schedule_create_volume(self.context,\n volume_id2)\n self.assertEqual(host, 'host2')\n volume1.delete_volume(self.context, volume_id1)\n db.volume_destroy(self.context, volume_id2)","def test_verify_ssh_access_with_root_works(driver):","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def verify_pool(self, pool):\n svc = self.pool_path % pool\n self.rest_get(svc, restclient.Status.OK)","def test_dashboards_v2_list_shares(self):\n pass","def __init__(self, win_server, share_folder, mount_point, user, password):\n \n share_folder = share_folder.replace(\"/\", \"\\\\\")\n network_folder = r'//%s/%s' %(win_server, share_folder)\n\n print('Mount_point - %s' %(mount_point))\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\n self.mount_point = mount_point\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\n self.success = []\n self.error = []\n\n mount_cmd = \"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\"\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\n mount_point=mount_point,\n user=user,\n password=password)\n self.umount_cmd = \"umount {mount_point}\".format(mount_point=mount_point)","def test_02_sys_vm_start(self):\n\n # 1. verify listHosts has all 'routing' hosts in UP state\n # 2. verify listStoragePools shows all primary storage pools\n # in UP state\n # 3. verify that secondary storage was added successfully\n\n list_hosts_response = list_hosts(\n self.apiclient,\n type='Routing',\n zoneid=self.zone.id,\n podid=self.pod.id\n )\n self.assertEqual(\n isinstance(list_hosts_response, list),\n True,\n \"Check list response returns a valid list\"\n )\n # ListHosts has all 'routing' hosts in UP state\n self.assertNotEqual(\n len(list_hosts_response),\n 0,\n \"Check list host response\"\n )\n for host in list_hosts_response:\n self.assertEqual(\n host.state,\n 'Up',\n \"Check state of routing hosts is Up or not\"\n )\n\n # ListStoragePools shows all primary storage pools in UP state\n list_storage_response = list_storage_pools(\n self.apiclient,\n zoneid=self.zone.id,\n podid=self.pod.id\n )\n self.assertEqual(\n isinstance(list_storage_response, list),\n True,\n \"Check list response returns a valid list\"\n )\n self.assertNotEqual(\n len(list_storage_response),\n 0,\n \"Check list storage pools response\"\n )\n\n for primary_storage in list_hosts_response:\n self.assertEqual(\n primary_storage.state,\n 'Up',\n \"Check state of primary storage pools is Up or not\"\n )\n\n # Secondary storage is added successfully\n timeout = self.services[\"timeout\"]\n while True:\n list_hosts_response = list_hosts(\n self.apiclient,\n type='SecondaryStorage',\n zoneid=self.zone.id,\n )\n\n if not isinstance(list_hosts_response, list):\n # Sleep to ensure Secondary storage is Up\n time.sleep(int(self.services[\"sleep\"]))\n timeout = timeout - 1\n elif timeout == 0 or isinstance(list_hosts_response, list):\n break\n \n self.assertEqual(\n isinstance(list_hosts_response, list),\n True,\n \"Check list response returns a valid list\"\n )\n \n self.assertNotEqual(\n len(list_hosts_response),\n 0,\n \"Check list Hosts response\"\n )\n\n host_response = list_hosts_response[0]\n #Check if host is Up and running\n self.assertEqual(\n host_response.state,\n 'Up',\n \"Check state of secondary storage\"\n )\n self.debug(\"Checking SSVM status in zone: %s\" % self.zone.id)\n\n timeout = self.services[\"timeout\"]\n\n while True:\n list_ssvm_response = list_ssvms(\n self.apiclient,\n systemvmtype='secondarystoragevm',\n zoneid=self.zone.id,\n podid=self.pod.id\n )\n if not isinstance(list_ssvm_response, list):\n # Sleep to ensure SSVMs are Up and Running\n time.sleep(int(self.services[\"sleep\"]))\n timeout = timeout - 1\n elif timeout == 0 or isinstance(list_ssvm_response, list):\n break\n \n self.assertEqual(\n isinstance(list_ssvm_response, list),\n True,\n \"Check list response returns a valid list\"\n )\n #Verify SSVM response\n self.assertNotEqual(\n len(list_ssvm_response),\n 0,\n \"Check list System VMs response\"\n )\n\n for ssvm in list_ssvm_response:\n self.assertEqual(\n ssvm.state,\n 'Running',\n \"Check whether state of SSVM is running\"\n )\n return","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_replace_cluster_resource_quota_status(self):\n pass","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def test_check_disk_space_sufficient(self):\n self.assertTrue(self.command.check_disk_space(1, self.temp_dir))\n self.assertTrue(self.command.check_disk_space(\n 1, self.temp_dir,\n label=\"Hello\", context=\"Contextual detail\", die=True))","def _ensure_share_mounted(self, nfs_share, mount_path=None):\n mnt_flags = []\n if self.shares.get(nfs_share) is not None:\n mnt_flags = self.shares[nfs_share].split()\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\n for attempt in range(num_attempts):\n try:\n if mount_path is None:\n self._remotefsclient.mount(nfs_share, mnt_flags)\n else:\n if mount_path in self._remotefsclient._read_mounts():\n LOG.info('Already mounted: %s', mount_path)\n return\n\n fileutils.ensure_tree(mount_path)\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\n mnt_flags)\n return\n except Exception as e:\n if attempt == (num_attempts - 1):\n LOG.error('Mount failure for %(share)s after '\n '%(count)d attempts.',\n {'share': nfs_share,\n 'count': num_attempts})\n raise exception.NfsException(six.text_type(e))\n LOG.warning(\n 'Mount attempt %(attempt)d failed: %(error)s. '\n 'Retrying mount ...',\n {'attempt': attempt, 'error': e})\n greenthread.sleep(1)","def test_HYD965(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpBadRequest(response)","def share():\n return True","def test_read_cluster_resource_quota(self):\n pass","def ensure_share(self, context, share, share_server=None):\n pass","def test_ls_no_shareddir():\n\n with bad_fixture() as root:\n assert next(pipeline.ls(root=root), None) is None","def _is_pool_owned(self, pdata):\n svc = '/api/system/v1/version'\n ret = self.rest_get(svc, restclient.Status.OK)\n vdata = jsonutils.loads(ret.data)\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\n vdata['version']['nodename'] == pdata['pool']['owner'])","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_create_cluster_resource_quota(self):\n pass","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_list_cluster_resource_quota(self):\n pass","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_create_cloned_volume(self, mock_ghn):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10,\n 'provider_id': 'space_orig'}\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10}\n pid = self.driver.create_cloned_volume(clone, orig)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': 'clone1', 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'clone1'}\n self.assertDictMatch(expected_pid, pid)","def task(ctx, config):\n if config is None:\n config = {}\n assert isinstance(config, dict), \\\n 'Resolve stuck peering only accepts a dict for config'\n\n manager = ctx.managers['ceph']\n\n while len(manager.get_osd_status()['up']) < 3:\n time.sleep(10)\n\n\n manager.wait_for_clean()\n\n dummyfile = '/etc/fstab'\n dummyfile1 = '/etc/resolv.conf'\n\n #create 1 PG pool\n pool='foo'\n log.info('creating pool foo')\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\n\n #set min_size of the pool to 1\n #so that we can continue with I/O\n #when 2 osds are down\n manager.set_pool_property(pool, \"min_size\", 1)\n\n osds = [0, 1, 2]\n\n primary = manager.get_pg_primary('foo', 0)\n log.info(\"primary osd is %d\", primary)\n\n others = list(osds)\n others.remove(primary)\n\n log.info('writing initial objects')\n first_mon = teuthology.get_first_mon(ctx, config)\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\n #create few objects\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\n\n manager.wait_for_clean()\n\n #kill other osds except primary\n log.info('killing other osds except primary')\n for i in others:\n manager.kill_osd(i)\n for i in others:\n manager.mark_down_osd(i)\n\n\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\n\n #kill primary osd\n manager.kill_osd(primary)\n manager.mark_down_osd(primary)\n\n #revive other 2 osds\n for i in others:\n manager.revive_osd(i)\n\n #make sure that pg is down\n #Assuming pg number for single pg pool will start from 0\n pgnum=0\n pgstr = manager.get_pgid(pool, pgnum)\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=60\n start=time.time()\n\n while 'down' not in stats['state']:\n assert time.time() - start < timeout, \\\n 'failed to reach down state before timeout expired'\n stats = manager.get_single_pg_stats(pgstr)\n\n #mark primary as lost\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\n '--yes-i-really-mean-it')\n\n\n #expect the pg status to be active+undersized+degraded\n #pg should recover and become active+clean within timeout\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=10\n start=time.time()\n\n while manager.get_num_down():\n assert time.time() - start < timeout, \\\n 'failed to recover before timeout expired'\n\n manager.revive_osd(primary)","def test_shd_should_not_crash_executed_heal_info(self):\n # pylint: disable=too-many-statements\n bricks_list = get_all_bricks(self.mnode, self.volname)\n # Setting options\n g.log.info('Setting options...')\n options = {\"metadata-self-heal\": \"off\",\n \"entry-self-heal\": \"off\",\n \"data-self-heal\": \"off\"}\n ret = set_volume_options(self.mnode, self.volname, options)\n self.assertTrue(ret, 'Failed to set options %s' % options)\n g.log.info(\"Successfully set %s for volume %s\",\n options, self.volname)\n\n # Creating files on client side\n for mount_obj in self.mounts:\n g.log.info(\"Generating data for %s:%s\",\n mount_obj.client_system, mount_obj.mountpoint)\n # Create files\n g.log.info('Creating files...')\n command = (\"python %s create_files -f 10 --fixed-file-size 1M %s\"\n % (self.script_upload_path, mount_obj.mountpoint))\n\n proc = g.run_async(mount_obj.client_system, command,\n user=mount_obj.user)\n self.all_mounts_procs.append(proc)\n self.io_validation_complete = False\n\n # Validate IO\n self.assertTrue(\n validate_io_procs(self.all_mounts_procs, self.mounts),\n \"IO failed on some of the clients\"\n )\n self.io_validation_complete = True\n\n # Bring brick0 offline\n g.log.info('Bringing bricks %s offline', bricks_list[0])\n ret = bring_bricks_offline(self.volname, bricks_list[0])\n self.assertTrue(ret, 'Failed to bring bricks %s offline'\n % bricks_list[0])\n\n ret = are_bricks_offline(self.mnode, self.volname,\n [bricks_list[0]])\n self.assertTrue(ret, 'Bricks %s are not offline'\n % bricks_list[0])\n g.log.info('Bringing bricks %s offline is successful',\n bricks_list[0])\n\n # Creating files on client side\n number_of_files_one_brick_off = '1000'\n self.all_mounts_procs = []\n for mount_obj in self.mounts:\n g.log.info(\"Generating data for %s:%s\",\n mount_obj.client_system, mount_obj.mountpoint)\n # Create files\n g.log.info('Creating files...')\n command = (\"python %s create_files \"\n \"-f %s \"\n \"--fixed-file-size 1k \"\n \"--base-file-name new_file \"\n \"%s\"\n % (self.script_upload_path,\n number_of_files_one_brick_off,\n mount_obj.mountpoint))\n\n proc = g.run_async(mount_obj.client_system, command,\n user=mount_obj.user)\n self.all_mounts_procs.append(proc)\n self.io_validation_complete = False\n\n # Validate IO\n self.assertTrue(\n validate_io_procs(self.all_mounts_procs, self.mounts),\n \"IO failed on some of the clients\"\n )\n self.io_validation_complete = True\n\n # Get heal info\n g.log.info(\"Getting heal info...\")\n heal_info_data = get_heal_info_summary(self.mnode, self.volname)\n self.assertIsNotNone(heal_info_data, 'Failed to get heal info.')\n g.log.info('Success in getting heal info')\n\n # Check quantity of file pending heal\n for brick in bricks_list[1:]:\n self.assertEqual(heal_info_data[brick]['numberOfEntries'],\n str(int(number_of_files_one_brick_off)+1),\n 'Number of files pending heal is not correct')\n\n # Setting options\n g.log.info('Setting options...')\n options = {\"performance.enable-least-priority\": \"enable\"}\n ret = set_volume_options(self.mnode, self.volname, options)\n self.assertTrue(ret, 'Failed to set options %s' % options)\n g.log.info(\"Successfully set %s for volume %s\",\n options, self.volname)\n\n # Bring brick1 offline\n g.log.info('Bringing bricks %s offline', bricks_list[1])\n ret = bring_bricks_offline(self.volname, bricks_list[1])\n self.assertTrue(ret, 'Failed to bring bricks %s offline'\n % bricks_list[1])\n\n ret = are_bricks_offline(self.mnode, self.volname,\n [bricks_list[1]])\n self.assertTrue(ret, 'Bricks %s are not offline'\n % bricks_list[1])\n g.log.info('Bringing bricks %s offline is successful',\n bricks_list[1])\n\n # Setting options\n g.log.info('Setting options...')\n options = {\"quorum-type\": \"fixed\"}\n ret = set_volume_options(self.mnode, self.volname, options)\n self.assertTrue(ret, 'Failed to set options %s' % options)\n g.log.info(\"Successfully set %s for volume %s\",\n options, self.volname)\n\n # Creating files on client side\n number_of_files_two_brick_off = '100'\n self.all_mounts_procs = []\n for mount_obj in self.mounts:\n g.log.info(\"Generating data for %s:%s\",\n mount_obj.client_system, mount_obj.mountpoint)\n # Create files\n g.log.info('Creating files...')\n command = (\"python %s create_files \"\n \"-f %s \"\n \"--fixed-file-size 1k \"\n \"--base-file-name new_new_file \"\n \"%s\"\n % (self.script_upload_path,\n number_of_files_two_brick_off,\n mount_obj.mountpoint))\n\n proc = g.run_async(mount_obj.client_system, command,\n user=mount_obj.user)\n self.all_mounts_procs.append(proc)\n self.io_validation_complete = False\n\n # Validate IO\n self.assertTrue(\n validate_io_procs(self.all_mounts_procs, self.mounts),\n \"IO failed on some of the clients\"\n )\n self.io_validation_complete = True\n\n # Get heal info\n g.log.info(\"Getting heal info...\")\n heal_info_data = get_heal_info_summary(self.mnode, self.volname)\n self.assertIsNotNone(heal_info_data, 'Failed to get heal info.')\n g.log.info('Success in getting heal info')\n\n # Check quantity of file pending heal\n number_of_files_to_check = str(int(number_of_files_one_brick_off) +\n int(number_of_files_two_brick_off) + 1)\n self.assertEqual(heal_info_data[bricks_list[-1]]['numberOfEntries'],\n number_of_files_to_check,\n 'Number of files pending heal is not correct')","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_set_state_full(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n mgt_uri = \"/api/target/%s/\" % self.mgt.id\n with mock.patch(\"chroma_core.models.Command.set_state\", mock.Mock(return_value=None)):\n self.api_set_state_full(mgt_uri, \"unmounted\")\n Command.set_state.assert_called_once()","async def test_endpoint_share_container_correct(self):\n self.json_mock.return_value.status = 204\n with self.patch_json_dump:\n resp = await share_container_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def _mount_point_exists(self, mountpoint):\n cmd = ['dir', mountpoint]\n logger.debug('running command: %s' % (' '.join(cmd)))\n stdout, stderr, retval = self._run_cli_process(cmd)\n\n if not retval:\n logger.debug(\"mountpoint %s ready\" % mountpoint)\n else:\n logger.debug(\"mountpoint %s reported not ready with error '%s'\" %\n (mountpoint, stderr.strip()))\n\n return not retval","def test_dashboards_v2_delete_share(self):\n pass","def testSupported2(t, env):\n c = env.c1.new_client(env.testname(t))\n sess = c.create_session()\n\n # GETFH after do a SECINFO_NO_NAME should get error NFS4ERR_NOFILEHANDLE\n res = sess.compound([op.putrootfh(), op.secinfo_no_name(0), op.getfh()])\n print res\n check(res, NFS4ERR_NOFILEHANDLE)","def test_patch_cluster_resource_quota_status(self):\n pass","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_object = RadosOrchestrator(node=cephadm)\n mon_obj = MonConfigMethods(rados_obj=rados_object)\n ceph_nodes = kw.get(\"ceph_nodes\")\n osd_list = []\n total_osd_app_mem = {}\n\n for node in ceph_nodes:\n if node.role == \"osd\":\n node_osds = rados_object.collect_osd_daemon_ids(node)\n osd_list = osd_list + node_osds\n\n target_configs = config[\"cache_trim_max_skip_pinned\"][\"configurations\"]\n max_skip_pinned_value = int(\n mon_obj.get_config(section=\"osd\", param=\"bluestore_cache_trim_max_skip_pinned\")\n )\n\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\n if max_skip_pinned_value != 1000:\n log.error(\n \"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\"\n )\n raise Exception(\n \"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\"\n )\n\n # Creating pools and starting the test\n for entry in target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n if entry.get(\"pool_type\", \"replicated\") == \"erasure\":\n method_should_succeed(\n rados_object.create_erasure_pool, name=entry[\"pool_name\"], **entry\n )\n else:\n method_should_succeed(\n rados_object.create_pool,\n **entry,\n )\n\n if not rados_object.bench_write(**entry):\n log.error(\"Failed to write objects into the EC Pool\")\n return 1\n rados_object.bench_read(**entry)\n log.info(\"Finished writing data into the pool\")\n\n # performing scrub and deep-scrub\n rados_object.run_scrub()\n rados_object.run_deep_scrub()\n time.sleep(10)\n\n rados_object.change_heap_profiler_state(osd_list, \"start\")\n # Executing tests for 45 minutes\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\n while datetime.datetime.now() < time_execution:\n # Get all OSDs heap dump\n heap_dump = rados_object.get_heap_dump(osd_list)\n # get the osd application used memory\n osd_app_mem = get_bytes_used_by_app(heap_dump)\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\n # wait for 10 seconds and collecting the memory\n time.sleep(10)\n for osd_id, mem_list in total_osd_app_mem.items():\n mem_growth = is_what_percent_mem(mem_list)\n if mem_growth > 80:\n log.error(\n f\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\"\n )\n raise Exception(\"No warning generated by PG Autoscaler\")\n log.info(f\"The relative memory growth for the osd.{osd_id} is {mem_growth} \")\n\n rados_object.change_heap_profiler_state(osd_list, \"stop\")\n\n # check fo the crashes in the cluster\n crash_list = rados_object.do_crash_ls()\n if not crash_list:\n return 0\n else:\n return 1","def test_01_dedicated_cluster_allocation(self):\n\n # Step 1\n dedicateCmd = dedicateCluster.dedicateClusterCmd()\n dedicateCmd.clusterid = self.clusters[0].id\n dedicateCmd.domainid = self.domain.id\n dedicateCmd.account = self.account_1.name\n self.apiclient.dedicateCluster(dedicateCmd)\n\n afcmd = listAffinityGroups.listAffinityGroupsCmd()\n afcmd.account = self.account_1.name\n afcmd.domainid = self.account_1.domainid\n affinitygr_list = self.apiclient.listAffinityGroups(afcmd)\n\n # Step 2\n self.vm = VirtualMachine.create(\n self.userapiclient_1,\n self.testdata[\"small\"],\n templateid=self.template.id,\n accountid=self.account_1.name,\n domainid=self.account_1.domainid,\n serviceofferingid=self.service_offering.id,\n affinitygroupids=[affinitygr_list[0].id],\n zoneid=self.zone.id,\n mode=self.zone.networktype\n )\n # Steps to verify if VM is created on dedicated account\n vmlist = list_virtual_machines(self.apiclient,\n id=self.vm.id)\n\n hostlist = list_hosts(self.apiclient,\n id=vmlist[0].hostid)\n\n self.assertEqual(hostlist[0].clusterid,\n self.clusters[0].id,\n \"check if vm gets deployed on dedicated clusture\"\n )\n # Step 3\n self.vm_1 = VirtualMachine.create(\n self.userapiclient_2,\n self.testdata[\"small\"],\n templateid=self.template.id,\n accountid=self.account_2.name,\n domainid=self.account_2.domainid,\n serviceofferingid=self.service_offering.id,\n zoneid=self.zone.id,\n mode=self.zone.networktype\n )\n\n # Steps to verify if VM is created on dedicated account\n vmlist_1 = list_virtual_machines(self.apiclient,\n id=self.vm_1.id)\n\n hostlist_1 = list_hosts(self.apiclient,\n id=vmlist_1[0].hostid)\n\n self.assertNotEqual(hostlist_1[0].clusterid,\n self.clusters[0].id,\n \"check if vm gets deployed on correct clusture\"\n )\n\n # Step 4\n routerList = list_routers(self.apiclient,\n clusterid=self.clusters[0].id,\n networkid=self.vm_1.nic[0].networkid\n )\n self.assertEqual(\n routerList,\n None,\n \"Check Dedicated cluster is used for virtual routers \\\n that belong to non-dedicated account\")\n\n return","def test_too_many_gigabytes(self):\n volume1 = self.start_service('volume', host='host1')\n volume2 = self.start_service('volume', host='host2')\n volume_ids1 = []\n volume_ids2 = []\n for index in xrange(FLAGS.max_gigabytes):\n volume_id = self._create_volume()\n volume1.create_volume(self.context, volume_id)\n volume_ids1.append(volume_id)\n volume_id = self._create_volume()\n volume2.create_volume(self.context, volume_id)\n volume_ids2.append(volume_id)\n volume_id = self._create_volume()\n self.assertRaises(driver.NoValidHost,\n self.scheduler.driver.schedule_create_volume,\n self.context,\n volume_id)\n for volume_id in volume_ids1:\n volume1.delete_volume(self.context, volume_id)\n for volume_id in volume_ids2:\n volume2.delete_volume(self.context, volume_id)\n volume1.kill()\n volume2.kill()","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_create_hyperflex_cluster_storage_policy(self):\n pass","def test_nuke_psfs():\n # Without multiprocessing\n mt.nuke_psfs(mprocessing=False)\n\n # With multiprocessing\n mt.nuke_psfs()","def active_mountpoint(mount_point):\n execute('mount', mount_point, sudo=True)\n yield\n execute('umount', mount_point, sudo=True)","def test_claim_resources_success_resize_to_same_host_with_shared(self):\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\n # source host allocation held by the migration_uuid so it is not\n # not returned to the claim code as that asks for the instance_uuid\n # consumer\n get_current_allocations_resp_mock.json.return_value = {\n 'allocations': {},\n \"consumer_generation\": 1,\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\n put_allocations_resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\n consumer_uuid = uuids.consumer_uuid\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\n # are all being increased but on the same host. We also throw a custom\n # resource class in the new allocation to make sure it's not lost\n alloc_req = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'CUSTOM_FOO': 1\n }\n },\n uuids.shared_storage: {\n 'resources': {\n 'DISK_GB': 40,\n }\n },\n },\n # this allocation request comes from the scheduler therefore it\n # does not have consumer_generation in it.\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.claim_resources(self.context, consumer_uuid,\n alloc_req, project_id, user_id,\n allocation_request_version='1.28')\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n expected_payload = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'CUSTOM_FOO': 1\n }\n },\n uuids.shared_storage: {\n 'resources': {\n 'DISK_GB': 40,\n }\n },\n },\n # report client assumes a new consumer in this case\n 'consumer_generation': None,\n 'project_id': project_id,\n 'user_id': user_id}\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n\n self.assertTrue(res)","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_obj = RadosOrchestrator(node=cephadm)\n pool_obj = PoolFunctions(node=cephadm)\n scrub_obj = RadosScrubber(node=cephadm)\n\n pool_target_configs = config[\"verify_osd_omap_entries\"][\"configurations\"]\n omap_target_configs = config[\"verify_osd_omap_entries\"][\"omap_config\"]\n\n # Creating pools and starting the test\n for entry in pool_target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n method_should_succeed(\n rados_obj.create_pool,\n **entry,\n )\n\n log.debug(\n \"Created the pool. beginning to create large number of omap entries on the pool\"\n )\n\n # Creating omaps\n create_omap(pool_obj, pool_target_configs, omap_target_configs)\n\n omap_thread = Thread(\n target=create_omap, args=[pool_obj, pool_target_configs, omap_target_configs]\n )\n\n # Get the scrub and deep scrup time stamp before scrub and deep scrub execution\n before_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_scrub_stamp\")\n before_deep_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_deep_scrub_stamp\")\n\n # performing scrub and deep-scrub\n rados_obj.run_scrub()\n rados_obj.run_deep_scrub()\n scrub_status = 1\n deep_scrub_status = 1\n\n while scrub_status == 1 and deep_scrub_status == 1:\n # Scrub check for every 20 seconds\n time.sleep(20)\n after_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_scrub_stamp\")\n after_deep_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_deep_scrub_stamp\")\n scrub_status = scrub_obj.verify_scrub_deepscrub(\n before_scrub_log, after_scrub_log, \"scrub\"\n )\n deep_scrub_status = scrub_obj.verify_scrub_deepscrub(\n before_deep_scrub_log, after_deep_scrub_log, \"deepscrub\"\n )\n log.info(\"scrubbing and deep-scrubbing are in progress\")\n log.info(\"scrubbing and deep-scrubbing completed\")\n\n # Check for large omap massage\n ceph_status = rados_obj.run_ceph_command(cmd=\" ceph health\")\n if \"LARGE_OMAP_OBJECTS\" in ceph_status[\"checks\"]:\n log.info(\" Generated large omaps in the cluster\")\n else:\n log.error(\" Unable to generate the large omaps in the cluster\")\n return 1\n\n # verification of OSDs for 30 minutes\n verification_osd_thread = Thread(target=verification_osd, args=[rados_obj, 30])\n omap_thread.daemon = True\n omap_thread.start()\n verification_osd_thread.start()\n verification_osd_thread.join()\n omap_thread._delete()\n if result == 0:\n return 0\n else:\n return 1","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_update_volume_stats_cached(self):\n self._fail_host_storage = True\n actual = self.driver.get_volume_stats(False)\n self.assertEqual('HGST', actual['vendor_name'])\n self.assertEqual('hgst', actual['storage_protocol'])\n self.assertEqual(90, actual['total_capacity_gb'])\n self.assertEqual(87, actual['free_capacity_gb'])\n self.assertEqual(0, actual['reserved_percentage'])","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def guid_fast_impl(pool):\n with open(f'/proc/spl/kstat/zfs/{pool}/guid') as f:\n return f.read().strip()","def is_guest_sharing_auto_mount(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))","def mac_pool_exists(handle, name, assignment_order=None,\r\n r_from=None, to=None, descr=None, parent_dn=\"org-root\"):\r\n dn = parent_dn + '/mac-pool-' + name\r\n mo = handle.query_dn(dn)\r\n if mo:\r\n if ((assignment_order and mo.assignment_order != assignment_order) and\r\n (r_from and mo.r_from != r_from) and\r\n (to and mo.to != to) and\r\n (descr and mo.descr != descr)):\r\n return False\r\n return True\r\n return False","def _get_mount_point_for_share(self, nfs_share):\n nfs_share = nfs_share.encode('utf-8')\n return os.path.join(self.configuration.nexenta_mount_point_base,\n md5(nfs_share, usedforsecurity=False).hexdigest())","def _pmount(self, action, args, error='exit'):\n args = ('p%s' % action,) + args + (self.devname,)\n if action == 'mount':\n if self.label:\n args += (self.label,)\n msg = 'Mounting %s on %s'\n else:\n msg = 'Unmounting %s from %s'\n print(msg % (self.devname, get_mount_target(self.devname, self.label)))\n result = call(args)\n if result and error == 'exit':\n exit(result)","def pool_snps(parent1, parent2):","def _fsal_hook(self, base, share, access):\n return {\"Hostname\": self.gluster_manager.host,\n \"Volume\": self.gluster_manager.volume,\n \"Volpath\": \"/\" + share['name']}","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()","def test_guest_os(self):\n self.check_guest_os()"],"string":"[\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_volume_service_pool(self):\\n self.assertEqual(\\n ChangeStateScript()._deployer._volume_service._pool,\\n StoragePool(reactor, b\\\"flocker\\\", FilePath(b\\\"/flocker\\\")))\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_get_drive_mount_point_name_unique_id_exists(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n gfs._unique_id = 0\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n gfs._unique_id = None\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def test_no_list_listings(self):\\n pool_name = p_n()\\n fs_name = fs_n()\\n StratisCli.pool_create(pool_name, block_devices=DISKS)\\n StratisCli.fs_create(pool_name, fs_name)\\n\\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\\n self.assertEqual(StratisCli.blockdev_list(),\\n StratisCli.blockdev_list(False))\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def check_free_space():\\n subprocess.run([\\\"ssh\\\",backup_host, \\\"du -h\\\", dest ]])\\n # get output\",\n \"def verify_avail_space(self, pool, project, share, size):\\n self.verify_project(pool, project)\\n avail = self.get_project_stats(pool, project)\\n if avail < size:\\n exception_msg = (_('Error creating '\\n 'share: %(share)s on '\\n 'pool: %(pool)s. '\\n 'Not enough space.')\\n % {'share': share,\\n 'pool': pool})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_get_drive_mount_point_name_unique_id_None(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_least_busy_host_gets_volume(self):\\n volume1 = self.start_service('volume', host='host1')\\n volume2 = self.start_service('volume', host='host2')\\n volume_id1 = self._create_volume()\\n volume1.create_volume(self.context, volume_id1)\\n volume_id2 = self._create_volume()\\n host = self.scheduler.driver.schedule_create_volume(self.context,\\n volume_id2)\\n self.assertEqual(host, 'host2')\\n volume1.delete_volume(self.context, volume_id1)\\n db.volume_destroy(self.context, volume_id2)\\n volume1.kill()\\n volume2.kill()\",\n \"def _create_volume_pool(self, pool_name):\\n osd_map = self._rados_command('osd dump', {})\\n\\n existing_id = self._get_pool_id(osd_map, pool_name)\\n if existing_id is not None:\\n log.info(\\\"Pool {0} already exists\\\".format(pool_name))\\n return existing_id\\n\\n osd_count = len(osd_map['osds'])\\n\\n # We can't query the actual cluster config remotely, but since this is\\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\\n # that in use in the rest of the cluster.\\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\\n\\n other_pgs = 0\\n for pool in osd_map['pools']:\\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\\n other_pgs += pool['pg_num']\\n\\n # A basic heuristic for picking pg_num: work out the max number of\\n # PGs we can have without tripping a warning, then subtract the number\\n # of PGs already created by non-manila pools, then divide by ten. That'll\\n # give you a reasonable result on a system where you have \\\"a few\\\" manila\\n # shares.\\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\\n # TODO Alternatively, respect an override set by the user.\\n\\n self._rados_command(\\n 'osd pool create',\\n {\\n 'pool': pool_name,\\n 'pg_num': int(pg_num),\\n }\\n )\\n\\n osd_map = self._rados_command('osd dump', {})\\n pool_id = self._get_pool_id(osd_map, pool_name)\\n\\n if pool_id is None:\\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\\n # removing it right after we created it.\\n log.error(\\\"OSD map doesn't contain expected pool '{0}':\\\\n{1}\\\".format(\\n pool_name, json.dumps(osd_map, indent=2)\\n ))\\n raise RuntimeError(\\\"Pool '{0}' not present in map after creation\\\".format(pool_name))\\n else:\\n return pool_id\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def mount_cifs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n share_name = share_config.get('share_name')\\n remote_host = share_config.get('remote_host')\\n if remote_host and share_name and mount_point:\\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\\n self.cmd(command)\",\n \"def _get_capacity_info(self, nfs_share):\\n nms = self.share2nms[nfs_share]\\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\\n ns_folder),\\n 'used|available')\\n free = utils.str2size(folder_props['available'])\\n allocated = utils.str2size(folder_props['used'])\\n self.shares_with_capacities[nfs_share] = {\\n 'free': utils.str2gib_size(free),\\n 'total': utils.str2gib_size(free + allocated)}\\n return free + allocated, free, allocated\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def umount_cifs_share(self, **kwargs):\\n mount_point = kwargs.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def test_least_busy_host_gets_volume_no_queue(self):\\n volume1 = service.Service('host1',\\n 'nova-volume',\\n 'volume',\\n FLAGS.volume_manager)\\n volume1.start()\\n volume2 = service.Service('host2',\\n 'nova-volume',\\n 'volume',\\n FLAGS.volume_manager)\\n volume2.start()\\n volume_id1 = self._create_volume()\\n volume1.create_volume(self.context, volume_id1)\\n volume_id2 = self._create_volume()\\n host = self.scheduler.driver.schedule_create_volume(self.context,\\n volume_id2)\\n self.assertEqual(host, 'host2')\\n volume1.delete_volume(self.context, volume_id1)\\n db.volume_destroy(self.context, volume_id2)\",\n \"def test_verify_ssh_access_with_root_works(driver):\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def verify_pool(self, pool):\\n svc = self.pool_path % pool\\n self.rest_get(svc, restclient.Status.OK)\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def __init__(self, win_server, share_folder, mount_point, user, password):\\n \\n share_folder = share_folder.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n network_folder = r'//%s/%s' %(win_server, share_folder)\\n\\n print('Mount_point - %s' %(mount_point))\\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\\n self.mount_point = mount_point\\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\\n self.success = []\\n self.error = []\\n\\n mount_cmd = \\\"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\\\"\\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\\n mount_point=mount_point,\\n user=user,\\n password=password)\\n self.umount_cmd = \\\"umount {mount_point}\\\".format(mount_point=mount_point)\",\n \"def test_02_sys_vm_start(self):\\n\\n # 1. verify listHosts has all 'routing' hosts in UP state\\n # 2. verify listStoragePools shows all primary storage pools\\n # in UP state\\n # 3. verify that secondary storage was added successfully\\n\\n list_hosts_response = list_hosts(\\n self.apiclient,\\n type='Routing',\\n zoneid=self.zone.id,\\n podid=self.pod.id\\n )\\n self.assertEqual(\\n isinstance(list_hosts_response, list),\\n True,\\n \\\"Check list response returns a valid list\\\"\\n )\\n # ListHosts has all 'routing' hosts in UP state\\n self.assertNotEqual(\\n len(list_hosts_response),\\n 0,\\n \\\"Check list host response\\\"\\n )\\n for host in list_hosts_response:\\n self.assertEqual(\\n host.state,\\n 'Up',\\n \\\"Check state of routing hosts is Up or not\\\"\\n )\\n\\n # ListStoragePools shows all primary storage pools in UP state\\n list_storage_response = list_storage_pools(\\n self.apiclient,\\n zoneid=self.zone.id,\\n podid=self.pod.id\\n )\\n self.assertEqual(\\n isinstance(list_storage_response, list),\\n True,\\n \\\"Check list response returns a valid list\\\"\\n )\\n self.assertNotEqual(\\n len(list_storage_response),\\n 0,\\n \\\"Check list storage pools response\\\"\\n )\\n\\n for primary_storage in list_hosts_response:\\n self.assertEqual(\\n primary_storage.state,\\n 'Up',\\n \\\"Check state of primary storage pools is Up or not\\\"\\n )\\n\\n # Secondary storage is added successfully\\n timeout = self.services[\\\"timeout\\\"]\\n while True:\\n list_hosts_response = list_hosts(\\n self.apiclient,\\n type='SecondaryStorage',\\n zoneid=self.zone.id,\\n )\\n\\n if not isinstance(list_hosts_response, list):\\n # Sleep to ensure Secondary storage is Up\\n time.sleep(int(self.services[\\\"sleep\\\"]))\\n timeout = timeout - 1\\n elif timeout == 0 or isinstance(list_hosts_response, list):\\n break\\n \\n self.assertEqual(\\n isinstance(list_hosts_response, list),\\n True,\\n \\\"Check list response returns a valid list\\\"\\n )\\n \\n self.assertNotEqual(\\n len(list_hosts_response),\\n 0,\\n \\\"Check list Hosts response\\\"\\n )\\n\\n host_response = list_hosts_response[0]\\n #Check if host is Up and running\\n self.assertEqual(\\n host_response.state,\\n 'Up',\\n \\\"Check state of secondary storage\\\"\\n )\\n self.debug(\\\"Checking SSVM status in zone: %s\\\" % self.zone.id)\\n\\n timeout = self.services[\\\"timeout\\\"]\\n\\n while True:\\n list_ssvm_response = list_ssvms(\\n self.apiclient,\\n systemvmtype='secondarystoragevm',\\n zoneid=self.zone.id,\\n podid=self.pod.id\\n )\\n if not isinstance(list_ssvm_response, list):\\n # Sleep to ensure SSVMs are Up and Running\\n time.sleep(int(self.services[\\\"sleep\\\"]))\\n timeout = timeout - 1\\n elif timeout == 0 or isinstance(list_ssvm_response, list):\\n break\\n \\n self.assertEqual(\\n isinstance(list_ssvm_response, list),\\n True,\\n \\\"Check list response returns a valid list\\\"\\n )\\n #Verify SSVM response\\n self.assertNotEqual(\\n len(list_ssvm_response),\\n 0,\\n \\\"Check list System VMs response\\\"\\n )\\n\\n for ssvm in list_ssvm_response:\\n self.assertEqual(\\n ssvm.state,\\n 'Running',\\n \\\"Check whether state of SSVM is running\\\"\\n )\\n return\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_replace_cluster_resource_quota_status(self):\\n pass\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def test_check_disk_space_sufficient(self):\\n self.assertTrue(self.command.check_disk_space(1, self.temp_dir))\\n self.assertTrue(self.command.check_disk_space(\\n 1, self.temp_dir,\\n label=\\\"Hello\\\", context=\\\"Contextual detail\\\", die=True))\",\n \"def _ensure_share_mounted(self, nfs_share, mount_path=None):\\n mnt_flags = []\\n if self.shares.get(nfs_share) is not None:\\n mnt_flags = self.shares[nfs_share].split()\\n num_attempts = max(1, self.configuration.nfs_mount_attempts)\\n for attempt in range(num_attempts):\\n try:\\n if mount_path is None:\\n self._remotefsclient.mount(nfs_share, mnt_flags)\\n else:\\n if mount_path in self._remotefsclient._read_mounts():\\n LOG.info('Already mounted: %s', mount_path)\\n return\\n\\n fileutils.ensure_tree(mount_path)\\n self._remotefsclient._mount_nfs(nfs_share, mount_path,\\n mnt_flags)\\n return\\n except Exception as e:\\n if attempt == (num_attempts - 1):\\n LOG.error('Mount failure for %(share)s after '\\n '%(count)d attempts.',\\n {'share': nfs_share,\\n 'count': num_attempts})\\n raise exception.NfsException(six.text_type(e))\\n LOG.warning(\\n 'Mount attempt %(attempt)d failed: %(error)s. '\\n 'Retrying mount ...',\\n {'attempt': attempt, 'error': e})\\n greenthread.sleep(1)\",\n \"def test_HYD965(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpBadRequest(response)\",\n \"def share():\\n return True\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def test_ls_no_shareddir():\\n\\n with bad_fixture() as root:\\n assert next(pipeline.ls(root=root), None) is None\",\n \"def _is_pool_owned(self, pdata):\\n svc = '/api/system/v1/version'\\n ret = self.rest_get(svc, restclient.Status.OK)\\n vdata = jsonutils.loads(ret.data)\\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\\n vdata['version']['nodename'] == pdata['pool']['owner'])\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_list_cluster_resource_quota(self):\\n pass\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_create_cloned_volume(self, mock_ghn):\\n ctxt = context.get_admin_context()\\n extra_specs = {}\\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10,\\n 'provider_id': 'space_orig'}\\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10}\\n pid = self.driver.create_cloned_volume(clone, orig)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': 'clone1', 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'clone1'}\\n self.assertDictMatch(expected_pid, pid)\",\n \"def task(ctx, config):\\n if config is None:\\n config = {}\\n assert isinstance(config, dict), \\\\\\n 'Resolve stuck peering only accepts a dict for config'\\n\\n manager = ctx.managers['ceph']\\n\\n while len(manager.get_osd_status()['up']) < 3:\\n time.sleep(10)\\n\\n\\n manager.wait_for_clean()\\n\\n dummyfile = '/etc/fstab'\\n dummyfile1 = '/etc/resolv.conf'\\n\\n #create 1 PG pool\\n pool='foo'\\n log.info('creating pool foo')\\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\\n\\n #set min_size of the pool to 1\\n #so that we can continue with I/O\\n #when 2 osds are down\\n manager.set_pool_property(pool, \\\"min_size\\\", 1)\\n\\n osds = [0, 1, 2]\\n\\n primary = manager.get_pg_primary('foo', 0)\\n log.info(\\\"primary osd is %d\\\", primary)\\n\\n others = list(osds)\\n others.remove(primary)\\n\\n log.info('writing initial objects')\\n first_mon = teuthology.get_first_mon(ctx, config)\\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\\n #create few objects\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\\n\\n manager.wait_for_clean()\\n\\n #kill other osds except primary\\n log.info('killing other osds except primary')\\n for i in others:\\n manager.kill_osd(i)\\n for i in others:\\n manager.mark_down_osd(i)\\n\\n\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\\n\\n #kill primary osd\\n manager.kill_osd(primary)\\n manager.mark_down_osd(primary)\\n\\n #revive other 2 osds\\n for i in others:\\n manager.revive_osd(i)\\n\\n #make sure that pg is down\\n #Assuming pg number for single pg pool will start from 0\\n pgnum=0\\n pgstr = manager.get_pgid(pool, pgnum)\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=60\\n start=time.time()\\n\\n while 'down' not in stats['state']:\\n assert time.time() - start < timeout, \\\\\\n 'failed to reach down state before timeout expired'\\n stats = manager.get_single_pg_stats(pgstr)\\n\\n #mark primary as lost\\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\\\\n '--yes-i-really-mean-it')\\n\\n\\n #expect the pg status to be active+undersized+degraded\\n #pg should recover and become active+clean within timeout\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=10\\n start=time.time()\\n\\n while manager.get_num_down():\\n assert time.time() - start < timeout, \\\\\\n 'failed to recover before timeout expired'\\n\\n manager.revive_osd(primary)\",\n \"def test_shd_should_not_crash_executed_heal_info(self):\\n # pylint: disable=too-many-statements\\n bricks_list = get_all_bricks(self.mnode, self.volname)\\n # Setting options\\n g.log.info('Setting options...')\\n options = {\\\"metadata-self-heal\\\": \\\"off\\\",\\n \\\"entry-self-heal\\\": \\\"off\\\",\\n \\\"data-self-heal\\\": \\\"off\\\"}\\n ret = set_volume_options(self.mnode, self.volname, options)\\n self.assertTrue(ret, 'Failed to set options %s' % options)\\n g.log.info(\\\"Successfully set %s for volume %s\\\",\\n options, self.volname)\\n\\n # Creating files on client side\\n for mount_obj in self.mounts:\\n g.log.info(\\\"Generating data for %s:%s\\\",\\n mount_obj.client_system, mount_obj.mountpoint)\\n # Create files\\n g.log.info('Creating files...')\\n command = (\\\"python %s create_files -f 10 --fixed-file-size 1M %s\\\"\\n % (self.script_upload_path, mount_obj.mountpoint))\\n\\n proc = g.run_async(mount_obj.client_system, command,\\n user=mount_obj.user)\\n self.all_mounts_procs.append(proc)\\n self.io_validation_complete = False\\n\\n # Validate IO\\n self.assertTrue(\\n validate_io_procs(self.all_mounts_procs, self.mounts),\\n \\\"IO failed on some of the clients\\\"\\n )\\n self.io_validation_complete = True\\n\\n # Bring brick0 offline\\n g.log.info('Bringing bricks %s offline', bricks_list[0])\\n ret = bring_bricks_offline(self.volname, bricks_list[0])\\n self.assertTrue(ret, 'Failed to bring bricks %s offline'\\n % bricks_list[0])\\n\\n ret = are_bricks_offline(self.mnode, self.volname,\\n [bricks_list[0]])\\n self.assertTrue(ret, 'Bricks %s are not offline'\\n % bricks_list[0])\\n g.log.info('Bringing bricks %s offline is successful',\\n bricks_list[0])\\n\\n # Creating files on client side\\n number_of_files_one_brick_off = '1000'\\n self.all_mounts_procs = []\\n for mount_obj in self.mounts:\\n g.log.info(\\\"Generating data for %s:%s\\\",\\n mount_obj.client_system, mount_obj.mountpoint)\\n # Create files\\n g.log.info('Creating files...')\\n command = (\\\"python %s create_files \\\"\\n \\\"-f %s \\\"\\n \\\"--fixed-file-size 1k \\\"\\n \\\"--base-file-name new_file \\\"\\n \\\"%s\\\"\\n % (self.script_upload_path,\\n number_of_files_one_brick_off,\\n mount_obj.mountpoint))\\n\\n proc = g.run_async(mount_obj.client_system, command,\\n user=mount_obj.user)\\n self.all_mounts_procs.append(proc)\\n self.io_validation_complete = False\\n\\n # Validate IO\\n self.assertTrue(\\n validate_io_procs(self.all_mounts_procs, self.mounts),\\n \\\"IO failed on some of the clients\\\"\\n )\\n self.io_validation_complete = True\\n\\n # Get heal info\\n g.log.info(\\\"Getting heal info...\\\")\\n heal_info_data = get_heal_info_summary(self.mnode, self.volname)\\n self.assertIsNotNone(heal_info_data, 'Failed to get heal info.')\\n g.log.info('Success in getting heal info')\\n\\n # Check quantity of file pending heal\\n for brick in bricks_list[1:]:\\n self.assertEqual(heal_info_data[brick]['numberOfEntries'],\\n str(int(number_of_files_one_brick_off)+1),\\n 'Number of files pending heal is not correct')\\n\\n # Setting options\\n g.log.info('Setting options...')\\n options = {\\\"performance.enable-least-priority\\\": \\\"enable\\\"}\\n ret = set_volume_options(self.mnode, self.volname, options)\\n self.assertTrue(ret, 'Failed to set options %s' % options)\\n g.log.info(\\\"Successfully set %s for volume %s\\\",\\n options, self.volname)\\n\\n # Bring brick1 offline\\n g.log.info('Bringing bricks %s offline', bricks_list[1])\\n ret = bring_bricks_offline(self.volname, bricks_list[1])\\n self.assertTrue(ret, 'Failed to bring bricks %s offline'\\n % bricks_list[1])\\n\\n ret = are_bricks_offline(self.mnode, self.volname,\\n [bricks_list[1]])\\n self.assertTrue(ret, 'Bricks %s are not offline'\\n % bricks_list[1])\\n g.log.info('Bringing bricks %s offline is successful',\\n bricks_list[1])\\n\\n # Setting options\\n g.log.info('Setting options...')\\n options = {\\\"quorum-type\\\": \\\"fixed\\\"}\\n ret = set_volume_options(self.mnode, self.volname, options)\\n self.assertTrue(ret, 'Failed to set options %s' % options)\\n g.log.info(\\\"Successfully set %s for volume %s\\\",\\n options, self.volname)\\n\\n # Creating files on client side\\n number_of_files_two_brick_off = '100'\\n self.all_mounts_procs = []\\n for mount_obj in self.mounts:\\n g.log.info(\\\"Generating data for %s:%s\\\",\\n mount_obj.client_system, mount_obj.mountpoint)\\n # Create files\\n g.log.info('Creating files...')\\n command = (\\\"python %s create_files \\\"\\n \\\"-f %s \\\"\\n \\\"--fixed-file-size 1k \\\"\\n \\\"--base-file-name new_new_file \\\"\\n \\\"%s\\\"\\n % (self.script_upload_path,\\n number_of_files_two_brick_off,\\n mount_obj.mountpoint))\\n\\n proc = g.run_async(mount_obj.client_system, command,\\n user=mount_obj.user)\\n self.all_mounts_procs.append(proc)\\n self.io_validation_complete = False\\n\\n # Validate IO\\n self.assertTrue(\\n validate_io_procs(self.all_mounts_procs, self.mounts),\\n \\\"IO failed on some of the clients\\\"\\n )\\n self.io_validation_complete = True\\n\\n # Get heal info\\n g.log.info(\\\"Getting heal info...\\\")\\n heal_info_data = get_heal_info_summary(self.mnode, self.volname)\\n self.assertIsNotNone(heal_info_data, 'Failed to get heal info.')\\n g.log.info('Success in getting heal info')\\n\\n # Check quantity of file pending heal\\n number_of_files_to_check = str(int(number_of_files_one_brick_off) +\\n int(number_of_files_two_brick_off) + 1)\\n self.assertEqual(heal_info_data[bricks_list[-1]]['numberOfEntries'],\\n number_of_files_to_check,\\n 'Number of files pending heal is not correct')\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_set_state_full(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n mgt_uri = \\\"/api/target/%s/\\\" % self.mgt.id\\n with mock.patch(\\\"chroma_core.models.Command.set_state\\\", mock.Mock(return_value=None)):\\n self.api_set_state_full(mgt_uri, \\\"unmounted\\\")\\n Command.set_state.assert_called_once()\",\n \"async def test_endpoint_share_container_correct(self):\\n self.json_mock.return_value.status = 204\\n with self.patch_json_dump:\\n resp = await share_container_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def _mount_point_exists(self, mountpoint):\\n cmd = ['dir', mountpoint]\\n logger.debug('running command: %s' % (' '.join(cmd)))\\n stdout, stderr, retval = self._run_cli_process(cmd)\\n\\n if not retval:\\n logger.debug(\\\"mountpoint %s ready\\\" % mountpoint)\\n else:\\n logger.debug(\\\"mountpoint %s reported not ready with error '%s'\\\" %\\n (mountpoint, stderr.strip()))\\n\\n return not retval\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def testSupported2(t, env):\\n c = env.c1.new_client(env.testname(t))\\n sess = c.create_session()\\n\\n # GETFH after do a SECINFO_NO_NAME should get error NFS4ERR_NOFILEHANDLE\\n res = sess.compound([op.putrootfh(), op.secinfo_no_name(0), op.getfh()])\\n print res\\n check(res, NFS4ERR_NOFILEHANDLE)\",\n \"def test_patch_cluster_resource_quota_status(self):\\n pass\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_object = RadosOrchestrator(node=cephadm)\\n mon_obj = MonConfigMethods(rados_obj=rados_object)\\n ceph_nodes = kw.get(\\\"ceph_nodes\\\")\\n osd_list = []\\n total_osd_app_mem = {}\\n\\n for node in ceph_nodes:\\n if node.role == \\\"osd\\\":\\n node_osds = rados_object.collect_osd_daemon_ids(node)\\n osd_list = osd_list + node_osds\\n\\n target_configs = config[\\\"cache_trim_max_skip_pinned\\\"][\\\"configurations\\\"]\\n max_skip_pinned_value = int(\\n mon_obj.get_config(section=\\\"osd\\\", param=\\\"bluestore_cache_trim_max_skip_pinned\\\")\\n )\\n\\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\\n if max_skip_pinned_value != 1000:\\n log.error(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\\\"\\n )\\n raise Exception(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\\\"\\n )\\n\\n # Creating pools and starting the test\\n for entry in target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n if entry.get(\\\"pool_type\\\", \\\"replicated\\\") == \\\"erasure\\\":\\n method_should_succeed(\\n rados_object.create_erasure_pool, name=entry[\\\"pool_name\\\"], **entry\\n )\\n else:\\n method_should_succeed(\\n rados_object.create_pool,\\n **entry,\\n )\\n\\n if not rados_object.bench_write(**entry):\\n log.error(\\\"Failed to write objects into the EC Pool\\\")\\n return 1\\n rados_object.bench_read(**entry)\\n log.info(\\\"Finished writing data into the pool\\\")\\n\\n # performing scrub and deep-scrub\\n rados_object.run_scrub()\\n rados_object.run_deep_scrub()\\n time.sleep(10)\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"start\\\")\\n # Executing tests for 45 minutes\\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\\n while datetime.datetime.now() < time_execution:\\n # Get all OSDs heap dump\\n heap_dump = rados_object.get_heap_dump(osd_list)\\n # get the osd application used memory\\n osd_app_mem = get_bytes_used_by_app(heap_dump)\\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\\n # wait for 10 seconds and collecting the memory\\n time.sleep(10)\\n for osd_id, mem_list in total_osd_app_mem.items():\\n mem_growth = is_what_percent_mem(mem_list)\\n if mem_growth > 80:\\n log.error(\\n f\\\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\\\"\\n )\\n raise Exception(\\\"No warning generated by PG Autoscaler\\\")\\n log.info(f\\\"The relative memory growth for the osd.{osd_id} is {mem_growth} \\\")\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"stop\\\")\\n\\n # check fo the crashes in the cluster\\n crash_list = rados_object.do_crash_ls()\\n if not crash_list:\\n return 0\\n else:\\n return 1\",\n \"def test_01_dedicated_cluster_allocation(self):\\n\\n # Step 1\\n dedicateCmd = dedicateCluster.dedicateClusterCmd()\\n dedicateCmd.clusterid = self.clusters[0].id\\n dedicateCmd.domainid = self.domain.id\\n dedicateCmd.account = self.account_1.name\\n self.apiclient.dedicateCluster(dedicateCmd)\\n\\n afcmd = listAffinityGroups.listAffinityGroupsCmd()\\n afcmd.account = self.account_1.name\\n afcmd.domainid = self.account_1.domainid\\n affinitygr_list = self.apiclient.listAffinityGroups(afcmd)\\n\\n # Step 2\\n self.vm = VirtualMachine.create(\\n self.userapiclient_1,\\n self.testdata[\\\"small\\\"],\\n templateid=self.template.id,\\n accountid=self.account_1.name,\\n domainid=self.account_1.domainid,\\n serviceofferingid=self.service_offering.id,\\n affinitygroupids=[affinitygr_list[0].id],\\n zoneid=self.zone.id,\\n mode=self.zone.networktype\\n )\\n # Steps to verify if VM is created on dedicated account\\n vmlist = list_virtual_machines(self.apiclient,\\n id=self.vm.id)\\n\\n hostlist = list_hosts(self.apiclient,\\n id=vmlist[0].hostid)\\n\\n self.assertEqual(hostlist[0].clusterid,\\n self.clusters[0].id,\\n \\\"check if vm gets deployed on dedicated clusture\\\"\\n )\\n # Step 3\\n self.vm_1 = VirtualMachine.create(\\n self.userapiclient_2,\\n self.testdata[\\\"small\\\"],\\n templateid=self.template.id,\\n accountid=self.account_2.name,\\n domainid=self.account_2.domainid,\\n serviceofferingid=self.service_offering.id,\\n zoneid=self.zone.id,\\n mode=self.zone.networktype\\n )\\n\\n # Steps to verify if VM is created on dedicated account\\n vmlist_1 = list_virtual_machines(self.apiclient,\\n id=self.vm_1.id)\\n\\n hostlist_1 = list_hosts(self.apiclient,\\n id=vmlist_1[0].hostid)\\n\\n self.assertNotEqual(hostlist_1[0].clusterid,\\n self.clusters[0].id,\\n \\\"check if vm gets deployed on correct clusture\\\"\\n )\\n\\n # Step 4\\n routerList = list_routers(self.apiclient,\\n clusterid=self.clusters[0].id,\\n networkid=self.vm_1.nic[0].networkid\\n )\\n self.assertEqual(\\n routerList,\\n None,\\n \\\"Check Dedicated cluster is used for virtual routers \\\\\\n that belong to non-dedicated account\\\")\\n\\n return\",\n \"def test_too_many_gigabytes(self):\\n volume1 = self.start_service('volume', host='host1')\\n volume2 = self.start_service('volume', host='host2')\\n volume_ids1 = []\\n volume_ids2 = []\\n for index in xrange(FLAGS.max_gigabytes):\\n volume_id = self._create_volume()\\n volume1.create_volume(self.context, volume_id)\\n volume_ids1.append(volume_id)\\n volume_id = self._create_volume()\\n volume2.create_volume(self.context, volume_id)\\n volume_ids2.append(volume_id)\\n volume_id = self._create_volume()\\n self.assertRaises(driver.NoValidHost,\\n self.scheduler.driver.schedule_create_volume,\\n self.context,\\n volume_id)\\n for volume_id in volume_ids1:\\n volume1.delete_volume(self.context, volume_id)\\n for volume_id in volume_ids2:\\n volume2.delete_volume(self.context, volume_id)\\n volume1.kill()\\n volume2.kill()\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_create_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_nuke_psfs():\\n # Without multiprocessing\\n mt.nuke_psfs(mprocessing=False)\\n\\n # With multiprocessing\\n mt.nuke_psfs()\",\n \"def active_mountpoint(mount_point):\\n execute('mount', mount_point, sudo=True)\\n yield\\n execute('umount', mount_point, sudo=True)\",\n \"def test_claim_resources_success_resize_to_same_host_with_shared(self):\\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\\n # source host allocation held by the migration_uuid so it is not\\n # not returned to the claim code as that asks for the instance_uuid\\n # consumer\\n get_current_allocations_resp_mock.json.return_value = {\\n 'allocations': {},\\n \\\"consumer_generation\\\": 1,\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\\n put_allocations_resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\\n # are all being increased but on the same host. We also throw a custom\\n # resource class in the new allocation to make sure it's not lost\\n alloc_req = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n uuids.shared_storage: {\\n 'resources': {\\n 'DISK_GB': 40,\\n }\\n },\\n },\\n # this allocation request comes from the scheduler therefore it\\n # does not have consumer_generation in it.\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.claim_resources(self.context, consumer_uuid,\\n alloc_req, project_id, user_id,\\n allocation_request_version='1.28')\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n expected_payload = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n uuids.shared_storage: {\\n 'resources': {\\n 'DISK_GB': 40,\\n }\\n },\\n },\\n # report client assumes a new consumer in this case\\n 'consumer_generation': None,\\n 'project_id': project_id,\\n 'user_id': user_id}\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n\\n self.assertTrue(res)\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_obj = RadosOrchestrator(node=cephadm)\\n pool_obj = PoolFunctions(node=cephadm)\\n scrub_obj = RadosScrubber(node=cephadm)\\n\\n pool_target_configs = config[\\\"verify_osd_omap_entries\\\"][\\\"configurations\\\"]\\n omap_target_configs = config[\\\"verify_osd_omap_entries\\\"][\\\"omap_config\\\"]\\n\\n # Creating pools and starting the test\\n for entry in pool_target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n method_should_succeed(\\n rados_obj.create_pool,\\n **entry,\\n )\\n\\n log.debug(\\n \\\"Created the pool. beginning to create large number of omap entries on the pool\\\"\\n )\\n\\n # Creating omaps\\n create_omap(pool_obj, pool_target_configs, omap_target_configs)\\n\\n omap_thread = Thread(\\n target=create_omap, args=[pool_obj, pool_target_configs, omap_target_configs]\\n )\\n\\n # Get the scrub and deep scrup time stamp before scrub and deep scrub execution\\n before_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_scrub_stamp\\\")\\n before_deep_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_deep_scrub_stamp\\\")\\n\\n # performing scrub and deep-scrub\\n rados_obj.run_scrub()\\n rados_obj.run_deep_scrub()\\n scrub_status = 1\\n deep_scrub_status = 1\\n\\n while scrub_status == 1 and deep_scrub_status == 1:\\n # Scrub check for every 20 seconds\\n time.sleep(20)\\n after_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_scrub_stamp\\\")\\n after_deep_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_deep_scrub_stamp\\\")\\n scrub_status = scrub_obj.verify_scrub_deepscrub(\\n before_scrub_log, after_scrub_log, \\\"scrub\\\"\\n )\\n deep_scrub_status = scrub_obj.verify_scrub_deepscrub(\\n before_deep_scrub_log, after_deep_scrub_log, \\\"deepscrub\\\"\\n )\\n log.info(\\\"scrubbing and deep-scrubbing are in progress\\\")\\n log.info(\\\"scrubbing and deep-scrubbing completed\\\")\\n\\n # Check for large omap massage\\n ceph_status = rados_obj.run_ceph_command(cmd=\\\" ceph health\\\")\\n if \\\"LARGE_OMAP_OBJECTS\\\" in ceph_status[\\\"checks\\\"]:\\n log.info(\\\" Generated large omaps in the cluster\\\")\\n else:\\n log.error(\\\" Unable to generate the large omaps in the cluster\\\")\\n return 1\\n\\n # verification of OSDs for 30 minutes\\n verification_osd_thread = Thread(target=verification_osd, args=[rados_obj, 30])\\n omap_thread.daemon = True\\n omap_thread.start()\\n verification_osd_thread.start()\\n verification_osd_thread.join()\\n omap_thread._delete()\\n if result == 0:\\n return 0\\n else:\\n return 1\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_update_volume_stats_cached(self):\\n self._fail_host_storage = True\\n actual = self.driver.get_volume_stats(False)\\n self.assertEqual('HGST', actual['vendor_name'])\\n self.assertEqual('hgst', actual['storage_protocol'])\\n self.assertEqual(90, actual['total_capacity_gb'])\\n self.assertEqual(87, actual['free_capacity_gb'])\\n self.assertEqual(0, actual['reserved_percentage'])\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def guid_fast_impl(pool):\\n with open(f'/proc/spl/kstat/zfs/{pool}/guid') as f:\\n return f.read().strip()\",\n \"def is_guest_sharing_auto_mount(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsGuestSharingAutoMount', self.handle))\",\n \"def mac_pool_exists(handle, name, assignment_order=None,\\r\\n r_from=None, to=None, descr=None, parent_dn=\\\"org-root\\\"):\\r\\n dn = parent_dn + '/mac-pool-' + name\\r\\n mo = handle.query_dn(dn)\\r\\n if mo:\\r\\n if ((assignment_order and mo.assignment_order != assignment_order) and\\r\\n (r_from and mo.r_from != r_from) and\\r\\n (to and mo.to != to) and\\r\\n (descr and mo.descr != descr)):\\r\\n return False\\r\\n return True\\r\\n return False\",\n \"def _get_mount_point_for_share(self, nfs_share):\\n nfs_share = nfs_share.encode('utf-8')\\n return os.path.join(self.configuration.nexenta_mount_point_base,\\n md5(nfs_share, usedforsecurity=False).hexdigest())\",\n \"def _pmount(self, action, args, error='exit'):\\n args = ('p%s' % action,) + args + (self.devname,)\\n if action == 'mount':\\n if self.label:\\n args += (self.label,)\\n msg = 'Mounting %s on %s'\\n else:\\n msg = 'Unmounting %s from %s'\\n print(msg % (self.devname, get_mount_target(self.devname, self.label)))\\n result = call(args)\\n if result and error == 'exit':\\n exit(result)\",\n \"def pool_snps(parent1, parent2):\",\n \"def _fsal_hook(self, base, share, access):\\n return {\\\"Hostname\\\": self.gluster_manager.host,\\n \\\"Volume\\\": self.gluster_manager.volume,\\n \\\"Volpath\\\": \\\"/\\\" + share['name']}\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\",\n \"def test_guest_os(self):\\n self.check_guest_os()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.85433346","0.84213686","0.8400509","0.81344026","0.76243025","0.75721836","0.7563653","0.7507107","0.7303699","0.72915065","0.7267744","0.6979238","0.69425905","0.66233706","0.6539754","0.6512662","0.63295096","0.631071","0.6240405","0.61339945","0.60027087","0.57583994","0.57158685","0.5699764","0.56939954","0.56197137","0.5611375","0.55994946","0.5537999","0.5520657","0.5510944","0.55079585","0.54918563","0.5490904","0.54757994","0.54503834","0.53613484","0.53571737","0.53387105","0.53341246","0.5320572","0.5317122","0.5301875","0.52926886","0.52875817","0.5272351","0.5240507","0.52378213","0.5235212","0.52316254","0.522887","0.52239096","0.520966","0.5205194","0.51926774","0.5187948","0.51772475","0.51717037","0.5170022","0.51524806","0.5138784","0.513287","0.5131765","0.51251143","0.5123281","0.51211166","0.51111007","0.5108176","0.5067743","0.50648904","0.5055809","0.50413704","0.5041316","0.50403917","0.5028801","0.5028764","0.50257957","0.5021766","0.5019308","0.5018538","0.50132406","0.50111294","0.5010313","0.5006178","0.49966002","0.49930117","0.49909246","0.49832314","0.49727863","0.49712527","0.49629465","0.49629173","0.4955669","0.49418178","0.4938796","0.4938796","0.4938796","0.4938796","0.4938796","0.4938796"],"string":"[\n \"0.85433346\",\n \"0.84213686\",\n \"0.8400509\",\n \"0.81344026\",\n \"0.76243025\",\n \"0.75721836\",\n \"0.7563653\",\n \"0.7507107\",\n \"0.7303699\",\n \"0.72915065\",\n \"0.7267744\",\n \"0.6979238\",\n \"0.69425905\",\n \"0.66233706\",\n \"0.6539754\",\n \"0.6512662\",\n \"0.63295096\",\n \"0.631071\",\n \"0.6240405\",\n \"0.61339945\",\n \"0.60027087\",\n \"0.57583994\",\n \"0.57158685\",\n \"0.5699764\",\n \"0.56939954\",\n \"0.56197137\",\n \"0.5611375\",\n \"0.55994946\",\n \"0.5537999\",\n \"0.5520657\",\n \"0.5510944\",\n \"0.55079585\",\n \"0.54918563\",\n \"0.5490904\",\n \"0.54757994\",\n \"0.54503834\",\n \"0.53613484\",\n \"0.53571737\",\n \"0.53387105\",\n \"0.53341246\",\n \"0.5320572\",\n \"0.5317122\",\n \"0.5301875\",\n \"0.52926886\",\n \"0.52875817\",\n \"0.5272351\",\n \"0.5240507\",\n \"0.52378213\",\n \"0.5235212\",\n \"0.52316254\",\n \"0.522887\",\n \"0.52239096\",\n \"0.520966\",\n \"0.5205194\",\n \"0.51926774\",\n \"0.5187948\",\n \"0.51772475\",\n \"0.51717037\",\n \"0.5170022\",\n \"0.51524806\",\n \"0.5138784\",\n \"0.513287\",\n \"0.5131765\",\n \"0.51251143\",\n \"0.5123281\",\n \"0.51211166\",\n \"0.51111007\",\n \"0.5108176\",\n \"0.5067743\",\n \"0.50648904\",\n \"0.5055809\",\n \"0.50413704\",\n \"0.5041316\",\n \"0.50403917\",\n \"0.5028801\",\n \"0.5028764\",\n \"0.50257957\",\n \"0.5021766\",\n \"0.5019308\",\n \"0.5018538\",\n \"0.50132406\",\n \"0.50111294\",\n \"0.5010313\",\n \"0.5006178\",\n \"0.49966002\",\n \"0.49930117\",\n \"0.49909246\",\n \"0.49832314\",\n \"0.49727863\",\n \"0.49712527\",\n \"0.49629465\",\n \"0.49629173\",\n \"0.4955669\",\n \"0.49418178\",\n \"0.4938796\",\n \"0.4938796\",\n \"0.4938796\",\n \"0.4938796\",\n \"0.4938796\",\n \"0.4938796\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9529886"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81382,"cells":{"query":{"kind":"string","value":"Test case for show_nas_share"},"document":{"kind":"string","value":"def test_show_nas_share(self):\n pass"},"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_show_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_dashboards_v2_share(self):\n pass","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def share():\n return True","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_dashboards_v2_list_shares(self):\n pass","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def dnt_share_app():\r\n msg, status = \"\", True\r\n try:\r\n\r\n 'Click on Do not share button'\r\n flag1 = ui_controls.button(get_obj_identifier('a'))\r\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\r\n \r\n \r\n\r\n status = False if not(flag1) else True\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_dashboards_v2_delete_share(self):\n pass","def ensure_share(self, context, share, share_server=None):\n pass","def canShare(self):\n return False","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def is_screenshare(self):\n return self._is_screenshare","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def _share():\n context = get_factcheck_context()\n return make_response(render_template('share.html', **context))","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def get_prov_shared(coast, stype=\"biz\",showOnly=False):\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\n print(\"!! Invalid syntax\\n\")\n print(\"Usage:\")\n print(\"\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\")\n print(\"Examples:\")\n print(\"\\tdkey --show --prov east # this will show current east-coast provisioning shared box\")\n print(\"\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\n\")\n print(\"If server type is not specified, 'biz' is used by default\\n\")\n sys.exit(170)\n\n coast = coast.lower()\n\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=4\n for trr in bs.tbody.find_all('tr'):\n tsrv, ttype = re.match(r'(.+)\\w*\\(([a-z]{2,3})\\).*', trr.find_all('td')[0].string).groups()\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\n if tnet == coast and ttype == stype: break\n\n tsrv = tsrv.strip()\n print(\"** Current %s provisioning server for %s coast is %s\" % (stype, coast, tsrv))\n if not showOnly:\n print(\">> Connecting to %s...\" % (tsrv))\n ssh_to(tsrv, srvuser=udata.userauth['user'])\n return tsrv.strip()","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def get_share(self, nShareIndex):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetShare', self.handle, nShareIndex))","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def is_share_all_host_disks(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))","def is_screenshare(self, is_screenshare):\n \n self._is_screenshare = is_screenshare","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def share(self):\n friend_sql = self.db.text(\"SELECT u.id, concat(u.second_name, ' ', u.first_name) text FROM user u \"\n \"inner join friend f on f.friend_id=u.id where f.user_id =%s \"\n \"and f.status = 1\" % self.current_user.id)\n share_sql = self.db.text(\"SELECT fs.user_assigned_id id, \"\n \"concat(u.first_name, ' ', COALESCE(u.second_name, '')) text \"\n \"FROM file_share fs inner join user u on u.id = fs.user_assigned_id \"\n \"where fs.file_id = %s\" % self.file_id)\n\n friend_db_list, share_db_list = self.db.execute([friend_sql, share_sql])\n return {'success': True,\n 'friend_list': friend_db_list,\n 'shared_list': share_db_list}","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_empty_public_owned(self):\n self.do_visible(True, 'pattieblack', True, is_admin=True)","def share_info(self) -> Sequence['outputs.ShareInfoElementResponse']:\n return pulumi.get(self, \"share_info\")","def get_workspace_share_details():\n\n # connect to mysql\n db_connection = mysql.connect(\n host=sql_host, user=\"metrics\", passwd=metrics_mysql_password, database=\"metrics\"\n )\n\n cursor = db_connection.cursor()\n query = \"use \" + query_on\n cursor.execute(query)\n\n workspaces_dict = get_workspaces(db_connection)\n kb_staff = get_kbase_staff(db_connection)\n (workspaces_dict, max_shared_count) = get_workspace_shares(\n workspaces_dict, kb_staff\n )\n\n ################\n # Print the header line:\n ################\n header_line = (\n \"Narrative ID\\tOwner\\tCreation Date\\tLast Modified\\tis_deleted\\tis_public\"\n )\n for i in range(max_shared_count):\n header_line += \"\\tShared_person_{}\\tShare_Type_{}\\tis_KB_Staff_{}\".format(\n str(i + 1), str(i + 1), str(i + 1)\n )\n print(header_line)\n\n ###############\n # Print the WS rows\n ###############\n for ws_id in workspaces_dict:\n print(\n \"{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\".format(\n str(ws_id),\n workspaces_dict[ws_id][\"username\"],\n workspaces_dict[ws_id][\"creation_date\"],\n workspaces_dict[ws_id][\"mod_date\"],\n str(workspaces_dict[ws_id][\"is_deleted\"]),\n str(workspaces_dict[ws_id][\"is_public\"]),\n \"\\t\".join(workspaces_dict[ws_id][\"shares_list\"]),\n )\n )","def mount_cifs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n share_name = share_config.get('share_name')\n remote_host = share_config.get('remote_host')\n if remote_host and share_name and mount_point:\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\n self.cmd(command)","def test_kyc_get_legal_share_holder_natural(self):\n pass","def test_remote_asns_non_spine(bf: Session, sot: SoT):\n peer_props = bf.q.bgpPeerConfiguration(nodes=f\"{SNAPSHOT_NODES_SPEC} \\\\ /spine.*/\").answer().frame()\n for _, row in peer_props.iterrows():\n node_name = row[\"Node\"]\n assert row[\"Peer_Group\"], \"Peer group is not set for neighbor {} on {}\".format(row[\"Remote_IP\"], node_name)\n peer_group = row[\"Peer_Group\"].lower()\n if peer_group.startswith(\"isp\"):\n continue\n asn_range = sot.get_peer_group_asn_range(peer_group)\n assert int(row[\"Remote_AS\"]) in asn_range, \\\n \"Remote AS of neighbor {} ({}) in peer group '{}' on {} is outside of the expected range {}\".format(\n row[\"Remote_IP\"], row[\"Remote_AS\"], peer_group, node_name, asn_range)","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","def delete_share(self, context, share, share_server=None):\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n if not volume_uuid:\n LOG.warning(\"No volume found for \"\n \"share %(project_id)s/%(name)s\",\n {\"project_id\": share['project_id'],\n \"name\": share['name']})\n return\n\n if self.configuration.quobyte_delete_shares:\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\n else:\n self.rpc.call('exportVolume', {\"volume_uuid\": volume_uuid,\n \"remove_export\": True,\n })","def test_kyc_put_legal_share_holder(self):\n pass","def share(job):\n client = get_dropbox_client()\n\n try:\n return client.share(\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\n\n except ErrorResponse:\n return False","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_kyc_post_legal_share_holder(self):\n pass","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def share_name(self) -> str:\n return pulumi.get(self, \"share_name\")","def test_kyc_get_legal_share_holders(self):\n pass","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def test_add_asset_share_feed(self):\n pass","def sharelist():\n # Get field to order by for displaying shares\n if(request.args.get('orderby')):\n orderby = request.args.get('orderby')\n else:\n orderby = None\n # Get order for displaying shares\n if(request.args.get('order')):\n order = request.args.get('order')\n else:\n order = \"asc\"\n # Get the page of shares to display and calculate offset\n # TODO: DEFINE LIMIT IN A CONFIG\n limit = 10\n if(request.args.get('page')):\n offset = 10*(int(request.args.get('page'))-1)\n else:\n offset = 0\n # Get shares\n shares, sharecount = gdb.getshares(\n orderby=orderby,\n order=order,\n offset=offset,\n limit=limit)\n\n # Render template\n return render_template('sharelist.html', shares=shares,\n sharecount=sharecount,\n countperpage=limit,\n userbalance=current_user.balance)","def get_list_shared(showOnly=False):\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=2\n slist = []\n for trr in bs.tbody.find_all('tr'):\n try:\n tsrv = re.match(r'(.+) \\(', trr.find_all('td')[0].text, re.I).group(1).strip()\n except:\n continue\n slist.append(tsrv)\n if not showOnly:\n print(tsrv)\n\n return slist","def test_anon_public_owned(self):\n self.do_visible(True, 'pattieblack', True)","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def share(observer, tid):\n try:\n manager = Actions()\n manager.share_task(observer, tid)\n except Exception as e:\n click.echo(e)","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def show(ctx):\n skale = ctx.obj['skale']\n # from skale.utils.contracts_provision.main import add_test_permissions\n # add_test_permissions(skale)\n show_all_schains_names(skale)","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def show_networks():\n return get_networks()","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def sendShare(self, program_counter, share):\n self.sendData(program_counter, SHARE, hex(share.value))","def get_share(self, activity_user_id, activity_id, share_id):\n return None","def cli(env, identifier, account_id):\n\n image_mgr = SoftLayer.ImageManager(env.client)\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\n shared_image = image_mgr.share_image(image_id, account_id)\n\n if shared_image:\n env.fout(f\"Image template {identifier} was shared to account {account_id}.\")","def share(self, path, short_url=True):\n path = \"/shares/%s%s\" % (self.session.root, format_path(path))\n\n params = {\n 'short_url': short_url,\n }\n\n url, params, headers = self.request(path, params, method='GET')\n\n return self.rest_client.GET(url, headers)","def is_shared_with_domain(self):\n return self.has_label(SHAREDWITHDOMAIN_LABEL)","def test_card_show(mock_card, capsys):\n mock_card.show()\n captured = capsys.readouterr()\n assert captured.out == \"SPADE, 1\\n\"","def test_no_list_listings(self):\n pool_name = p_n()\n fs_name = fs_n()\n StratisCli.pool_create(pool_name, block_devices=DISKS)\n StratisCli.fs_create(pool_name, fs_name)\n\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\n self.assertEqual(StratisCli.blockdev_list(),\n StratisCli.blockdev_list(False))","def link(path):\n abs_path = navigate.get_abs_path(path)\n parent, name = navigate.split_path(abs_path)\n if not db.file_exists(parent, name):\n print \"Error: '\" + path + \"' does not exist.\"\n else:\n dbox_path = '/' + name\n access_token = db.get_access_to_file(parent, name)\n client = dropbox.client.DropboxClient(access_token)\n short_link = client.share(dbox_path)['url']\n normal_link = client.share(dbox_path, short_url=False)['url']\n dl_link = normal_link.replace('www.dropbox.com',\n 'dl.dropboxusercontent.com', 1)\n print \"short link: \" + short_link\n print \"normal link: \" + normal_link\n print \"download link: \" + dl_link","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def dvs_remote_sg_simple(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(3)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.show_step(4)\n _sg_rules = os_conn.neutron.list_security_group_rules()\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\n for rule in sg_rules:\n os_conn.neutron.delete_security_group_rule(rule['id'])\n\n self.show_step(5)\n self.show_step(6)\n for sg in [sg1, sg2]:\n for rule in [self.icmp, self.tcp]:\n rule[\"security_group_rule\"][\"security_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(rule)\n rule[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(rule)\n\n # Create access_point to instances from SG1 and SG2\n _, access_point_ip = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg1.name, sg2.name])\n\n self.show_step(7)\n istances_sg1 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg1.name])\n\n self.show_step(8)\n istances_sg2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg2.name])\n openstack.verify_instance_state(os_conn)\n\n # Get private ips of instances\n ips = {\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg1],\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg2]\n }\n\n self.show_step(9)\n self.show_step(10)\n for group in ips:\n ip_pair = dict.fromkeys(ips[group])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips[group] if key != value]\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, timeout=60 * 5)\n\n self.show_step(11)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = ips['SG2']\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def _get_mount_point_for_share(self, nfs_share):\n nfs_share = nfs_share.encode('utf-8')\n return os.path.join(self.configuration.nexenta_mount_point_base,\n md5(nfs_share, usedforsecurity=False).hexdigest())","def test_disk_media_item_display_url(db):\n data = datadir.join('1200x6566.png').read(mode='rb')\n item = media.fetch_or_create_media_item(data, file_type='png')\n assert item.display_url == (\n '/static/media/a5/de/ef/a5deef985bde4438969b5f74a1864f7a5b1d127df3197b4fadf3f855201278b4.png')","def __init__(self, logger):\n self.share_names = []\n self.share_info = []\n self.logger = logger\n self.rz = zeroconf.Zeroconf()\n self.renamed = {}\n old_titles = self.scan()\n address = socket.inet_aton(config.get_ip())\n port = int(config.getPort())\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\n for section, settings in config.getShares():\n try:\n plugin = GetPlugin(settings['type'])\n ct = plugin.CONTENT_TYPE\n # if the plugin provides a test for validity use it otherwise assume valid\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\n logger.warning('share \"%s\" is invalid. It will be ignored (maybe check that path exists)', section)\n continue\n except Exception as e:\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\n continue\n\n if ct.startswith('x-container/'):\n if 'video' in ct:\n platform = PLATFORM_VIDEO\n else:\n platform = PLATFORM_MAIN\n\n logger.info('Registering: %s' % section)\n self.share_names.append(section)\n\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\n b'platform': bytes(platform, 'utf-8'),\n b'protocol': b'http',\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\n tt = ct.split('/')[1]\n title = section\n count = 1\n while title in old_titles:\n # debugging info while I try to figure out what this loop is for\n logger.info(\" title b4: {}\".format(title))\n count += 1\n title = '%s [%d]' % (section, count)\n self.renamed[section] = title\n # more debugging info\n logger.info(\" title after: {}\\n section: {}\".format(title, section))\n\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\n '%s._%s._tcp.local.' % (title, tt),\n port=port, addresses=[address], properties=desc)\n\n log_serviceinfo(self.logger, info)\n self.rz.register_service(info)\n self.share_info.append(info)","def test_show_sneaker(self, mock_find):\n mock_find.return_value = sample_sneaker\n\n result = self.client.get(f'/sneakers/{sample_sneaker_id}')\n self.assertEqual(result.status, '200 OK')\n self.assertIn(b'sneakers', result.data)","def show(args, syn):\n \n ent = syn.get(args.id, downloadFile=False)\n syn.printEntity(ent)","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_auth_sharable_owned(self):\n self.do_sharable(True, 'pattieblack', None, tenant='pattieblack')","def requestShowLink(self, *args, **kwargs): # real signature unknown\n pass","def test_list_cluster_network(self):\n pass","def test_empty_private_owned(self):\n self.do_visible(True, 'pattieblack', False, is_admin=True)"],"string":"[\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def share():\\n return True\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def dnt_share_app():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n\\r\\n 'Click on Do not share button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('a'))\\r\\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not(flag1) else True\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def canShare(self):\\n return False\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def is_screenshare(self):\\n return self._is_screenshare\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def _share():\\n context = get_factcheck_context()\\n return make_response(render_template('share.html', **context))\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def get_prov_shared(coast, stype=\\\"biz\\\",showOnly=False):\\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\\n print(\\\"!! Invalid syntax\\\\n\\\")\\n print(\\\"Usage:\\\")\\n print(\\\"\\\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\\\")\\n print(\\\"Examples:\\\")\\n print(\\\"\\\\tdkey --show --prov east # this will show current east-coast provisioning shared box\\\")\\n print(\\\"\\\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\\\n\\\")\\n print(\\\"If server type is not specified, 'biz' is used by default\\\\n\\\")\\n sys.exit(170)\\n\\n coast = coast.lower()\\n\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=4\\n for trr in bs.tbody.find_all('tr'):\\n tsrv, ttype = re.match(r'(.+)\\\\w*\\\\(([a-z]{2,3})\\\\).*', trr.find_all('td')[0].string).groups()\\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\\n if tnet == coast and ttype == stype: break\\n\\n tsrv = tsrv.strip()\\n print(\\\"** Current %s provisioning server for %s coast is %s\\\" % (stype, coast, tsrv))\\n if not showOnly:\\n print(\\\">> Connecting to %s...\\\" % (tsrv))\\n ssh_to(tsrv, srvuser=udata.userauth['user'])\\n return tsrv.strip()\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def get_share(self, nShareIndex):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetShare', self.handle, nShareIndex))\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def is_share_all_host_disks(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))\",\n \"def is_screenshare(self, is_screenshare):\\n \\n self._is_screenshare = is_screenshare\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def share(self):\\n friend_sql = self.db.text(\\\"SELECT u.id, concat(u.second_name, ' ', u.first_name) text FROM user u \\\"\\n \\\"inner join friend f on f.friend_id=u.id where f.user_id =%s \\\"\\n \\\"and f.status = 1\\\" % self.current_user.id)\\n share_sql = self.db.text(\\\"SELECT fs.user_assigned_id id, \\\"\\n \\\"concat(u.first_name, ' ', COALESCE(u.second_name, '')) text \\\"\\n \\\"FROM file_share fs inner join user u on u.id = fs.user_assigned_id \\\"\\n \\\"where fs.file_id = %s\\\" % self.file_id)\\n\\n friend_db_list, share_db_list = self.db.execute([friend_sql, share_sql])\\n return {'success': True,\\n 'friend_list': friend_db_list,\\n 'shared_list': share_db_list}\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_empty_public_owned(self):\\n self.do_visible(True, 'pattieblack', True, is_admin=True)\",\n \"def share_info(self) -> Sequence['outputs.ShareInfoElementResponse']:\\n return pulumi.get(self, \\\"share_info\\\")\",\n \"def get_workspace_share_details():\\n\\n # connect to mysql\\n db_connection = mysql.connect(\\n host=sql_host, user=\\\"metrics\\\", passwd=metrics_mysql_password, database=\\\"metrics\\\"\\n )\\n\\n cursor = db_connection.cursor()\\n query = \\\"use \\\" + query_on\\n cursor.execute(query)\\n\\n workspaces_dict = get_workspaces(db_connection)\\n kb_staff = get_kbase_staff(db_connection)\\n (workspaces_dict, max_shared_count) = get_workspace_shares(\\n workspaces_dict, kb_staff\\n )\\n\\n ################\\n # Print the header line:\\n ################\\n header_line = (\\n \\\"Narrative ID\\\\tOwner\\\\tCreation Date\\\\tLast Modified\\\\tis_deleted\\\\tis_public\\\"\\n )\\n for i in range(max_shared_count):\\n header_line += \\\"\\\\tShared_person_{}\\\\tShare_Type_{}\\\\tis_KB_Staff_{}\\\".format(\\n str(i + 1), str(i + 1), str(i + 1)\\n )\\n print(header_line)\\n\\n ###############\\n # Print the WS rows\\n ###############\\n for ws_id in workspaces_dict:\\n print(\\n \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\".format(\\n str(ws_id),\\n workspaces_dict[ws_id][\\\"username\\\"],\\n workspaces_dict[ws_id][\\\"creation_date\\\"],\\n workspaces_dict[ws_id][\\\"mod_date\\\"],\\n str(workspaces_dict[ws_id][\\\"is_deleted\\\"]),\\n str(workspaces_dict[ws_id][\\\"is_public\\\"]),\\n \\\"\\\\t\\\".join(workspaces_dict[ws_id][\\\"shares_list\\\"]),\\n )\\n )\",\n \"def mount_cifs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n share_name = share_config.get('share_name')\\n remote_host = share_config.get('remote_host')\\n if remote_host and share_name and mount_point:\\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\\n self.cmd(command)\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"def test_remote_asns_non_spine(bf: Session, sot: SoT):\\n peer_props = bf.q.bgpPeerConfiguration(nodes=f\\\"{SNAPSHOT_NODES_SPEC} \\\\\\\\ /spine.*/\\\").answer().frame()\\n for _, row in peer_props.iterrows():\\n node_name = row[\\\"Node\\\"]\\n assert row[\\\"Peer_Group\\\"], \\\"Peer group is not set for neighbor {} on {}\\\".format(row[\\\"Remote_IP\\\"], node_name)\\n peer_group = row[\\\"Peer_Group\\\"].lower()\\n if peer_group.startswith(\\\"isp\\\"):\\n continue\\n asn_range = sot.get_peer_group_asn_range(peer_group)\\n assert int(row[\\\"Remote_AS\\\"]) in asn_range, \\\\\\n \\\"Remote AS of neighbor {} ({}) in peer group '{}' on {} is outside of the expected range {}\\\".format(\\n row[\\\"Remote_IP\\\"], row[\\\"Remote_AS\\\"], peer_group, node_name, asn_range)\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"def delete_share(self, context, share, share_server=None):\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n if not volume_uuid:\\n LOG.warning(\\\"No volume found for \\\"\\n \\\"share %(project_id)s/%(name)s\\\",\\n {\\\"project_id\\\": share['project_id'],\\n \\\"name\\\": share['name']})\\n return\\n\\n if self.configuration.quobyte_delete_shares:\\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\\n else:\\n self.rpc.call('exportVolume', {\\\"volume_uuid\\\": volume_uuid,\\n \\\"remove_export\\\": True,\\n })\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def share(job):\\n client = get_dropbox_client()\\n\\n try:\\n return client.share(\\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\\n\\n except ErrorResponse:\\n return False\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def share_name(self) -> str:\\n return pulumi.get(self, \\\"share_name\\\")\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def sharelist():\\n # Get field to order by for displaying shares\\n if(request.args.get('orderby')):\\n orderby = request.args.get('orderby')\\n else:\\n orderby = None\\n # Get order for displaying shares\\n if(request.args.get('order')):\\n order = request.args.get('order')\\n else:\\n order = \\\"asc\\\"\\n # Get the page of shares to display and calculate offset\\n # TODO: DEFINE LIMIT IN A CONFIG\\n limit = 10\\n if(request.args.get('page')):\\n offset = 10*(int(request.args.get('page'))-1)\\n else:\\n offset = 0\\n # Get shares\\n shares, sharecount = gdb.getshares(\\n orderby=orderby,\\n order=order,\\n offset=offset,\\n limit=limit)\\n\\n # Render template\\n return render_template('sharelist.html', shares=shares,\\n sharecount=sharecount,\\n countperpage=limit,\\n userbalance=current_user.balance)\",\n \"def get_list_shared(showOnly=False):\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=2\\n slist = []\\n for trr in bs.tbody.find_all('tr'):\\n try:\\n tsrv = re.match(r'(.+) \\\\(', trr.find_all('td')[0].text, re.I).group(1).strip()\\n except:\\n continue\\n slist.append(tsrv)\\n if not showOnly:\\n print(tsrv)\\n\\n return slist\",\n \"def test_anon_public_owned(self):\\n self.do_visible(True, 'pattieblack', True)\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def share(observer, tid):\\n try:\\n manager = Actions()\\n manager.share_task(observer, tid)\\n except Exception as e:\\n click.echo(e)\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def show(ctx):\\n skale = ctx.obj['skale']\\n # from skale.utils.contracts_provision.main import add_test_permissions\\n # add_test_permissions(skale)\\n show_all_schains_names(skale)\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def show_networks():\\n return get_networks()\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def sendShare(self, program_counter, share):\\n self.sendData(program_counter, SHARE, hex(share.value))\",\n \"def get_share(self, activity_user_id, activity_id, share_id):\\n return None\",\n \"def cli(env, identifier, account_id):\\n\\n image_mgr = SoftLayer.ImageManager(env.client)\\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\\n shared_image = image_mgr.share_image(image_id, account_id)\\n\\n if shared_image:\\n env.fout(f\\\"Image template {identifier} was shared to account {account_id}.\\\")\",\n \"def share(self, path, short_url=True):\\n path = \\\"/shares/%s%s\\\" % (self.session.root, format_path(path))\\n\\n params = {\\n 'short_url': short_url,\\n }\\n\\n url, params, headers = self.request(path, params, method='GET')\\n\\n return self.rest_client.GET(url, headers)\",\n \"def is_shared_with_domain(self):\\n return self.has_label(SHAREDWITHDOMAIN_LABEL)\",\n \"def test_card_show(mock_card, capsys):\\n mock_card.show()\\n captured = capsys.readouterr()\\n assert captured.out == \\\"SPADE, 1\\\\n\\\"\",\n \"def test_no_list_listings(self):\\n pool_name = p_n()\\n fs_name = fs_n()\\n StratisCli.pool_create(pool_name, block_devices=DISKS)\\n StratisCli.fs_create(pool_name, fs_name)\\n\\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\\n self.assertEqual(StratisCli.blockdev_list(),\\n StratisCli.blockdev_list(False))\",\n \"def link(path):\\n abs_path = navigate.get_abs_path(path)\\n parent, name = navigate.split_path(abs_path)\\n if not db.file_exists(parent, name):\\n print \\\"Error: '\\\" + path + \\\"' does not exist.\\\"\\n else:\\n dbox_path = '/' + name\\n access_token = db.get_access_to_file(parent, name)\\n client = dropbox.client.DropboxClient(access_token)\\n short_link = client.share(dbox_path)['url']\\n normal_link = client.share(dbox_path, short_url=False)['url']\\n dl_link = normal_link.replace('www.dropbox.com',\\n 'dl.dropboxusercontent.com', 1)\\n print \\\"short link: \\\" + short_link\\n print \\\"normal link: \\\" + normal_link\\n print \\\"download link: \\\" + dl_link\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def dvs_remote_sg_simple(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(3)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.show_step(4)\\n _sg_rules = os_conn.neutron.list_security_group_rules()\\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\\n for rule in sg_rules:\\n os_conn.neutron.delete_security_group_rule(rule['id'])\\n\\n self.show_step(5)\\n self.show_step(6)\\n for sg in [sg1, sg2]:\\n for rule in [self.icmp, self.tcp]:\\n rule[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n\\n # Create access_point to instances from SG1 and SG2\\n _, access_point_ip = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg1.name, sg2.name])\\n\\n self.show_step(7)\\n istances_sg1 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg1.name])\\n\\n self.show_step(8)\\n istances_sg2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg2.name])\\n openstack.verify_instance_state(os_conn)\\n\\n # Get private ips of instances\\n ips = {\\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg1],\\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg2]\\n }\\n\\n self.show_step(9)\\n self.show_step(10)\\n for group in ips:\\n ip_pair = dict.fromkeys(ips[group])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips[group] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, timeout=60 * 5)\\n\\n self.show_step(11)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = ips['SG2']\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def _get_mount_point_for_share(self, nfs_share):\\n nfs_share = nfs_share.encode('utf-8')\\n return os.path.join(self.configuration.nexenta_mount_point_base,\\n md5(nfs_share, usedforsecurity=False).hexdigest())\",\n \"def test_disk_media_item_display_url(db):\\n data = datadir.join('1200x6566.png').read(mode='rb')\\n item = media.fetch_or_create_media_item(data, file_type='png')\\n assert item.display_url == (\\n '/static/media/a5/de/ef/a5deef985bde4438969b5f74a1864f7a5b1d127df3197b4fadf3f855201278b4.png')\",\n \"def __init__(self, logger):\\n self.share_names = []\\n self.share_info = []\\n self.logger = logger\\n self.rz = zeroconf.Zeroconf()\\n self.renamed = {}\\n old_titles = self.scan()\\n address = socket.inet_aton(config.get_ip())\\n port = int(config.getPort())\\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\\n for section, settings in config.getShares():\\n try:\\n plugin = GetPlugin(settings['type'])\\n ct = plugin.CONTENT_TYPE\\n # if the plugin provides a test for validity use it otherwise assume valid\\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\\n logger.warning('share \\\"%s\\\" is invalid. It will be ignored (maybe check that path exists)', section)\\n continue\\n except Exception as e:\\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\\n continue\\n\\n if ct.startswith('x-container/'):\\n if 'video' in ct:\\n platform = PLATFORM_VIDEO\\n else:\\n platform = PLATFORM_MAIN\\n\\n logger.info('Registering: %s' % section)\\n self.share_names.append(section)\\n\\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\\n b'platform': bytes(platform, 'utf-8'),\\n b'protocol': b'http',\\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\\n tt = ct.split('/')[1]\\n title = section\\n count = 1\\n while title in old_titles:\\n # debugging info while I try to figure out what this loop is for\\n logger.info(\\\" title b4: {}\\\".format(title))\\n count += 1\\n title = '%s [%d]' % (section, count)\\n self.renamed[section] = title\\n # more debugging info\\n logger.info(\\\" title after: {}\\\\n section: {}\\\".format(title, section))\\n\\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\\n '%s._%s._tcp.local.' % (title, tt),\\n port=port, addresses=[address], properties=desc)\\n\\n log_serviceinfo(self.logger, info)\\n self.rz.register_service(info)\\n self.share_info.append(info)\",\n \"def test_show_sneaker(self, mock_find):\\n mock_find.return_value = sample_sneaker\\n\\n result = self.client.get(f'/sneakers/{sample_sneaker_id}')\\n self.assertEqual(result.status, '200 OK')\\n self.assertIn(b'sneakers', result.data)\",\n \"def show(args, syn):\\n \\n ent = syn.get(args.id, downloadFile=False)\\n syn.printEntity(ent)\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_auth_sharable_owned(self):\\n self.do_sharable(True, 'pattieblack', None, tenant='pattieblack')\",\n \"def requestShowLink(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def test_empty_private_owned(self):\\n self.do_visible(True, 'pattieblack', False, is_admin=True)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9303875","0.85624135","0.84599024","0.8404861","0.8154698","0.80376023","0.7731183","0.75881684","0.74865353","0.74834853","0.73471814","0.7230511","0.7218506","0.7175002","0.6964021","0.66760683","0.64869213","0.6413816","0.6327175","0.6229252","0.6192084","0.61339104","0.6128782","0.6103687","0.60235023","0.57838595","0.57135457","0.5702588","0.56768787","0.56486356","0.56415117","0.5639964","0.5616757","0.5591431","0.5564516","0.55399996","0.55131805","0.55072016","0.54361767","0.5425094","0.5423456","0.53768176","0.534402","0.53093565","0.5274755","0.5256468","0.52537477","0.52397865","0.5197893","0.51971847","0.51917964","0.51840234","0.5182121","0.5178613","0.51781553","0.5170478","0.5159764","0.5145712","0.5143255","0.5138094","0.51292086","0.5126112","0.5121918","0.50983274","0.50846606","0.5083393","0.50739753","0.5028021","0.5026538","0.50050867","0.50039893","0.49999723","0.4996885","0.49949726","0.49935508","0.49903342","0.49894127","0.49884415","0.49862224","0.49815693","0.49593505","0.49533126","0.49490464","0.49448913","0.49412972","0.492944","0.4925792","0.4925539","0.4924534","0.4921698","0.4909445","0.49002752","0.48968613","0.488999","0.48894548","0.48890272","0.48878112","0.48820665","0.4869552","0.48643532"],"string":"[\n \"0.9303875\",\n \"0.85624135\",\n \"0.84599024\",\n \"0.8404861\",\n \"0.8154698\",\n \"0.80376023\",\n \"0.7731183\",\n \"0.75881684\",\n \"0.74865353\",\n \"0.74834853\",\n \"0.73471814\",\n \"0.7230511\",\n \"0.7218506\",\n \"0.7175002\",\n \"0.6964021\",\n \"0.66760683\",\n \"0.64869213\",\n \"0.6413816\",\n \"0.6327175\",\n \"0.6229252\",\n \"0.6192084\",\n \"0.61339104\",\n \"0.6128782\",\n \"0.6103687\",\n \"0.60235023\",\n \"0.57838595\",\n \"0.57135457\",\n \"0.5702588\",\n \"0.56768787\",\n \"0.56486356\",\n \"0.56415117\",\n \"0.5639964\",\n \"0.5616757\",\n \"0.5591431\",\n \"0.5564516\",\n \"0.55399996\",\n \"0.55131805\",\n \"0.55072016\",\n \"0.54361767\",\n \"0.5425094\",\n \"0.5423456\",\n \"0.53768176\",\n \"0.534402\",\n \"0.53093565\",\n \"0.5274755\",\n \"0.5256468\",\n \"0.52537477\",\n \"0.52397865\",\n \"0.5197893\",\n \"0.51971847\",\n \"0.51917964\",\n \"0.51840234\",\n \"0.5182121\",\n \"0.5178613\",\n \"0.51781553\",\n \"0.5170478\",\n \"0.5159764\",\n \"0.5145712\",\n \"0.5143255\",\n \"0.5138094\",\n \"0.51292086\",\n \"0.5126112\",\n \"0.5121918\",\n \"0.50983274\",\n \"0.50846606\",\n \"0.5083393\",\n \"0.50739753\",\n \"0.5028021\",\n \"0.5026538\",\n \"0.50050867\",\n \"0.50039893\",\n \"0.49999723\",\n \"0.4996885\",\n \"0.49949726\",\n \"0.49935508\",\n \"0.49903342\",\n \"0.49894127\",\n \"0.49884415\",\n \"0.49862224\",\n \"0.49815693\",\n \"0.49593505\",\n \"0.49533126\",\n \"0.49490464\",\n \"0.49448913\",\n \"0.49412972\",\n \"0.492944\",\n \"0.4925792\",\n \"0.4925539\",\n \"0.4924534\",\n \"0.4921698\",\n \"0.4909445\",\n \"0.49002752\",\n \"0.48968613\",\n \"0.488999\",\n \"0.48894548\",\n \"0.48890272\",\n \"0.48878112\",\n \"0.48820665\",\n \"0.4869552\",\n \"0.48643532\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.94518304"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81383,"cells":{"query":{"kind":"string","value":"Test case for show_nas_share_by_nas"},"document":{"kind":"string","value":"def test_show_nas_share_by_nas(self):\n pass"},"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_show_nas_share(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_update_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_dashboards_v2_share(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def share():\n return True","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def dnt_share_app():\r\n msg, status = \"\", True\r\n try:\r\n\r\n 'Click on Do not share button'\r\n flag1 = ui_controls.button(get_obj_identifier('a'))\r\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\r\n \r\n \r\n\r\n status = False if not(flag1) else True\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_dashboards_v2_delete_share(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def canShare(self):\n return False","def share(self):\n friend_sql = self.db.text(\"SELECT u.id, concat(u.second_name, ' ', u.first_name) text FROM user u \"\n \"inner join friend f on f.friend_id=u.id where f.user_id =%s \"\n \"and f.status = 1\" % self.current_user.id)\n share_sql = self.db.text(\"SELECT fs.user_assigned_id id, \"\n \"concat(u.first_name, ' ', COALESCE(u.second_name, '')) text \"\n \"FROM file_share fs inner join user u on u.id = fs.user_assigned_id \"\n \"where fs.file_id = %s\" % self.file_id)\n\n friend_db_list, share_db_list = self.db.execute([friend_sql, share_sql])\n return {'success': True,\n 'friend_list': friend_db_list,\n 'shared_list': share_db_list}","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def get_workspace_share_details():\n\n # connect to mysql\n db_connection = mysql.connect(\n host=sql_host, user=\"metrics\", passwd=metrics_mysql_password, database=\"metrics\"\n )\n\n cursor = db_connection.cursor()\n query = \"use \" + query_on\n cursor.execute(query)\n\n workspaces_dict = get_workspaces(db_connection)\n kb_staff = get_kbase_staff(db_connection)\n (workspaces_dict, max_shared_count) = get_workspace_shares(\n workspaces_dict, kb_staff\n )\n\n ################\n # Print the header line:\n ################\n header_line = (\n \"Narrative ID\\tOwner\\tCreation Date\\tLast Modified\\tis_deleted\\tis_public\"\n )\n for i in range(max_shared_count):\n header_line += \"\\tShared_person_{}\\tShare_Type_{}\\tis_KB_Staff_{}\".format(\n str(i + 1), str(i + 1), str(i + 1)\n )\n print(header_line)\n\n ###############\n # Print the WS rows\n ###############\n for ws_id in workspaces_dict:\n print(\n \"{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\".format(\n str(ws_id),\n workspaces_dict[ws_id][\"username\"],\n workspaces_dict[ws_id][\"creation_date\"],\n workspaces_dict[ws_id][\"mod_date\"],\n str(workspaces_dict[ws_id][\"is_deleted\"]),\n str(workspaces_dict[ws_id][\"is_public\"]),\n \"\\t\".join(workspaces_dict[ws_id][\"shares_list\"]),\n )\n )","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def get_list_shared(showOnly=False):\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=2\n slist = []\n for trr in bs.tbody.find_all('tr'):\n try:\n tsrv = re.match(r'(.+) \\(', trr.find_all('td')[0].text, re.I).group(1).strip()\n except:\n continue\n slist.append(tsrv)\n if not showOnly:\n print(tsrv)\n\n return slist","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def share_info(self) -> Sequence['outputs.ShareInfoElementResponse']:\n return pulumi.get(self, \"share_info\")","def test_remote_asns_non_spine(bf: Session, sot: SoT):\n peer_props = bf.q.bgpPeerConfiguration(nodes=f\"{SNAPSHOT_NODES_SPEC} \\\\ /spine.*/\").answer().frame()\n for _, row in peer_props.iterrows():\n node_name = row[\"Node\"]\n assert row[\"Peer_Group\"], \"Peer group is not set for neighbor {} on {}\".format(row[\"Remote_IP\"], node_name)\n peer_group = row[\"Peer_Group\"].lower()\n if peer_group.startswith(\"isp\"):\n continue\n asn_range = sot.get_peer_group_asn_range(peer_group)\n assert int(row[\"Remote_AS\"]) in asn_range, \\\n \"Remote AS of neighbor {} ({}) in peer group '{}' on {} is outside of the expected range {}\".format(\n row[\"Remote_IP\"], row[\"Remote_AS\"], peer_group, node_name, asn_range)","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_kyc_get_legal_share_holders(self):\n pass","def ensure_share(self, context, share, share_server=None):\n pass","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_kyc_get_legal_share_holder_natural(self):\n pass","def is_screenshare(self):\n return self._is_screenshare","def sharelist():\n # Get field to order by for displaying shares\n if(request.args.get('orderby')):\n orderby = request.args.get('orderby')\n else:\n orderby = None\n # Get order for displaying shares\n if(request.args.get('order')):\n order = request.args.get('order')\n else:\n order = \"asc\"\n # Get the page of shares to display and calculate offset\n # TODO: DEFINE LIMIT IN A CONFIG\n limit = 10\n if(request.args.get('page')):\n offset = 10*(int(request.args.get('page'))-1)\n else:\n offset = 0\n # Get shares\n shares, sharecount = gdb.getshares(\n orderby=orderby,\n order=order,\n offset=offset,\n limit=limit)\n\n # Render template\n return render_template('sharelist.html', shares=shares,\n sharecount=sharecount,\n countperpage=limit,\n userbalance=current_user.balance)","def test_list_cluster_network(self):\n pass","def sendShare(self, program_counter, share):\n self.sendData(program_counter, SHARE, hex(share.value))","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def get_prov_shared(coast, stype=\"biz\",showOnly=False):\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\n print(\"!! Invalid syntax\\n\")\n print(\"Usage:\")\n print(\"\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\")\n print(\"Examples:\")\n print(\"\\tdkey --show --prov east # this will show current east-coast provisioning shared box\")\n print(\"\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\n\")\n print(\"If server type is not specified, 'biz' is used by default\\n\")\n sys.exit(170)\n\n coast = coast.lower()\n\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=4\n for trr in bs.tbody.find_all('tr'):\n tsrv, ttype = re.match(r'(.+)\\w*\\(([a-z]{2,3})\\).*', trr.find_all('td')[0].string).groups()\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\n if tnet == coast and ttype == stype: break\n\n tsrv = tsrv.strip()\n print(\"** Current %s provisioning server for %s coast is %s\" % (stype, coast, tsrv))\n if not showOnly:\n print(\">> Connecting to %s...\" % (tsrv))\n ssh_to(tsrv, srvuser=udata.userauth['user'])\n return tsrv.strip()","def get_share(self, nShareIndex):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetShare', self.handle, nShareIndex))","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def is_share_all_host_disks(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def _share():\n context = get_factcheck_context()\n return make_response(render_template('share.html', **context))","def is_shared_with_domain(self):\n return self.has_label(SHAREDWITHDOMAIN_LABEL)","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.cluster_lists[longer_index]) \n # build the noeds for shorter cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[shorter_index]:\n len_spectra = len(cluster.get_spectra())\n star = ClusterNode(cluster.id, len_spectra) \n self.stars[cluster.id] = star\n\n self.cluster_spectra_num[shorter_index] += len_spectra\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\n # build the noeds for longer cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[longer_index]:\n len_spectra = len(cluster.get_spectra())\n starlet = ClusterNode(cluster.id, len_spectra) \n self.starlets[cluster.id] = starlet\n\n self.cluster_spectra_num[longer_index] += len_spectra\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\n # do the comparing, and network building\n for i in range (0, len(self.cluster_lists[shorter_index])):\n cluster0 = self.cluster_lists[shorter_index][i] \n for j in range (i, len(self.cluster_lists[longer_index])):\n cluster1 = self.cluster_lists[longer_index][j] \n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\n if similarity == 0:\n continue\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\n self.shared_spec_num += shared_spec_num\n\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\n\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length","def share_name(self) -> str:\n return pulumi.get(self, \"share_name\")","def test_kyc_put_legal_share_holder(self):\n pass","def get_share(self, activity_user_id, activity_id, share_id):\n return None","def share(self, request):\n try:\n article = self.get_object()\n except PermissionDenied as pd:\n return Response({'error': str(pd)})\n\n article.shared_by.add(request.user)\n return Response({'message': '\"{}\" is shared'.format(article.title)})","def is_screenshare(self, is_screenshare):\n \n self._is_screenshare = is_screenshare","def share(observer, tid):\n try:\n manager = Actions()\n manager.share_task(observer, tid)\n except Exception as e:\n click.echo(e)","def share_instances_get_all_by_share_network(context, share_network_id):\n result = (\n model_query(context, models.ShareInstance).filter(\n models.ShareInstance.share_network_id == share_network_id,\n ).all()\n )\n return result","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def test_kyc_post_legal_share_holder(self):\n pass","def test_add_asset_share_feed(self):\n pass","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def show_networks():\n return get_networks()","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","def cli(env, identifier, account_id):\n\n image_mgr = SoftLayer.ImageManager(env.client)\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\n shared_image = image_mgr.share_image(image_id, account_id)\n\n if shared_image:\n env.fout(f\"Image template {identifier} was shared to account {account_id}.\")","def display(self,source,matched_network=False):\n \n if len(self._members) == 0: # matchch\n raise NameError(\"Network is empty, no such source exists!\")\n \n handled_members = 0\n \n for k in range(len(self._members)):\n try:\n depth_k = self.collect(source,k)\n counter = len(depth_k)\n for member in depth_k:\n curr_node = self._get(member)\n\n curr_node.displayed = True # Marks node as displayed\n handled_members += 1\n\n if matched_network is True:\n if curr_node.weight is not None:\n weight_perc = str(round((curr_node.weight*100),2))+\"%\"+\" match!\"\n else:\n weight_perc = \" No weight\"\n else:\n weight_perc = curr_node.weight\n\n if counter != 1:\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"|\", curr_node.alias, str(weight_perc), \"|\")\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"^\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"|\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\"SHARED DISTANCE FROM SOURCE\")\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"|\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"v\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n\n counter -= 1\n elif counter == 1:\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"|\", curr_node.alias, str(weight_perc), \"|\")\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n\n except ValueError:\n pass\n \n # Handles disconnected graphs\n for member in self._members:\n if member.displayed == False:\n print(\"!!DISCONNECTED NETWORK!!\")\n if matched_network is True:\n self.display(source=member.alias,matched_network=True)\n else:\n self.display(source=member.alias)\n if handled_members == len(self._members):\n member.displayed = False","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def delete_share(self, context, share, share_server=None):\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n if not volume_uuid:\n LOG.warning(\"No volume found for \"\n \"share %(project_id)s/%(name)s\",\n {\"project_id\": share['project_id'],\n \"name\": share['name']})\n return\n\n if self.configuration.quobyte_delete_shares:\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\n else:\n self.rpc.call('exportVolume', {\"volume_uuid\": volume_uuid,\n \"remove_export\": True,\n })","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def share_link(cls, user, link):","def share_link(cls, user, link):","def __init__(self, logger):\n self.share_names = []\n self.share_info = []\n self.logger = logger\n self.rz = zeroconf.Zeroconf()\n self.renamed = {}\n old_titles = self.scan()\n address = socket.inet_aton(config.get_ip())\n port = int(config.getPort())\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\n for section, settings in config.getShares():\n try:\n plugin = GetPlugin(settings['type'])\n ct = plugin.CONTENT_TYPE\n # if the plugin provides a test for validity use it otherwise assume valid\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\n logger.warning('share \"%s\" is invalid. It will be ignored (maybe check that path exists)', section)\n continue\n except Exception as e:\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\n continue\n\n if ct.startswith('x-container/'):\n if 'video' in ct:\n platform = PLATFORM_VIDEO\n else:\n platform = PLATFORM_MAIN\n\n logger.info('Registering: %s' % section)\n self.share_names.append(section)\n\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\n b'platform': bytes(platform, 'utf-8'),\n b'protocol': b'http',\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\n tt = ct.split('/')[1]\n title = section\n count = 1\n while title in old_titles:\n # debugging info while I try to figure out what this loop is for\n logger.info(\" title b4: {}\".format(title))\n count += 1\n title = '%s [%d]' % (section, count)\n self.renamed[section] = title\n # more debugging info\n logger.info(\" title after: {}\\n section: {}\".format(title, section))\n\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\n '%s._%s._tcp.local.' % (title, tt),\n port=port, addresses=[address], properties=desc)\n\n log_serviceinfo(self.logger, info)\n self.rz.register_service(info)\n self.share_info.append(info)","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def get_shares_in_recycle_bin_by_network(\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\n if filters is None:\n filters = {}\n filters[\"share_network_id\"] = share_network_id\n filters[\"is_soft_deleted\"] = True\n query = _share_get_all_with_filters(context, filters=filters,\n sort_key=sort_key, sort_dir=sort_dir)\n return query","def get_shares_in_recycle_bin_by_share_server(\n context, share_server_id, filters=None, sort_key=None, sort_dir=None):\n if filters is None:\n filters = {}\n filters[\"is_soft_deleted\"] = True\n query = _share_get_all_with_filters(\n context, share_server_id=share_server_id, filters=filters,\n sort_key=sort_key, sort_dir=sort_dir)\n return query","def share(job):\n client = get_dropbox_client()\n\n try:\n return client.share(\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\n\n except ErrorResponse:\n return False","def share_type(self) -> str:\n return pulumi.get(self, \"share_type\")","def test_ap_anqp_sharing(dev, apdev):\n bssid = apdev[0]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n hostapd.add_ap(apdev[0]['ifname'], params)\n\n bssid2 = apdev[1]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n params['nai_realm'] = [ \"0,example.com,13[5:6],21[2:4][5:7]\" ]\n hostapd.add_ap(apdev[1]['ifname'], params)\n\n dev[0].hs20_enable()\n id = dev[0].add_cred_values({ 'realm': \"example.com\", 'username': \"test\",\n 'password': \"secret\",\n 'domain': \"example.com\" })\n logger.info(\"Normal network selection with shared ANQP results\")\n interworking_select(dev[0], None, \"home\", freq=\"2412\")\n dev[0].dump_monitor()\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not shared between BSSes\")\n\n logger.info(\"Explicit ANQP request to unshare ANQP results\")\n dev[0].request(\"ANQP_GET \" + bssid + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n dev[0].request(\"ANQP_GET \" + bssid2 + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not unshared\")","def dvs_remote_sg_simple(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(3)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.show_step(4)\n _sg_rules = os_conn.neutron.list_security_group_rules()\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\n for rule in sg_rules:\n os_conn.neutron.delete_security_group_rule(rule['id'])\n\n self.show_step(5)\n self.show_step(6)\n for sg in [sg1, sg2]:\n for rule in [self.icmp, self.tcp]:\n rule[\"security_group_rule\"][\"security_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(rule)\n rule[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(rule)\n\n # Create access_point to instances from SG1 and SG2\n _, access_point_ip = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg1.name, sg2.name])\n\n self.show_step(7)\n istances_sg1 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg1.name])\n\n self.show_step(8)\n istances_sg2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg2.name])\n openstack.verify_instance_state(os_conn)\n\n # Get private ips of instances\n ips = {\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg1],\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg2]\n }\n\n self.show_step(9)\n self.show_step(10)\n for group in ips:\n ip_pair = dict.fromkeys(ips[group])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips[group] if key != value]\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, timeout=60 * 5)\n\n self.show_step(11)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = ips['SG2']\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)","def test_empty_public_owned(self):\n self.do_visible(True, 'pattieblack', True, is_admin=True)","def test_show_sneaker(self, mock_find):\n mock_find.return_value = sample_sneaker\n\n result = self.client.get(f'/sneakers/{sample_sneaker_id}')\n self.assertEqual(result.status, '200 OK')\n self.assertIn(b'sneakers', result.data)","def test_no_list_listings(self):\n pool_name = p_n()\n fs_name = fs_n()\n StratisCli.pool_create(pool_name, block_devices=DISKS)\n StratisCli.fs_create(pool_name, fs_name)\n\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\n self.assertEqual(StratisCli.blockdev_list(),\n StratisCli.blockdev_list(False))","def share(self, share):\n if share is None:\n raise ValueError(\"Invalid value for `share`, must not be `None`\") # noqa: E501\n\n self._share = share","def testNanotecSharedMemory():\n\t\n\tmemoryClient = NanotecSharedMemoryClient()\n\t\n\t\n\t\n\tserialPort1 = memoryClient.sendInstruction(\"NanotecMotor,/dev/ttyACM0,17\")\n\t\n\tID1 = memoryClient.sendInstruction(\"getID,\" + serialPort1)\n\tprint(\"ID1 (actual): \" + ID1 + \", expected: 17\")\n\tprint(\"\")\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tID1 = memoryClient.sendInstruction(\"getSerialPort,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"ID Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tposition = memoryClient.sendInstruction(\"getAbsoluteAngularPosition,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"Position Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\treturn"],"string":"[\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def share():\\n return True\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def dnt_share_app():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n\\r\\n 'Click on Do not share button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('a'))\\r\\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not(flag1) else True\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def canShare(self):\\n return False\",\n \"def share(self):\\n friend_sql = self.db.text(\\\"SELECT u.id, concat(u.second_name, ' ', u.first_name) text FROM user u \\\"\\n \\\"inner join friend f on f.friend_id=u.id where f.user_id =%s \\\"\\n \\\"and f.status = 1\\\" % self.current_user.id)\\n share_sql = self.db.text(\\\"SELECT fs.user_assigned_id id, \\\"\\n \\\"concat(u.first_name, ' ', COALESCE(u.second_name, '')) text \\\"\\n \\\"FROM file_share fs inner join user u on u.id = fs.user_assigned_id \\\"\\n \\\"where fs.file_id = %s\\\" % self.file_id)\\n\\n friend_db_list, share_db_list = self.db.execute([friend_sql, share_sql])\\n return {'success': True,\\n 'friend_list': friend_db_list,\\n 'shared_list': share_db_list}\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def get_workspace_share_details():\\n\\n # connect to mysql\\n db_connection = mysql.connect(\\n host=sql_host, user=\\\"metrics\\\", passwd=metrics_mysql_password, database=\\\"metrics\\\"\\n )\\n\\n cursor = db_connection.cursor()\\n query = \\\"use \\\" + query_on\\n cursor.execute(query)\\n\\n workspaces_dict = get_workspaces(db_connection)\\n kb_staff = get_kbase_staff(db_connection)\\n (workspaces_dict, max_shared_count) = get_workspace_shares(\\n workspaces_dict, kb_staff\\n )\\n\\n ################\\n # Print the header line:\\n ################\\n header_line = (\\n \\\"Narrative ID\\\\tOwner\\\\tCreation Date\\\\tLast Modified\\\\tis_deleted\\\\tis_public\\\"\\n )\\n for i in range(max_shared_count):\\n header_line += \\\"\\\\tShared_person_{}\\\\tShare_Type_{}\\\\tis_KB_Staff_{}\\\".format(\\n str(i + 1), str(i + 1), str(i + 1)\\n )\\n print(header_line)\\n\\n ###############\\n # Print the WS rows\\n ###############\\n for ws_id in workspaces_dict:\\n print(\\n \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\".format(\\n str(ws_id),\\n workspaces_dict[ws_id][\\\"username\\\"],\\n workspaces_dict[ws_id][\\\"creation_date\\\"],\\n workspaces_dict[ws_id][\\\"mod_date\\\"],\\n str(workspaces_dict[ws_id][\\\"is_deleted\\\"]),\\n str(workspaces_dict[ws_id][\\\"is_public\\\"]),\\n \\\"\\\\t\\\".join(workspaces_dict[ws_id][\\\"shares_list\\\"]),\\n )\\n )\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def get_list_shared(showOnly=False):\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=2\\n slist = []\\n for trr in bs.tbody.find_all('tr'):\\n try:\\n tsrv = re.match(r'(.+) \\\\(', trr.find_all('td')[0].text, re.I).group(1).strip()\\n except:\\n continue\\n slist.append(tsrv)\\n if not showOnly:\\n print(tsrv)\\n\\n return slist\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def share_info(self) -> Sequence['outputs.ShareInfoElementResponse']:\\n return pulumi.get(self, \\\"share_info\\\")\",\n \"def test_remote_asns_non_spine(bf: Session, sot: SoT):\\n peer_props = bf.q.bgpPeerConfiguration(nodes=f\\\"{SNAPSHOT_NODES_SPEC} \\\\\\\\ /spine.*/\\\").answer().frame()\\n for _, row in peer_props.iterrows():\\n node_name = row[\\\"Node\\\"]\\n assert row[\\\"Peer_Group\\\"], \\\"Peer group is not set for neighbor {} on {}\\\".format(row[\\\"Remote_IP\\\"], node_name)\\n peer_group = row[\\\"Peer_Group\\\"].lower()\\n if peer_group.startswith(\\\"isp\\\"):\\n continue\\n asn_range = sot.get_peer_group_asn_range(peer_group)\\n assert int(row[\\\"Remote_AS\\\"]) in asn_range, \\\\\\n \\\"Remote AS of neighbor {} ({}) in peer group '{}' on {} is outside of the expected range {}\\\".format(\\n row[\\\"Remote_IP\\\"], row[\\\"Remote_AS\\\"], peer_group, node_name, asn_range)\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"def is_screenshare(self):\\n return self._is_screenshare\",\n \"def sharelist():\\n # Get field to order by for displaying shares\\n if(request.args.get('orderby')):\\n orderby = request.args.get('orderby')\\n else:\\n orderby = None\\n # Get order for displaying shares\\n if(request.args.get('order')):\\n order = request.args.get('order')\\n else:\\n order = \\\"asc\\\"\\n # Get the page of shares to display and calculate offset\\n # TODO: DEFINE LIMIT IN A CONFIG\\n limit = 10\\n if(request.args.get('page')):\\n offset = 10*(int(request.args.get('page'))-1)\\n else:\\n offset = 0\\n # Get shares\\n shares, sharecount = gdb.getshares(\\n orderby=orderby,\\n order=order,\\n offset=offset,\\n limit=limit)\\n\\n # Render template\\n return render_template('sharelist.html', shares=shares,\\n sharecount=sharecount,\\n countperpage=limit,\\n userbalance=current_user.balance)\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def sendShare(self, program_counter, share):\\n self.sendData(program_counter, SHARE, hex(share.value))\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def get_prov_shared(coast, stype=\\\"biz\\\",showOnly=False):\\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\\n print(\\\"!! Invalid syntax\\\\n\\\")\\n print(\\\"Usage:\\\")\\n print(\\\"\\\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\\\")\\n print(\\\"Examples:\\\")\\n print(\\\"\\\\tdkey --show --prov east # this will show current east-coast provisioning shared box\\\")\\n print(\\\"\\\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\\\n\\\")\\n print(\\\"If server type is not specified, 'biz' is used by default\\\\n\\\")\\n sys.exit(170)\\n\\n coast = coast.lower()\\n\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=4\\n for trr in bs.tbody.find_all('tr'):\\n tsrv, ttype = re.match(r'(.+)\\\\w*\\\\(([a-z]{2,3})\\\\).*', trr.find_all('td')[0].string).groups()\\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\\n if tnet == coast and ttype == stype: break\\n\\n tsrv = tsrv.strip()\\n print(\\\"** Current %s provisioning server for %s coast is %s\\\" % (stype, coast, tsrv))\\n if not showOnly:\\n print(\\\">> Connecting to %s...\\\" % (tsrv))\\n ssh_to(tsrv, srvuser=udata.userauth['user'])\\n return tsrv.strip()\",\n \"def get_share(self, nShareIndex):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetShare', self.handle, nShareIndex))\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def is_share_all_host_disks(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def _share():\\n context = get_factcheck_context()\\n return make_response(render_template('share.html', **context))\",\n \"def is_shared_with_domain(self):\\n return self.has_label(SHAREDWITHDOMAIN_LABEL)\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def compare(self):\\n len0 = len(self.cluster_lists[0])\\n len1 = len(self.cluster_lists[1])\\n longer_index = 0 if len0 >= len1 else 1\\n shorter_index = 1 if len1 <= len0 else 0\\n self.stars_length = len(self.cluster_lists[shorter_index]) \\n self.starlets_length = len(self.cluster_lists[longer_index]) \\n # build the noeds for shorter cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[shorter_index]:\\n len_spectra = len(cluster.get_spectra())\\n star = ClusterNode(cluster.id, len_spectra) \\n self.stars[cluster.id] = star\\n\\n self.cluster_spectra_num[shorter_index] += len_spectra\\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\\n # build the noeds for longer cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[longer_index]:\\n len_spectra = len(cluster.get_spectra())\\n starlet = ClusterNode(cluster.id, len_spectra) \\n self.starlets[cluster.id] = starlet\\n\\n self.cluster_spectra_num[longer_index] += len_spectra\\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\\n # do the comparing, and network building\\n for i in range (0, len(self.cluster_lists[shorter_index])):\\n cluster0 = self.cluster_lists[shorter_index][i] \\n for j in range (i, len(self.cluster_lists[longer_index])):\\n cluster1 = self.cluster_lists[longer_index][j] \\n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\\n if similarity == 0:\\n continue\\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\\n self.shared_spec_num += shared_spec_num\\n\\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\\n\\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length\",\n \"def share_name(self) -> str:\\n return pulumi.get(self, \\\"share_name\\\")\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def get_share(self, activity_user_id, activity_id, share_id):\\n return None\",\n \"def share(self, request):\\n try:\\n article = self.get_object()\\n except PermissionDenied as pd:\\n return Response({'error': str(pd)})\\n\\n article.shared_by.add(request.user)\\n return Response({'message': '\\\"{}\\\" is shared'.format(article.title)})\",\n \"def is_screenshare(self, is_screenshare):\\n \\n self._is_screenshare = is_screenshare\",\n \"def share(observer, tid):\\n try:\\n manager = Actions()\\n manager.share_task(observer, tid)\\n except Exception as e:\\n click.echo(e)\",\n \"def share_instances_get_all_by_share_network(context, share_network_id):\\n result = (\\n model_query(context, models.ShareInstance).filter(\\n models.ShareInstance.share_network_id == share_network_id,\\n ).all()\\n )\\n return result\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def show_networks():\\n return get_networks()\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"def cli(env, identifier, account_id):\\n\\n image_mgr = SoftLayer.ImageManager(env.client)\\n image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')\\n shared_image = image_mgr.share_image(image_id, account_id)\\n\\n if shared_image:\\n env.fout(f\\\"Image template {identifier} was shared to account {account_id}.\\\")\",\n \"def display(self,source,matched_network=False):\\n \\n if len(self._members) == 0: # matchch\\n raise NameError(\\\"Network is empty, no such source exists!\\\")\\n \\n handled_members = 0\\n \\n for k in range(len(self._members)):\\n try:\\n depth_k = self.collect(source,k)\\n counter = len(depth_k)\\n for member in depth_k:\\n curr_node = self._get(member)\\n\\n curr_node.displayed = True # Marks node as displayed\\n handled_members += 1\\n\\n if matched_network is True:\\n if curr_node.weight is not None:\\n weight_perc = str(round((curr_node.weight*100),2))+\\\"%\\\"+\\\" match!\\\"\\n else:\\n weight_perc = \\\" No weight\\\"\\n else:\\n weight_perc = curr_node.weight\\n\\n if counter != 1:\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"|\\\", curr_node.alias, str(weight_perc), \\\"|\\\")\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"^\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"|\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\"SHARED DISTANCE FROM SOURCE\\\")\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"|\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"v\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n\\n counter -= 1\\n elif counter == 1:\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"|\\\", curr_node.alias, str(weight_perc), \\\"|\\\")\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n\\n except ValueError:\\n pass\\n \\n # Handles disconnected graphs\\n for member in self._members:\\n if member.displayed == False:\\n print(\\\"!!DISCONNECTED NETWORK!!\\\")\\n if matched_network is True:\\n self.display(source=member.alias,matched_network=True)\\n else:\\n self.display(source=member.alias)\\n if handled_members == len(self._members):\\n member.displayed = False\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def delete_share(self, context, share, share_server=None):\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n if not volume_uuid:\\n LOG.warning(\\\"No volume found for \\\"\\n \\\"share %(project_id)s/%(name)s\\\",\\n {\\\"project_id\\\": share['project_id'],\\n \\\"name\\\": share['name']})\\n return\\n\\n if self.configuration.quobyte_delete_shares:\\n self.rpc.call('deleteVolume', {'volume_uuid': volume_uuid})\\n else:\\n self.rpc.call('exportVolume', {\\\"volume_uuid\\\": volume_uuid,\\n \\\"remove_export\\\": True,\\n })\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def share_link(cls, user, link):\",\n \"def share_link(cls, user, link):\",\n \"def __init__(self, logger):\\n self.share_names = []\\n self.share_info = []\\n self.logger = logger\\n self.rz = zeroconf.Zeroconf()\\n self.renamed = {}\\n old_titles = self.scan()\\n address = socket.inet_aton(config.get_ip())\\n port = int(config.getPort())\\n logger.info('Announcing pytivo shares ({}:{})...'.format(config.get_ip(), port))\\n for section, settings in config.getShares():\\n try:\\n plugin = GetPlugin(settings['type'])\\n ct = plugin.CONTENT_TYPE\\n # if the plugin provides a test for validity use it otherwise assume valid\\n if hasattr(plugin, 'is_valid') and not plugin.is_valid(section, settings):\\n logger.warning('share \\\"%s\\\" is invalid. It will be ignored (maybe check that path exists)', section)\\n continue\\n except Exception as e:\\n logger.error('ZCBroadcast.__init__: raised %s: %s', e.__class__.__name__, e)\\n continue\\n\\n if ct.startswith('x-container/'):\\n if 'video' in ct:\\n platform = PLATFORM_VIDEO\\n else:\\n platform = PLATFORM_MAIN\\n\\n logger.info('Registering: %s' % section)\\n self.share_names.append(section)\\n\\n desc = {b'path': bytes(SHARE_TEMPLATE % quote(section), 'utf-8'),\\n b'platform': bytes(platform, 'utf-8'),\\n b'protocol': b'http',\\n b'tsn': bytes('{%s}' % uuid.uuid4(), 'utf-8')}\\n tt = ct.split('/')[1]\\n title = section\\n count = 1\\n while title in old_titles:\\n # debugging info while I try to figure out what this loop is for\\n logger.info(\\\" title b4: {}\\\".format(title))\\n count += 1\\n title = '%s [%d]' % (section, count)\\n self.renamed[section] = title\\n # more debugging info\\n logger.info(\\\" title after: {}\\\\n section: {}\\\".format(title, section))\\n\\n info = zeroconf.ServiceInfo('_%s._tcp.local.' % tt,\\n '%s._%s._tcp.local.' % (title, tt),\\n port=port, addresses=[address], properties=desc)\\n\\n log_serviceinfo(self.logger, info)\\n self.rz.register_service(info)\\n self.share_info.append(info)\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def get_shares_in_recycle_bin_by_network(\\n context, share_network_id, filters=None, sort_key=None, sort_dir=None):\\n if filters is None:\\n filters = {}\\n filters[\\\"share_network_id\\\"] = share_network_id\\n filters[\\\"is_soft_deleted\\\"] = True\\n query = _share_get_all_with_filters(context, filters=filters,\\n sort_key=sort_key, sort_dir=sort_dir)\\n return query\",\n \"def get_shares_in_recycle_bin_by_share_server(\\n context, share_server_id, filters=None, sort_key=None, sort_dir=None):\\n if filters is None:\\n filters = {}\\n filters[\\\"is_soft_deleted\\\"] = True\\n query = _share_get_all_with_filters(\\n context, share_server_id=share_server_id, filters=filters,\\n sort_key=sort_key, sort_dir=sort_dir)\\n return query\",\n \"def share(job):\\n client = get_dropbox_client()\\n\\n try:\\n return client.share(\\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\\n\\n except ErrorResponse:\\n return False\",\n \"def share_type(self) -> str:\\n return pulumi.get(self, \\\"share_type\\\")\",\n \"def test_ap_anqp_sharing(dev, apdev):\\n bssid = apdev[0]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n hostapd.add_ap(apdev[0]['ifname'], params)\\n\\n bssid2 = apdev[1]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n params['nai_realm'] = [ \\\"0,example.com,13[5:6],21[2:4][5:7]\\\" ]\\n hostapd.add_ap(apdev[1]['ifname'], params)\\n\\n dev[0].hs20_enable()\\n id = dev[0].add_cred_values({ 'realm': \\\"example.com\\\", 'username': \\\"test\\\",\\n 'password': \\\"secret\\\",\\n 'domain': \\\"example.com\\\" })\\n logger.info(\\\"Normal network selection with shared ANQP results\\\")\\n interworking_select(dev[0], None, \\\"home\\\", freq=\\\"2412\\\")\\n dev[0].dump_monitor()\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not shared between BSSes\\\")\\n\\n logger.info(\\\"Explicit ANQP request to unshare ANQP results\\\")\\n dev[0].request(\\\"ANQP_GET \\\" + bssid + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n dev[0].request(\\\"ANQP_GET \\\" + bssid2 + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not unshared\\\")\",\n \"def dvs_remote_sg_simple(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(3)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.show_step(4)\\n _sg_rules = os_conn.neutron.list_security_group_rules()\\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\\n for rule in sg_rules:\\n os_conn.neutron.delete_security_group_rule(rule['id'])\\n\\n self.show_step(5)\\n self.show_step(6)\\n for sg in [sg1, sg2]:\\n for rule in [self.icmp, self.tcp]:\\n rule[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n\\n # Create access_point to instances from SG1 and SG2\\n _, access_point_ip = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg1.name, sg2.name])\\n\\n self.show_step(7)\\n istances_sg1 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg1.name])\\n\\n self.show_step(8)\\n istances_sg2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg2.name])\\n openstack.verify_instance_state(os_conn)\\n\\n # Get private ips of instances\\n ips = {\\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg1],\\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg2]\\n }\\n\\n self.show_step(9)\\n self.show_step(10)\\n for group in ips:\\n ip_pair = dict.fromkeys(ips[group])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips[group] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, timeout=60 * 5)\\n\\n self.show_step(11)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = ips['SG2']\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)\",\n \"def test_empty_public_owned(self):\\n self.do_visible(True, 'pattieblack', True, is_admin=True)\",\n \"def test_show_sneaker(self, mock_find):\\n mock_find.return_value = sample_sneaker\\n\\n result = self.client.get(f'/sneakers/{sample_sneaker_id}')\\n self.assertEqual(result.status, '200 OK')\\n self.assertIn(b'sneakers', result.data)\",\n \"def test_no_list_listings(self):\\n pool_name = p_n()\\n fs_name = fs_n()\\n StratisCli.pool_create(pool_name, block_devices=DISKS)\\n StratisCli.fs_create(pool_name, fs_name)\\n\\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\\n self.assertEqual(StratisCli.blockdev_list(),\\n StratisCli.blockdev_list(False))\",\n \"def share(self, share):\\n if share is None:\\n raise ValueError(\\\"Invalid value for `share`, must not be `None`\\\") # noqa: E501\\n\\n self._share = share\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9115962","0.8672631","0.83680737","0.83024406","0.81769687","0.7848348","0.7818351","0.7816461","0.74024487","0.737524","0.73302305","0.72978896","0.7211219","0.71098095","0.6981241","0.69681144","0.66827077","0.6341193","0.633762","0.631773","0.60930634","0.5943885","0.5906489","0.5758518","0.5721136","0.5690488","0.56715465","0.5591429","0.55536145","0.5528771","0.5517968","0.5490215","0.54717094","0.5454345","0.5441224","0.5371867","0.5355685","0.53253996","0.53225046","0.5313826","0.53066003","0.5302072","0.52933156","0.5292952","0.52736986","0.52723616","0.52714354","0.52712196","0.52711606","0.52547467","0.5252933","0.5244704","0.5229822","0.52279264","0.5226014","0.52216285","0.5211919","0.52050203","0.51866627","0.5161002","0.5160344","0.5158706","0.51539284","0.51412","0.5079022","0.5073316","0.5066821","0.5058735","0.50499845","0.5046477","0.50384897","0.5027101","0.5023581","0.5017701","0.49935925","0.49922195","0.49763557","0.49689993","0.4968954","0.49402776","0.4934041","0.49337268","0.49313727","0.49267375","0.4924032","0.48974442","0.48974442","0.4889739","0.48857075","0.48848584","0.4883632","0.48808783","0.4866605","0.4860699","0.48413464","0.4839756","0.4835452","0.48210138","0.4815781","0.4814636"],"string":"[\n \"0.9115962\",\n \"0.8672631\",\n \"0.83680737\",\n \"0.83024406\",\n \"0.81769687\",\n \"0.7848348\",\n \"0.7818351\",\n \"0.7816461\",\n \"0.74024487\",\n \"0.737524\",\n \"0.73302305\",\n \"0.72978896\",\n \"0.7211219\",\n \"0.71098095\",\n \"0.6981241\",\n \"0.69681144\",\n \"0.66827077\",\n \"0.6341193\",\n \"0.633762\",\n \"0.631773\",\n \"0.60930634\",\n \"0.5943885\",\n \"0.5906489\",\n \"0.5758518\",\n \"0.5721136\",\n \"0.5690488\",\n \"0.56715465\",\n \"0.5591429\",\n \"0.55536145\",\n \"0.5528771\",\n \"0.5517968\",\n \"0.5490215\",\n \"0.54717094\",\n \"0.5454345\",\n \"0.5441224\",\n \"0.5371867\",\n \"0.5355685\",\n \"0.53253996\",\n \"0.53225046\",\n \"0.5313826\",\n \"0.53066003\",\n \"0.5302072\",\n \"0.52933156\",\n \"0.5292952\",\n \"0.52736986\",\n \"0.52723616\",\n \"0.52714354\",\n \"0.52712196\",\n \"0.52711606\",\n \"0.52547467\",\n \"0.5252933\",\n \"0.5244704\",\n \"0.5229822\",\n \"0.52279264\",\n \"0.5226014\",\n \"0.52216285\",\n \"0.5211919\",\n \"0.52050203\",\n \"0.51866627\",\n \"0.5161002\",\n \"0.5160344\",\n \"0.5158706\",\n \"0.51539284\",\n \"0.51412\",\n \"0.5079022\",\n \"0.5073316\",\n \"0.5066821\",\n \"0.5058735\",\n \"0.50499845\",\n \"0.5046477\",\n \"0.50384897\",\n \"0.5027101\",\n \"0.5023581\",\n \"0.5017701\",\n \"0.49935925\",\n \"0.49922195\",\n \"0.49763557\",\n \"0.49689993\",\n \"0.4968954\",\n \"0.49402776\",\n \"0.4934041\",\n \"0.49337268\",\n \"0.49313727\",\n \"0.49267375\",\n \"0.4924032\",\n \"0.48974442\",\n \"0.48974442\",\n \"0.4889739\",\n \"0.48857075\",\n \"0.48848584\",\n \"0.4883632\",\n \"0.48808783\",\n \"0.4866605\",\n \"0.4860699\",\n \"0.48413464\",\n \"0.4839756\",\n \"0.4835452\",\n \"0.48210138\",\n \"0.4815781\",\n \"0.4814636\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.94415253"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81384,"cells":{"query":{"kind":"string","value":"Test case for show_nas_share_by_pool"},"document":{"kind":"string","value":"def test_show_nas_share_by_pool(self):\n pass"},"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_show_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_show_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_index_nas_shares(self):\n pass","def test_destroy_nas_share(self):\n pass","def show_pool(self, pool, **_params):\r\n return self.get(self.pool_path % (pool), params=_params)","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_dashboards_v2_share(self):\n pass","def pool_snps(parent1, parent2):","def test_list_cluster_network(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def pool_list(mnode):\n cmd = \"gluster pool list\"\n return g.run(mnode, cmd)","def get_pool_info(_ns, pool, human_friendly):\n size = size2str(pool.TotalManagedSpace, human_friendly)\n return (pool.InstanceID,\n pool.ElementName,\n pool.ElementName,\n size,\n \"volume group (LVM)\")","def test_no_list_listings(self):\n pool_name = p_n()\n fs_name = fs_n()\n StratisCli.pool_create(pool_name, block_devices=DISKS)\n StratisCli.fs_create(pool_name, fs_name)\n\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\n self.assertEqual(StratisCli.blockdev_list(),\n StratisCli.blockdev_list(False))","def share():\n return True","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def get_workspace_share_details():\n\n # connect to mysql\n db_connection = mysql.connect(\n host=sql_host, user=\"metrics\", passwd=metrics_mysql_password, database=\"metrics\"\n )\n\n cursor = db_connection.cursor()\n query = \"use \" + query_on\n cursor.execute(query)\n\n workspaces_dict = get_workspaces(db_connection)\n kb_staff = get_kbase_staff(db_connection)\n (workspaces_dict, max_shared_count) = get_workspace_shares(\n workspaces_dict, kb_staff\n )\n\n ################\n # Print the header line:\n ################\n header_line = (\n \"Narrative ID\\tOwner\\tCreation Date\\tLast Modified\\tis_deleted\\tis_public\"\n )\n for i in range(max_shared_count):\n header_line += \"\\tShared_person_{}\\tShare_Type_{}\\tis_KB_Staff_{}\".format(\n str(i + 1), str(i + 1), str(i + 1)\n )\n print(header_line)\n\n ###############\n # Print the WS rows\n ###############\n for ws_id in workspaces_dict:\n print(\n \"{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\".format(\n str(ws_id),\n workspaces_dict[ws_id][\"username\"],\n workspaces_dict[ws_id][\"creation_date\"],\n workspaces_dict[ws_id][\"mod_date\"],\n str(workspaces_dict[ws_id][\"is_deleted\"]),\n str(workspaces_dict[ws_id][\"is_public\"]),\n \"\\t\".join(workspaces_dict[ws_id][\"shares_list\"]),\n )\n )","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def get_prov_shared(coast, stype=\"biz\",showOnly=False):\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\n print(\"!! Invalid syntax\\n\")\n print(\"Usage:\")\n print(\"\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\")\n print(\"Examples:\")\n print(\"\\tdkey --show --prov east # this will show current east-coast provisioning shared box\")\n print(\"\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\n\")\n print(\"If server type is not specified, 'biz' is used by default\\n\")\n sys.exit(170)\n\n coast = coast.lower()\n\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=4\n for trr in bs.tbody.find_all('tr'):\n tsrv, ttype = re.match(r'(.+)\\w*\\(([a-z]{2,3})\\).*', trr.find_all('td')[0].string).groups()\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\n if tnet == coast and ttype == stype: break\n\n tsrv = tsrv.strip()\n print(\"** Current %s provisioning server for %s coast is %s\" % (stype, coast, tsrv))\n if not showOnly:\n print(\">> Connecting to %s...\" % (tsrv))\n ssh_to(tsrv, srvuser=udata.userauth['user'])\n return tsrv.strip()","def _list_pool_vm(args):\n _logger.debug('_list_pool_vm')\n #\n #\n _data_struct = {'name': {'head': 'Name', 'func': 'name', 'type': 'str'},\n 'uuid': {'head': 'UUID', 'func': 'UUIDString', 'type': 'str'},\n 'autostart': {'head': 'Autostart', 'func': 'autostart', 'type': 'yesno', 'convert': get_yesno},\n 'active': {'head': 'Active', 'func': 'isActive', 'type': 'yesno', 'convert': get_yesno},\n 'persistent': {'head': 'Persistent', 'func': 'isPersistent', 'type': 'yesno', 'convert': get_yesno},\n 'volumes': {'head': 'Volumes', 'func': 'numOfVolumes', 'type': 'int'},\n 'state': {'head': 'State', 'func': 'info', 'type': 'list', 'index': 0, 'convert': get_pool_state},\n 'capacity': {'head': 'Capacity', 'func': 'info', 'type': 'list', 'index': 1, 'convert': format_size},\n 'allocation': {'head': 'Allocation', 'func': 'info', 'type': 'list', 'index': 2, 'convert': format_size},\n 'available': {'head': 'Available', 'func': 'info', 'type': 'list', 'index': 3, 'convert': format_size},\n 'type': {'head': 'Type', 'func': None, 'type': 'str'}\n }\n #\n # get the pools\n _sps_fs, _sps_netfs = _get_pools()\n _sps = _sps_fs + _sps_netfs\n if len(_sps) == 0:\n _logger.info('No pools found.')\n return\n #\n # initialise the column widths\n _data_struct = initalise_column_lengths(_data_struct)\n #\n # column cantains only 'fs' or 'net fs'\n _data_struct['type']['len'] = 6\n #\n # format data and determine optimal length of fields.\n pool_data = list()\n for _sp in _sps:\n _sp_data = dict()\n for key, value in _data_struct.items():\n value_data = get_value_data(_sp, _data_struct[key])\n _sp_data[key] = value_data[0]\n val_length = value_data[1]\n _data_struct[key]['collen'] = max(val_length, _data_struct[key]['collen'])\n _sp_data['type'] = 'fs' if _sp in _sps_fs else 'net fs'\n pool_data.append(_sp_data)\n #\n # compose data\n _title = 'VM pool Information:'\n _columns = list()\n for key, value in _data_struct.items():\n _columns.append([value['head'], value['collen']+2, key])\n #\n printerKlass = get_row_printer_impl(args.output_mode)\n printer = printerKlass(title=_title, columns=_columns)\n printer.printHeader()\n #\n # print\n for _sp in pool_data:\n printer.rowBreak()\n printer.printRow(_sp)\n printer.printFooter()\n printer.finish()\n return","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_list_cluster_resource_quota(self):\n pass","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def verify_avail_space(self, pool, project, share, size):\n self.verify_project(pool, project)\n avail = self.get_project_stats(pool, project)\n if avail < size:\n exception_msg = (_('Error creating '\n 'share: %(share)s on '\n 'pool: %(pool)s. '\n 'Not enough space.')\n % {'share': share,\n 'pool': pool})\n raise exception.ShareBackendException(msg=exception_msg)","def test_create_cluster_network(self):\n pass","def _share():\n context = get_factcheck_context()\n return make_response(render_template('share.html', **context))","def test_kyc_get_legal_share_holders(self):\n pass","def csAddPool(self,pool,creatorid,nas=None):\n\n logger.debug(\"Attempting to create pool '\"+pool+\"'.\")\n\n localpath = \"/.\"+pool\n\n url = self.csurl + \"/polcentral/v1_0/pools/\"\n\n if nas == None:\n logger.debug(\"No NAS object provided, will create pool '\"+pool+\"' type 'MW'.\")\n pooltype = 'MW'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n else:\n logger.debug(\"NAS object provided, will create pool '\"+pool+\"' type 'PS'.\")\n pooltype = 'PS'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n\n payload = {\n \"name\": pool,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath\n }\n \"\"\"\n payload = {\n \"name\": poolname,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath,\n \"subscribedevices\":subscribedevices,\n \"deviceid\": deviceid,\n \"pathinpool\": pathinpool,\n \"servername\": servername,\n \"sharename\": sharename,\n \"sharepath\": sharepath,\n \"credsetname\": creditname,\n \"overridewarnings\": overridewarnings\n }\n \"\"\"\n\n try:\n r = requests.post(url, data=json.dumps(payload))\n except Exception:\n logger.error(\"Exception during api call to add pool.\")\n return 'Error'\n\n if r.status_code == 200:\n logger.debug(\"Pool '\"+pool+\"' was successfully created.\")\n poolid = r.json()['_id']\n return poolid['$id']\n else:\n logger.error(\"Pool '\"+pool+\"' was not created. Error code is \"+str(r.status_code)+\".\")\n return 'Error'","def get_list_shared(showOnly=False):\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0 net=2\n slist = []\n for trr in bs.tbody.find_all('tr'):\n try:\n tsrv = re.match(r'(.+) \\(', trr.find_all('td')[0].text, re.I).group(1).strip()\n except:\n continue\n slist.append(tsrv)\n if not showOnly:\n print(tsrv)\n\n return slist","def verify_pool(self, pool):\n svc = self.pool_path % pool\n self.rest_get(svc, restclient.Status.OK)","def test_read_cluster_network(self):\n pass","def dvs_remote_sg_simple(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(3)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.show_step(4)\n _sg_rules = os_conn.neutron.list_security_group_rules()\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\n for rule in sg_rules:\n os_conn.neutron.delete_security_group_rule(rule['id'])\n\n self.show_step(5)\n self.show_step(6)\n for sg in [sg1, sg2]:\n for rule in [self.icmp, self.tcp]:\n rule[\"security_group_rule\"][\"security_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n rule[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(rule)\n rule[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(rule)\n\n # Create access_point to instances from SG1 and SG2\n _, access_point_ip = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg1.name, sg2.name])\n\n self.show_step(7)\n istances_sg1 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg1.name])\n\n self.show_step(8)\n istances_sg2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg2.name])\n openstack.verify_instance_state(os_conn)\n\n # Get private ips of instances\n ips = {\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg1],\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg2]\n }\n\n self.show_step(9)\n self.show_step(10)\n for group in ips:\n ip_pair = dict.fromkeys(ips[group])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips[group] if key != value]\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, timeout=60 * 5)\n\n self.show_step(11)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = ips['SG2']\n openstack.check_connection_through_host(\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)","def get_spooled(self):\r\n return True","def test_volume_service_pool(self):\n self.assertEqual(\n ChangeStateScript()._deployer._volume_service._pool,\n StoragePool(reactor, b\"flocker\", FilePath(b\"/flocker\")))","def share(observer, tid):\n try:\n manager = Actions()\n manager.share_task(observer, tid)\n except Exception as e:\n click.echo(e)","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def test_switch_vlan_pool_default(self):\n self.assertEqual(self.options.vlan_pool, {})","def test_dashboards_v2_delete_share(self):\n pass","def _is_pool_owned(self, pdata):\n svc = '/api/system/v1/version'\n ret = self.rest_get(svc, restclient.Status.OK)\n vdata = jsonutils.loads(ret.data)\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\n vdata['version']['nodename'] == pdata['pool']['owner'])","def test_read_cluster_resource_quota(self):\n pass","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def dvs_instances_batch_mix_sg(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n self.show_step(2)\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network is created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n # Get max count of instances which we can create according to\n # resource limit\n vm_count = min(\n [os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']\n for h in os_conn.nova.hypervisors.list()])\n\n self.show_step(3)\n self.show_step(4)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n self.icmp[\"security_group_rule\"][\"security_group_id\"] = sg1.id\n self.icmp[\"security_group_rule\"][\"remote_group_id\"] = sg1.id\n self.icmp[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(self.icmp)\n self.icmp[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(self.icmp)\n\n for sg in [sg1, sg2]:\n self.tcp[\"security_group_rule\"][\"security_group_id\"] = sg.id\n self.tcp[\"security_group_rule\"][\"remote_group_id\"] = sg.id\n self.tcp[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(self.tcp)\n self.tcp[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(self.tcp)\n\n # Add rules for ssh and ping\n os_conn.goodbye_security()\n _s_groups = os_conn.neutron.list_security_groups()['security_groups']\n _srv_tenant_id = os_conn.get_tenant(SERVTEST_TENANT).id\n default_sg = [sg for sg in _s_groups\n if sg['tenant_id'] == _srv_tenant_id and\n sg['name'] == 'default'][0]\n\n for step in (5, 9):\n self.show_step(step) # step 5, 9\n step += 1\n self.show_step(step) # step 6, 10\n step += 1\n\n openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=vm_count,\n security_groups=[sg1.name, sg2.name, default_sg['name']])\n openstack.verify_instance_state(os_conn)\n\n self.show_step(step) # step 7, 11\n step += 1\n\n instances = os_conn.nova.servers.list()\n fip = openstack.create_and_assign_floating_ips(os_conn, instances)\n ip_pair = dict.fromkeys(fip)\n for key in ip_pair:\n ip_pair[key] = [value for value in fip if key != value]\n openstack.check_connection_vms(ip_pair,\n timeout=60 * 5,\n interval=10)\n\n self.show_step(step) # step 8, 12\n step += 1\n\n for instance in instances:\n os_conn.nova.servers.delete(instance)\n logger.info(\"Check that instance was deleted.\")\n os_conn.verify_srv_deleted(instance)","def _create_volume_pool(self, pool_name):\n osd_map = self._rados_command('osd dump', {})\n\n existing_id = self._get_pool_id(osd_map, pool_name)\n if existing_id is not None:\n log.info(\"Pool {0} already exists\".format(pool_name))\n return existing_id\n\n osd_count = len(osd_map['osds'])\n\n # We can't query the actual cluster config remotely, but since this is\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\n # that in use in the rest of the cluster.\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\n\n other_pgs = 0\n for pool in osd_map['pools']:\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\n other_pgs += pool['pg_num']\n\n # A basic heuristic for picking pg_num: work out the max number of\n # PGs we can have without tripping a warning, then subtract the number\n # of PGs already created by non-manila pools, then divide by ten. That'll\n # give you a reasonable result on a system where you have \"a few\" manila\n # shares.\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\n # TODO Alternatively, respect an override set by the user.\n\n self._rados_command(\n 'osd pool create',\n {\n 'pool': pool_name,\n 'pg_num': int(pg_num),\n }\n )\n\n osd_map = self._rados_command('osd dump', {})\n pool_id = self._get_pool_id(osd_map, pool_name)\n\n if pool_id is None:\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\n # removing it right after we created it.\n log.error(\"OSD map doesn't contain expected pool '{0}':\\n{1}\".format(\n pool_name, json.dumps(osd_map, indent=2)\n ))\n raise RuntimeError(\"Pool '{0}' not present in map after creation\".format(pool_name))\n else:\n return pool_id","def p_n():\n return TEST_PREF + \"pool\" + random_string()","def test_list_cluster_policy(self):\n pass","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def dvs_different_networks(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n _sg_groups = os_conn.neutron.list_security_groups()['security_groups']\n _srv_tenant = os_conn.get_tenant(SERVTEST_TENANT).id\n default_sg = [sg for sg in _sg_groups\n if sg['tenant_id'] == _srv_tenant and\n sg['name'] == 'default'][0]\n\n instances_group = []\n networks = []\n map_router_subnet = []\n step = 2\n self.show_step(step)\n for net in self.net_data:\n network = os_conn.create_network(network_name=net.keys()[0],\n tenant_id=tenant.id)['network']\n\n logger.info('Create subnet {}'.format(net.keys()[0]))\n subnet = os_conn.create_subnet(subnet_name=net.keys()[0],\n network_id=network['id'],\n cidr=net[net.keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(\n os_conn.get_network(network['name'])['id'] == network['id'])\n self.show_step(step + 1)\n router = os_conn.create_router(\n 'router_0{}'.format(self.net_data.index(net) + 1),\n tenant=tenant)\n\n self.show_step(step + 3)\n os_conn.add_router_interface(router_id=router[\"id\"],\n subnet_id=subnet[\"id\"])\n\n access_point, access_point_ip = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': network['id']}],\n security_groups=[security_group.name, default_sg['name']])\n if step == 3:\n step += 1\n self.show_step(step + 5)\n self.show_step(step + 6)\n openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': network['id']}],\n vm_count=1,\n security_groups=[default_sg['name']])\n openstack.verify_instance_state(os_conn)\n\n instances = [instance for instance in os_conn.get_servers()\n if network['name'] == instance.networks.keys()[0] and\n instance.id != access_point.id]\n\n private_ips = [\n os_conn.get_nova_instance_ip(i, net_name=network['name'])\n for i in instances]\n\n instances_group.append({'access_point': access_point,\n 'access_point_ip': access_point_ip,\n 'private_ips': private_ips})\n\n networks.append(network)\n map_router_subnet.append({'subnet': subnet['id'],\n 'router': router['id']})\n step = 3\n self.show_step(11)\n for group in instances_group:\n ip_pair = dict.fromkeys(group['private_ips'])\n for key in ip_pair:\n ip_pair[key] = [value for value in group['private_ips']\n if key != value]\n openstack.check_connection_through_host(\n group['access_point_ip'], ip_pair)\n\n self.show_step(12)\n ip_pair = dict.fromkeys(instances_group[0]['private_ips'])\n for key in ip_pair:\n ip_pair[key] = instances_group[1]['private_ips']\n openstack.check_connection_through_host(\n remote=instances_group[0]['access_point_ip'],\n ip_pair=ip_pair,\n result_of_command=1)\n\n self.show_step(13)\n\n access_point_fip = instances_group[1]['access_point_ip']\n _fips = os_conn.neutron.list_floatingips()['floatingips']\n fip_id = [fip['id'] for fip in _fips\n if fip['floating_ip_address'] == access_point_fip][0]\n\n os_conn.neutron.delete_floatingip(fip_id)\n\n os_conn.neutron.remove_interface_router(\n router=map_router_subnet[1]['router'],\n body={\"subnet_id\": map_router_subnet[1]['subnet']})\n\n os_conn.add_router_interface(router_id=map_router_subnet[0]['router'],\n subnet_id=map_router_subnet[1]['subnet'])\n self.show_step(14)\n openstack.check_connection_through_host(\n remote=instances_group[0]['access_point_ip'], ip_pair=ip_pair)","def _get_capacity_info(self, nfs_share):\n nms = self.share2nms[nfs_share]\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\n ns_folder),\n 'used|available')\n free = utils.str2size(folder_props['available'])\n allocated = utils.str2size(folder_props['used'])\n self.shares_with_capacities[nfs_share] = {\n 'free': utils.str2gib_size(free),\n 'total': utils.str2gib_size(free + allocated)}\n return free + allocated, free, allocated","async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\n\n trusted, fee = trusted_and_fee\n num_blocks = 4 # Num blocks to farm at a time\n total_blocks = 0 # Total blocks farmed so far\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n wallet_node_0 = wallet_nodes[0]\n our_ph = receive_address[0]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_node_0.config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_node_0.config[\"trusted_peers\"] = {}\n\n await wallet_node_0.server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\n total_block_rewards = await get_total_block_rewards(total_blocks)\n\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n assert total_block_rewards > 0\n\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5001\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx_2.spend_bundle,\n creation_tx_2.name,\n )\n\n for r in creation_tx.removals:\n assert r not in creation_tx_2.removals\n\n await farm_blocks(full_node_api, our_ph, 1)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 2\n wallet_id: int = summaries_response[0][\"id\"]\n wallet_id_2: int = summaries_response[1][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n assert status_2.target is None\n\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\n return fetched is not None and fetched.is_in_mempool()\n\n join_pool: Dict = await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 10,\n fee,\n )\n assert join_pool[\"success\"]\n join_pool_tx: TransactionRecord = join_pool[\"transaction\"]\n assert join_pool_tx is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\n\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \"https://pool.example.com\", 10, fee)\n assert join_pool_2[\"success\"]\n join_pool_tx_2: TransactionRecord = join_pool_2[\"transaction\"]\n for r in join_pool_tx.removals:\n assert r not in join_pool_tx_2.removals\n assert join_pool_tx_2 is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is not None\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.target is not None\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await farm_blocks(full_node_api, our_ph, 1)\n\n async def status_is_farming_to_pool(w_id: int):\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def test_thread_pool(self):\n self.assertIdentical(self.tx_client._pool, self.pool)","def dvs_remote_ip_prefix(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(2)\n net_1 = os_conn.create_network(network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n # Check that network are created\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n # Create Router_01, set gateway and add interface to external network.\n router_1 = os_conn.create_router('router_1', tenant=tenant)\n\n # Add net_1 to router_1\n os_conn.add_router_interface(router_id=router_1[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(3)\n self.show_step(4)\n self.show_step(5)\n sg1 = os_conn.nova.security_groups.create('SG1', \"descr\")\n sg2 = os_conn.nova.security_groups.create('SG2', \"descr\")\n\n access_point_1, access_point_ip_1 = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg1.name])\n\n access_point_2, access_point_ip_2 = openstack.create_access_point(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n security_groups=[security_group.name, sg2.name])\n\n self.show_step(6)\n _sg_rules = os_conn.neutron.list_security_group_rules()\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\n for rule in sg_rules:\n os_conn.neutron.delete_security_group_rule(rule['id'])\n\n self.show_step(7)\n for rule in [self.icmp, self.tcp]:\n rule[\"security_group_rule\"][\"security_group_id\"] = sg1.id\n rule[\"security_group_rule\"][\"remote_ip_prefix\"] = access_point_ip_1\n rule[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(rule)\n rule[\"security_group_rule\"][\"direction\"] = \"egress\"\n os_conn.neutron.create_security_group_rule(rule)\n\n # Get private ip of access_point_2\n private_ip = os_conn.get_nova_instance_ip(access_point_2,\n net_name=net_1['name'])\n\n self.show_step(8)\n self.tcp[\"security_group_rule\"][\"security_group_id\"] = sg2.id\n self.tcp[\"security_group_rule\"][\"remote_ip_prefix\"] = private_ip\n os_conn.neutron.create_security_group_rule(self.tcp)\n self.tcp[\"security_group_rule\"][\"direction\"] = \"ingress\"\n os_conn.neutron.create_security_group_rule(self.tcp)\n\n self.show_step(9)\n istances_sg1 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg1.name])\n\n istances_sg2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[sg2.name])\n openstack.verify_instance_state(os_conn)\n\n # Get private ips of instances\n ips = {\n 'SG1': [os_conn.assign_floating_ip(i).ip for i in istances_sg1],\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\n for i in istances_sg2]\n }\n\n self.show_step(10)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = [access_point_ip_1]\n openstack.check_connection_through_host(access_point_ip_1,\n ip_pair,\n timeout=60 * 4)\n\n self.show_step(11)\n ip_pair = dict.fromkeys(ips['SG1'])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips['SG1'] if key != value]\n openstack.check_connection_through_host(\n access_point_ip_1, ip_pair, result_of_command=1)\n\n self.show_step(12)\n self.show_step(13)\n ip_pair = dict.fromkeys(ips['SG2'])\n for key in ip_pair:\n ip_pair[key] = [value for value in ips['SG2'] if key != value]\n openstack.check_connection_through_host(\n access_point_ip_2, ip_pair, result_of_command=1)","def dnt_share_app():\r\n msg, status = \"\", True\r\n try:\r\n\r\n 'Click on Do not share button'\r\n flag1 = ui_controls.button(get_obj_identifier('a'))\r\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\r\n \r\n \r\n\r\n status = False if not(flag1) else True\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def show_resource_pool(client, private_cloud, resource_pool, location):\n return client.get(location, private_cloud, resource_pool)","def show_networks():\n return get_networks()","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_object = RadosOrchestrator(node=cephadm)\n mon_obj = MonConfigMethods(rados_obj=rados_object)\n ceph_nodes = kw.get(\"ceph_nodes\")\n osd_list = []\n total_osd_app_mem = {}\n\n for node in ceph_nodes:\n if node.role == \"osd\":\n node_osds = rados_object.collect_osd_daemon_ids(node)\n osd_list = osd_list + node_osds\n\n target_configs = config[\"cache_trim_max_skip_pinned\"][\"configurations\"]\n max_skip_pinned_value = int(\n mon_obj.get_config(section=\"osd\", param=\"bluestore_cache_trim_max_skip_pinned\")\n )\n\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\n if max_skip_pinned_value != 1000:\n log.error(\n \"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\"\n )\n raise Exception(\n \"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\"\n )\n\n # Creating pools and starting the test\n for entry in target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n if entry.get(\"pool_type\", \"replicated\") == \"erasure\":\n method_should_succeed(\n rados_object.create_erasure_pool, name=entry[\"pool_name\"], **entry\n )\n else:\n method_should_succeed(\n rados_object.create_pool,\n **entry,\n )\n\n if not rados_object.bench_write(**entry):\n log.error(\"Failed to write objects into the EC Pool\")\n return 1\n rados_object.bench_read(**entry)\n log.info(\"Finished writing data into the pool\")\n\n # performing scrub and deep-scrub\n rados_object.run_scrub()\n rados_object.run_deep_scrub()\n time.sleep(10)\n\n rados_object.change_heap_profiler_state(osd_list, \"start\")\n # Executing tests for 45 minutes\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\n while datetime.datetime.now() < time_execution:\n # Get all OSDs heap dump\n heap_dump = rados_object.get_heap_dump(osd_list)\n # get the osd application used memory\n osd_app_mem = get_bytes_used_by_app(heap_dump)\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\n # wait for 10 seconds and collecting the memory\n time.sleep(10)\n for osd_id, mem_list in total_osd_app_mem.items():\n mem_growth = is_what_percent_mem(mem_list)\n if mem_growth > 80:\n log.error(\n f\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\"\n )\n raise Exception(\"No warning generated by PG Autoscaler\")\n log.info(f\"The relative memory growth for the osd.{osd_id} is {mem_growth} \")\n\n rados_object.change_heap_profiler_state(osd_list, \"stop\")\n\n # check fo the crashes in the cluster\n crash_list = rados_object.do_crash_ls()\n if not crash_list:\n return 0\n else:\n return 1","def test_kyc_put_legal_share_holder(self):\n pass","def is_share_all_host_disks(self):\n\t\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))","def test_anon_public_owned(self):\n self.do_visible(True, 'pattieblack', True)","def test_empty_public_owned(self):\n self.do_visible(True, 'pattieblack', True, is_admin=True)","def test_no_overprovision(self):\n command_line = (\n self._MENU + [self._POOLNAME] + self._DEVICES + [\"--no-overprovision\"]\n )\n TEST_RUNNER(command_line)","def test_create_hyperflex_cluster_network_policy(self):\n pass","def check_free_space():\n subprocess.run([\"ssh\",backup_host, \"du -h\", dest ]])\n # get output","def test_list_pools_no_filter(api: API, account: Account, raw_pools):\n api.candlepin.get_pools.return_value = raw_pools\n pools = account.list_pools(filter_attributes={})\n assert pools == raw_pools","async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 5,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.current.pool_url == \"\"\n assert status.current.relative_lock_height == 0\n assert status.current.state == 1\n assert status.current.version == 1\n\n assert status.target\n assert status.target.pool_url == \"https://pool.example.com\"\n assert status.target.relative_lock_height == 5\n assert status.target.state == 3\n assert status.target.version == 1\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\n assert leave_pool_tx[\"transaction\"].wallet_id == wallet_id\n assert leave_pool_tx[\"transaction\"].amount == 1\n\n async def status_is_leaving():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\n\n async def status_is_self_pooling():\n # Farm enough blocks to wait for relative_lock_height\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_kyc_get_legal_share_holder_natural(self):\n pass","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def test_delete_cluster_network(self):\n pass","def set_dfuse_pool_params(self, pool, display=True):\n self.puuid.update(pool.uuid, \"puuid\" if display else None)","def test_get_hyperflex_cluster_list(self):\n pass","def test_01_dedicated_cluster_allocation(self):\n\n # Step 1\n dedicateCmd = dedicateCluster.dedicateClusterCmd()\n dedicateCmd.clusterid = self.clusters[0].id\n dedicateCmd.domainid = self.domain.id\n dedicateCmd.account = self.account_1.name\n self.apiclient.dedicateCluster(dedicateCmd)\n\n afcmd = listAffinityGroups.listAffinityGroupsCmd()\n afcmd.account = self.account_1.name\n afcmd.domainid = self.account_1.domainid\n affinitygr_list = self.apiclient.listAffinityGroups(afcmd)\n\n # Step 2\n self.vm = VirtualMachine.create(\n self.userapiclient_1,\n self.testdata[\"small\"],\n templateid=self.template.id,\n accountid=self.account_1.name,\n domainid=self.account_1.domainid,\n serviceofferingid=self.service_offering.id,\n affinitygroupids=[affinitygr_list[0].id],\n zoneid=self.zone.id,\n mode=self.zone.networktype\n )\n # Steps to verify if VM is created on dedicated account\n vmlist = list_virtual_machines(self.apiclient,\n id=self.vm.id)\n\n hostlist = list_hosts(self.apiclient,\n id=vmlist[0].hostid)\n\n self.assertEqual(hostlist[0].clusterid,\n self.clusters[0].id,\n \"check if vm gets deployed on dedicated clusture\"\n )\n # Step 3\n self.vm_1 = VirtualMachine.create(\n self.userapiclient_2,\n self.testdata[\"small\"],\n templateid=self.template.id,\n accountid=self.account_2.name,\n domainid=self.account_2.domainid,\n serviceofferingid=self.service_offering.id,\n zoneid=self.zone.id,\n mode=self.zone.networktype\n )\n\n # Steps to verify if VM is created on dedicated account\n vmlist_1 = list_virtual_machines(self.apiclient,\n id=self.vm_1.id)\n\n hostlist_1 = list_hosts(self.apiclient,\n id=vmlist_1[0].hostid)\n\n self.assertNotEqual(hostlist_1[0].clusterid,\n self.clusters[0].id,\n \"check if vm gets deployed on correct clusture\"\n )\n\n # Step 4\n routerList = list_routers(self.apiclient,\n clusterid=self.clusters[0].id,\n networkid=self.vm_1.nic[0].networkid\n )\n self.assertEqual(\n routerList,\n None,\n \"Check Dedicated cluster is used for virtual routers \\\n that belong to non-dedicated account\")\n\n return","def test_switch_vlan_pool_options(self):\n dpid = \"00:00:00:00:00:00:00:01\"\n vlan_pool = {\"00:00:00:00:00:00:00:01\":\n {\"1\": [[1, 2], [5, 10]], \"4\": [[3, 4]]}}\n self.controller.switches[dpid] = self.switch\n self.options.vlan_pool = vlan_pool\n self.controller.get_switch_or_create(dpid, self.switch.connection)\n\n port_id = 1\n intf = self.controller.switches[dpid].interfaces[port_id]\n tag_values = [tag.value for tag in intf.available_tags]\n self.assertEqual(tag_values, [1, 5, 6, 7, 8, 9])\n\n port_id = 4\n intf = self.controller.switches[dpid].interfaces[port_id]\n tag_values = [tag.value for tag in intf.available_tags]\n self.assertEqual(tag_values, [3])\n\n # this port number doesn't exist yet.\n port_7 = 7\n intf = Interface(\"test\", port_7, self.switch)\n # no attr filters, so should associate as it is\n self.controller.switches[dpid].update_interface(intf)\n intf_obj = self.controller.switches[dpid].interfaces[port_7]\n self.assertEqual(intf_obj, intf)\n # assert default vlan_pool range (1, 4096)\n tag_values = [tag.value for tag in intf_obj.available_tags]\n self.assertEqual(tag_values, list(range(1, 4096)))","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_create_cluster_resource_quota(self):\n pass","def dvs_vcenter_same_ip(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant_admin = os_conn.get_tenant(SERVTEST_TENANT)\n\n self.show_step(2)\n os_conn.create_user_and_tenant('test', 'test', 'test')\n openstack.add_role_to_user(os_conn, 'test', 'admin', 'test')\n\n test_os = os_actions.OpenStackActions(os_ip, 'test', 'test', 'test')\n\n tenant = test_os.get_tenant('test')\n\n self.show_step(3)\n logger.info('Create network {}'.format(self.net_data[0].keys()[0]))\n net_1 = test_os.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n subnet = test_os.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n self.show_step(4)\n router = test_os.create_router('router_1', tenant=tenant)\n test_os.add_router_interface(router_id=router[\"id\"],\n subnet_id=subnet[\"id\"])\n\n # Create security group with rules for ssh and ping\n security_group = test_os.create_sec_group_for_ssh()\n\n self.show_step(5)\n self.show_step(6)\n srv_1 = openstack.create_instances(\n os_conn=test_os,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[security_group.name])\n openstack.verify_instance_state(test_os)\n\n fip_1 = openstack.create_and_assign_floating_ips(test_os, srv_1)\n ips_1 = [test_os.get_nova_instance_ip(s, net_name=net_1['name'])\n for s in srv_1]\n\n # Create security group with rules for ssh and ping\n security_group = os_conn.create_sec_group_for_ssh()\n\n self.show_step(7)\n logger.info('Create network {}'.format(self.net_data[0].keys()[0]))\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant_admin.id)['network']\n\n subnet = os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n self.show_step(8)\n router = os_conn.create_router('router_1', tenant=tenant_admin)\n os_conn.add_router_interface(\n router_id=router[\"id\"],\n subnet_id=subnet[\"id\"])\n\n self.show_step(9)\n self.show_step(10)\n srv_2 = openstack.create_instances(\n os_conn=os_conn,\n nics=[{'net-id': net_1['id']}],\n vm_count=1,\n security_groups=[security_group.name])\n openstack.verify_instance_state(os_conn)\n\n self.show_step(11)\n self.show_step(12)\n fip_2 = openstack.create_and_assign_floating_ips(os_conn, srv_2)\n ips_2 = [os_conn.get_nova_instance_ip(s, net_name=net_1['name'])\n for s in srv_2]\n\n ip_pair = dict.fromkeys(fip_1)\n for key in ip_pair:\n ip_pair[key] = ips_1\n openstack.check_connection_vms(ip_pair)\n\n ip_pair = dict.fromkeys(fip_2)\n for key in ip_pair:\n ip_pair[key] = ips_2\n openstack.check_connection_vms(ip_pair)","def get_list_node(showOnly=False, full=False):\n # start Requests session\n sc = requests.Session()\n\n # import cookies from Firefox\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\n\n # send request\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=VPNodes')\n\n # check if login failed\n check_sc_login(vpx.text)\n\n # parse with BS4\n bs = BeautifulSoup(vpx.text, \"xml\")\n\n # server=0\n slist = []\n for trr in bs.tbody.find_all('tr'):\n try:\n if full:\n tsrv = {\n 'name': trr.find_all('td')[0].text.strip(),\n 'ip': trr.find_all('td')[2].text.strip(),\n 'lan': trr.find_all('td')[3].text.strip(),\n 'cpus': trr.find_all('td')[4].text.strip(),\n 'memory': trr.find_all('td')[5].text.strip(),\n 'os': trr.find_all('td')[6].text.strip(),\n 'vz': trr.find_all('td')[7].text.strip(),\n 'license': trr.find_all('td')[8].text.strip(),\n 'cap': int(trr.find_all('td')[9].text.strip()),\n 'on': int(trr.find_all('td')[10].text.strip()),\n 'off': int(trr.find_all('td')[11].text.strip()),\n 'disk_used': trr.find_all('td')[12].text.strip(),\n 'disk_free': trr.find_all('td')[13].text.strip(),\n 'psc1': trr.find_all('td')[14].text.strip(),\n 'psc2': trr.find_all('td')[15].text.strip(),\n 'loc': trr.find_all('td')[16].text.strip(),\n 'ra': trr.find_all('td')[17].text.strip(),\n 'ba': trr.find_all('td')[18].text.strip(),\n 'model': trr.find_all('td')[19].text.strip()\n }\n else:\n tsrv = trr.find_all('td')[0].text.strip()\n except:\n continue\n slist.append(tsrv)\n if not showOnly:\n if full:\n json.dumps(tsrv)\n else:\n print(tsrv)\n\n return slist","def test_get_alloc_format_overlap():\n time = \"10:00:00\"\n nodes = 5\n account = \"A35311\"\n options = {\"N\": 10, \"time\": \"15\", \"account\": \"S1242\"}\n alloc_cmd = _get_alloc_cmd(nodes, time, account, options)\n result = [\n \"--no-shell\",\n \"-N\",\n \"5\",\n \"-J\",\n \"SmartSim\",\n \"-t\",\n \"10:00:00\",\n \"-A\",\n \"A35311\",\n ]\n assert result == alloc_cmd","def task6(self, doc_uuid):\n doc_shares = {}\n for entry in self.records:\n if ((entry['event_type'] == 'share') and (entry['subject_doc_id'] == doc_uuid)):\n service = entry['event_service']\n if(service in doc_shares):\n doc_shares[service] += 1\n else:\n doc_shares[service] = 1\n GUI.show_histo(doc_shares, \"vert\", \"Number Of Shares for Platform\", \"Platform Distribution\")","def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.cluster_lists[longer_index]) \n # build the noeds for shorter cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[shorter_index]:\n len_spectra = len(cluster.get_spectra())\n star = ClusterNode(cluster.id, len_spectra) \n self.stars[cluster.id] = star\n\n self.cluster_spectra_num[shorter_index] += len_spectra\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\n # build the noeds for longer cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[longer_index]:\n len_spectra = len(cluster.get_spectra())\n starlet = ClusterNode(cluster.id, len_spectra) \n self.starlets[cluster.id] = starlet\n\n self.cluster_spectra_num[longer_index] += len_spectra\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\n # do the comparing, and network building\n for i in range (0, len(self.cluster_lists[shorter_index])):\n cluster0 = self.cluster_lists[shorter_index][i] \n for j in range (i, len(self.cluster_lists[longer_index])):\n cluster1 = self.cluster_lists[longer_index][j] \n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\n if similarity == 0:\n continue\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\n self.shared_spec_num += shared_spec_num\n\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\n\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length","def usage(self, host):","def show(self, threadID):\n print(\"[thread %d] Simulated Clustered Disk Space Allocation\" % threadID)\n line = '=' * 32\n print line\n for i in range(self.size/32):\n print ''.join(self.disk_mem[32*i:32*(i+1)])\n print line","def test_read_cluster_resource_quota_status(self):\n pass","def test_replace_cluster_network(self):\n pass"],"string":"[\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def show_pool(self, pool, **_params):\\r\\n return self.get(self.pool_path % (pool), params=_params)\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def pool_snps(parent1, parent2):\",\n \"def test_list_cluster_network(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def pool_list(mnode):\\n cmd = \\\"gluster pool list\\\"\\n return g.run(mnode, cmd)\",\n \"def get_pool_info(_ns, pool, human_friendly):\\n size = size2str(pool.TotalManagedSpace, human_friendly)\\n return (pool.InstanceID,\\n pool.ElementName,\\n pool.ElementName,\\n size,\\n \\\"volume group (LVM)\\\")\",\n \"def test_no_list_listings(self):\\n pool_name = p_n()\\n fs_name = fs_n()\\n StratisCli.pool_create(pool_name, block_devices=DISKS)\\n StratisCli.fs_create(pool_name, fs_name)\\n\\n self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))\\n self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))\\n self.assertEqual(StratisCli.blockdev_list(),\\n StratisCli.blockdev_list(False))\",\n \"def share():\\n return True\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def get_workspace_share_details():\\n\\n # connect to mysql\\n db_connection = mysql.connect(\\n host=sql_host, user=\\\"metrics\\\", passwd=metrics_mysql_password, database=\\\"metrics\\\"\\n )\\n\\n cursor = db_connection.cursor()\\n query = \\\"use \\\" + query_on\\n cursor.execute(query)\\n\\n workspaces_dict = get_workspaces(db_connection)\\n kb_staff = get_kbase_staff(db_connection)\\n (workspaces_dict, max_shared_count) = get_workspace_shares(\\n workspaces_dict, kb_staff\\n )\\n\\n ################\\n # Print the header line:\\n ################\\n header_line = (\\n \\\"Narrative ID\\\\tOwner\\\\tCreation Date\\\\tLast Modified\\\\tis_deleted\\\\tis_public\\\"\\n )\\n for i in range(max_shared_count):\\n header_line += \\\"\\\\tShared_person_{}\\\\tShare_Type_{}\\\\tis_KB_Staff_{}\\\".format(\\n str(i + 1), str(i + 1), str(i + 1)\\n )\\n print(header_line)\\n\\n ###############\\n # Print the WS rows\\n ###############\\n for ws_id in workspaces_dict:\\n print(\\n \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\".format(\\n str(ws_id),\\n workspaces_dict[ws_id][\\\"username\\\"],\\n workspaces_dict[ws_id][\\\"creation_date\\\"],\\n workspaces_dict[ws_id][\\\"mod_date\\\"],\\n str(workspaces_dict[ws_id][\\\"is_deleted\\\"]),\\n str(workspaces_dict[ws_id][\\\"is_public\\\"]),\\n \\\"\\\\t\\\".join(workspaces_dict[ws_id][\\\"shares_list\\\"]),\\n )\\n )\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def get_prov_shared(coast, stype=\\\"biz\\\",showOnly=False):\\n if not coast or not re.match(r'(east|west)', coast) or not re.match(r'(biz|ld|res)', stype):\\n print(\\\"!! Invalid syntax\\\\n\\\")\\n print(\\\"Usage:\\\")\\n print(\\\"\\\\tdkey [--show] --prov <east|west> [<biz|ld|res>]\\\")\\n print(\\\"Examples:\\\")\\n print(\\\"\\\\tdkey --show --prov east # this will show current east-coast provisioning shared box\\\")\\n print(\\\"\\\\tdkey --prov west res # this will connect to the current west-coast provisioning reseller box\\\\n\\\")\\n print(\\\"If server type is not specified, 'biz' is used by default\\\\n\\\")\\n sys.exit(170)\\n\\n coast = coast.lower()\\n\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared&isprov=1')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=4\\n for trr in bs.tbody.find_all('tr'):\\n tsrv, ttype = re.match(r'(.+)\\\\w*\\\\(([a-z]{2,3})\\\\).*', trr.find_all('td')[0].string).groups()\\n tnet = NETMAP.get(re.match(r'.*([A-Z]{1,2}).*', trr.find_all('td')[4].string).group(1), 'unknown')\\n if tnet == coast and ttype == stype: break\\n\\n tsrv = tsrv.strip()\\n print(\\\"** Current %s provisioning server for %s coast is %s\\\" % (stype, coast, tsrv))\\n if not showOnly:\\n print(\\\">> Connecting to %s...\\\" % (tsrv))\\n ssh_to(tsrv, srvuser=udata.userauth['user'])\\n return tsrv.strip()\",\n \"def _list_pool_vm(args):\\n _logger.debug('_list_pool_vm')\\n #\\n #\\n _data_struct = {'name': {'head': 'Name', 'func': 'name', 'type': 'str'},\\n 'uuid': {'head': 'UUID', 'func': 'UUIDString', 'type': 'str'},\\n 'autostart': {'head': 'Autostart', 'func': 'autostart', 'type': 'yesno', 'convert': get_yesno},\\n 'active': {'head': 'Active', 'func': 'isActive', 'type': 'yesno', 'convert': get_yesno},\\n 'persistent': {'head': 'Persistent', 'func': 'isPersistent', 'type': 'yesno', 'convert': get_yesno},\\n 'volumes': {'head': 'Volumes', 'func': 'numOfVolumes', 'type': 'int'},\\n 'state': {'head': 'State', 'func': 'info', 'type': 'list', 'index': 0, 'convert': get_pool_state},\\n 'capacity': {'head': 'Capacity', 'func': 'info', 'type': 'list', 'index': 1, 'convert': format_size},\\n 'allocation': {'head': 'Allocation', 'func': 'info', 'type': 'list', 'index': 2, 'convert': format_size},\\n 'available': {'head': 'Available', 'func': 'info', 'type': 'list', 'index': 3, 'convert': format_size},\\n 'type': {'head': 'Type', 'func': None, 'type': 'str'}\\n }\\n #\\n # get the pools\\n _sps_fs, _sps_netfs = _get_pools()\\n _sps = _sps_fs + _sps_netfs\\n if len(_sps) == 0:\\n _logger.info('No pools found.')\\n return\\n #\\n # initialise the column widths\\n _data_struct = initalise_column_lengths(_data_struct)\\n #\\n # column cantains only 'fs' or 'net fs'\\n _data_struct['type']['len'] = 6\\n #\\n # format data and determine optimal length of fields.\\n pool_data = list()\\n for _sp in _sps:\\n _sp_data = dict()\\n for key, value in _data_struct.items():\\n value_data = get_value_data(_sp, _data_struct[key])\\n _sp_data[key] = value_data[0]\\n val_length = value_data[1]\\n _data_struct[key]['collen'] = max(val_length, _data_struct[key]['collen'])\\n _sp_data['type'] = 'fs' if _sp in _sps_fs else 'net fs'\\n pool_data.append(_sp_data)\\n #\\n # compose data\\n _title = 'VM pool Information:'\\n _columns = list()\\n for key, value in _data_struct.items():\\n _columns.append([value['head'], value['collen']+2, key])\\n #\\n printerKlass = get_row_printer_impl(args.output_mode)\\n printer = printerKlass(title=_title, columns=_columns)\\n printer.printHeader()\\n #\\n # print\\n for _sp in pool_data:\\n printer.rowBreak()\\n printer.printRow(_sp)\\n printer.printFooter()\\n printer.finish()\\n return\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_list_cluster_resource_quota(self):\\n pass\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def verify_avail_space(self, pool, project, share, size):\\n self.verify_project(pool, project)\\n avail = self.get_project_stats(pool, project)\\n if avail < size:\\n exception_msg = (_('Error creating '\\n 'share: %(share)s on '\\n 'pool: %(pool)s. '\\n 'Not enough space.')\\n % {'share': share,\\n 'pool': pool})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def _share():\\n context = get_factcheck_context()\\n return make_response(render_template('share.html', **context))\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def csAddPool(self,pool,creatorid,nas=None):\\n\\n logger.debug(\\\"Attempting to create pool '\\\"+pool+\\\"'.\\\")\\n\\n localpath = \\\"/.\\\"+pool\\n\\n url = self.csurl + \\\"/polcentral/v1_0/pools/\\\"\\n\\n if nas == None:\\n logger.debug(\\\"No NAS object provided, will create pool '\\\"+pool+\\\"' type 'MW'.\\\")\\n pooltype = 'MW'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n else:\\n logger.debug(\\\"NAS object provided, will create pool '\\\"+pool+\\\"' type 'PS'.\\\")\\n pooltype = 'PS'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n\\n payload = {\\n \\\"name\\\": pool,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath\\n }\\n \\\"\\\"\\\"\\n payload = {\\n \\\"name\\\": poolname,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath,\\n \\\"subscribedevices\\\":subscribedevices,\\n \\\"deviceid\\\": deviceid,\\n \\\"pathinpool\\\": pathinpool,\\n \\\"servername\\\": servername,\\n \\\"sharename\\\": sharename,\\n \\\"sharepath\\\": sharepath,\\n \\\"credsetname\\\": creditname,\\n \\\"overridewarnings\\\": overridewarnings\\n }\\n \\\"\\\"\\\"\\n\\n try:\\n r = requests.post(url, data=json.dumps(payload))\\n except Exception:\\n logger.error(\\\"Exception during api call to add pool.\\\")\\n return 'Error'\\n\\n if r.status_code == 200:\\n logger.debug(\\\"Pool '\\\"+pool+\\\"' was successfully created.\\\")\\n poolid = r.json()['_id']\\n return poolid['$id']\\n else:\\n logger.error(\\\"Pool '\\\"+pool+\\\"' was not created. Error code is \\\"+str(r.status_code)+\\\".\\\")\\n return 'Error'\",\n \"def get_list_shared(showOnly=False):\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=Shared')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0 net=2\\n slist = []\\n for trr in bs.tbody.find_all('tr'):\\n try:\\n tsrv = re.match(r'(.+) \\\\(', trr.find_all('td')[0].text, re.I).group(1).strip()\\n except:\\n continue\\n slist.append(tsrv)\\n if not showOnly:\\n print(tsrv)\\n\\n return slist\",\n \"def verify_pool(self, pool):\\n svc = self.pool_path % pool\\n self.rest_get(svc, restclient.Status.OK)\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def dvs_remote_sg_simple(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(3)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.show_step(4)\\n _sg_rules = os_conn.neutron.list_security_group_rules()\\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\\n for rule in sg_rules:\\n os_conn.neutron.delete_security_group_rule(rule['id'])\\n\\n self.show_step(5)\\n self.show_step(6)\\n for sg in [sg1, sg2]:\\n for rule in [self.icmp, self.tcp]:\\n rule[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n\\n # Create access_point to instances from SG1 and SG2\\n _, access_point_ip = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg1.name, sg2.name])\\n\\n self.show_step(7)\\n istances_sg1 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg1.name])\\n\\n self.show_step(8)\\n istances_sg2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg2.name])\\n openstack.verify_instance_state(os_conn)\\n\\n # Get private ips of instances\\n ips = {\\n 'SG1': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg1],\\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg2]\\n }\\n\\n self.show_step(9)\\n self.show_step(10)\\n for group in ips:\\n ip_pair = dict.fromkeys(ips[group])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips[group] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, timeout=60 * 5)\\n\\n self.show_step(11)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = ips['SG2']\\n openstack.check_connection_through_host(\\n access_point_ip, ip_pair, result_of_command=1, timeout=60 * 5)\",\n \"def get_spooled(self):\\r\\n return True\",\n \"def test_volume_service_pool(self):\\n self.assertEqual(\\n ChangeStateScript()._deployer._volume_service._pool,\\n StoragePool(reactor, b\\\"flocker\\\", FilePath(b\\\"/flocker\\\")))\",\n \"def share(observer, tid):\\n try:\\n manager = Actions()\\n manager.share_task(observer, tid)\\n except Exception as e:\\n click.echo(e)\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def test_switch_vlan_pool_default(self):\\n self.assertEqual(self.options.vlan_pool, {})\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def _is_pool_owned(self, pdata):\\n svc = '/api/system/v1/version'\\n ret = self.rest_get(svc, restclient.Status.OK)\\n vdata = jsonutils.loads(ret.data)\\n return (vdata['version']['asn'] == pdata['pool']['asn'] and\\n vdata['version']['nodename'] == pdata['pool']['owner'])\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def dvs_instances_batch_mix_sg(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network is created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n # Get max count of instances which we can create according to\\n # resource limit\\n vm_count = min(\\n [os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']\\n for h in os_conn.nova.hypervisors.list()])\\n\\n self.show_step(3)\\n self.show_step(4)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n self.icmp[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg1.id\\n self.icmp[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg1.id\\n self.icmp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(self.icmp)\\n self.icmp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(self.icmp)\\n\\n for sg in [sg1, sg2]:\\n self.tcp[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg.id\\n self.tcp[\\\"security_group_rule\\\"][\\\"remote_group_id\\\"] = sg.id\\n self.tcp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n self.tcp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n\\n # Add rules for ssh and ping\\n os_conn.goodbye_security()\\n _s_groups = os_conn.neutron.list_security_groups()['security_groups']\\n _srv_tenant_id = os_conn.get_tenant(SERVTEST_TENANT).id\\n default_sg = [sg for sg in _s_groups\\n if sg['tenant_id'] == _srv_tenant_id and\\n sg['name'] == 'default'][0]\\n\\n for step in (5, 9):\\n self.show_step(step) # step 5, 9\\n step += 1\\n self.show_step(step) # step 6, 10\\n step += 1\\n\\n openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=vm_count,\\n security_groups=[sg1.name, sg2.name, default_sg['name']])\\n openstack.verify_instance_state(os_conn)\\n\\n self.show_step(step) # step 7, 11\\n step += 1\\n\\n instances = os_conn.nova.servers.list()\\n fip = openstack.create_and_assign_floating_ips(os_conn, instances)\\n ip_pair = dict.fromkeys(fip)\\n for key in ip_pair:\\n ip_pair[key] = [value for value in fip if key != value]\\n openstack.check_connection_vms(ip_pair,\\n timeout=60 * 5,\\n interval=10)\\n\\n self.show_step(step) # step 8, 12\\n step += 1\\n\\n for instance in instances:\\n os_conn.nova.servers.delete(instance)\\n logger.info(\\\"Check that instance was deleted.\\\")\\n os_conn.verify_srv_deleted(instance)\",\n \"def _create_volume_pool(self, pool_name):\\n osd_map = self._rados_command('osd dump', {})\\n\\n existing_id = self._get_pool_id(osd_map, pool_name)\\n if existing_id is not None:\\n log.info(\\\"Pool {0} already exists\\\".format(pool_name))\\n return existing_id\\n\\n osd_count = len(osd_map['osds'])\\n\\n # We can't query the actual cluster config remotely, but since this is\\n # just a heuristic we'll assume that the ceph.conf we have locally reflects\\n # that in use in the rest of the cluster.\\n pg_warn_max_per_osd = int(self.rados.conf_get('mon_max_pg_per_osd'))\\n\\n other_pgs = 0\\n for pool in osd_map['pools']:\\n if not pool['pool_name'].startswith(self.POOL_PREFIX):\\n other_pgs += pool['pg_num']\\n\\n # A basic heuristic for picking pg_num: work out the max number of\\n # PGs we can have without tripping a warning, then subtract the number\\n # of PGs already created by non-manila pools, then divide by ten. That'll\\n # give you a reasonable result on a system where you have \\\"a few\\\" manila\\n # shares.\\n pg_num = ((pg_warn_max_per_osd * osd_count) - other_pgs) // 10\\n # TODO Alternatively, respect an override set by the user.\\n\\n self._rados_command(\\n 'osd pool create',\\n {\\n 'pool': pool_name,\\n 'pg_num': int(pg_num),\\n }\\n )\\n\\n osd_map = self._rados_command('osd dump', {})\\n pool_id = self._get_pool_id(osd_map, pool_name)\\n\\n if pool_id is None:\\n # If the pool isn't there, that's either a ceph bug, or it's some outside influence\\n # removing it right after we created it.\\n log.error(\\\"OSD map doesn't contain expected pool '{0}':\\\\n{1}\\\".format(\\n pool_name, json.dumps(osd_map, indent=2)\\n ))\\n raise RuntimeError(\\\"Pool '{0}' not present in map after creation\\\".format(pool_name))\\n else:\\n return pool_id\",\n \"def p_n():\\n return TEST_PREF + \\\"pool\\\" + random_string()\",\n \"def test_list_cluster_policy(self):\\n pass\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def dvs_different_networks(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n _sg_groups = os_conn.neutron.list_security_groups()['security_groups']\\n _srv_tenant = os_conn.get_tenant(SERVTEST_TENANT).id\\n default_sg = [sg for sg in _sg_groups\\n if sg['tenant_id'] == _srv_tenant and\\n sg['name'] == 'default'][0]\\n\\n instances_group = []\\n networks = []\\n map_router_subnet = []\\n step = 2\\n self.show_step(step)\\n for net in self.net_data:\\n network = os_conn.create_network(network_name=net.keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n logger.info('Create subnet {}'.format(net.keys()[0]))\\n subnet = os_conn.create_subnet(subnet_name=net.keys()[0],\\n network_id=network['id'],\\n cidr=net[net.keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(\\n os_conn.get_network(network['name'])['id'] == network['id'])\\n self.show_step(step + 1)\\n router = os_conn.create_router(\\n 'router_0{}'.format(self.net_data.index(net) + 1),\\n tenant=tenant)\\n\\n self.show_step(step + 3)\\n os_conn.add_router_interface(router_id=router[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n access_point, access_point_ip = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': network['id']}],\\n security_groups=[security_group.name, default_sg['name']])\\n if step == 3:\\n step += 1\\n self.show_step(step + 5)\\n self.show_step(step + 6)\\n openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': network['id']}],\\n vm_count=1,\\n security_groups=[default_sg['name']])\\n openstack.verify_instance_state(os_conn)\\n\\n instances = [instance for instance in os_conn.get_servers()\\n if network['name'] == instance.networks.keys()[0] and\\n instance.id != access_point.id]\\n\\n private_ips = [\\n os_conn.get_nova_instance_ip(i, net_name=network['name'])\\n for i in instances]\\n\\n instances_group.append({'access_point': access_point,\\n 'access_point_ip': access_point_ip,\\n 'private_ips': private_ips})\\n\\n networks.append(network)\\n map_router_subnet.append({'subnet': subnet['id'],\\n 'router': router['id']})\\n step = 3\\n self.show_step(11)\\n for group in instances_group:\\n ip_pair = dict.fromkeys(group['private_ips'])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in group['private_ips']\\n if key != value]\\n openstack.check_connection_through_host(\\n group['access_point_ip'], ip_pair)\\n\\n self.show_step(12)\\n ip_pair = dict.fromkeys(instances_group[0]['private_ips'])\\n for key in ip_pair:\\n ip_pair[key] = instances_group[1]['private_ips']\\n openstack.check_connection_through_host(\\n remote=instances_group[0]['access_point_ip'],\\n ip_pair=ip_pair,\\n result_of_command=1)\\n\\n self.show_step(13)\\n\\n access_point_fip = instances_group[1]['access_point_ip']\\n _fips = os_conn.neutron.list_floatingips()['floatingips']\\n fip_id = [fip['id'] for fip in _fips\\n if fip['floating_ip_address'] == access_point_fip][0]\\n\\n os_conn.neutron.delete_floatingip(fip_id)\\n\\n os_conn.neutron.remove_interface_router(\\n router=map_router_subnet[1]['router'],\\n body={\\\"subnet_id\\\": map_router_subnet[1]['subnet']})\\n\\n os_conn.add_router_interface(router_id=map_router_subnet[0]['router'],\\n subnet_id=map_router_subnet[1]['subnet'])\\n self.show_step(14)\\n openstack.check_connection_through_host(\\n remote=instances_group[0]['access_point_ip'], ip_pair=ip_pair)\",\n \"def _get_capacity_info(self, nfs_share):\\n nms = self.share2nms[nfs_share]\\n ns_volume, ns_folder = self._get_share_datasets(nfs_share)\\n folder_props = nms.folder.get_child_props('%s/%s' % (ns_volume,\\n ns_folder),\\n 'used|available')\\n free = utils.str2size(folder_props['available'])\\n allocated = utils.str2size(folder_props['used'])\\n self.shares_with_capacities[nfs_share] = {\\n 'free': utils.str2gib_size(free),\\n 'total': utils.str2gib_size(free + allocated)}\\n return free + allocated, free, allocated\",\n \"async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\\n\\n trusted, fee = trusted_and_fee\\n num_blocks = 4 # Num blocks to farm at a time\\n total_blocks = 0 # Total blocks farmed so far\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n wallet_node_0 = wallet_nodes[0]\\n our_ph = receive_address[0]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_node_0.server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\\n total_block_rewards = await get_total_block_rewards(total_blocks)\\n\\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n assert total_block_rewards > 0\\n\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5001\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx_2.spend_bundle,\\n creation_tx_2.name,\\n )\\n\\n for r in creation_tx.removals:\\n assert r not in creation_tx_2.removals\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 2\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n wallet_id_2: int = summaries_response[1][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n assert status_2.target is None\\n\\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\\n return fetched is not None and fetched.is_in_mempool()\\n\\n join_pool: Dict = await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 10,\\n fee,\\n )\\n assert join_pool[\\\"success\\\"]\\n join_pool_tx: TransactionRecord = join_pool[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\\n\\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \\\"https://pool.example.com\\\", 10, fee)\\n assert join_pool_2[\\\"success\\\"]\\n join_pool_tx_2: TransactionRecord = join_pool_2[\\\"transaction\\\"]\\n for r in join_pool_tx.removals:\\n assert r not in join_pool_tx_2.removals\\n assert join_pool_tx_2 is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is not None\\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.target is not None\\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n\\n async def status_is_farming_to_pool(w_id: int):\\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def test_thread_pool(self):\\n self.assertIdentical(self.tx_client._pool, self.pool)\",\n \"def dvs_remote_ip_prefix(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(2)\\n net_1 = os_conn.create_network(network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n # Check that network are created\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n # Create Router_01, set gateway and add interface to external network.\\n router_1 = os_conn.create_router('router_1', tenant=tenant)\\n\\n # Add net_1 to router_1\\n os_conn.add_router_interface(router_id=router_1[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(3)\\n self.show_step(4)\\n self.show_step(5)\\n sg1 = os_conn.nova.security_groups.create('SG1', \\\"descr\\\")\\n sg2 = os_conn.nova.security_groups.create('SG2', \\\"descr\\\")\\n\\n access_point_1, access_point_ip_1 = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg1.name])\\n\\n access_point_2, access_point_ip_2 = openstack.create_access_point(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n security_groups=[security_group.name, sg2.name])\\n\\n self.show_step(6)\\n _sg_rules = os_conn.neutron.list_security_group_rules()\\n sg_rules = [sg_rule for sg_rule in _sg_rules['security_group_rules']\\n if sg_rule['security_group_id'] in [sg1.id, sg2.id]]\\n for rule in sg_rules:\\n os_conn.neutron.delete_security_group_rule(rule['id'])\\n\\n self.show_step(7)\\n for rule in [self.icmp, self.tcp]:\\n rule[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg1.id\\n rule[\\\"security_group_rule\\\"][\\\"remote_ip_prefix\\\"] = access_point_ip_1\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n rule[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"egress\\\"\\n os_conn.neutron.create_security_group_rule(rule)\\n\\n # Get private ip of access_point_2\\n private_ip = os_conn.get_nova_instance_ip(access_point_2,\\n net_name=net_1['name'])\\n\\n self.show_step(8)\\n self.tcp[\\\"security_group_rule\\\"][\\\"security_group_id\\\"] = sg2.id\\n self.tcp[\\\"security_group_rule\\\"][\\\"remote_ip_prefix\\\"] = private_ip\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n self.tcp[\\\"security_group_rule\\\"][\\\"direction\\\"] = \\\"ingress\\\"\\n os_conn.neutron.create_security_group_rule(self.tcp)\\n\\n self.show_step(9)\\n istances_sg1 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg1.name])\\n\\n istances_sg2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[sg2.name])\\n openstack.verify_instance_state(os_conn)\\n\\n # Get private ips of instances\\n ips = {\\n 'SG1': [os_conn.assign_floating_ip(i).ip for i in istances_sg1],\\n 'SG2': [os_conn.get_nova_instance_ip(i, net_name=net_1['name'])\\n for i in istances_sg2]\\n }\\n\\n self.show_step(10)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = [access_point_ip_1]\\n openstack.check_connection_through_host(access_point_ip_1,\\n ip_pair,\\n timeout=60 * 4)\\n\\n self.show_step(11)\\n ip_pair = dict.fromkeys(ips['SG1'])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips['SG1'] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip_1, ip_pair, result_of_command=1)\\n\\n self.show_step(12)\\n self.show_step(13)\\n ip_pair = dict.fromkeys(ips['SG2'])\\n for key in ip_pair:\\n ip_pair[key] = [value for value in ips['SG2'] if key != value]\\n openstack.check_connection_through_host(\\n access_point_ip_2, ip_pair, result_of_command=1)\",\n \"def dnt_share_app():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n\\r\\n 'Click on Do not share button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('a'))\\r\\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not(flag1) else True\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def show_resource_pool(client, private_cloud, resource_pool, location):\\n return client.get(location, private_cloud, resource_pool)\",\n \"def show_networks():\\n return get_networks()\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_object = RadosOrchestrator(node=cephadm)\\n mon_obj = MonConfigMethods(rados_obj=rados_object)\\n ceph_nodes = kw.get(\\\"ceph_nodes\\\")\\n osd_list = []\\n total_osd_app_mem = {}\\n\\n for node in ceph_nodes:\\n if node.role == \\\"osd\\\":\\n node_osds = rados_object.collect_osd_daemon_ids(node)\\n osd_list = osd_list + node_osds\\n\\n target_configs = config[\\\"cache_trim_max_skip_pinned\\\"][\\\"configurations\\\"]\\n max_skip_pinned_value = int(\\n mon_obj.get_config(section=\\\"osd\\\", param=\\\"bluestore_cache_trim_max_skip_pinned\\\")\\n )\\n\\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\\n if max_skip_pinned_value != 1000:\\n log.error(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\\\"\\n )\\n raise Exception(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\\\"\\n )\\n\\n # Creating pools and starting the test\\n for entry in target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n if entry.get(\\\"pool_type\\\", \\\"replicated\\\") == \\\"erasure\\\":\\n method_should_succeed(\\n rados_object.create_erasure_pool, name=entry[\\\"pool_name\\\"], **entry\\n )\\n else:\\n method_should_succeed(\\n rados_object.create_pool,\\n **entry,\\n )\\n\\n if not rados_object.bench_write(**entry):\\n log.error(\\\"Failed to write objects into the EC Pool\\\")\\n return 1\\n rados_object.bench_read(**entry)\\n log.info(\\\"Finished writing data into the pool\\\")\\n\\n # performing scrub and deep-scrub\\n rados_object.run_scrub()\\n rados_object.run_deep_scrub()\\n time.sleep(10)\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"start\\\")\\n # Executing tests for 45 minutes\\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\\n while datetime.datetime.now() < time_execution:\\n # Get all OSDs heap dump\\n heap_dump = rados_object.get_heap_dump(osd_list)\\n # get the osd application used memory\\n osd_app_mem = get_bytes_used_by_app(heap_dump)\\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\\n # wait for 10 seconds and collecting the memory\\n time.sleep(10)\\n for osd_id, mem_list in total_osd_app_mem.items():\\n mem_growth = is_what_percent_mem(mem_list)\\n if mem_growth > 80:\\n log.error(\\n f\\\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\\\"\\n )\\n raise Exception(\\\"No warning generated by PG Autoscaler\\\")\\n log.info(f\\\"The relative memory growth for the osd.{osd_id} is {mem_growth} \\\")\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"stop\\\")\\n\\n # check fo the crashes in the cluster\\n crash_list = rados_object.do_crash_ls()\\n if not crash_list:\\n return 0\\n else:\\n return 1\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def is_share_all_host_disks(self):\\n\\t\\treturn bool(call_sdk_function('PrlVmCfg_IsShareAllHostDisks', self.handle))\",\n \"def test_anon_public_owned(self):\\n self.do_visible(True, 'pattieblack', True)\",\n \"def test_empty_public_owned(self):\\n self.do_visible(True, 'pattieblack', True, is_admin=True)\",\n \"def test_no_overprovision(self):\\n command_line = (\\n self._MENU + [self._POOLNAME] + self._DEVICES + [\\\"--no-overprovision\\\"]\\n )\\n TEST_RUNNER(command_line)\",\n \"def test_create_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def check_free_space():\\n subprocess.run([\\\"ssh\\\",backup_host, \\\"du -h\\\", dest ]])\\n # get output\",\n \"def test_list_pools_no_filter(api: API, account: Account, raw_pools):\\n api.candlepin.get_pools.return_value = raw_pools\\n pools = account.list_pools(filter_attributes={})\\n assert pools == raw_pools\",\n \"async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 5,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.current.pool_url == \\\"\\\"\\n assert status.current.relative_lock_height == 0\\n assert status.current.state == 1\\n assert status.current.version == 1\\n\\n assert status.target\\n assert status.target.pool_url == \\\"https://pool.example.com\\\"\\n assert status.target.relative_lock_height == 5\\n assert status.target.state == 3\\n assert status.target.version == 1\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\\n assert leave_pool_tx[\\\"transaction\\\"].wallet_id == wallet_id\\n assert leave_pool_tx[\\\"transaction\\\"].amount == 1\\n\\n async def status_is_leaving():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\\n\\n async def status_is_self_pooling():\\n # Farm enough blocks to wait for relative_lock_height\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_delete_cluster_network(self):\\n pass\",\n \"def set_dfuse_pool_params(self, pool, display=True):\\n self.puuid.update(pool.uuid, \\\"puuid\\\" if display else None)\",\n \"def test_get_hyperflex_cluster_list(self):\\n pass\",\n \"def test_01_dedicated_cluster_allocation(self):\\n\\n # Step 1\\n dedicateCmd = dedicateCluster.dedicateClusterCmd()\\n dedicateCmd.clusterid = self.clusters[0].id\\n dedicateCmd.domainid = self.domain.id\\n dedicateCmd.account = self.account_1.name\\n self.apiclient.dedicateCluster(dedicateCmd)\\n\\n afcmd = listAffinityGroups.listAffinityGroupsCmd()\\n afcmd.account = self.account_1.name\\n afcmd.domainid = self.account_1.domainid\\n affinitygr_list = self.apiclient.listAffinityGroups(afcmd)\\n\\n # Step 2\\n self.vm = VirtualMachine.create(\\n self.userapiclient_1,\\n self.testdata[\\\"small\\\"],\\n templateid=self.template.id,\\n accountid=self.account_1.name,\\n domainid=self.account_1.domainid,\\n serviceofferingid=self.service_offering.id,\\n affinitygroupids=[affinitygr_list[0].id],\\n zoneid=self.zone.id,\\n mode=self.zone.networktype\\n )\\n # Steps to verify if VM is created on dedicated account\\n vmlist = list_virtual_machines(self.apiclient,\\n id=self.vm.id)\\n\\n hostlist = list_hosts(self.apiclient,\\n id=vmlist[0].hostid)\\n\\n self.assertEqual(hostlist[0].clusterid,\\n self.clusters[0].id,\\n \\\"check if vm gets deployed on dedicated clusture\\\"\\n )\\n # Step 3\\n self.vm_1 = VirtualMachine.create(\\n self.userapiclient_2,\\n self.testdata[\\\"small\\\"],\\n templateid=self.template.id,\\n accountid=self.account_2.name,\\n domainid=self.account_2.domainid,\\n serviceofferingid=self.service_offering.id,\\n zoneid=self.zone.id,\\n mode=self.zone.networktype\\n )\\n\\n # Steps to verify if VM is created on dedicated account\\n vmlist_1 = list_virtual_machines(self.apiclient,\\n id=self.vm_1.id)\\n\\n hostlist_1 = list_hosts(self.apiclient,\\n id=vmlist_1[0].hostid)\\n\\n self.assertNotEqual(hostlist_1[0].clusterid,\\n self.clusters[0].id,\\n \\\"check if vm gets deployed on correct clusture\\\"\\n )\\n\\n # Step 4\\n routerList = list_routers(self.apiclient,\\n clusterid=self.clusters[0].id,\\n networkid=self.vm_1.nic[0].networkid\\n )\\n self.assertEqual(\\n routerList,\\n None,\\n \\\"Check Dedicated cluster is used for virtual routers \\\\\\n that belong to non-dedicated account\\\")\\n\\n return\",\n \"def test_switch_vlan_pool_options(self):\\n dpid = \\\"00:00:00:00:00:00:00:01\\\"\\n vlan_pool = {\\\"00:00:00:00:00:00:00:01\\\":\\n {\\\"1\\\": [[1, 2], [5, 10]], \\\"4\\\": [[3, 4]]}}\\n self.controller.switches[dpid] = self.switch\\n self.options.vlan_pool = vlan_pool\\n self.controller.get_switch_or_create(dpid, self.switch.connection)\\n\\n port_id = 1\\n intf = self.controller.switches[dpid].interfaces[port_id]\\n tag_values = [tag.value for tag in intf.available_tags]\\n self.assertEqual(tag_values, [1, 5, 6, 7, 8, 9])\\n\\n port_id = 4\\n intf = self.controller.switches[dpid].interfaces[port_id]\\n tag_values = [tag.value for tag in intf.available_tags]\\n self.assertEqual(tag_values, [3])\\n\\n # this port number doesn't exist yet.\\n port_7 = 7\\n intf = Interface(\\\"test\\\", port_7, self.switch)\\n # no attr filters, so should associate as it is\\n self.controller.switches[dpid].update_interface(intf)\\n intf_obj = self.controller.switches[dpid].interfaces[port_7]\\n self.assertEqual(intf_obj, intf)\\n # assert default vlan_pool range (1, 4096)\\n tag_values = [tag.value for tag in intf_obj.available_tags]\\n self.assertEqual(tag_values, list(range(1, 4096)))\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_create_cluster_resource_quota(self):\\n pass\",\n \"def dvs_vcenter_same_ip(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant_admin = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n self.show_step(2)\\n os_conn.create_user_and_tenant('test', 'test', 'test')\\n openstack.add_role_to_user(os_conn, 'test', 'admin', 'test')\\n\\n test_os = os_actions.OpenStackActions(os_ip, 'test', 'test', 'test')\\n\\n tenant = test_os.get_tenant('test')\\n\\n self.show_step(3)\\n logger.info('Create network {}'.format(self.net_data[0].keys()[0]))\\n net_1 = test_os.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n subnet = test_os.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n self.show_step(4)\\n router = test_os.create_router('router_1', tenant=tenant)\\n test_os.add_router_interface(router_id=router[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n # Create security group with rules for ssh and ping\\n security_group = test_os.create_sec_group_for_ssh()\\n\\n self.show_step(5)\\n self.show_step(6)\\n srv_1 = openstack.create_instances(\\n os_conn=test_os,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[security_group.name])\\n openstack.verify_instance_state(test_os)\\n\\n fip_1 = openstack.create_and_assign_floating_ips(test_os, srv_1)\\n ips_1 = [test_os.get_nova_instance_ip(s, net_name=net_1['name'])\\n for s in srv_1]\\n\\n # Create security group with rules for ssh and ping\\n security_group = os_conn.create_sec_group_for_ssh()\\n\\n self.show_step(7)\\n logger.info('Create network {}'.format(self.net_data[0].keys()[0]))\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant_admin.id)['network']\\n\\n subnet = os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n self.show_step(8)\\n router = os_conn.create_router('router_1', tenant=tenant_admin)\\n os_conn.add_router_interface(\\n router_id=router[\\\"id\\\"],\\n subnet_id=subnet[\\\"id\\\"])\\n\\n self.show_step(9)\\n self.show_step(10)\\n srv_2 = openstack.create_instances(\\n os_conn=os_conn,\\n nics=[{'net-id': net_1['id']}],\\n vm_count=1,\\n security_groups=[security_group.name])\\n openstack.verify_instance_state(os_conn)\\n\\n self.show_step(11)\\n self.show_step(12)\\n fip_2 = openstack.create_and_assign_floating_ips(os_conn, srv_2)\\n ips_2 = [os_conn.get_nova_instance_ip(s, net_name=net_1['name'])\\n for s in srv_2]\\n\\n ip_pair = dict.fromkeys(fip_1)\\n for key in ip_pair:\\n ip_pair[key] = ips_1\\n openstack.check_connection_vms(ip_pair)\\n\\n ip_pair = dict.fromkeys(fip_2)\\n for key in ip_pair:\\n ip_pair[key] = ips_2\\n openstack.check_connection_vms(ip_pair)\",\n \"def get_list_node(showOnly=False, full=False):\\n # start Requests session\\n sc = requests.Session()\\n\\n # import cookies from Firefox\\n sc.cookies.update(get_cookies('imhsc.imhadmin.net'))\\n\\n # send request\\n vpx = sc.post('https://imhsc.imhadmin.net/index.php?v=VPNodes')\\n\\n # check if login failed\\n check_sc_login(vpx.text)\\n\\n # parse with BS4\\n bs = BeautifulSoup(vpx.text, \\\"xml\\\")\\n\\n # server=0\\n slist = []\\n for trr in bs.tbody.find_all('tr'):\\n try:\\n if full:\\n tsrv = {\\n 'name': trr.find_all('td')[0].text.strip(),\\n 'ip': trr.find_all('td')[2].text.strip(),\\n 'lan': trr.find_all('td')[3].text.strip(),\\n 'cpus': trr.find_all('td')[4].text.strip(),\\n 'memory': trr.find_all('td')[5].text.strip(),\\n 'os': trr.find_all('td')[6].text.strip(),\\n 'vz': trr.find_all('td')[7].text.strip(),\\n 'license': trr.find_all('td')[8].text.strip(),\\n 'cap': int(trr.find_all('td')[9].text.strip()),\\n 'on': int(trr.find_all('td')[10].text.strip()),\\n 'off': int(trr.find_all('td')[11].text.strip()),\\n 'disk_used': trr.find_all('td')[12].text.strip(),\\n 'disk_free': trr.find_all('td')[13].text.strip(),\\n 'psc1': trr.find_all('td')[14].text.strip(),\\n 'psc2': trr.find_all('td')[15].text.strip(),\\n 'loc': trr.find_all('td')[16].text.strip(),\\n 'ra': trr.find_all('td')[17].text.strip(),\\n 'ba': trr.find_all('td')[18].text.strip(),\\n 'model': trr.find_all('td')[19].text.strip()\\n }\\n else:\\n tsrv = trr.find_all('td')[0].text.strip()\\n except:\\n continue\\n slist.append(tsrv)\\n if not showOnly:\\n if full:\\n json.dumps(tsrv)\\n else:\\n print(tsrv)\\n\\n return slist\",\n \"def test_get_alloc_format_overlap():\\n time = \\\"10:00:00\\\"\\n nodes = 5\\n account = \\\"A35311\\\"\\n options = {\\\"N\\\": 10, \\\"time\\\": \\\"15\\\", \\\"account\\\": \\\"S1242\\\"}\\n alloc_cmd = _get_alloc_cmd(nodes, time, account, options)\\n result = [\\n \\\"--no-shell\\\",\\n \\\"-N\\\",\\n \\\"5\\\",\\n \\\"-J\\\",\\n \\\"SmartSim\\\",\\n \\\"-t\\\",\\n \\\"10:00:00\\\",\\n \\\"-A\\\",\\n \\\"A35311\\\",\\n ]\\n assert result == alloc_cmd\",\n \"def task6(self, doc_uuid):\\n doc_shares = {}\\n for entry in self.records:\\n if ((entry['event_type'] == 'share') and (entry['subject_doc_id'] == doc_uuid)):\\n service = entry['event_service']\\n if(service in doc_shares):\\n doc_shares[service] += 1\\n else:\\n doc_shares[service] = 1\\n GUI.show_histo(doc_shares, \\\"vert\\\", \\\"Number Of Shares for Platform\\\", \\\"Platform Distribution\\\")\",\n \"def compare(self):\\n len0 = len(self.cluster_lists[0])\\n len1 = len(self.cluster_lists[1])\\n longer_index = 0 if len0 >= len1 else 1\\n shorter_index = 1 if len1 <= len0 else 0\\n self.stars_length = len(self.cluster_lists[shorter_index]) \\n self.starlets_length = len(self.cluster_lists[longer_index]) \\n # build the noeds for shorter cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[shorter_index]:\\n len_spectra = len(cluster.get_spectra())\\n star = ClusterNode(cluster.id, len_spectra) \\n self.stars[cluster.id] = star\\n\\n self.cluster_spectra_num[shorter_index] += len_spectra\\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\\n # build the noeds for longer cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[longer_index]:\\n len_spectra = len(cluster.get_spectra())\\n starlet = ClusterNode(cluster.id, len_spectra) \\n self.starlets[cluster.id] = starlet\\n\\n self.cluster_spectra_num[longer_index] += len_spectra\\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\\n # do the comparing, and network building\\n for i in range (0, len(self.cluster_lists[shorter_index])):\\n cluster0 = self.cluster_lists[shorter_index][i] \\n for j in range (i, len(self.cluster_lists[longer_index])):\\n cluster1 = self.cluster_lists[longer_index][j] \\n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\\n if similarity == 0:\\n continue\\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\\n self.shared_spec_num += shared_spec_num\\n\\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\\n\\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length\",\n \"def usage(self, host):\",\n \"def show(self, threadID):\\n print(\\\"[thread %d] Simulated Clustered Disk Space Allocation\\\" % threadID)\\n line = '=' * 32\\n print line\\n for i in range(self.size/32):\\n print ''.join(self.disk_mem[32*i:32*(i+1)])\\n print line\",\n \"def test_read_cluster_resource_quota_status(self):\\n pass\",\n \"def test_replace_cluster_network(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.838688","0.82205","0.82004833","0.81190896","0.8064236","0.76910836","0.7640043","0.7465289","0.7388782","0.7017174","0.6918035","0.68557525","0.6643733","0.65673494","0.65449506","0.652991","0.6403193","0.6230861","0.61453474","0.5764217","0.56883866","0.56527525","0.56369704","0.55728155","0.5520617","0.551702","0.53948784","0.53913003","0.5387639","0.5348172","0.5316683","0.5258533","0.51868147","0.5173981","0.51692736","0.51573783","0.51551425","0.51464736","0.5136405","0.51229197","0.509903","0.50811106","0.50787795","0.5073101","0.5063485","0.5050356","0.5046225","0.50459695","0.5043852","0.50428146","0.5042362","0.5035088","0.50344396","0.5032127","0.5030029","0.49890473","0.49874383","0.49862024","0.49856713","0.49764308","0.49576828","0.4946452","0.4942587","0.49341252","0.49255833","0.4899205","0.48950413","0.4887309","0.4878087","0.48744544","0.48668614","0.48662433","0.48599812","0.48596746","0.4849876","0.48491913","0.48384768","0.4822382","0.48157734","0.48137513","0.48086053","0.4805006","0.4803268","0.48025987","0.4800545","0.47836828","0.4781405","0.47809365","0.47773808","0.47772178","0.47763324","0.47751397","0.4774606","0.47674054","0.47668472","0.47588894","0.47527543","0.4743866","0.47426078","0.4742501"],"string":"[\n \"0.838688\",\n \"0.82205\",\n \"0.82004833\",\n \"0.81190896\",\n \"0.8064236\",\n \"0.76910836\",\n \"0.7640043\",\n \"0.7465289\",\n \"0.7388782\",\n \"0.7017174\",\n \"0.6918035\",\n \"0.68557525\",\n \"0.6643733\",\n \"0.65673494\",\n \"0.65449506\",\n \"0.652991\",\n \"0.6403193\",\n \"0.6230861\",\n \"0.61453474\",\n \"0.5764217\",\n \"0.56883866\",\n \"0.56527525\",\n \"0.56369704\",\n \"0.55728155\",\n \"0.5520617\",\n \"0.551702\",\n \"0.53948784\",\n \"0.53913003\",\n \"0.5387639\",\n \"0.5348172\",\n \"0.5316683\",\n \"0.5258533\",\n \"0.51868147\",\n \"0.5173981\",\n \"0.51692736\",\n \"0.51573783\",\n \"0.51551425\",\n \"0.51464736\",\n \"0.5136405\",\n \"0.51229197\",\n \"0.509903\",\n \"0.50811106\",\n \"0.50787795\",\n \"0.5073101\",\n \"0.5063485\",\n \"0.5050356\",\n \"0.5046225\",\n \"0.50459695\",\n \"0.5043852\",\n \"0.50428146\",\n \"0.5042362\",\n \"0.5035088\",\n \"0.50344396\",\n \"0.5032127\",\n \"0.5030029\",\n \"0.49890473\",\n \"0.49874383\",\n \"0.49862024\",\n \"0.49856713\",\n \"0.49764308\",\n \"0.49576828\",\n \"0.4946452\",\n \"0.4942587\",\n \"0.49341252\",\n \"0.49255833\",\n \"0.4899205\",\n \"0.48950413\",\n \"0.4887309\",\n \"0.4878087\",\n \"0.48744544\",\n \"0.48668614\",\n \"0.48662433\",\n \"0.48599812\",\n \"0.48596746\",\n \"0.4849876\",\n \"0.48491913\",\n \"0.48384768\",\n \"0.4822382\",\n \"0.48157734\",\n \"0.48137513\",\n \"0.48086053\",\n \"0.4805006\",\n \"0.4803268\",\n \"0.48025987\",\n \"0.4800545\",\n \"0.47836828\",\n \"0.4781405\",\n \"0.47809365\",\n \"0.47773808\",\n \"0.47772178\",\n \"0.47763324\",\n \"0.47751397\",\n \"0.4774606\",\n \"0.47674054\",\n \"0.47668472\",\n \"0.47588894\",\n \"0.47527543\",\n \"0.4743866\",\n \"0.47426078\",\n \"0.4742501\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9581628"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81385,"cells":{"query":{"kind":"string","value":"Test case for test_nas_share"},"document":{"kind":"string","value":"def test_test_nas_share(self):\n pass"},"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_test_result_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_index_nas_shares(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_dashboards_v2_share(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def share():\n return True","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def ensure_share(self, context, share, share_server=None):\n pass","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def test_dashboards_v2_list_shares(self):\n pass","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_dashboards_v2_delete_share(self):\n pass","def test_kyc_put_legal_share_holder(self):\n pass","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def __fake_data__(self):\n\n # Set directory for configuration files\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\n \n # Add some share's\n for i in xrange(3):\n share = NFSShare()\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\n self.shares[share.name] = share","def test_HYD965(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpBadRequest(response)","def test_download_host(self):\n pass","def test_clone_system(self):\n pass","def test_kyc_post_legal_share_holder(self):\n pass","def canShare(self):\n return False","def test_add_asset_share_feed(self):\n pass","def test_create_cluster_network(self):\n pass","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","def test_put_without_parent_datastore_nor_share_id(self):\n\n url = reverse('file')\n\n data = {\n 'shard_id': self.shard1.id,\n 'link_id': \"b8866161-0b1f-4a8e-acde-07047313ec8f\",\n #'parent_datastore_id': str(self.test_datastore_obj.id),\n 'chunk_count': 1,\n 'size': 512,\n }\n\n self.client.force_authenticate(user=self.test_user_obj)\n response = self.client.put(url, data)\n\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_read_cluster_network(self):\n pass","def test_sharedstatedir(self):\n self.chck_triple('sharedstatedir')","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def test_post_creation(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)","def mount_cifs_share(self, share_config):\n mount_point = share_config.get('mount_point')\n share_name = share_config.get('share_name')\n remote_host = share_config.get('remote_host')\n if remote_host and share_name and mount_point:\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\n self.cmd(command)","def test_get_drive_mount_point_name_unique_id_exists(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n gfs._unique_id = 0\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n gfs._unique_id = None\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def step_impl(context):\n log.info(\"====> verify the NSA files are not placed under container_nsa directory\")\n\n nsa_container = get_nsa_container_string(context)\n container_nsa_path = \"/tmp/cme/local/GFD/{nsa_container}/container_nsa\".format(nsa_container=nsa_container)\n log.info(\" ****> DEBUG: nsa container path is: {container_nsa_path}\".format(container_nsa_path=container_nsa_path))\n\n command = \"cd {container_nsa_path}; ls -a | wc -l\".format(container_nsa_path=container_nsa_path)\n if \"2\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\n log.info(\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\")\n else:\n assert False, \" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\"","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def test_constants(self):\n self.assertTrue(getattr(unshare, 'CLONE_NEWNS'))\n self.assertTrue(getattr(unshare, 'CLONE_NEWNET'))","def test_create_cloned_volume(self, mock_ghn):\n ctxt = context.get_admin_context()\n extra_specs = {}\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10,\n 'provider_id': 'space_orig'}\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\n 'volume_type_id': type_ref['id'], 'size': 10}\n pid = self.driver.create_cloned_volume(clone, orig)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': 'clone1', 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'clone1'}\n self.assertDictMatch(expected_pid, pid)","def test_verify_ssh_access_with_root_works(driver):","def test_create_snapshot(self, mock_ghn):\n # Now snapshot the volume and check commands\n snapshot = {'volume_name': 'volume10',\n 'volume_id': 'xxx', 'display_name': 'snap10',\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\n 'volume': {'provider_id': 'space10'}}\n ret = self.driver.create_snapshot(snapshot)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': snapshot['display_name'], 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'snap10'}\n self.assertDictMatch(expected_pid, ret)","def test_smoker_get(self):\n pass","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def createCifsShare(self,sharename=\"opt\",sharepath=\"/opt\",rootpasswd=\"rooter\"):\n self.install(\"samba\")\n self.writeTemplate(\"/etc/samba/smb.conf\",q.system.fs.joinPaths(q.dirs.baseDir,\"utils\",\"defaults\",\"etc\",\"smb.conf\"),[[\"$sharename$\",sharename],[\"$sharepath$\",sharepath]])\n self.execute(\"echo -ne \\\"%s\\\\n%s\\\\n\\\" | smbpasswd -a -s root\" %(rootpasswd,rootpasswd))\n self.execute(\"/etc/init.d/samba restart\")","def test_get_drive_mount_point_name_unique_id_None(self):\n try:\n tmpdir = mkdtemp()\n root = os.path.join(tmpdir, 'mnt/gluster-object')\n drive = 'test'\n\n _init_mock_variables(tmpdir)\n gfs._allow_mount_per_server = True\n self.assertTrue(gfs.mount(root, drive))\n finally:\n gfs._allow_mount_per_server = False\n _reset_mock_variables()\n shutil.rmtree(tmpdir)","def test_nova_create(tiny_cirros_server):\n\n assert ping_from_mnaio(tiny_cirros_server.accessIPv4)\n\n @pytest.mark.testinfra('ansible://' + tiny_cirros_server.accessIPv4)\n @pytest.mark.test_id('57f87c9e-3adb-11e9-b2ca-6a00035510c0')\n @pytest.mark.jira('ASC-31')\n def test_nova_create_connect(host):\n f = host.file('/etc/hosts')\n assert f.exists\n assert f.user == 'root'\n assert f.group == 'root'","def test_fileOperations(self): \n from DIRAC import gConfig\n testSE = 'testSE'\n #rssClient = ResourceStatusClient()\n #result = rssClient.getStorageElementsList( 'Read' )\n #result = gConfig.getSections( '/Resources/StorageElements' )\n #if result['OK'] and result['Value']:\n # testSE = result['Value'][0]\n #if result['Ok']:\n # testSE = result['Value'][ 0 ] \n \n result = self.fc.addFile( { testFile: { 'PFN': 'testfile', \n 'SE': testSE , \n 'Size':0, \n 'GUID':0, \n 'Checksum':'0' } } )\n self.assert_( result['OK'] )\n if gConfig.getValue( '/Resources/StorageElements/%s/AccessProtocol.1/Host' % testSE, '' ):\n result = self.fc.getReplicas( testFile )\n self.assert_( result['OK'] )\n self.assert_( testFile in result['Value']['Successful'] )","def test_create_net_namespace(self):\n pass","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_sync_no_archives_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\")\n assert \"No archives found to transfer\" in str(err)","def test_shared_albums(self):\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n t = (\n TestAccount.album_image_count\n + TestAccount.album_shared_image_count\n + TestAccount.shared_album_image_count\n + TestAccount.shared_album_shared_image_count\n )\n\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums including shared\".format(t),\n )\n\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\", \"--skip-shared-albums\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n # note that unless we use --no-album-index the shared files in the\n # visible album will show up here\n t = (\n TestAccount.album_image_count + TestAccount.album_shared_image_count\n ) # see above\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums excluding shared\".format(t),\n )","def test_auth_sharable_owned(self):\n self.do_sharable(True, 'pattieblack', None, tenant='pattieblack')","def test_kyc_get_legal_share_holders(self):\n pass","def allow_access_nfs(self, pool, project, share, access):\n if access['access_type'] != 'ip':\n reason = _('Only ip access type allowed.')\n raise exception.InvalidShareAccess(reason)\n\n ip = access['access_to']\n details = self.get_share(pool, project, share)\n sharenfs = details['sharenfs']\n\n if sharenfs == 'on' or sharenfs == 'rw':\n LOG.debug('Share %s has read/write permission '\n 'open to all.', share)\n return\n if sharenfs == 'off':\n sharenfs = 'sec=sys'\n if ip in sharenfs:\n LOG.debug('Access to share %(share)s via NFS '\n 'already granted to %(ip)s.',\n {'share': share,\n 'ip': ip})\n return\n\n entry = (',rw=@%s' % ip)\n if '/' not in ip:\n entry = \"%s/32\" % entry\n arg = {'sharenfs': sharenfs + entry}\n self.modify_share(pool, project, share, arg)","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def share(job):\n client = get_dropbox_client()\n\n try:\n return client.share(\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\n\n except ErrorResponse:\n return False","def test_create_hyperflex_cluster_storage_policy(self):\n pass","def __init__(self, win_server, share_folder, mount_point, user, password):\n \n share_folder = share_folder.replace(\"/\", \"\\\\\")\n network_folder = r'//%s/%s' %(win_server, share_folder)\n\n print('Mount_point - %s' %(mount_point))\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\n self.mount_point = mount_point\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\n self.success = []\n self.error = []\n\n mount_cmd = \"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\"\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\n mount_point=mount_point,\n user=user,\n password=password)\n self.umount_cmd = \"umount {mount_point}\".format(mount_point=mount_point)","def _get_share_capacity_info(self):\n lcfg = self.configuration\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\n lcfg.zfssa_nfs_project,\n lcfg.zfssa_nfs_share)\n\n free = share_details['space_available']\n used = share_details['space_total']\n return free, used","def testNanotecSharedMemory():\n\t\n\tmemoryClient = NanotecSharedMemoryClient()\n\t\n\t\n\t\n\tserialPort1 = memoryClient.sendInstruction(\"NanotecMotor,/dev/ttyACM0,17\")\n\t\n\tID1 = memoryClient.sendInstruction(\"getID,\" + serialPort1)\n\tprint(\"ID1 (actual): \" + ID1 + \", expected: 17\")\n\tprint(\"\")\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tID1 = memoryClient.sendInstruction(\"getSerialPort,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"ID Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tposition = memoryClient.sendInstruction(\"getAbsoluteAngularPosition,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"Position Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\treturn","def test_ls_no_shareddir():\n\n with bad_fixture() as root:\n assert next(pipeline.ls(root=root), None) is None","def test_share_template_registration(self):\n pass"],"string":"[\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def share():\\n return True\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def __fake_data__(self):\\n\\n # Set directory for configuration files\\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\\n \\n # Add some share's\\n for i in xrange(3):\\n share = NFSShare()\\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\\n self.shares[share.name] = share\",\n \"def test_HYD965(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpBadRequest(response)\",\n \"def test_download_host(self):\\n pass\",\n \"def test_clone_system(self):\\n pass\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def canShare(self):\\n return False\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"def test_put_without_parent_datastore_nor_share_id(self):\\n\\n url = reverse('file')\\n\\n data = {\\n 'shard_id': self.shard1.id,\\n 'link_id': \\\"b8866161-0b1f-4a8e-acde-07047313ec8f\\\",\\n #'parent_datastore_id': str(self.test_datastore_obj.id),\\n 'chunk_count': 1,\\n 'size': 512,\\n }\\n\\n self.client.force_authenticate(user=self.test_user_obj)\\n response = self.client.put(url, data)\\n\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def test_sharedstatedir(self):\\n self.chck_triple('sharedstatedir')\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def test_post_creation(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\",\n \"def mount_cifs_share(self, share_config):\\n mount_point = share_config.get('mount_point')\\n share_name = share_config.get('share_name')\\n remote_host = share_config.get('remote_host')\\n if remote_host and share_name and mount_point:\\n command = 'mount -t cifs -o guest //%s/%s %s' % (remote_host, share_name, mount_point)\\n self.cmd(command)\",\n \"def test_get_drive_mount_point_name_unique_id_exists(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n gfs._unique_id = 0\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n gfs._unique_id = None\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def step_impl(context):\\n log.info(\\\"====> verify the NSA files are not placed under container_nsa directory\\\")\\n\\n nsa_container = get_nsa_container_string(context)\\n container_nsa_path = \\\"/tmp/cme/local/GFD/{nsa_container}/container_nsa\\\".format(nsa_container=nsa_container)\\n log.info(\\\" ****> DEBUG: nsa container path is: {container_nsa_path}\\\".format(container_nsa_path=container_nsa_path))\\n\\n command = \\\"cd {container_nsa_path}; ls -a | wc -l\\\".format(container_nsa_path=container_nsa_path)\\n if \\\"2\\\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\\n log.info(\\\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\\\")\\n else:\\n assert False, \\\" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\\\"\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_constants(self):\\n self.assertTrue(getattr(unshare, 'CLONE_NEWNS'))\\n self.assertTrue(getattr(unshare, 'CLONE_NEWNET'))\",\n \"def test_create_cloned_volume(self, mock_ghn):\\n ctxt = context.get_admin_context()\\n extra_specs = {}\\n type_ref = volume_types.create(ctxt, 'hgst-1', extra_specs)\\n orig = {'id': '1', 'name': 'volume1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10,\\n 'provider_id': 'space_orig'}\\n clone = {'id': '2', 'name': 'clone1', 'display_name': '',\\n 'volume_type_id': type_ref['id'], 'size': 10}\\n pid = self.driver.create_cloned_volume(clone, orig)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': 'clone1', 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'clone1'}\\n self.assertDictMatch(expected_pid, pid)\",\n \"def test_verify_ssh_access_with_root_works(driver):\",\n \"def test_create_snapshot(self, mock_ghn):\\n # Now snapshot the volume and check commands\\n snapshot = {'volume_name': 'volume10',\\n 'volume_id': 'xxx', 'display_name': 'snap10',\\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\\n 'volume': {'provider_id': 'space10'}}\\n ret = self.driver.create_snapshot(snapshot)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': snapshot['display_name'], 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'snap10'}\\n self.assertDictMatch(expected_pid, ret)\",\n \"def test_smoker_get(self):\\n pass\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def createCifsShare(self,sharename=\\\"opt\\\",sharepath=\\\"/opt\\\",rootpasswd=\\\"rooter\\\"):\\n self.install(\\\"samba\\\")\\n self.writeTemplate(\\\"/etc/samba/smb.conf\\\",q.system.fs.joinPaths(q.dirs.baseDir,\\\"utils\\\",\\\"defaults\\\",\\\"etc\\\",\\\"smb.conf\\\"),[[\\\"$sharename$\\\",sharename],[\\\"$sharepath$\\\",sharepath]])\\n self.execute(\\\"echo -ne \\\\\\\"%s\\\\\\\\n%s\\\\\\\\n\\\\\\\" | smbpasswd -a -s root\\\" %(rootpasswd,rootpasswd))\\n self.execute(\\\"/etc/init.d/samba restart\\\")\",\n \"def test_get_drive_mount_point_name_unique_id_None(self):\\n try:\\n tmpdir = mkdtemp()\\n root = os.path.join(tmpdir, 'mnt/gluster-object')\\n drive = 'test'\\n\\n _init_mock_variables(tmpdir)\\n gfs._allow_mount_per_server = True\\n self.assertTrue(gfs.mount(root, drive))\\n finally:\\n gfs._allow_mount_per_server = False\\n _reset_mock_variables()\\n shutil.rmtree(tmpdir)\",\n \"def test_nova_create(tiny_cirros_server):\\n\\n assert ping_from_mnaio(tiny_cirros_server.accessIPv4)\\n\\n @pytest.mark.testinfra('ansible://' + tiny_cirros_server.accessIPv4)\\n @pytest.mark.test_id('57f87c9e-3adb-11e9-b2ca-6a00035510c0')\\n @pytest.mark.jira('ASC-31')\\n def test_nova_create_connect(host):\\n f = host.file('/etc/hosts')\\n assert f.exists\\n assert f.user == 'root'\\n assert f.group == 'root'\",\n \"def test_fileOperations(self): \\n from DIRAC import gConfig\\n testSE = 'testSE'\\n #rssClient = ResourceStatusClient()\\n #result = rssClient.getStorageElementsList( 'Read' )\\n #result = gConfig.getSections( '/Resources/StorageElements' )\\n #if result['OK'] and result['Value']:\\n # testSE = result['Value'][0]\\n #if result['Ok']:\\n # testSE = result['Value'][ 0 ] \\n \\n result = self.fc.addFile( { testFile: { 'PFN': 'testfile', \\n 'SE': testSE , \\n 'Size':0, \\n 'GUID':0, \\n 'Checksum':'0' } } )\\n self.assert_( result['OK'] )\\n if gConfig.getValue( '/Resources/StorageElements/%s/AccessProtocol.1/Host' % testSE, '' ):\\n result = self.fc.getReplicas( testFile )\\n self.assert_( result['OK'] )\\n self.assert_( testFile in result['Value']['Successful'] )\",\n \"def test_create_net_namespace(self):\\n pass\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_sync_no_archives_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\")\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_shared_albums(self):\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n t = (\\n TestAccount.album_image_count\\n + TestAccount.album_shared_image_count\\n + TestAccount.shared_album_image_count\\n + TestAccount.shared_album_shared_image_count\\n )\\n\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums including shared\\\".format(t),\\n )\\n\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\", \\\"--skip-shared-albums\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n # note that unless we use --no-album-index the shared files in the\\n # visible album will show up here\\n t = (\\n TestAccount.album_image_count + TestAccount.album_shared_image_count\\n ) # see above\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums excluding shared\\\".format(t),\\n )\",\n \"def test_auth_sharable_owned(self):\\n self.do_sharable(True, 'pattieblack', None, tenant='pattieblack')\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def allow_access_nfs(self, pool, project, share, access):\\n if access['access_type'] != 'ip':\\n reason = _('Only ip access type allowed.')\\n raise exception.InvalidShareAccess(reason)\\n\\n ip = access['access_to']\\n details = self.get_share(pool, project, share)\\n sharenfs = details['sharenfs']\\n\\n if sharenfs == 'on' or sharenfs == 'rw':\\n LOG.debug('Share %s has read/write permission '\\n 'open to all.', share)\\n return\\n if sharenfs == 'off':\\n sharenfs = 'sec=sys'\\n if ip in sharenfs:\\n LOG.debug('Access to share %(share)s via NFS '\\n 'already granted to %(ip)s.',\\n {'share': share,\\n 'ip': ip})\\n return\\n\\n entry = (',rw=@%s' % ip)\\n if '/' not in ip:\\n entry = \\\"%s/32\\\" % entry\\n arg = {'sharenfs': sharenfs + entry}\\n self.modify_share(pool, project, share, arg)\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def share(job):\\n client = get_dropbox_client()\\n\\n try:\\n return client.share(\\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\\n\\n except ErrorResponse:\\n return False\",\n \"def test_create_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def __init__(self, win_server, share_folder, mount_point, user, password):\\n \\n share_folder = share_folder.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n network_folder = r'//%s/%s' %(win_server, share_folder)\\n\\n print('Mount_point - %s' %(mount_point))\\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\\n self.mount_point = mount_point\\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\\n self.success = []\\n self.error = []\\n\\n mount_cmd = \\\"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\\\"\\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\\n mount_point=mount_point,\\n user=user,\\n password=password)\\n self.umount_cmd = \\\"umount {mount_point}\\\".format(mount_point=mount_point)\",\n \"def _get_share_capacity_info(self):\\n lcfg = self.configuration\\n share_details = self.zfssa.get_share(lcfg.zfssa_nfs_pool,\\n lcfg.zfssa_nfs_project,\\n lcfg.zfssa_nfs_share)\\n\\n free = share_details['space_available']\\n used = share_details['space_total']\\n return free, used\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\",\n \"def test_ls_no_shareddir():\\n\\n with bad_fixture() as root:\\n assert next(pipeline.ls(root=root), None) is None\",\n \"def test_share_template_registration(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.93370456","0.93197984","0.9103192","0.90562487","0.887185","0.87910056","0.876829","0.85913104","0.8434087","0.8427662","0.8250264","0.8236316","0.8182762","0.81814677","0.81565195","0.76892686","0.7569769","0.73527855","0.69095725","0.68744296","0.6867588","0.68445563","0.6740641","0.65553653","0.652544","0.6476702","0.64176154","0.6415081","0.63031036","0.62862116","0.6216686","0.62125564","0.61705554","0.6166906","0.61663646","0.61559176","0.6150488","0.6135035","0.6131397","0.6101652","0.6066716","0.606286","0.60461926","0.60029066","0.59505117","0.59498036","0.59210527","0.58751845","0.5859792","0.5817544","0.58169264","0.57911146","0.5760557","0.5759348","0.5745277","0.5712767","0.5706198","0.5697081","0.5653219","0.5623373","0.56133324","0.55672413","0.5563012","0.55533785","0.5521223","0.55209064","0.55207765","0.5517556","0.5500214","0.54906803","0.5490232","0.5489739","0.5486086","0.5477429","0.54556936","0.54462636","0.5444324","0.5438717","0.5436439","0.5430274","0.5417549","0.5414475","0.53993237","0.53987104","0.5390572","0.5386748","0.5373923","0.5370169","0.5359741","0.5356028","0.53518075","0.53254324","0.5321989","0.5321652","0.5317674","0.5306655","0.5306621","0.5299857","0.52970684","0.5292679"],"string":"[\n \"0.93370456\",\n \"0.93197984\",\n \"0.9103192\",\n \"0.90562487\",\n \"0.887185\",\n \"0.87910056\",\n \"0.876829\",\n \"0.85913104\",\n \"0.8434087\",\n \"0.8427662\",\n \"0.8250264\",\n \"0.8236316\",\n \"0.8182762\",\n \"0.81814677\",\n \"0.81565195\",\n \"0.76892686\",\n \"0.7569769\",\n \"0.73527855\",\n \"0.69095725\",\n \"0.68744296\",\n \"0.6867588\",\n \"0.68445563\",\n \"0.6740641\",\n \"0.65553653\",\n \"0.652544\",\n \"0.6476702\",\n \"0.64176154\",\n \"0.6415081\",\n \"0.63031036\",\n \"0.62862116\",\n \"0.6216686\",\n \"0.62125564\",\n \"0.61705554\",\n \"0.6166906\",\n \"0.61663646\",\n \"0.61559176\",\n \"0.6150488\",\n \"0.6135035\",\n \"0.6131397\",\n \"0.6101652\",\n \"0.6066716\",\n \"0.606286\",\n \"0.60461926\",\n \"0.60029066\",\n \"0.59505117\",\n \"0.59498036\",\n \"0.59210527\",\n \"0.58751845\",\n \"0.5859792\",\n \"0.5817544\",\n \"0.58169264\",\n \"0.57911146\",\n \"0.5760557\",\n \"0.5759348\",\n \"0.5745277\",\n \"0.5712767\",\n \"0.5706198\",\n \"0.5697081\",\n \"0.5653219\",\n \"0.5623373\",\n \"0.56133324\",\n \"0.55672413\",\n \"0.5563012\",\n \"0.55533785\",\n \"0.5521223\",\n \"0.55209064\",\n \"0.55207765\",\n \"0.5517556\",\n \"0.5500214\",\n \"0.54906803\",\n \"0.5490232\",\n \"0.5489739\",\n \"0.5486086\",\n \"0.5477429\",\n \"0.54556936\",\n \"0.54462636\",\n \"0.5444324\",\n \"0.5438717\",\n \"0.5436439\",\n \"0.5430274\",\n \"0.5417549\",\n \"0.5414475\",\n \"0.53993237\",\n \"0.53987104\",\n \"0.5390572\",\n \"0.5386748\",\n \"0.5373923\",\n \"0.5370169\",\n \"0.5359741\",\n \"0.5356028\",\n \"0.53518075\",\n \"0.53254324\",\n \"0.5321989\",\n \"0.5321652\",\n \"0.5317674\",\n \"0.5306655\",\n \"0.5306621\",\n \"0.5299857\",\n \"0.52970684\",\n \"0.5292679\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9618386"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81386,"cells":{"query":{"kind":"string","value":"Test case for test_result_nas_share"},"document":{"kind":"string","value":"def test_test_result_nas_share(self):\n pass"},"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_test_nas_share(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_dashboards_v2_share(self):\n pass","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_dashboards_v2_list_shares(self):\n pass","def share():\n return True","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_kyc_put_legal_share_holder(self):\n pass","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_dashboards_v2_delete_share(self):\n pass","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)","def create_share(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))","def test_get_results(self):\n pass","def test_kyc_post_legal_share_holder(self):\n pass","def create_share(self, context, share, share_server=None):\n if share['share_proto'] != 'NFS':\n raise exception.QBException(\n _('Quobyte driver only supports NFS shares'))\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n if not volume_uuid:\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\n self.rpc.call('setTenant',\n dict(tenant=dict(tenant_id=share['project_id'])),\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\n result = self.rpc.call('createVolume', dict(\n name=share['name'],\n tenant_domain=share['project_id'],\n root_user_id=self.configuration.quobyte_default_volume_user,\n root_group_id=self.configuration.quobyte_default_volume_group,\n configuration_name=(self.configuration.\n quobyte_volume_configuration)))\n volume_uuid = result['volume_uuid']\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n self._resize_share(share, share['size'])\n\n return self._build_share_export_string(result)","def testGoodput( self ):\n \n for server in self.servers():\n setOutputQueueSize( server )\n setRtoMin( server )\n launchServerProcess(server)\n \n switch = self.getNodeByName( 'switch0' ) \n setOutputQueueSize( switch )\n\n for i in range(1,args.servers+1):\n setInputQueueLength(switch,i,args.input_queue_size)\n \n setOutputQueueSize( self.client() )\n setRtoMin( self.client() )\n\n if args.ping:\n for server in self.servers():\n print self.client().cmd( 'ping -c 9 %s' % server.IP() )\n return 0.0\n \n self.writeServerIpFile()\n \n goodput = float(runClient(self.client()))\n \n retransmits = 0\n for server in self.servers():\n server.waitOutput()\n retransmits += countRetransmits(netstat(server))\n\n retransFile = open('retransmissions.txt','a')\n retransFile.write( \"%d servers: %d retransmissions\\n\" % (args.servers, retransmits ))\n retransFile.close()\n\n return goodput","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def testNanotecSharedMemory():\n\t\n\tmemoryClient = NanotecSharedMemoryClient()\n\t\n\t\n\t\n\tserialPort1 = memoryClient.sendInstruction(\"NanotecMotor,/dev/ttyACM0,17\")\n\t\n\tID1 = memoryClient.sendInstruction(\"getID,\" + serialPort1)\n\tprint(\"ID1 (actual): \" + ID1 + \", expected: 17\")\n\tprint(\"\")\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tID1 = memoryClient.sendInstruction(\"getSerialPort,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"ID Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\t\n\tstartTime = time.time()\n\tnumCalls = 1000\n\tfor _ in range(numCalls):\n\t\tposition = memoryClient.sendInstruction(\"getAbsoluteAngularPosition,\" + serialPort1)\n\tendTime = time.time()\n\ttotalTime = endTime - startTime\n\tprint(\"\")\n\tprint(\"Position Call\")\n\tprint(\"numCalls: \" + str(numCalls))\n\tprint(\"total time: \" + str(totalTime))\n\tprint(\"time per call: \" + str(totalTime/numCalls))\n\t\n\treturn","def test_smoker_get(self):\n pass","def test_download_host(self):\n pass","def dnt_share_app():\r\n msg, status = \"\", True\r\n try:\r\n\r\n 'Click on Do not share button'\r\n flag1 = ui_controls.button(get_obj_identifier('a'))\r\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\r\n \r\n \r\n\r\n status = False if not(flag1) else True\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def test_read_cluster_network(self):\n pass","def step_impl(context):\n log.info(\"====> verify the NSA files are not placed under container_nsa directory\")\n\n nsa_container = get_nsa_container_string(context)\n container_nsa_path = \"/tmp/cme/local/GFD/{nsa_container}/container_nsa\".format(nsa_container=nsa_container)\n log.info(\" ****> DEBUG: nsa container path is: {container_nsa_path}\".format(container_nsa_path=container_nsa_path))\n\n command = \"cd {container_nsa_path}; ls -a | wc -l\".format(container_nsa_path=container_nsa_path)\n if \"2\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\n log.info(\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\")\n else:\n assert False, \" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\"","def test_11_clone(self):\n # Test basic operation of cloning repo which contains one\n # publisher to repo which contains same publisher\n self.pkgrecv(self.durl1, \"--clone -d {0}\".format(self.dpath2))\n\n ret = subprocess.call([\"/usr/bin/gdiff\", \"-Naur\", \"-x\", \n \"index\", \"-x\", \"trans\", self.dpath1, self.dpath2])\n self.assertTrue(ret==0)\n\n # Test that packages in dst which are not in src get removed.\n self.pkgsend_bulk(self.durl2, (self.amber30))\n self.pkgrecv(self.durl1, \"--clone -d {0}\".format(self.dpath2))\n ret = subprocess.call([\"/usr/bin/gdiff\", \"-Naur\", \"-x\", \n \"index\", \"-x\", \"trans\", self.dpath1, self.dpath2])\n self.assertTrue(ret==0)\n\n # Test that clone reports publishers not in the dest repo.\n amber = self.amber10.replace(\"open \", \"open pkg://test2/\")\n self.pkgsend_bulk(self.durl1, amber)\n self.pkgrecv(self.durl1, \"--clone -d {0}\".format(self.dpath2), exit=1)\n\n # Test that clone adds new publishers if requested.\n amber = self.amber10.replace(\"open \", \"open pkg://test2/\")\n self.pkgsend_bulk(self.durl1, amber)\n self.pkgrecv(self.durl1, \"--clone -d {0} -p test2\".format(self.dpath2))\n ret = subprocess.call([\"/usr/bin/gdiff\", \"-Naur\", \"-x\", \n \"index\", \"-x\", \"trans\", self.dpath1,\n self.dpath2])\n self.assertTrue(ret==0)\n\n # Test that clone removes all packages if source is empty\n self.pkgrecv(self.durl3, \"--clone -d {0}\".format(self.dpath2))\n self.pkgrepo(\"-s {0} list -H -p test2\".format(self.dpath2))\n self.assertEqualDiff(\"\", self.output)\n\n # Test that clone works fine with mulitple publishers\n amber = self.amber10.replace(\"open \", \"open pkg://test2/\")\n self.pkgsend_bulk(self.durl1, amber)\n\n path = os.path.join(self.dpath2, \"publisher/test1\")\n shutil.rmtree(path)\n path = os.path.join(self.dpath2, \"publisher/test2\")\n shutil.rmtree(path)\n self.pkgrecv(self.durl1, \"--clone -d {0} -p test2 -p test1\".format(\n self.dpath2))\n ret = subprocess.call([\"/usr/bin/gdiff\", \"-Naur\", \"-x\",\n \"index\", \"-x\", \"trans\", self.dpath1, self.dpath2])\n self.assertTrue(ret==0)\n\n # Test that clone fails if --raw is specified.\n self.pkgrecv(self.durl1, \"--raw --clone -d {0} -p test2\".format(\n self.dpath2), exit=2)\n\n # Test that clone fails if -c is specified.\n self.pkgrecv(self.durl1, \"-c /tmp/ --clone -d {0} -p test2\".format(\n self.dpath2), exit=2)\n\n # Test that clone fails if -a is specified.\n self.pkgrecv(self.durl1, \"-a --clone -d {0} -p test2\".format(\n self.dpath2), exit=2)\n\n # Test that clone fails if --newest is specified.\n self.pkgrecv(self.durl1, \"--newest --clone -d {0} -p test2\".format(\n self.dpath2), exit=2)","def test_kyc_get_legal_share_holders(self):\n pass","def ensure_share(self, context, share, share_server=None):\n pass","def test_add_asset_share_feed(self):\n pass","def share(job):\n client = get_dropbox_client()\n\n try:\n return client.share(\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\n\n except ErrorResponse:\n return False","def test_sign_offline(cluster):\n # 1. first create two hd new wallet\n seed = \"dune car envelope chuckle elbow slight proud fury remove candy uphold \\\n puzzle call select sibling sport gadget please want vault glance verb damage gown\"\n wallet_1 = Wallet(seed)\n address_1 = wallet_1.address\n wallet_2 = Wallet.new()\n address_2 = wallet_2.address\n\n sender_addr = cluster.address(\"signer1\")\n\n sender_balance = cluster.balance(sender_addr)\n assert sender_balance > 100 * 10 ** 8\n balance_1 = cluster.balance(wallet_1.address)\n assert balance_1 == 0\n balance_2 = cluster.balance(wallet_2.address)\n assert balance_2 == 0\n\n # 2. transfer some coin to wallet_1\n cluster.transfer(sender_addr, address_1, \"100cro\")\n wait_for_new_blocks(cluster, 2)\n\n assert cluster.balance(sender_addr) == sender_balance - 100 * 10 ** 8\n assert cluster.balance(address_1) == 100 * 10 ** 8\n\n # 3. get the send's account info\n port = ports.api_port(cluster.base_port(0))\n api = ApiUtil(port)\n\n amount = 1 * 10 ** 8\n # make transaction without/with fee\n for fee in [0, 600000]:\n sender_account_info = api.account_info(address_1)\n balance_1_before = api.balance(address_1)\n balance_2_before = api.balance(address_2)\n tx = Transaction(\n wallet=wallet_1,\n account_num=sender_account_info[\"account_num\"],\n sequence=sender_account_info[\"sequence\"],\n chain_id=cluster.chain_id,\n fee=fee,\n )\n tx.add_transfer(to_address=address_2, amount=amount, base_denom=\"basecro\")\n signed_tx = tx.get_pushable()\n assert isinstance(signed_tx, dict)\n api.broadcast_tx(signed_tx)\n wait_for_new_blocks(cluster, 3)\n balance_1_after = api.balance(address_1)\n balance_2_after = api.balance(address_2)\n assert balance_2_after == balance_2_before + amount\n assert balance_1_after == balance_1_before - amount - fee","def test_create_snapshot(self, mock_ghn):\n # Now snapshot the volume and check commands\n snapshot = {'volume_name': 'volume10',\n 'volume_id': 'xxx', 'display_name': 'snap10',\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\n 'volume': {'provider_id': 'space10'}}\n ret = self.driver.create_snapshot(snapshot)\n # We must copy entier underlying storage, ~12GB, not just 10GB\n self.assertEqual(11444 * units.Mi, self.dd_count)\n self.assertEqual('1M', self.bs)\n # Check space-create command\n expected = {'redundancy': '0', 'group': 'xanadu',\n 'name': snapshot['display_name'], 'mode': '0777',\n 'user': 'kane', 'net': 'net1',\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\n 'size': '12'}\n self.assertDictMatch(expected, self.created)\n # Check the returned provider\n expected_pid = {'provider_id': 'snap10'}\n self.assertDictMatch(expected_pid, ret)","def test_create_cluster_network(self):\n pass","def test_get_site_scans(self):\n pass","def test_get_scan(self):\n pass","def canShare(self):\n return False","def test_13_output(self):\n\n # Now attempt to receive from a repository.\n self.pkgrepo(\"create {0}\".format(self.tempdir))\n self.pkgrecv(self.dpath1, \"-d {0} -n -v \\*\".format(self.tempdir))\n expected = \"\"\"\\\nRetrieving packages (dry-run) ...\n Packages to add: 9\n Files to retrieve: 17\nEstimated transfer size: 528.00 B\n\"\"\"\n self.assert_(expected in self.output, self.output)\n for s in self.published:\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\n include_scheme=False) in self.output)\n\n # Clean up for next test.\n shutil.rmtree(self.tempdir)\n\n # Now attempt to receive from a repository to a package archive.\n self.pkgrecv(self.dpath1, \"-a -d {0} -n -v \\*\".format(self.tempdir))\n expected = \"\"\"\\\nArchiving packages (dry-run) ...\n Packages to add: 9\n Files to retrieve: 17\nEstimated transfer size: 528.00 B\n\"\"\"\n self.assert_(expected in self.output, self.output)\n for s in self.published:\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\n include_scheme=False) in self.output)\n\n # Now attempt to clone a repository.\n self.pkgrepo(\"create {0}\".format(self.tempdir))\n self.pkgrecv(self.dpath1, \"--clone -d {0} -p \\* -n -v\" \\\n .format(self.tempdir))\n expected = \"\"\"\\\nRetrieving packages (dry-run) ...\n Packages to add: 9\n Files to retrieve: 17\nEstimated transfer size: 528.00 B\n\"\"\"\n self.assert_(expected in self.output, self.output)\n for s in self.published:\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\n include_scheme=False) in self.output)\n\n # Test that output is correct if -n is not specified.\n self.pkgrecv(self.dpath1, \"-d {0} -v \\*\".format(self.tempdir))\n self.assert_(\"dry-run\" not in self.output)","def test_norn(task, result):\n if type(result) != str:\n c_print(f\"*** {task.host}: ERROR running Nornir task ***\")","def test_sync_no_archives_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\")\n assert \"No archives found to transfer\" in str(err)","def test_clone_system(self):\n pass","def test_download1(self):\n pass","def test_get_scans(self):\n pass","def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\"(SMB)\")]', 'clickable')\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\"(SMB)\")]').click()\n assert wait_on_element(driver, 5, f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]', 'clickable')\n driver.find_element_by_xpath(f'//tr[contains(.,\"rt-test\")]//button[@aria-label=\"Actionable Options\"]').click()\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]', 'clickable')\n driver.find_element_by_xpath(f'//button[@ix-auto=\"action__rt-test_Edit Filesystem ACL\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(text(),\"Edit POSIX.1e ACL\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"/mnt/tank/rt-acl-test-1/share\")]')\n assert wait_on_element(driver, 5, '//div[contains(text(),\"User - games\")]')","def test_auth_sharable_cannot_share(self):\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\n tenant='froggy')","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_download2(self):\n pass","def test_kyc_get_legal_share_holder_natural(self):\n pass","def test_wrong_config_shares1(self):\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\n\n for i in config:\n k = config\n k[i] = ''\n print k\n self.app.post_json(url=\"/config/shares\", params=k, status=400)\n return config","def create_share(self, ctx, share, share_server=None):\n # probe into getting a NAS protocol helper for the share in order\n # to facilitate early detection of unsupported protocol type\n self._get_helper(share)\n sizestr = six.text_type(share['size']) + 'GB'\n share_dir = '/' + share['name']\n local_share_path = self._get_local_share_path(share)\n cmd = ['mkdir', local_share_path]\n # set hard limit quota on the sub-directory/share\n args = ('volume', 'quota', self.gluster_manager.volume,\n 'limit-usage', share_dir, sizestr)\n try:\n self._execute(*cmd, run_as_root=True)\n self.gluster_manager.gluster_call(*args)\n except exception.ProcessExecutionError as exc:\n self._cleanup_create_share(local_share_path, share['name'])\n LOG.error(_LE('Unable to create share %s'), share['name'])\n raise exception.GlusterfsException(exc)\n\n export_location = os.path.join(self.gluster_manager.qualified,\n share['name'])\n return export_location","def test_rsp_success(self):\n\n def handle(event):\n ds = Dataset()\n ds.PatientName = \"Test\"\n ds.SOPClassUID = DisplaySystem\n ds.SOPInstanceUID = \"1.2.3.4\"\n return 0x0000, ds\n\n self.ae = ae = AE()\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n ae.network_timeout = 5\n ae.add_supported_context(DisplaySystem)\n scp = ae.start_server(\n (\"localhost\", 11112), block=False, evt_handlers=[(evt.EVT_N_GET, handle)]\n )\n\n ae.add_requested_context(DisplaySystem)\n assoc = ae.associate(\"localhost\", 11112)\n assert assoc.is_established\n\n status, ds = assoc.send_n_get(\n [(0x7FE0, 0x0010)], DisplaySystem, \"1.2.840.10008.5.1.1.40.1\"\n )\n assert status.Status == 0x0000\n assert ds is not None\n assert isinstance(ds, Dataset)\n assert ds.PatientName == \"Test\"\n assert ds.SOPClassUID == DisplaySystem\n assert ds.SOPInstanceUID == \"1.2.3.4\"\n assoc.release()\n assert assoc.is_released\n\n scp.shutdown()","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def test_finished_new_keycard_scan(self):\n new_scan_pk = 1\n new_rfid = '9999999999'\n\n t_info('Creating new NewKeycardScan object we should have'\n 'at this point..........', 3)\n new_nks_obj = NewKeycardScan.objects.create(\n rfid=new_rfid, assigner_user_id=self.staff_only_user.pk)\n\n t_info('Make sure it has the pk from URL', 4)\n self.assertEqual(new_nks_obj.pk, new_scan_pk)\n\n t_info('Getting response..........', 3)\n response = self.client.get('/done_scan/%d/' % new_scan_pk)\n\n t_info('Check response status code', 4)\n self.assertEqual(response.status_code, 200)\n\n t_info('Check response content type', 4)\n self.assertEqual(response['content-type'], 'application/json')\n\n t_info('Check response content', 4)\n self.assertEqual(simplejson.loads(response.content)['success'], True)\n self.assertEqual(simplejson.loads(response.content)['rfid'], new_rfid)\n\n t_info('Getting the changed NewKeycardScan obj........', 3)\n new_nks_obj = NewKeycardScan.objects.get(pk=1)\n\n t_info('Check that NewKeycardScan object has correct attributes', 4)\n self.assertFalse(new_nks_obj.waiting_for_scan)\n self.assertTrue(new_nks_obj.ready_to_assign)","def test_ap_anqp_sharing(dev, apdev):\n bssid = apdev[0]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n hostapd.add_ap(apdev[0]['ifname'], params)\n\n bssid2 = apdev[1]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n params['nai_realm'] = [ \"0,example.com,13[5:6],21[2:4][5:7]\" ]\n hostapd.add_ap(apdev[1]['ifname'], params)\n\n dev[0].hs20_enable()\n id = dev[0].add_cred_values({ 'realm': \"example.com\", 'username': \"test\",\n 'password': \"secret\",\n 'domain': \"example.com\" })\n logger.info(\"Normal network selection with shared ANQP results\")\n interworking_select(dev[0], None, \"home\", freq=\"2412\")\n dev[0].dump_monitor()\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not shared between BSSes\")\n\n logger.info(\"Explicit ANQP request to unshare ANQP results\")\n dev[0].request(\"ANQP_GET \" + bssid + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n dev[0].request(\"ANQP_GET \" + bssid2 + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not unshared\")","def test_shared_albums(self):\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n t = (\n TestAccount.album_image_count\n + TestAccount.album_shared_image_count\n + TestAccount.shared_album_image_count\n + TestAccount.shared_album_shared_image_count\n )\n\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums including shared\".format(t),\n )\n\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\", \"--skip-shared-albums\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n # note that unless we use --no-album-index the shared files in the\n # visible album will show up here\n t = (\n TestAccount.album_image_count + TestAccount.album_shared_image_count\n ) # see above\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums excluding shared\".format(t),\n )","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_read_cluster_resource_quota(self):\n pass","def test_download(self):\n pass","def test_01_basics(self):\n\n self.ac.start()\n\n arg_dict = {\n \"cert\": os.path.join(self.cs_dir, self.get_cli_cert(\"src\")),\n \"key\": os.path.join(self.keys_dir, self.get_cli_key(\"src\")),\n \"dst\": self.durl,\n \"dcert\": os.path.join(self.cs_dir, self.get_cli_cert(\"dst\")),\n \"dkey\": os.path.join(self.keys_dir, self.get_cli_key(\"dst\")),\n \"pkg\": \"example_pkg@1.0,5.11-0\",\n \"empty\": os.path.join(self.test_root, \"tmp/empty\"),\n \"noexist\": os.path.join(self.test_root, \"octopus\"),\n \"verboten\": self.verboten,\n }\n\n # We need an image for seed_ta_dir() to work.\n # TODO: there might be a cleaner way of doing this\n self.image_create()\n # Add the trust anchor needed to verify the server's identity.\n self.seed_ta_dir(\"ta7\")\n\n # We try to receive a pkg from a secured repo and publish it to\n # another secured repo where both repos require different\n # credentials\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict))\n\n # Now try to use the same credentials for source and dest.\n # This should fail.\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {key} --dcert {cert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Make sure we don't traceback when credential files are invalid\n # Src certificate option missing\n self.pkgrecv(self.surl, \"--key {key} -d {dst} \"\n \"--dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst certificate option missing\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {dkey} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Src key option missing\n self.pkgrecv(self.surl, \"--cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst key option missing\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Src certificate not found\n self.pkgrecv(self.surl, \"--key {key} --cert {noexist} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst certificate not found\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {noexist} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Src key not found\n self.pkgrecv(self.surl, \"--key {noexist} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst key not found\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {noexist} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Src certificate is empty file\n self.pkgrecv(self.surl, \"--key {key} --cert {empty} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst certificate is empty file\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {empty} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Src key is empty file\n self.pkgrecv(self.surl, \"--key {empty} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n\n # Dst key is empty file\n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {empty} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), exit=1)\n \n # No permissions to read src certificate \n self.pkgrecv(self.surl, \"--key {key} --cert {verboten} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), su_wrap=True, exit=1)\n\n # No permissions to read dst certificate \n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {verboten} \"\n \"{pkg}\".format(**arg_dict), su_wrap=True, exit=1)\n\n # No permissions to read src key \n self.pkgrecv(self.surl, \"--key {verboten} --cert {cert} \"\n \"-d {dst} --dkey {dkey} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), su_wrap=True, exit=1)\n\n # No permissions to read dst key \n self.pkgrecv(self.surl, \"--key {key} --cert {cert} \"\n \"-d {dst} --dkey {verboten} --dcert {dcert} \"\n \"{pkg}\".format(**arg_dict), su_wrap=True, exit=1)","def _share():\n context = get_factcheck_context()\n return make_response(render_template('share.html', **context))","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","async def test_endpoint_share_container_correct(self):\n self.json_mock.return_value.status = 204\n with self.patch_json_dump:\n resp = await share_container_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_initial_share_all_users(self) -> None:\n self.handler.search_all_users = True\n self.hs.config.userdirectory.user_directory_search_all_users = True\n\n u1 = self.register_user(\"user1\", \"pass\")\n self.register_user(\"user2\", \"pass\")\n u3 = self.register_user(\"user3\", \"pass\")\n\n shares_private = self.get_success(\n self.user_dir_helper.get_users_who_share_private_rooms()\n )\n public_users = self.get_success(\n self.user_dir_helper.get_users_in_public_rooms()\n )\n\n # No users share rooms\n self.assertEqual(public_users, set())\n self.assertEqual(shares_private, set())\n\n # Despite not sharing a room, search_all_users means we get a search\n # result.\n s = self.get_success(self.handler.search_users(u1, u3, 10))\n self.assertEqual(len(s[\"results\"]), 1)\n\n # We can find the other two users\n s = self.get_success(self.handler.search_users(u1, \"user\", 10))\n self.assertEqual(len(s[\"results\"]), 2)\n\n # Registering a user and then searching for them works.\n u4 = self.register_user(\"user4\", \"pass\")\n s = self.get_success(self.handler.search_users(u1, u4, 10))\n self.assertEqual(len(s[\"results\"]), 1)","def test_HYD965(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume = synthetic_volume_full(host)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpAccepted(response)\n\n response = self.api_client.post(\n \"/api/target/\", data={\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume.id}\n )\n self.assertHttpBadRequest(response)","def test_fileOperations(self): \n from DIRAC import gConfig\n testSE = 'testSE'\n #rssClient = ResourceStatusClient()\n #result = rssClient.getStorageElementsList( 'Read' )\n #result = gConfig.getSections( '/Resources/StorageElements' )\n #if result['OK'] and result['Value']:\n # testSE = result['Value'][0]\n #if result['Ok']:\n # testSE = result['Value'][ 0 ] \n \n result = self.fc.addFile( { testFile: { 'PFN': 'testfile', \n 'SE': testSE , \n 'Size':0, \n 'GUID':0, \n 'Checksum':'0' } } )\n self.assert_( result['OK'] )\n if gConfig.getValue( '/Resources/StorageElements/%s/AccessProtocol.1/Host' % testSE, '' ):\n result = self.fc.getReplicas( testFile )\n self.assert_( result['OK'] )\n self.assert_( testFile in result['Value']['Successful'] )","def test_get_placement_w_exception(self, mock__get_nslcmop,\n mock__get_nsd,\n mock__get_vim_accounts,\n mock_create_ns_placement_data,\n mock_do_placement_computation):\n server = self.serverSetup()\n\n server.msgBus.aiowrite = _async_mock()\n mock__get_nsd.return_value = nsd_from_db\n mock__get_nsd.side_effect = RuntimeError('kaboom!')\n mock__get_vim_accounts.return_value = list_of_vims\n mock_do_placement_computation.return_value = \\\n [{'vimAccountId': 'bbbbbbbb-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '1'},\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '2'},\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '3'}]\n\n _run(server.get_placement(nslcmop_record_w_pinning['id']))\n self.assertTrue(server.msgBus.aiowrite.mock.called)\n args, kwargs = server.msgBus.aiowrite.mock.call_args\n rsp_payload = args[2]\n expected_keys = {'placement'}\n self.assertEqual(expected_keys, set(rsp_payload.keys()), \"placement response missing keys\")\n self.assertIs(type(rsp_payload['placement']['vnf']), list, 'vnf not a list')\n self.assertEqual([], rsp_payload['placement']['vnf'], 'vnf list not empty')\n self.assertEqual(nslcmop_record_w_pinning['id'], rsp_payload['placement']['nslcmopId'], \"nslcmopId invalid\")"],"string":"[\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def share():\\n return True\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def test_get_results(self):\\n pass\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def create_share(self, context, share, share_server=None):\\n if share['share_proto'] != 'NFS':\\n raise exception.QBException(\\n _('Quobyte driver only supports NFS shares'))\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n if not volume_uuid:\\n # create tenant, expect ERROR_GARBAGE_ARGS if it already exists\\n self.rpc.call('setTenant',\\n dict(tenant=dict(tenant_id=share['project_id'])),\\n expected_errors=[jsonrpc.ERROR_GARBAGE_ARGS])\\n result = self.rpc.call('createVolume', dict(\\n name=share['name'],\\n tenant_domain=share['project_id'],\\n root_user_id=self.configuration.quobyte_default_volume_user,\\n root_group_id=self.configuration.quobyte_default_volume_group,\\n configuration_name=(self.configuration.\\n quobyte_volume_configuration)))\\n volume_uuid = result['volume_uuid']\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n self._resize_share(share, share['size'])\\n\\n return self._build_share_export_string(result)\",\n \"def testGoodput( self ):\\n \\n for server in self.servers():\\n setOutputQueueSize( server )\\n setRtoMin( server )\\n launchServerProcess(server)\\n \\n switch = self.getNodeByName( 'switch0' ) \\n setOutputQueueSize( switch )\\n\\n for i in range(1,args.servers+1):\\n setInputQueueLength(switch,i,args.input_queue_size)\\n \\n setOutputQueueSize( self.client() )\\n setRtoMin( self.client() )\\n\\n if args.ping:\\n for server in self.servers():\\n print self.client().cmd( 'ping -c 9 %s' % server.IP() )\\n return 0.0\\n \\n self.writeServerIpFile()\\n \\n goodput = float(runClient(self.client()))\\n \\n retransmits = 0\\n for server in self.servers():\\n server.waitOutput()\\n retransmits += countRetransmits(netstat(server))\\n\\n retransFile = open('retransmissions.txt','a')\\n retransFile.write( \\\"%d servers: %d retransmissions\\\\n\\\" % (args.servers, retransmits ))\\n retransFile.close()\\n\\n return goodput\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\",\n \"def test_smoker_get(self):\\n pass\",\n \"def test_download_host(self):\\n pass\",\n \"def dnt_share_app():\\r\\n msg, status = \\\"\\\", True\\r\\n try:\\r\\n\\r\\n 'Click on Do not share button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('a'))\\r\\n #flag2 = ui_controls.button(get_obj_identifier('share_dontShare_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not(flag1) else True\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n return status, msg\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_read_cluster_network(self):\\n pass\",\n \"def step_impl(context):\\n log.info(\\\"====> verify the NSA files are not placed under container_nsa directory\\\")\\n\\n nsa_container = get_nsa_container_string(context)\\n container_nsa_path = \\\"/tmp/cme/local/GFD/{nsa_container}/container_nsa\\\".format(nsa_container=nsa_container)\\n log.info(\\\" ****> DEBUG: nsa container path is: {container_nsa_path}\\\".format(container_nsa_path=container_nsa_path))\\n\\n command = \\\"cd {container_nsa_path}; ls -a | wc -l\\\".format(container_nsa_path=container_nsa_path)\\n if \\\"2\\\" in context.cme_session.send_ssh_command(command=command): # Means that directory is empty\\n log.info(\\\" ****> Passed The NSA files are placed under the container_nsa directory - As expected.\\\")\\n else:\\n assert False, \\\" ****> Failed: The NSA files are placed under the container_nsa directory - While they should not be there.\\\"\",\n \"def test_11_clone(self):\\n # Test basic operation of cloning repo which contains one\\n # publisher to repo which contains same publisher\\n self.pkgrecv(self.durl1, \\\"--clone -d {0}\\\".format(self.dpath2))\\n\\n ret = subprocess.call([\\\"/usr/bin/gdiff\\\", \\\"-Naur\\\", \\\"-x\\\", \\n \\\"index\\\", \\\"-x\\\", \\\"trans\\\", self.dpath1, self.dpath2])\\n self.assertTrue(ret==0)\\n\\n # Test that packages in dst which are not in src get removed.\\n self.pkgsend_bulk(self.durl2, (self.amber30))\\n self.pkgrecv(self.durl1, \\\"--clone -d {0}\\\".format(self.dpath2))\\n ret = subprocess.call([\\\"/usr/bin/gdiff\\\", \\\"-Naur\\\", \\\"-x\\\", \\n \\\"index\\\", \\\"-x\\\", \\\"trans\\\", self.dpath1, self.dpath2])\\n self.assertTrue(ret==0)\\n\\n # Test that clone reports publishers not in the dest repo.\\n amber = self.amber10.replace(\\\"open \\\", \\\"open pkg://test2/\\\")\\n self.pkgsend_bulk(self.durl1, amber)\\n self.pkgrecv(self.durl1, \\\"--clone -d {0}\\\".format(self.dpath2), exit=1)\\n\\n # Test that clone adds new publishers if requested.\\n amber = self.amber10.replace(\\\"open \\\", \\\"open pkg://test2/\\\")\\n self.pkgsend_bulk(self.durl1, amber)\\n self.pkgrecv(self.durl1, \\\"--clone -d {0} -p test2\\\".format(self.dpath2))\\n ret = subprocess.call([\\\"/usr/bin/gdiff\\\", \\\"-Naur\\\", \\\"-x\\\", \\n \\\"index\\\", \\\"-x\\\", \\\"trans\\\", self.dpath1,\\n self.dpath2])\\n self.assertTrue(ret==0)\\n\\n # Test that clone removes all packages if source is empty\\n self.pkgrecv(self.durl3, \\\"--clone -d {0}\\\".format(self.dpath2))\\n self.pkgrepo(\\\"-s {0} list -H -p test2\\\".format(self.dpath2))\\n self.assertEqualDiff(\\\"\\\", self.output)\\n\\n # Test that clone works fine with mulitple publishers\\n amber = self.amber10.replace(\\\"open \\\", \\\"open pkg://test2/\\\")\\n self.pkgsend_bulk(self.durl1, amber)\\n\\n path = os.path.join(self.dpath2, \\\"publisher/test1\\\")\\n shutil.rmtree(path)\\n path = os.path.join(self.dpath2, \\\"publisher/test2\\\")\\n shutil.rmtree(path)\\n self.pkgrecv(self.durl1, \\\"--clone -d {0} -p test2 -p test1\\\".format(\\n self.dpath2))\\n ret = subprocess.call([\\\"/usr/bin/gdiff\\\", \\\"-Naur\\\", \\\"-x\\\",\\n \\\"index\\\", \\\"-x\\\", \\\"trans\\\", self.dpath1, self.dpath2])\\n self.assertTrue(ret==0)\\n\\n # Test that clone fails if --raw is specified.\\n self.pkgrecv(self.durl1, \\\"--raw --clone -d {0} -p test2\\\".format(\\n self.dpath2), exit=2)\\n\\n # Test that clone fails if -c is specified.\\n self.pkgrecv(self.durl1, \\\"-c /tmp/ --clone -d {0} -p test2\\\".format(\\n self.dpath2), exit=2)\\n\\n # Test that clone fails if -a is specified.\\n self.pkgrecv(self.durl1, \\\"-a --clone -d {0} -p test2\\\".format(\\n self.dpath2), exit=2)\\n\\n # Test that clone fails if --newest is specified.\\n self.pkgrecv(self.durl1, \\\"--newest --clone -d {0} -p test2\\\".format(\\n self.dpath2), exit=2)\",\n \"def test_kyc_get_legal_share_holders(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def share(job):\\n client = get_dropbox_client()\\n\\n try:\\n return client.share(\\n '/Video Automation Platform/jobs/{job}/{job}.mov'.format(job=job))\\n\\n except ErrorResponse:\\n return False\",\n \"def test_sign_offline(cluster):\\n # 1. first create two hd new wallet\\n seed = \\\"dune car envelope chuckle elbow slight proud fury remove candy uphold \\\\\\n puzzle call select sibling sport gadget please want vault glance verb damage gown\\\"\\n wallet_1 = Wallet(seed)\\n address_1 = wallet_1.address\\n wallet_2 = Wallet.new()\\n address_2 = wallet_2.address\\n\\n sender_addr = cluster.address(\\\"signer1\\\")\\n\\n sender_balance = cluster.balance(sender_addr)\\n assert sender_balance > 100 * 10 ** 8\\n balance_1 = cluster.balance(wallet_1.address)\\n assert balance_1 == 0\\n balance_2 = cluster.balance(wallet_2.address)\\n assert balance_2 == 0\\n\\n # 2. transfer some coin to wallet_1\\n cluster.transfer(sender_addr, address_1, \\\"100cro\\\")\\n wait_for_new_blocks(cluster, 2)\\n\\n assert cluster.balance(sender_addr) == sender_balance - 100 * 10 ** 8\\n assert cluster.balance(address_1) == 100 * 10 ** 8\\n\\n # 3. get the send's account info\\n port = ports.api_port(cluster.base_port(0))\\n api = ApiUtil(port)\\n\\n amount = 1 * 10 ** 8\\n # make transaction without/with fee\\n for fee in [0, 600000]:\\n sender_account_info = api.account_info(address_1)\\n balance_1_before = api.balance(address_1)\\n balance_2_before = api.balance(address_2)\\n tx = Transaction(\\n wallet=wallet_1,\\n account_num=sender_account_info[\\\"account_num\\\"],\\n sequence=sender_account_info[\\\"sequence\\\"],\\n chain_id=cluster.chain_id,\\n fee=fee,\\n )\\n tx.add_transfer(to_address=address_2, amount=amount, base_denom=\\\"basecro\\\")\\n signed_tx = tx.get_pushable()\\n assert isinstance(signed_tx, dict)\\n api.broadcast_tx(signed_tx)\\n wait_for_new_blocks(cluster, 3)\\n balance_1_after = api.balance(address_1)\\n balance_2_after = api.balance(address_2)\\n assert balance_2_after == balance_2_before + amount\\n assert balance_1_after == balance_1_before - amount - fee\",\n \"def test_create_snapshot(self, mock_ghn):\\n # Now snapshot the volume and check commands\\n snapshot = {'volume_name': 'volume10',\\n 'volume_id': 'xxx', 'display_name': 'snap10',\\n 'name': '123abc', 'volume_size': 10, 'id': '123abc',\\n 'volume': {'provider_id': 'space10'}}\\n ret = self.driver.create_snapshot(snapshot)\\n # We must copy entier underlying storage, ~12GB, not just 10GB\\n self.assertEqual(11444 * units.Mi, self.dd_count)\\n self.assertEqual('1M', self.bs)\\n # Check space-create command\\n expected = {'redundancy': '0', 'group': 'xanadu',\\n 'name': snapshot['display_name'], 'mode': '0777',\\n 'user': 'kane', 'net': 'net1',\\n 'storageserver': 'stor1:gbd0,stor2:gbd0,',\\n 'size': '12'}\\n self.assertDictMatch(expected, self.created)\\n # Check the returned provider\\n expected_pid = {'provider_id': 'snap10'}\\n self.assertDictMatch(expected_pid, ret)\",\n \"def test_create_cluster_network(self):\\n pass\",\n \"def test_get_site_scans(self):\\n pass\",\n \"def test_get_scan(self):\\n pass\",\n \"def canShare(self):\\n return False\",\n \"def test_13_output(self):\\n\\n # Now attempt to receive from a repository.\\n self.pkgrepo(\\\"create {0}\\\".format(self.tempdir))\\n self.pkgrecv(self.dpath1, \\\"-d {0} -n -v \\\\*\\\".format(self.tempdir))\\n expected = \\\"\\\"\\\"\\\\\\nRetrieving packages (dry-run) ...\\n Packages to add: 9\\n Files to retrieve: 17\\nEstimated transfer size: 528.00 B\\n\\\"\\\"\\\"\\n self.assert_(expected in self.output, self.output)\\n for s in self.published:\\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\\n include_scheme=False) in self.output)\\n\\n # Clean up for next test.\\n shutil.rmtree(self.tempdir)\\n\\n # Now attempt to receive from a repository to a package archive.\\n self.pkgrecv(self.dpath1, \\\"-a -d {0} -n -v \\\\*\\\".format(self.tempdir))\\n expected = \\\"\\\"\\\"\\\\\\nArchiving packages (dry-run) ...\\n Packages to add: 9\\n Files to retrieve: 17\\nEstimated transfer size: 528.00 B\\n\\\"\\\"\\\"\\n self.assert_(expected in self.output, self.output)\\n for s in self.published:\\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\\n include_scheme=False) in self.output)\\n\\n # Now attempt to clone a repository.\\n self.pkgrepo(\\\"create {0}\\\".format(self.tempdir))\\n self.pkgrecv(self.dpath1, \\\"--clone -d {0} -p \\\\* -n -v\\\" \\\\\\n .format(self.tempdir))\\n expected = \\\"\\\"\\\"\\\\\\nRetrieving packages (dry-run) ...\\n Packages to add: 9\\n Files to retrieve: 17\\nEstimated transfer size: 528.00 B\\n\\\"\\\"\\\"\\n self.assert_(expected in self.output, self.output)\\n for s in self.published:\\n self.assert_(fmri.PkgFmri(s).get_fmri(anarchy=True,\\n include_scheme=False) in self.output)\\n\\n # Test that output is correct if -n is not specified.\\n self.pkgrecv(self.dpath1, \\\"-d {0} -v \\\\*\\\".format(self.tempdir))\\n self.assert_(\\\"dry-run\\\" not in self.output)\",\n \"def test_norn(task, result):\\n if type(result) != str:\\n c_print(f\\\"*** {task.host}: ERROR running Nornir task ***\\\")\",\n \"def test_sync_no_archives_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\")\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_clone_system(self):\\n pass\",\n \"def test_download1(self):\\n pass\",\n \"def test_get_scans(self):\\n pass\",\n \"def verify_the_smb_share_filesystem_has_the_acl_that_was_applied_to_rtacltest1(driver):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 5, '//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-panel-title//h5//a[contains(.,\\\"(SMB)\\\")]').click()\\n assert wait_on_element(driver, 5, f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//tr[contains(.,\\\"rt-test\\\")]//button[@aria-label=\\\"Actionable Options\\\"]').click()\\n assert wait_on_element(driver, 5, f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath(f'//button[@ix-auto=\\\"action__rt-test_Edit Filesystem ACL\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(text(),\\\"Edit POSIX.1e ACL\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"/mnt/tank/rt-acl-test-1/share\\\")]')\\n assert wait_on_element(driver, 5, '//div[contains(text(),\\\"User - games\\\")]')\",\n \"def test_auth_sharable_cannot_share(self):\\n self.do_sharable(False, 'pattieblack', FakeMembership(False),\\n tenant='froggy')\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_download2(self):\\n pass\",\n \"def test_kyc_get_legal_share_holder_natural(self):\\n pass\",\n \"def test_wrong_config_shares1(self):\\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\\n\\n for i in config:\\n k = config\\n k[i] = ''\\n print k\\n self.app.post_json(url=\\\"/config/shares\\\", params=k, status=400)\\n return config\",\n \"def create_share(self, ctx, share, share_server=None):\\n # probe into getting a NAS protocol helper for the share in order\\n # to facilitate early detection of unsupported protocol type\\n self._get_helper(share)\\n sizestr = six.text_type(share['size']) + 'GB'\\n share_dir = '/' + share['name']\\n local_share_path = self._get_local_share_path(share)\\n cmd = ['mkdir', local_share_path]\\n # set hard limit quota on the sub-directory/share\\n args = ('volume', 'quota', self.gluster_manager.volume,\\n 'limit-usage', share_dir, sizestr)\\n try:\\n self._execute(*cmd, run_as_root=True)\\n self.gluster_manager.gluster_call(*args)\\n except exception.ProcessExecutionError as exc:\\n self._cleanup_create_share(local_share_path, share['name'])\\n LOG.error(_LE('Unable to create share %s'), share['name'])\\n raise exception.GlusterfsException(exc)\\n\\n export_location = os.path.join(self.gluster_manager.qualified,\\n share['name'])\\n return export_location\",\n \"def test_rsp_success(self):\\n\\n def handle(event):\\n ds = Dataset()\\n ds.PatientName = \\\"Test\\\"\\n ds.SOPClassUID = DisplaySystem\\n ds.SOPInstanceUID = \\\"1.2.3.4\\\"\\n return 0x0000, ds\\n\\n self.ae = ae = AE()\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n ae.network_timeout = 5\\n ae.add_supported_context(DisplaySystem)\\n scp = ae.start_server(\\n (\\\"localhost\\\", 11112), block=False, evt_handlers=[(evt.EVT_N_GET, handle)]\\n )\\n\\n ae.add_requested_context(DisplaySystem)\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n assert assoc.is_established\\n\\n status, ds = assoc.send_n_get(\\n [(0x7FE0, 0x0010)], DisplaySystem, \\\"1.2.840.10008.5.1.1.40.1\\\"\\n )\\n assert status.Status == 0x0000\\n assert ds is not None\\n assert isinstance(ds, Dataset)\\n assert ds.PatientName == \\\"Test\\\"\\n assert ds.SOPClassUID == DisplaySystem\\n assert ds.SOPInstanceUID == \\\"1.2.3.4\\\"\\n assoc.release()\\n assert assoc.is_released\\n\\n scp.shutdown()\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def test_finished_new_keycard_scan(self):\\n new_scan_pk = 1\\n new_rfid = '9999999999'\\n\\n t_info('Creating new NewKeycardScan object we should have'\\n 'at this point..........', 3)\\n new_nks_obj = NewKeycardScan.objects.create(\\n rfid=new_rfid, assigner_user_id=self.staff_only_user.pk)\\n\\n t_info('Make sure it has the pk from URL', 4)\\n self.assertEqual(new_nks_obj.pk, new_scan_pk)\\n\\n t_info('Getting response..........', 3)\\n response = self.client.get('/done_scan/%d/' % new_scan_pk)\\n\\n t_info('Check response status code', 4)\\n self.assertEqual(response.status_code, 200)\\n\\n t_info('Check response content type', 4)\\n self.assertEqual(response['content-type'], 'application/json')\\n\\n t_info('Check response content', 4)\\n self.assertEqual(simplejson.loads(response.content)['success'], True)\\n self.assertEqual(simplejson.loads(response.content)['rfid'], new_rfid)\\n\\n t_info('Getting the changed NewKeycardScan obj........', 3)\\n new_nks_obj = NewKeycardScan.objects.get(pk=1)\\n\\n t_info('Check that NewKeycardScan object has correct attributes', 4)\\n self.assertFalse(new_nks_obj.waiting_for_scan)\\n self.assertTrue(new_nks_obj.ready_to_assign)\",\n \"def test_ap_anqp_sharing(dev, apdev):\\n bssid = apdev[0]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n hostapd.add_ap(apdev[0]['ifname'], params)\\n\\n bssid2 = apdev[1]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n params['nai_realm'] = [ \\\"0,example.com,13[5:6],21[2:4][5:7]\\\" ]\\n hostapd.add_ap(apdev[1]['ifname'], params)\\n\\n dev[0].hs20_enable()\\n id = dev[0].add_cred_values({ 'realm': \\\"example.com\\\", 'username': \\\"test\\\",\\n 'password': \\\"secret\\\",\\n 'domain': \\\"example.com\\\" })\\n logger.info(\\\"Normal network selection with shared ANQP results\\\")\\n interworking_select(dev[0], None, \\\"home\\\", freq=\\\"2412\\\")\\n dev[0].dump_monitor()\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not shared between BSSes\\\")\\n\\n logger.info(\\\"Explicit ANQP request to unshare ANQP results\\\")\\n dev[0].request(\\\"ANQP_GET \\\" + bssid + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n dev[0].request(\\\"ANQP_GET \\\" + bssid2 + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not unshared\\\")\",\n \"def test_shared_albums(self):\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n t = (\\n TestAccount.album_image_count\\n + TestAccount.album_shared_image_count\\n + TestAccount.shared_album_image_count\\n + TestAccount.shared_album_shared_image_count\\n )\\n\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums including shared\\\".format(t),\\n )\\n\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\", \\\"--skip-shared-albums\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n # note that unless we use --no-album-index the shared files in the\\n # visible album will show up here\\n t = (\\n TestAccount.album_image_count + TestAccount.album_shared_image_count\\n ) # see above\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums excluding shared\\\".format(t),\\n )\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_read_cluster_resource_quota(self):\\n pass\",\n \"def test_download(self):\\n pass\",\n \"def test_01_basics(self):\\n\\n self.ac.start()\\n\\n arg_dict = {\\n \\\"cert\\\": os.path.join(self.cs_dir, self.get_cli_cert(\\\"src\\\")),\\n \\\"key\\\": os.path.join(self.keys_dir, self.get_cli_key(\\\"src\\\")),\\n \\\"dst\\\": self.durl,\\n \\\"dcert\\\": os.path.join(self.cs_dir, self.get_cli_cert(\\\"dst\\\")),\\n \\\"dkey\\\": os.path.join(self.keys_dir, self.get_cli_key(\\\"dst\\\")),\\n \\\"pkg\\\": \\\"example_pkg@1.0,5.11-0\\\",\\n \\\"empty\\\": os.path.join(self.test_root, \\\"tmp/empty\\\"),\\n \\\"noexist\\\": os.path.join(self.test_root, \\\"octopus\\\"),\\n \\\"verboten\\\": self.verboten,\\n }\\n\\n # We need an image for seed_ta_dir() to work.\\n # TODO: there might be a cleaner way of doing this\\n self.image_create()\\n # Add the trust anchor needed to verify the server's identity.\\n self.seed_ta_dir(\\\"ta7\\\")\\n\\n # We try to receive a pkg from a secured repo and publish it to\\n # another secured repo where both repos require different\\n # credentials\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict))\\n\\n # Now try to use the same credentials for source and dest.\\n # This should fail.\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {key} --dcert {cert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Make sure we don't traceback when credential files are invalid\\n # Src certificate option missing\\n self.pkgrecv(self.surl, \\\"--key {key} -d {dst} \\\"\\n \\\"--dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst certificate option missing\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Src key option missing\\n self.pkgrecv(self.surl, \\\"--cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst key option missing\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Src certificate not found\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {noexist} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst certificate not found\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {noexist} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Src key not found\\n self.pkgrecv(self.surl, \\\"--key {noexist} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst key not found\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {noexist} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Src certificate is empty file\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {empty} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst certificate is empty file\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {empty} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Src key is empty file\\n self.pkgrecv(self.surl, \\\"--key {empty} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n\\n # Dst key is empty file\\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {empty} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), exit=1)\\n \\n # No permissions to read src certificate \\n self.pkgrecv(self.surl, \\\"--key {key} --cert {verboten} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), su_wrap=True, exit=1)\\n\\n # No permissions to read dst certificate \\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {verboten} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), su_wrap=True, exit=1)\\n\\n # No permissions to read src key \\n self.pkgrecv(self.surl, \\\"--key {verboten} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {dkey} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), su_wrap=True, exit=1)\\n\\n # No permissions to read dst key \\n self.pkgrecv(self.surl, \\\"--key {key} --cert {cert} \\\"\\n \\\"-d {dst} --dkey {verboten} --dcert {dcert} \\\"\\n \\\"{pkg}\\\".format(**arg_dict), su_wrap=True, exit=1)\",\n \"def _share():\\n context = get_factcheck_context()\\n return make_response(render_template('share.html', **context))\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"async def test_endpoint_share_container_correct(self):\\n self.json_mock.return_value.status = 204\\n with self.patch_json_dump:\\n resp = await share_container_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_initial_share_all_users(self) -> None:\\n self.handler.search_all_users = True\\n self.hs.config.userdirectory.user_directory_search_all_users = True\\n\\n u1 = self.register_user(\\\"user1\\\", \\\"pass\\\")\\n self.register_user(\\\"user2\\\", \\\"pass\\\")\\n u3 = self.register_user(\\\"user3\\\", \\\"pass\\\")\\n\\n shares_private = self.get_success(\\n self.user_dir_helper.get_users_who_share_private_rooms()\\n )\\n public_users = self.get_success(\\n self.user_dir_helper.get_users_in_public_rooms()\\n )\\n\\n # No users share rooms\\n self.assertEqual(public_users, set())\\n self.assertEqual(shares_private, set())\\n\\n # Despite not sharing a room, search_all_users means we get a search\\n # result.\\n s = self.get_success(self.handler.search_users(u1, u3, 10))\\n self.assertEqual(len(s[\\\"results\\\"]), 1)\\n\\n # We can find the other two users\\n s = self.get_success(self.handler.search_users(u1, \\\"user\\\", 10))\\n self.assertEqual(len(s[\\\"results\\\"]), 2)\\n\\n # Registering a user and then searching for them works.\\n u4 = self.register_user(\\\"user4\\\", \\\"pass\\\")\\n s = self.get_success(self.handler.search_users(u1, u4, 10))\\n self.assertEqual(len(s[\\\"results\\\"]), 1)\",\n \"def test_HYD965(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume = synthetic_volume_full(host)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpAccepted(response)\\n\\n response = self.api_client.post(\\n \\\"/api/target/\\\", data={\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume.id}\\n )\\n self.assertHttpBadRequest(response)\",\n \"def test_fileOperations(self): \\n from DIRAC import gConfig\\n testSE = 'testSE'\\n #rssClient = ResourceStatusClient()\\n #result = rssClient.getStorageElementsList( 'Read' )\\n #result = gConfig.getSections( '/Resources/StorageElements' )\\n #if result['OK'] and result['Value']:\\n # testSE = result['Value'][0]\\n #if result['Ok']:\\n # testSE = result['Value'][ 0 ] \\n \\n result = self.fc.addFile( { testFile: { 'PFN': 'testfile', \\n 'SE': testSE , \\n 'Size':0, \\n 'GUID':0, \\n 'Checksum':'0' } } )\\n self.assert_( result['OK'] )\\n if gConfig.getValue( '/Resources/StorageElements/%s/AccessProtocol.1/Host' % testSE, '' ):\\n result = self.fc.getReplicas( testFile )\\n self.assert_( result['OK'] )\\n self.assert_( testFile in result['Value']['Successful'] )\",\n \"def test_get_placement_w_exception(self, mock__get_nslcmop,\\n mock__get_nsd,\\n mock__get_vim_accounts,\\n mock_create_ns_placement_data,\\n mock_do_placement_computation):\\n server = self.serverSetup()\\n\\n server.msgBus.aiowrite = _async_mock()\\n mock__get_nsd.return_value = nsd_from_db\\n mock__get_nsd.side_effect = RuntimeError('kaboom!')\\n mock__get_vim_accounts.return_value = list_of_vims\\n mock_do_placement_computation.return_value = \\\\\\n [{'vimAccountId': 'bbbbbbbb-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '1'},\\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '2'},\\n {'vimAccountId': 'aaaaaaaa-38f5-438d-b8ee-3f93b3531f87', 'member-vnf-index': '3'}]\\n\\n _run(server.get_placement(nslcmop_record_w_pinning['id']))\\n self.assertTrue(server.msgBus.aiowrite.mock.called)\\n args, kwargs = server.msgBus.aiowrite.mock.call_args\\n rsp_payload = args[2]\\n expected_keys = {'placement'}\\n self.assertEqual(expected_keys, set(rsp_payload.keys()), \\\"placement response missing keys\\\")\\n self.assertIs(type(rsp_payload['placement']['vnf']), list, 'vnf not a list')\\n self.assertEqual([], rsp_payload['placement']['vnf'], 'vnf list not empty')\\n self.assertEqual(nslcmop_record_w_pinning['id'], rsp_payload['placement']['nslcmopId'], \\\"nslcmopId invalid\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.87205005","0.8468603","0.84374386","0.84110034","0.81306785","0.80009717","0.79637134","0.795491","0.7851127","0.7800759","0.77983934","0.7788885","0.75479025","0.73223394","0.73046243","0.72120965","0.6860787","0.6632178","0.64907837","0.6297669","0.6247304","0.61807805","0.61047405","0.6089239","0.6021602","0.5981041","0.59392893","0.584327","0.582032","0.5798633","0.5791046","0.5771555","0.5750302","0.572431","0.5677668","0.565012","0.56462127","0.560499","0.55602694","0.55556756","0.55483085","0.5546693","0.5517523","0.55007744","0.5495216","0.5494952","0.54825455","0.5477893","0.54522055","0.544451","0.5442432","0.5440399","0.5431407","0.5431239","0.5404265","0.5398867","0.5396841","0.5394251","0.5378865","0.53775674","0.53197217","0.5317281","0.5312341","0.5307244","0.52766293","0.5265793","0.52544606","0.5244194","0.52415216","0.5232725","0.52277225","0.52234966","0.52059275","0.52050006","0.5187632","0.51828486","0.51740164","0.5160275","0.5156754","0.51477283","0.51442057","0.51383835","0.5135349","0.5125826","0.5112258","0.5109788","0.51005733","0.509735","0.5096633","0.5095714","0.50825894","0.50803673","0.5079415","0.5072579","0.5072444","0.5063291","0.50594866","0.5046717","0.50462705","0.5045074"],"string":"[\n \"0.87205005\",\n \"0.8468603\",\n \"0.84374386\",\n \"0.84110034\",\n \"0.81306785\",\n \"0.80009717\",\n \"0.79637134\",\n \"0.795491\",\n \"0.7851127\",\n \"0.7800759\",\n \"0.77983934\",\n \"0.7788885\",\n \"0.75479025\",\n \"0.73223394\",\n \"0.73046243\",\n \"0.72120965\",\n \"0.6860787\",\n \"0.6632178\",\n \"0.64907837\",\n \"0.6297669\",\n \"0.6247304\",\n \"0.61807805\",\n \"0.61047405\",\n \"0.6089239\",\n \"0.6021602\",\n \"0.5981041\",\n \"0.59392893\",\n \"0.584327\",\n \"0.582032\",\n \"0.5798633\",\n \"0.5791046\",\n \"0.5771555\",\n \"0.5750302\",\n \"0.572431\",\n \"0.5677668\",\n \"0.565012\",\n \"0.56462127\",\n \"0.560499\",\n \"0.55602694\",\n \"0.55556756\",\n \"0.55483085\",\n \"0.5546693\",\n \"0.5517523\",\n \"0.55007744\",\n \"0.5495216\",\n \"0.5494952\",\n \"0.54825455\",\n \"0.5477893\",\n \"0.54522055\",\n \"0.544451\",\n \"0.5442432\",\n \"0.5440399\",\n \"0.5431407\",\n \"0.5431239\",\n \"0.5404265\",\n \"0.5398867\",\n \"0.5396841\",\n \"0.5394251\",\n \"0.5378865\",\n \"0.53775674\",\n \"0.53197217\",\n \"0.5317281\",\n \"0.5312341\",\n \"0.5307244\",\n \"0.52766293\",\n \"0.5265793\",\n \"0.52544606\",\n \"0.5244194\",\n \"0.52415216\",\n \"0.5232725\",\n \"0.52277225\",\n \"0.52234966\",\n \"0.52059275\",\n \"0.52050006\",\n \"0.5187632\",\n \"0.51828486\",\n \"0.51740164\",\n \"0.5160275\",\n \"0.5156754\",\n \"0.51477283\",\n \"0.51442057\",\n \"0.51383835\",\n \"0.5135349\",\n \"0.5125826\",\n \"0.5112258\",\n \"0.5109788\",\n \"0.51005733\",\n \"0.509735\",\n \"0.5096633\",\n \"0.5095714\",\n \"0.50825894\",\n \"0.50803673\",\n \"0.5079415\",\n \"0.5072579\",\n \"0.5072444\",\n \"0.5063291\",\n \"0.50594866\",\n \"0.5046717\",\n \"0.50462705\",\n \"0.5045074\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.957169"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81387,"cells":{"query":{"kind":"string","value":"Test case for update_nas_share"},"document":{"kind":"string","value":"def test_update_nas_share(self):\n pass"},"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_update_nas_share_by_nas(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_show_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_update_non_shareable(self):\n self.create_common_users_and_groups()\n sync = SyncUserAndGroups(\n tsurl=TS_URL,\n username=TS_USER,\n password=TS_PASSWORD,\n disable_ssl=True,\n )\n auag = sync.get_all_users_and_groups()\n\n # Need to remove the common users since they don't have emails.\n auag.remove_user(\"guest\")\n auag.remove_user(\"su\")\n auag.remove_user(\"system\")\n auag.remove_user(\"tsadmin\")\n\n # Change Group 1 and Group 2 and verify change took.\n group1 = auag.get_group(\"Group 1\")\n group1.visibility = Visibility.NON_SHAREABLE\n group2 = auag.get_group(\"Group 2\")\n group2.visibility = Visibility.DEFAULT\n\n # sync updates\n sync.sync_users_and_groups(users_and_groups=auag)\n\n # verify changes\n auag = sync.get_all_users_and_groups()\n self.assertEqual(\n auag.get_group(\"Group 1\").visibility, Visibility.NON_SHAREABLE\n )\n self.assertEqual(\n auag.get_group(\"Group 2\").visibility, Visibility.DEFAULT\n )\n self.assertEqual(\n auag.get_group('Group \"3\"').visibility, Visibility.NON_SHAREABLE\n )","def test_kyc_put_legal_share_holder(self):\n pass","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_dashboards_v2_share(self):\n pass","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def modify_share(self, pool, project, share, arg):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.put(svc, arg)\n if ret.status != restclient.Status.ACCEPTED:\n exception_msg = (_('Error modifying %(arg)s '\n ' of share %(id)s.')\n % {'arg': arg,\n 'id': share})\n raise exception.ShareBackendException(msg=exception_msg)","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","async def test_endpoint_edit_share_correct(self):\n with self.patch_json_dump:\n await edit_share_handler(self.mock_request)\n self.json_mock.assert_called_once()","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def ensure_share(self, context, share, share_server=None):\n pass","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def test_update_pci_link(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_dashboards_v2_delete_share(self):\n pass","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def test_put_without_parent_datastore_nor_share_id(self):\n\n url = reverse('file')\n\n data = {\n 'shard_id': self.shard1.id,\n 'link_id': \"b8866161-0b1f-4a8e-acde-07047313ec8f\",\n #'parent_datastore_id': str(self.test_datastore_obj.id),\n 'chunk_count': 1,\n 'size': 512,\n }\n\n self.client.force_authenticate(user=self.test_user_obj)\n response = self.client.put(url, data)\n\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_update_hyperflex_cluster(self):\n pass","def share():\n return True","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_056_netbios_name_change_check_sid(request):\n depends(request, [\"service_cifs_running\"], scope=\"session\")\n global new_sid\n global old_netbiosname\n\n results = GET(\"/smb/\")\n assert results.status_code == 200, results.text\n old_netbiosname = results.json()[\"netbiosname\"]\n old_sid = results.json()[\"cifs_SID\"]\n\n payload = {\n \"netbiosname\": \"nb_new\",\n }\n results = PUT(\"/smb/\", payload)\n assert results.status_code == 200, results.text\n new_sid_resp = results.json()[\"cifs_SID\"]\n assert old_sid != new_sid_resp, results.text\n sleep(5)\n\n results = GET(\"/smb/\")\n assert results.status_code == 200, results.text\n new_sid = results.json()[\"cifs_SID\"]\n assert new_sid != old_sid, results.text","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_networking_project_network_update(self):\n pass","def test_update_system(self):\n pass","def test_update_hyperflex_cluster_storage_policy(self):\n pass","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_kyc_post_legal_share_holder(self):\n pass","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_update_software_asset(self):\n pass","def test_update_pci_switch(self):\n pass","def test_dashboards_v2_list_shares(self):\n pass","def test_ipam_vrfs_update(self):\n pass","def test_update_hyperflex_cluster_network_policy(self):\n pass","def update_shares(self):\n self.nb_shares = self.shares.count()\n self.save()","def test_update_device(self):\n pass","def test_update_device(self):\n pass","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def test_updating_a_segment(self):\n pass","def test_update_node_driveconfig(self):\n pass","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def test_patch_creation(self):\n host = synthetic_host(\"myserver\")\n self.create_simple_filesystem(host)\n\n spare_volume_1 = synthetic_volume_full(host)\n spare_volume_2 = synthetic_volume_full(host)\n\n response = self.api_client.patch(\n \"/api/target/\",\n data={\n \"objects\": [\n {\"kind\": \"OST\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume_1.id},\n {\"kind\": \"MDT\", \"filesystem_id\": self.fs.id, \"volume_id\": spare_volume_2.id},\n ],\n \"deletions\": [],\n },\n )\n self.assertHttpAccepted(response)","def test_update_pci_device(self):\n pass","def _update_volume_stats(self):\n LOG.debug('Updating volume stats')\n total_space = 0\n free_space = 0\n share = None\n for _share in self._mounted_shares:\n if self.shares_with_capacities[_share]['free'] > free_space:\n free_space = self.shares_with_capacities[_share]['free']\n total_space = self.shares_with_capacities[_share]['total']\n share = _share\n\n location_info = '%(driver)s:%(share)s' % {\n 'driver': self.__class__.__name__,\n 'share': share\n }\n nms_url = self.share2nms[share].url\n self._stats = {\n 'vendor_name': 'Nexenta',\n 'dedup': self.volume_deduplication,\n 'compression': self.volume_compression,\n 'description': self.volume_description,\n 'nms_url': nms_url,\n 'ns_shares': self.shares_with_capacities,\n 'driver_version': self.VERSION,\n 'storage_protocol': constants.NFS,\n 'total_capacity_gb': total_space,\n 'free_capacity_gb': free_space,\n 'reserved_percentage': self.configuration.reserved_percentage,\n 'QoS_support': False,\n 'location_info': location_info,\n 'volume_backend_name': self.backend_name,\n 'nfs_mount_point_base': self.nfs_mount_point_base\n }","def test_kyc_put_document_shareholder(self):\n pass","def test_update_hyperflex_server_model(self):\n pass","def test_update(self):\n pass","def test_update(self):\n pass","def test_update(self):\n pass","def test_update_system_asset(self):\n pass","def test_kyc_delete_legal_share_holder_natural(self):\n pass","async def test_update(aresponses):\n aresponses.add(\n MATCH_HOST,\n \"/api/system/status\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"system-status.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n async with ClientSession() as session:\n client = Sonarr(HOST, API_KEY, session=session)\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)\n\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)","def test_update_cloud(self):\n pass","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","def upgrade_share_to_safe(\n ui,\n hgvfs,\n storevfs,\n current_requirements,\n mismatch_config,\n mismatch_warn,\n):\n wlock = None\n store_requirements = localrepo._readrequires(storevfs, False)\n original_crequirements = current_requirements.copy()\n # after upgrade, store requires will be shared, so lets find\n # the requirements which are not present in store and\n # write them to share's .hg/requires\n diffrequires = current_requirements - store_requirements\n # add share-safe requirement as it will mark the share as share-safe\n diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)\n current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)\n # in `allow` case, we don't try to upgrade, we just respect the source\n # state, update requirements and continue\n if mismatch_config == b'allow':\n return\n try:\n wlock = lockmod.trylock(ui, hgvfs, b'wlock', 0, 0)\n # some process might change the requirement in between, re-read\n # and update current_requirements\n locked_requirements = localrepo._readrequires(hgvfs, True)\n if locked_requirements != original_crequirements:\n removed = current_requirements - locked_requirements\n # update current_requirements in place because it's passed\n # as reference\n current_requirements -= removed\n current_requirements |= locked_requirements\n diffrequires = current_requirements - store_requirements\n # add share-safe requirement as it will mark the share as share-safe\n diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)\n current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)\n scmutil.writerequires(hgvfs, diffrequires)\n ui.warn(_(b'repository upgraded to use share-safe mode\\n'))\n except error.LockError as e:\n hint = _(\n \"see `hg help config.format.use-share-safe` for more information\"\n )\n if mismatch_config == b'upgrade-abort':\n raise error.Abort(\n _(b'failed to upgrade share, got error: %s')\n % stringutil.forcebytestr(e.strerror),\n hint=hint,\n )\n elif mismatch_warn:\n ui.warn(\n _(b'failed to upgrade share, got error: %s\\n')\n % stringutil.forcebytestr(e.strerror),\n hint=hint,\n )\n finally:\n if wlock:\n wlock.release()","def test_update_bucket(self):\n pass","def test_update_domain_only(self):\n self.test_update()","def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\n ingest_shares = \"\"\"\n UNWIND $shares_list as s\n MERGE (share:AzureStorageFileShare{id: s.id})\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\n SET share.name = s.name,\n share.lastupdated = $azure_update_tag,\n share.lastmodifiedtime = s.last_modified_time,\n share.sharequota = s.share_quota,\n share.accesstier = s.access_tier,\n share.deleted = s.deleted,\n share.accesstierchangetime = s.access_tier_change_time,\n share.accesstierstatus = s.access_tier_status,\n share.deletedtime = s.deleted_time,\n share.enabledprotocols = s.enabled_protocols,\n share.remainingretentiondays = s.remaining_retention_days,\n share.shareusagebytes = s.share_usage_bytes,\n share.version = s.version\n WITH share, s\n MATCH (fs:AzureStorageFileService{id: s.service_id})\n MERGE (fs)-[r:CONTAINS]->(share)\n ON CREATE SET r.firstseen = timestamp()\n SET r.lastupdated = $azure_update_tag\n \"\"\"\n\n neo4j_session.run(\n ingest_shares,\n shares_list=shares,\n azure_update_tag=update_tag,\n )","def test_update(self):\n # this is tested graphically, as it is UI\n pass","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_share_no_os_environ(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.sys_exit_mock.assert_called_once()","def test_put(self):\n\n url = reverse('file')\n\n data = {\n 'shard_id': self.shard1.id,\n 'link_id': \"b8866161-0b1f-4a8e-acde-07047313ec8f\",\n 'parent_datastore_id': str(self.test_datastore_obj.id),\n 'chunk_count': 1,\n 'size': 512,\n }\n\n self.client.force_authenticate(user=self.test_user_obj)\n response = self.client.put(url, data)\n\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n self.assertIn('file_id', response.data)\n self.assertIn('file_transfer_id', response.data)\n self.assertIn('file_transfer_secret_key', response.data)","def test_sg_update_name(self):\n\n # Add a faked storage_group\n faked_storage_group = self.add_storage_group1()\n storage_group_name = faked_storage_group.name\n\n storage_group_mgr = self.console.storage_groups\n storage_group = storage_group_mgr.find(name=storage_group_name)\n\n new_storage_group_name = \"new-\" + storage_group_name\n\n # Execute the code to be tested\n storage_group.update_properties(\n properties={'name': new_storage_group_name})\n\n # Verify that the resource is no longer found by its old name, using\n # list() (this does not use the name-to-URI cache).\n storage_groups_list = storage_group_mgr.list(\n filter_args=dict(name=storage_group_name))\n assert len(storage_groups_list) == 0\n\n # Verify that the resource is no longer found by its old name, using\n # find() (this uses the name-to-URI cache).\n with pytest.raises(NotFound):\n storage_group_mgr.find(name=storage_group_name)\n\n # Verify that the resource object already reflects the update, even\n # though it has not been refreshed yet.\n assert storage_group.properties['name'] == new_storage_group_name\n\n # Refresh the resource object and verify that it still reflects the\n # update.\n storage_group.pull_full_properties()\n assert storage_group.properties['name'] == new_storage_group_name\n\n # Verify that the resource can be found by its new name, using find()\n new_storage_group_find = storage_group_mgr.find(\n name=new_storage_group_name)\n assert new_storage_group_find.properties['name'] == \\\n new_storage_group_name\n\n # Verify that the resource can be found by its new name, using list()\n new_storage_groups_list = storage_group_mgr.list(\n filter_args=dict(name=new_storage_group_name))\n assert len(new_storage_groups_list) == 1\n new_storage_group_list = new_storage_groups_list[0]\n assert new_storage_group_list.properties['name'] == \\\n new_storage_group_name","def test_synchronize_all_networks(self):\n\n # Store two tenants in a db and none on EOS.\n # The sync should send details of all tenants to EOS\n tenant_1_id = 'tenant-1'\n tenant_1_net_1_id = 'ten-1-net-1'\n tenant_1_net_1_seg_id = 11\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id,\n tenant_1_net_1_seg_id, 'segment_id_11')\n\n tenant_2_id = 'tenant-2'\n tenant_2_net_1_id = 'ten-2-net-1'\n tenant_2_net_1_seg_id = 21\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id,\n tenant_2_net_1_seg_id, 'segment_id_21')\n\n self.rpc.get_tenants.return_value = {}\n\n self.rpc.sync_start.return_value = True\n self.rpc.sync_end.return_value = True\n self.rpc.check_cvx_availability.return_value = True\n\n self.rpc._baremetal_supported.return_value = False\n self.rpc.get_all_baremetal_hosts.return_value = {}\n\n self.sync_service.do_synchronize()\n\n expected_calls = [\n mock.call.perform_sync_of_sg(self.sync_service._context),\n mock.call.check_cvx_availability(),\n mock.call.get_region_updated_time(),\n mock.call.get_region_updated_time().__bool__(),\n mock.call.sync_start(),\n mock.call.register_with_eos(sync=True),\n mock.call.check_supported_features(),\n mock.call.get_tenants(),\n\n mock.call.create_network_bulk(\n tenant_1_id,\n [{'network_id': tenant_1_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n\n mock.call.create_network_bulk(\n tenant_2_id,\n [{'network_id': tenant_2_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n mock.call.sync_end(),\n mock.call.get_region_updated_time()\n ]\n\n # The create_network_bulk() can be called in different order. So split\n # it up. The first part checks if the initial set of methods are\n # invoked.\n idx = expected_calls.index(mock.call.get_tenants()) + 1\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 1 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 2 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if the sync end methods are invoked.\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\n expected_calls[idx + 2:],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id)\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)","def test_sync_no_archives_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\")\n assert \"No archives found to transfer\" in str(err)","def test_update_case(self):\n pass","def test_update_instance_limit1(self):\n pass","def test_update(tmp_path):\n _ = get_logger(verbosity=4)\n for osdk_version in [\"latest\", \"1.3.1\", \"1.3.1\"]:\n version = osdk_update.osdk_update(version=osdk_version, **tmp_path)\n file_data = osdk_update.OsdkFileData(version=version, **tmp_path)\n assert file_data.files_not_matching() == []\n for filename in file_data.downloads:\n try:\n os.remove(file_data.downloads[filename]['dst'])\n except Exception:\n pass","def test_update_ban(self):\n pass","def test_update_software_asset_content(self):\n pass","def test_wrong_config_shares1(self):\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\n\n for i in config:\n k = config\n k[i] = ''\n print k\n self.app.post_json(url=\"/config/shares\", params=k, status=400)\n return config","def share(source, dest, branch=None, revision=None):\n run_cmd(['hg', 'share', '-U', source, dest])\n return update(dest, branch=branch, revision=revision)","def test_vault_update_vault_item(self):\n pass","def test_add_asset_share_feed(self):\n pass","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))"],"string":"[\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_update_non_shareable(self):\\n self.create_common_users_and_groups()\\n sync = SyncUserAndGroups(\\n tsurl=TS_URL,\\n username=TS_USER,\\n password=TS_PASSWORD,\\n disable_ssl=True,\\n )\\n auag = sync.get_all_users_and_groups()\\n\\n # Need to remove the common users since they don't have emails.\\n auag.remove_user(\\\"guest\\\")\\n auag.remove_user(\\\"su\\\")\\n auag.remove_user(\\\"system\\\")\\n auag.remove_user(\\\"tsadmin\\\")\\n\\n # Change Group 1 and Group 2 and verify change took.\\n group1 = auag.get_group(\\\"Group 1\\\")\\n group1.visibility = Visibility.NON_SHAREABLE\\n group2 = auag.get_group(\\\"Group 2\\\")\\n group2.visibility = Visibility.DEFAULT\\n\\n # sync updates\\n sync.sync_users_and_groups(users_and_groups=auag)\\n\\n # verify changes\\n auag = sync.get_all_users_and_groups()\\n self.assertEqual(\\n auag.get_group(\\\"Group 1\\\").visibility, Visibility.NON_SHAREABLE\\n )\\n self.assertEqual(\\n auag.get_group(\\\"Group 2\\\").visibility, Visibility.DEFAULT\\n )\\n self.assertEqual(\\n auag.get_group('Group \\\"3\\\"').visibility, Visibility.NON_SHAREABLE\\n )\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def modify_share(self, pool, project, share, arg):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.put(svc, arg)\\n if ret.status != restclient.Status.ACCEPTED:\\n exception_msg = (_('Error modifying %(arg)s '\\n ' of share %(id)s.')\\n % {'arg': arg,\\n 'id': share})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"async def test_endpoint_edit_share_correct(self):\\n with self.patch_json_dump:\\n await edit_share_handler(self.mock_request)\\n self.json_mock.assert_called_once()\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def test_update_pci_link(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def test_put_without_parent_datastore_nor_share_id(self):\\n\\n url = reverse('file')\\n\\n data = {\\n 'shard_id': self.shard1.id,\\n 'link_id': \\\"b8866161-0b1f-4a8e-acde-07047313ec8f\\\",\\n #'parent_datastore_id': str(self.test_datastore_obj.id),\\n 'chunk_count': 1,\\n 'size': 512,\\n }\\n\\n self.client.force_authenticate(user=self.test_user_obj)\\n response = self.client.put(url, data)\\n\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def share():\\n return True\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_056_netbios_name_change_check_sid(request):\\n depends(request, [\\\"service_cifs_running\\\"], scope=\\\"session\\\")\\n global new_sid\\n global old_netbiosname\\n\\n results = GET(\\\"/smb/\\\")\\n assert results.status_code == 200, results.text\\n old_netbiosname = results.json()[\\\"netbiosname\\\"]\\n old_sid = results.json()[\\\"cifs_SID\\\"]\\n\\n payload = {\\n \\\"netbiosname\\\": \\\"nb_new\\\",\\n }\\n results = PUT(\\\"/smb/\\\", payload)\\n assert results.status_code == 200, results.text\\n new_sid_resp = results.json()[\\\"cifs_SID\\\"]\\n assert old_sid != new_sid_resp, results.text\\n sleep(5)\\n\\n results = GET(\\\"/smb/\\\")\\n assert results.status_code == 200, results.text\\n new_sid = results.json()[\\\"cifs_SID\\\"]\\n assert new_sid != old_sid, results.text\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_networking_project_network_update(self):\\n pass\",\n \"def test_update_system(self):\\n pass\",\n \"def test_update_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_update_software_asset(self):\\n pass\",\n \"def test_update_pci_switch(self):\\n pass\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def test_ipam_vrfs_update(self):\\n pass\",\n \"def test_update_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def update_shares(self):\\n self.nb_shares = self.shares.count()\\n self.save()\",\n \"def test_update_device(self):\\n pass\",\n \"def test_update_device(self):\\n pass\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def test_updating_a_segment(self):\\n pass\",\n \"def test_update_node_driveconfig(self):\\n pass\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def test_patch_creation(self):\\n host = synthetic_host(\\\"myserver\\\")\\n self.create_simple_filesystem(host)\\n\\n spare_volume_1 = synthetic_volume_full(host)\\n spare_volume_2 = synthetic_volume_full(host)\\n\\n response = self.api_client.patch(\\n \\\"/api/target/\\\",\\n data={\\n \\\"objects\\\": [\\n {\\\"kind\\\": \\\"OST\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume_1.id},\\n {\\\"kind\\\": \\\"MDT\\\", \\\"filesystem_id\\\": self.fs.id, \\\"volume_id\\\": spare_volume_2.id},\\n ],\\n \\\"deletions\\\": [],\\n },\\n )\\n self.assertHttpAccepted(response)\",\n \"def test_update_pci_device(self):\\n pass\",\n \"def _update_volume_stats(self):\\n LOG.debug('Updating volume stats')\\n total_space = 0\\n free_space = 0\\n share = None\\n for _share in self._mounted_shares:\\n if self.shares_with_capacities[_share]['free'] > free_space:\\n free_space = self.shares_with_capacities[_share]['free']\\n total_space = self.shares_with_capacities[_share]['total']\\n share = _share\\n\\n location_info = '%(driver)s:%(share)s' % {\\n 'driver': self.__class__.__name__,\\n 'share': share\\n }\\n nms_url = self.share2nms[share].url\\n self._stats = {\\n 'vendor_name': 'Nexenta',\\n 'dedup': self.volume_deduplication,\\n 'compression': self.volume_compression,\\n 'description': self.volume_description,\\n 'nms_url': nms_url,\\n 'ns_shares': self.shares_with_capacities,\\n 'driver_version': self.VERSION,\\n 'storage_protocol': constants.NFS,\\n 'total_capacity_gb': total_space,\\n 'free_capacity_gb': free_space,\\n 'reserved_percentage': self.configuration.reserved_percentage,\\n 'QoS_support': False,\\n 'location_info': location_info,\\n 'volume_backend_name': self.backend_name,\\n 'nfs_mount_point_base': self.nfs_mount_point_base\\n }\",\n \"def test_kyc_put_document_shareholder(self):\\n pass\",\n \"def test_update_hyperflex_server_model(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def test_update_system_asset(self):\\n pass\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"async def test_update(aresponses):\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/system/status\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"system-status.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n async with ClientSession() as session:\\n client = Sonarr(HOST, API_KEY, session=session)\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\\n\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\",\n \"def test_update_cloud(self):\\n pass\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"def upgrade_share_to_safe(\\n ui,\\n hgvfs,\\n storevfs,\\n current_requirements,\\n mismatch_config,\\n mismatch_warn,\\n):\\n wlock = None\\n store_requirements = localrepo._readrequires(storevfs, False)\\n original_crequirements = current_requirements.copy()\\n # after upgrade, store requires will be shared, so lets find\\n # the requirements which are not present in store and\\n # write them to share's .hg/requires\\n diffrequires = current_requirements - store_requirements\\n # add share-safe requirement as it will mark the share as share-safe\\n diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)\\n current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)\\n # in `allow` case, we don't try to upgrade, we just respect the source\\n # state, update requirements and continue\\n if mismatch_config == b'allow':\\n return\\n try:\\n wlock = lockmod.trylock(ui, hgvfs, b'wlock', 0, 0)\\n # some process might change the requirement in between, re-read\\n # and update current_requirements\\n locked_requirements = localrepo._readrequires(hgvfs, True)\\n if locked_requirements != original_crequirements:\\n removed = current_requirements - locked_requirements\\n # update current_requirements in place because it's passed\\n # as reference\\n current_requirements -= removed\\n current_requirements |= locked_requirements\\n diffrequires = current_requirements - store_requirements\\n # add share-safe requirement as it will mark the share as share-safe\\n diffrequires.add(requirementsmod.SHARESAFE_REQUIREMENT)\\n current_requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)\\n scmutil.writerequires(hgvfs, diffrequires)\\n ui.warn(_(b'repository upgraded to use share-safe mode\\\\n'))\\n except error.LockError as e:\\n hint = _(\\n \\\"see `hg help config.format.use-share-safe` for more information\\\"\\n )\\n if mismatch_config == b'upgrade-abort':\\n raise error.Abort(\\n _(b'failed to upgrade share, got error: %s')\\n % stringutil.forcebytestr(e.strerror),\\n hint=hint,\\n )\\n elif mismatch_warn:\\n ui.warn(\\n _(b'failed to upgrade share, got error: %s\\\\n')\\n % stringutil.forcebytestr(e.strerror),\\n hint=hint,\\n )\\n finally:\\n if wlock:\\n wlock.release()\",\n \"def test_update_bucket(self):\\n pass\",\n \"def test_update_domain_only(self):\\n self.test_update()\",\n \"def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\\n ingest_shares = \\\"\\\"\\\"\\n UNWIND $shares_list as s\\n MERGE (share:AzureStorageFileShare{id: s.id})\\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\\n SET share.name = s.name,\\n share.lastupdated = $azure_update_tag,\\n share.lastmodifiedtime = s.last_modified_time,\\n share.sharequota = s.share_quota,\\n share.accesstier = s.access_tier,\\n share.deleted = s.deleted,\\n share.accesstierchangetime = s.access_tier_change_time,\\n share.accesstierstatus = s.access_tier_status,\\n share.deletedtime = s.deleted_time,\\n share.enabledprotocols = s.enabled_protocols,\\n share.remainingretentiondays = s.remaining_retention_days,\\n share.shareusagebytes = s.share_usage_bytes,\\n share.version = s.version\\n WITH share, s\\n MATCH (fs:AzureStorageFileService{id: s.service_id})\\n MERGE (fs)-[r:CONTAINS]->(share)\\n ON CREATE SET r.firstseen = timestamp()\\n SET r.lastupdated = $azure_update_tag\\n \\\"\\\"\\\"\\n\\n neo4j_session.run(\\n ingest_shares,\\n shares_list=shares,\\n azure_update_tag=update_tag,\\n )\",\n \"def test_update(self):\\n # this is tested graphically, as it is UI\\n pass\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_share_no_os_environ(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_put(self):\\n\\n url = reverse('file')\\n\\n data = {\\n 'shard_id': self.shard1.id,\\n 'link_id': \\\"b8866161-0b1f-4a8e-acde-07047313ec8f\\\",\\n 'parent_datastore_id': str(self.test_datastore_obj.id),\\n 'chunk_count': 1,\\n 'size': 512,\\n }\\n\\n self.client.force_authenticate(user=self.test_user_obj)\\n response = self.client.put(url, data)\\n\\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n self.assertIn('file_id', response.data)\\n self.assertIn('file_transfer_id', response.data)\\n self.assertIn('file_transfer_secret_key', response.data)\",\n \"def test_sg_update_name(self):\\n\\n # Add a faked storage_group\\n faked_storage_group = self.add_storage_group1()\\n storage_group_name = faked_storage_group.name\\n\\n storage_group_mgr = self.console.storage_groups\\n storage_group = storage_group_mgr.find(name=storage_group_name)\\n\\n new_storage_group_name = \\\"new-\\\" + storage_group_name\\n\\n # Execute the code to be tested\\n storage_group.update_properties(\\n properties={'name': new_storage_group_name})\\n\\n # Verify that the resource is no longer found by its old name, using\\n # list() (this does not use the name-to-URI cache).\\n storage_groups_list = storage_group_mgr.list(\\n filter_args=dict(name=storage_group_name))\\n assert len(storage_groups_list) == 0\\n\\n # Verify that the resource is no longer found by its old name, using\\n # find() (this uses the name-to-URI cache).\\n with pytest.raises(NotFound):\\n storage_group_mgr.find(name=storage_group_name)\\n\\n # Verify that the resource object already reflects the update, even\\n # though it has not been refreshed yet.\\n assert storage_group.properties['name'] == new_storage_group_name\\n\\n # Refresh the resource object and verify that it still reflects the\\n # update.\\n storage_group.pull_full_properties()\\n assert storage_group.properties['name'] == new_storage_group_name\\n\\n # Verify that the resource can be found by its new name, using find()\\n new_storage_group_find = storage_group_mgr.find(\\n name=new_storage_group_name)\\n assert new_storage_group_find.properties['name'] == \\\\\\n new_storage_group_name\\n\\n # Verify that the resource can be found by its new name, using list()\\n new_storage_groups_list = storage_group_mgr.list(\\n filter_args=dict(name=new_storage_group_name))\\n assert len(new_storage_groups_list) == 1\\n new_storage_group_list = new_storage_groups_list[0]\\n assert new_storage_group_list.properties['name'] == \\\\\\n new_storage_group_name\",\n \"def test_synchronize_all_networks(self):\\n\\n # Store two tenants in a db and none on EOS.\\n # The sync should send details of all tenants to EOS\\n tenant_1_id = 'tenant-1'\\n tenant_1_net_1_id = 'ten-1-net-1'\\n tenant_1_net_1_seg_id = 11\\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id,\\n tenant_1_net_1_seg_id, 'segment_id_11')\\n\\n tenant_2_id = 'tenant-2'\\n tenant_2_net_1_id = 'ten-2-net-1'\\n tenant_2_net_1_seg_id = 21\\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id,\\n tenant_2_net_1_seg_id, 'segment_id_21')\\n\\n self.rpc.get_tenants.return_value = {}\\n\\n self.rpc.sync_start.return_value = True\\n self.rpc.sync_end.return_value = True\\n self.rpc.check_cvx_availability.return_value = True\\n\\n self.rpc._baremetal_supported.return_value = False\\n self.rpc.get_all_baremetal_hosts.return_value = {}\\n\\n self.sync_service.do_synchronize()\\n\\n expected_calls = [\\n mock.call.perform_sync_of_sg(self.sync_service._context),\\n mock.call.check_cvx_availability(),\\n mock.call.get_region_updated_time(),\\n mock.call.get_region_updated_time().__bool__(),\\n mock.call.sync_start(),\\n mock.call.register_with_eos(sync=True),\\n mock.call.check_supported_features(),\\n mock.call.get_tenants(),\\n\\n mock.call.create_network_bulk(\\n tenant_1_id,\\n [{'network_id': tenant_1_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n\\n mock.call.create_network_bulk(\\n tenant_2_id,\\n [{'network_id': tenant_2_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n mock.call.sync_end(),\\n mock.call.get_region_updated_time()\\n ]\\n\\n # The create_network_bulk() can be called in different order. So split\\n # it up. The first part checks if the initial set of methods are\\n # invoked.\\n idx = expected_calls.index(mock.call.get_tenants()) + 1\\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 1 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 2 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if the sync end methods are invoked.\\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\\n expected_calls[idx + 2:],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n\\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id)\\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)\",\n \"def test_sync_no_archives_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\")\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_update_case(self):\\n pass\",\n \"def test_update_instance_limit1(self):\\n pass\",\n \"def test_update(tmp_path):\\n _ = get_logger(verbosity=4)\\n for osdk_version in [\\\"latest\\\", \\\"1.3.1\\\", \\\"1.3.1\\\"]:\\n version = osdk_update.osdk_update(version=osdk_version, **tmp_path)\\n file_data = osdk_update.OsdkFileData(version=version, **tmp_path)\\n assert file_data.files_not_matching() == []\\n for filename in file_data.downloads:\\n try:\\n os.remove(file_data.downloads[filename]['dst'])\\n except Exception:\\n pass\",\n \"def test_update_ban(self):\\n pass\",\n \"def test_update_software_asset_content(self):\\n pass\",\n \"def test_wrong_config_shares1(self):\\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\\n\\n for i in config:\\n k = config\\n k[i] = ''\\n print k\\n self.app.post_json(url=\\\"/config/shares\\\", params=k, status=400)\\n return config\",\n \"def share(source, dest, branch=None, revision=None):\\n run_cmd(['hg', 'share', '-U', source, dest])\\n return update(dest, branch=branch, revision=revision)\",\n \"def test_vault_update_vault_item(self):\\n pass\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.94022584","0.8667093","0.82092834","0.8034242","0.79996043","0.77217346","0.76853245","0.76770335","0.7653774","0.7644211","0.7401856","0.7383217","0.73583794","0.718956","0.7073682","0.69962233","0.6705802","0.658027","0.64904004","0.6448504","0.6363711","0.6194675","0.6189743","0.618568","0.61355776","0.6110313","0.60654366","0.603497","0.6011409","0.6006921","0.5993471","0.5983591","0.5957416","0.5905269","0.58967227","0.58240247","0.5818787","0.5809649","0.57774955","0.5774274","0.5757128","0.57383823","0.5699706","0.5634423","0.5614233","0.5591934","0.5577715","0.5546211","0.5544441","0.5540451","0.5537638","0.553005","0.55108106","0.5491301","0.5460963","0.54606014","0.5459523","0.54524386","0.5431261","0.54091203","0.54091203","0.5408576","0.5401266","0.53997153","0.539449","0.5387878","0.53866017","0.53780717","0.53702533","0.5365887","0.5362908","0.5362908","0.5362908","0.5361026","0.5336349","0.5315547","0.53025293","0.52994704","0.52974945","0.5296869","0.5276759","0.52765036","0.52738357","0.52738214","0.5267399","0.52583194","0.5257967","0.52535266","0.5239348","0.5219572","0.5217633","0.520711","0.5198863","0.5196238","0.5195875","0.51859426","0.51820767","0.5181557","0.5179897","0.51787126"],"string":"[\n \"0.94022584\",\n \"0.8667093\",\n \"0.82092834\",\n \"0.8034242\",\n \"0.79996043\",\n \"0.77217346\",\n \"0.76853245\",\n \"0.76770335\",\n \"0.7653774\",\n \"0.7644211\",\n \"0.7401856\",\n \"0.7383217\",\n \"0.73583794\",\n \"0.718956\",\n \"0.7073682\",\n \"0.69962233\",\n \"0.6705802\",\n \"0.658027\",\n \"0.64904004\",\n \"0.6448504\",\n \"0.6363711\",\n \"0.6194675\",\n \"0.6189743\",\n \"0.618568\",\n \"0.61355776\",\n \"0.6110313\",\n \"0.60654366\",\n \"0.603497\",\n \"0.6011409\",\n \"0.6006921\",\n \"0.5993471\",\n \"0.5983591\",\n \"0.5957416\",\n \"0.5905269\",\n \"0.58967227\",\n \"0.58240247\",\n \"0.5818787\",\n \"0.5809649\",\n \"0.57774955\",\n \"0.5774274\",\n \"0.5757128\",\n \"0.57383823\",\n \"0.5699706\",\n \"0.5634423\",\n \"0.5614233\",\n \"0.5591934\",\n \"0.5577715\",\n \"0.5546211\",\n \"0.5544441\",\n \"0.5540451\",\n \"0.5537638\",\n \"0.553005\",\n \"0.55108106\",\n \"0.5491301\",\n \"0.5460963\",\n \"0.54606014\",\n \"0.5459523\",\n \"0.54524386\",\n \"0.5431261\",\n \"0.54091203\",\n \"0.54091203\",\n \"0.5408576\",\n \"0.5401266\",\n \"0.53997153\",\n \"0.539449\",\n \"0.5387878\",\n \"0.53866017\",\n \"0.53780717\",\n \"0.53702533\",\n \"0.5365887\",\n \"0.5362908\",\n \"0.5362908\",\n \"0.5362908\",\n \"0.5361026\",\n \"0.5336349\",\n \"0.5315547\",\n \"0.53025293\",\n \"0.52994704\",\n \"0.52974945\",\n \"0.5296869\",\n \"0.5276759\",\n \"0.52765036\",\n \"0.52738357\",\n \"0.52738214\",\n \"0.5267399\",\n \"0.52583194\",\n \"0.5257967\",\n \"0.52535266\",\n \"0.5239348\",\n \"0.5219572\",\n \"0.5217633\",\n \"0.520711\",\n \"0.5198863\",\n \"0.5196238\",\n \"0.5195875\",\n \"0.51859426\",\n \"0.51820767\",\n \"0.5181557\",\n \"0.5179897\",\n \"0.51787126\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.9529857"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81388,"cells":{"query":{"kind":"string","value":"Test case for update_nas_share_by_nas"},"document":{"kind":"string","value":"def test_update_nas_share_by_nas(self):\n pass"},"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_update_nas_share(self):\n pass","def test_update_nas_share_by_pool(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_nas_share(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_show_nas_share(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share(self):\n pass","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_update_non_shareable(self):\n self.create_common_users_and_groups()\n sync = SyncUserAndGroups(\n tsurl=TS_URL,\n username=TS_USER,\n password=TS_PASSWORD,\n disable_ssl=True,\n )\n auag = sync.get_all_users_and_groups()\n\n # Need to remove the common users since they don't have emails.\n auag.remove_user(\"guest\")\n auag.remove_user(\"su\")\n auag.remove_user(\"system\")\n auag.remove_user(\"tsadmin\")\n\n # Change Group 1 and Group 2 and verify change took.\n group1 = auag.get_group(\"Group 1\")\n group1.visibility = Visibility.NON_SHAREABLE\n group2 = auag.get_group(\"Group 2\")\n group2.visibility = Visibility.DEFAULT\n\n # sync updates\n sync.sync_users_and_groups(users_and_groups=auag)\n\n # verify changes\n auag = sync.get_all_users_and_groups()\n self.assertEqual(\n auag.get_group(\"Group 1\").visibility, Visibility.NON_SHAREABLE\n )\n self.assertEqual(\n auag.get_group(\"Group 2\").visibility, Visibility.DEFAULT\n )\n self.assertEqual(\n auag.get_group('Group \"3\"').visibility, Visibility.NON_SHAREABLE\n )","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_kyc_put_legal_share_holder(self):\n pass","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_dashboards_v2_share(self):\n pass","async def test_endpoint_edit_share_correct(self):\n with self.patch_json_dump:\n await edit_share_handler(self.mock_request)\n self.json_mock.assert_called_once()","def modify_share(self, pool, project, share, arg):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.put(svc, arg)\n if ret.status != restclient.Status.ACCEPTED:\n exception_msg = (_('Error modifying %(arg)s '\n ' of share %(id)s.')\n % {'arg': arg,\n 'id': share})\n raise exception.ShareBackendException(msg=exception_msg)","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def test_update_pci_link(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def test_remove_share(self):\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\", status=400)\n self.app.delete(url=\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\", status=204)","def test_put_without_parent_datastore_nor_share_id(self):\n\n url = reverse('file')\n\n data = {\n 'shard_id': self.shard1.id,\n 'link_id': \"b8866161-0b1f-4a8e-acde-07047313ec8f\",\n #'parent_datastore_id': str(self.test_datastore_obj.id),\n 'chunk_count': 1,\n 'size': 512,\n }\n\n self.client.force_authenticate(user=self.test_user_obj)\n response = self.client.put(url, data)\n\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_update_hyperflex_cluster(self):\n pass","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def ensure_share(self, context, share, share_server=None):\n pass","def createPublicNfsShare(self,sharepath=\"/opt\"):\n self.prepareForSSODebug() \n self.install(\"nfs-kernel-server\")\n self.writeFile(\"/etc/exports\",\"/opt *(rw,sync,no_root_squash,no_subtree_check)\") \n self.execute(\"echo '' > /etc/hosts.allow\",dieOnError=True)\n self.execute(\"echo '' > /etc/hosts.deny\",dieOnError=True)\n self.execute(\"exportfs -rav\")","def test_dashboards_v2_list_shares(self):\n pass","def update_shares(self):\n self.nb_shares = self.shares.count()\n self.save()","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def test_share_01(self, mocker):\n contributors = ['alice@gmail.com']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert not g.spreadsheet.share.called","def share():\n return True","def ensure_share(self, context, share, share_server=None):\n\n volume_uuid = self._resolve_volume_name(share['name'],\n share['project_id'])\n\n LOG.debug(\"Ensuring Quobyte share %s\", share['name'])\n\n if not volume_uuid:\n raise (exception.ShareResourceNotFound(\n share_id=share['id']))\n\n result = self.rpc.call('exportVolume', dict(\n volume_uuid=volume_uuid,\n protocol='NFS'))\n\n return self._build_share_export_string(result)","def create_smb_share_with_path_tankrtacltest1share(driver, path):\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\"option__Shares\"]', 'clickable')\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\"option__Shares\"]').click()\n assert wait_on_element(driver, 5, '//div[contains(.,\"Shares\")]')\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]', 'clickable')\n driver.find_element_by_xpath('//mat-card[contains(.,\"Windows (SMB) Shares\")]//button[contains(.,\"Add\")]').click()\n assert wait_on_element(driver, 5, '//h3[contains(text(),\"Add SMB\")]')\n global smb_path\n smb_path = path\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__path\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__path\"]').send_keys(path)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Name\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Name\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'clickable')\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n if not checkbox_checked:\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]').click()\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\"checkbox__Enabled\"]', 'class', 'mat-checkbox-checked')\n time.sleep(1)\n assert wait_on_element(driver, 5, '//input[@ix-auto=\"input__Description\"]', 'inputable')\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').clear()\n driver.find_element_by_xpath('//input[@ix-auto=\"input__Description\"]').send_keys(\"rt-test\")\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SAVE\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SAVE\"]').click()\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\"Please wait\")]')\n if is_element_present(driver, '//h1[contains(., \"Enable service\")]'):\n driver.find_element_by_xpath('//button[@ix-auto=\"button__ENABLE SERVICE\"]').click()\n assert wait_on_element(driver, 5, '//h1[contains(., \"SMB Service\")]')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__CLOSE\"]').click()","def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\n ingest_shares = \"\"\"\n UNWIND $shares_list as s\n MERGE (share:AzureStorageFileShare{id: s.id})\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\n SET share.name = s.name,\n share.lastupdated = $azure_update_tag,\n share.lastmodifiedtime = s.last_modified_time,\n share.sharequota = s.share_quota,\n share.accesstier = s.access_tier,\n share.deleted = s.deleted,\n share.accesstierchangetime = s.access_tier_change_time,\n share.accesstierstatus = s.access_tier_status,\n share.deletedtime = s.deleted_time,\n share.enabledprotocols = s.enabled_protocols,\n share.remainingretentiondays = s.remaining_retention_days,\n share.shareusagebytes = s.share_usage_bytes,\n share.version = s.version\n WITH share, s\n MATCH (fs:AzureStorageFileService{id: s.service_id})\n MERGE (fs)-[r:CONTAINS]->(share)\n ON CREATE SET r.firstseen = timestamp()\n SET r.lastupdated = $azure_update_tag\n \"\"\"\n\n neo4j_session.run(\n ingest_shares,\n shares_list=shares,\n azure_update_tag=update_tag,\n )","def test_kyc_post_legal_share_holder(self):\n pass","def _share_folder(self, nms, volume, folder):\n path = '%s/%s' % (volume, folder.lstrip('/'))\n share_opts = {\n 'read_write': '*',\n 'read_only': '',\n 'root': 'nobody',\n 'extra_options': 'anon=0',\n 'recursive': 'true',\n 'anonymous_rw': 'true',\n }\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\n share_opts)","def test_synchronize_all_networks(self):\n\n # Store two tenants in a db and none on EOS.\n # The sync should send details of all tenants to EOS\n tenant_1_id = 'tenant-1'\n tenant_1_net_1_id = 'ten-1-net-1'\n tenant_1_net_1_seg_id = 11\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id,\n tenant_1_net_1_seg_id, 'segment_id_11')\n\n tenant_2_id = 'tenant-2'\n tenant_2_net_1_id = 'ten-2-net-1'\n tenant_2_net_1_seg_id = 21\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id,\n tenant_2_net_1_seg_id, 'segment_id_21')\n\n self.rpc.get_tenants.return_value = {}\n\n self.rpc.sync_start.return_value = True\n self.rpc.sync_end.return_value = True\n self.rpc.check_cvx_availability.return_value = True\n\n self.rpc._baremetal_supported.return_value = False\n self.rpc.get_all_baremetal_hosts.return_value = {}\n\n self.sync_service.do_synchronize()\n\n expected_calls = [\n mock.call.perform_sync_of_sg(self.sync_service._context),\n mock.call.check_cvx_availability(),\n mock.call.get_region_updated_time(),\n mock.call.get_region_updated_time().__bool__(),\n mock.call.sync_start(),\n mock.call.register_with_eos(sync=True),\n mock.call.check_supported_features(),\n mock.call.get_tenants(),\n\n mock.call.create_network_bulk(\n tenant_1_id,\n [{'network_id': tenant_1_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n\n mock.call.create_network_bulk(\n tenant_2_id,\n [{'network_id': tenant_2_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n mock.call.sync_end(),\n mock.call.get_region_updated_time()\n ]\n\n # The create_network_bulk() can be called in different order. So split\n # it up. The first part checks if the initial set of methods are\n # invoked.\n idx = expected_calls.index(mock.call.get_tenants()) + 1\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 1 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 2 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if the sync end methods are invoked.\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\n expected_calls[idx + 2:],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id)\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_kyc_delete_legal_share_holder_natural(self):\n pass","def test_networking_project_network_update(self):\n pass","def test_update_hyperflex_cluster_network_policy(self):\n pass","def is_nas_server_matched(nas_server, nfs_export_details):\n\n nas_id_from_details = \\\n nfs_export_details['file_system']['nas_server']['id']\n nas_name_from_details = \\\n nfs_export_details['file_system']['nas_server']['name']\n\n if nfs_export_details and nas_server:\n if utils.name_or_id(nas_server) == \"ID\" and \\\n nas_id_from_details != nas_server:\n return False\n if utils.name_or_id(nas_server) == \"NAME\" and \\\n nas_name_from_details != nas_server:\n return False\n return True","def test_update_network(self):\n policies_ports = [\n (None, {self.ports[0].id}),\n (self.qos_policies[1].id, {self.ports[0].id})]\n\n self.ports[1].qos_policy_id = self.qos_policies[0].id\n self.ports[1].update()\n self.ports[2].qos_policy_id = self.qos_policies[1].id\n self.ports[2].update()\n for qos_policy_id, reference_ports in policies_ports:\n self.networks[0].qos_policy_id = qos_policy_id\n self.networks[0].update()\n original_network = {'qos_policy_id': self.qos_policies[0]}\n reviewed_port_ids, _, _ = self.qos_driver.update_network(\n mock.ANY, self.networks[0], original_network)\n self.assertEqual(reference_ports, reviewed_port_ids)\n calls = [mock.call(mock.ANY, self.ports[0].id,\n self.ports[0].network_id, qos_policy_id,\n None)]\n self.mock_rules.assert_has_calls(calls)\n self.mock_rules.reset_mock()","def test_kyc_put_document_shareholder(self):\n pass","def test_056_netbios_name_change_check_sid(request):\n depends(request, [\"service_cifs_running\"], scope=\"session\")\n global new_sid\n global old_netbiosname\n\n results = GET(\"/smb/\")\n assert results.status_code == 200, results.text\n old_netbiosname = results.json()[\"netbiosname\"]\n old_sid = results.json()[\"cifs_SID\"]\n\n payload = {\n \"netbiosname\": \"nb_new\",\n }\n results = PUT(\"/smb/\", payload)\n assert results.status_code == 200, results.text\n new_sid_resp = results.json()[\"cifs_SID\"]\n assert old_sid != new_sid_resp, results.text\n sleep(5)\n\n results = GET(\"/smb/\")\n assert results.status_code == 200, results.text\n new_sid = results.json()[\"cifs_SID\"]\n assert new_sid != old_sid, results.text","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def share_replica_update(context, share_replica_id, values,\n with_share_data=False, session=None):\n session = session or get_session()\n\n with session.begin():\n _ensure_availability_zone_exists(context, values, session,\n strict=False)\n updated_share_replica = _share_instance_update(\n context, share_replica_id, values, session=session)\n\n if with_share_data:\n updated_share_replica = _set_instances_share_data(\n context, updated_share_replica, session)[0]\n\n return updated_share_replica","def test_synchronize_one_network(self):\n\n # Store two tenants in a db and a single tenant in EOS.\n # The sync should send details of the second tenant to EOS\n tenant_1_id = 'tenant-1'\n tenant_1_net_1_id = 'ten-1-net-1'\n tenant_1_net_1_seg_id = 11\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id,\n tenant_1_net_1_seg_id, 'segment_id_11')\n\n tenant_2_id = 'tenant-2'\n tenant_2_net_1_id = 'ten-2-net-1'\n tenant_2_net_1_seg_id = 21\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id,\n tenant_2_net_1_seg_id, 'segment_id_21')\n\n self.rpc.get_tenants.return_value = {\n tenant_1_id: {\n 'tenantVmInstances': {},\n 'tenantBaremetalInstances': {},\n 'tenantNetworks': {\n tenant_1_net_1_id: {\n 'networkId': tenant_1_net_1_id,\n 'shared': False,\n 'networkName': 'Net1',\n 'segmenationType': 'vlan',\n 'segmentationTypeId': tenant_1_net_1_seg_id,\n }\n }\n }\n }\n\n self.rpc.sync_start.return_value = True\n self.rpc.sync_end.return_value = True\n self.rpc.check_cvx_availability.return_value = True\n\n self.rpc._baremetal_supported.return_value = False\n self.rpc.get_all_baremetal_hosts.return_value = {}\n\n self.sync_service.do_synchronize()\n\n expected_calls = [\n mock.call.perform_sync_of_sg(self.sync_service._context),\n mock.call.check_cvx_availability(),\n mock.call.get_region_updated_time(),\n mock.call.get_region_updated_time().__bool__(),\n mock.call.sync_start(),\n mock.call.register_with_eos(sync=True),\n mock.call.check_supported_features(),\n mock.call.get_tenants(),\n\n mock.call.create_network_bulk(\n tenant_2_id,\n [{'network_id': tenant_2_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n\n mock.call.sync_end(),\n mock.call.get_region_updated_time()\n ]\n\n self.assertTrue(self.rpc.mock_calls == expected_calls,\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id)\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)","async def test_endpoint_delete_share_correct(self):\n with self.patch_json_dump:\n resp = await delete_share_handler(self.mock_request)\n self.assertEqual(resp.status, 204)","def sendShare(self, program_counter, share):\n self.sendData(program_counter, SHARE, hex(share.value))","def test_auth_sharable_can_share(self):\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\n tenant='froggy')","def test_wrong_config_shares1(self):\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\n\n for i in config:\n k = config\n k[i] = ''\n print k\n self.app.post_json(url=\"/config/shares\", params=k, status=400)\n return config","def test_sell_shares_success(self):\n\t\texpected_response_code = 200\n\t\tsymbol = \"DDD\" \n\t\tquantity = 100\n\t\t\n\t\tdisplayName, email, password = (\"John Doe\", \"johndoe@test.com\", \"12345678\")\n\t\tregistration_response = ApiFacade.register_user(displayName, email, password)\n\t\tauthentication_response = ApiFacade.authenticate_user(email, password)\n\t\ttoken = authentication_response.get_token()\n\n\t\t# get account id\n\t\tviewdetails_response = ApiFacade.view_details(token)\n\t\taccount_id = viewdetails_response.get_main_account_id()\n\n\t\t# buy shares first\n\t\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\n\t\t\n\t\t# sell the shares\n\t\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\n\n\t\tdeletion_response = ApiFacade.delete_user(token)\n\n\t\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \n\t\t\tmsg = \"Expected HTTP{0}; got HTTP{1}\"\n\t\t\t.format(expected_response_code, sellshare_response.get_http_status()))","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_put_nveto_pmt_item(self):\n pass","def test_update_pci_switch(self):\n pass","def test_shared_table(self, test_info):\n\n test_results = test_info\n\n # execute request\n try:\n\n # Step 1: Get the list of public tables\n tables = self.gaia.load_tables(only_names=True)\n # Now we will keep the number of results returned\n n_public_tables = len(tables)\n log.debug(f'N public tables is {n_public_tables}')\n\n # Step 2: Now we need to do login in to de Gaia Tap.\n\n # Now we can do the login()\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\n\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\n # the tables that we are sharing with other users from our user_schema.\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\n # Let's keep now the number of results returned\n n_shared_tables = len(all_tables)\n log.debug(f'N all tables is {n_shared_tables}')\n\n # Step 4: Finally we will do a logout from the system.\n self.gaia.logout()\n\n # Get current time to complete our result object\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n test_results['test_finished'] = f'{time_str} CET'\n\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\n # is equal or higher than the number of public tables the test is correct.\n if n_public_tables <= n_shared_tables:\n # Test passed\n test_results['test_result'] = PASSED\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\n f'of public tables: {n_public_tables}'\n log.debug(debug_message)\n test_results['test_additional_info'] = debug_message + \" Test PASSED!\"\n else:\n test_results['test_result'] = NOT_PASSED\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\n f'of public tables: {n_public_tables}'\n test_results['test_additional_info'] = error_message\n log.error(error_message)\n raise ValueError(error_message)\n self.gaia.logout()\n return test_results\n\n except ValueError as err:\n log.error(str(err))\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = str(err)\n self.gaia.logout()\n return test_results\n except HTTPError as err:\n\n error_message = \"Error connecting TAP server\"\n log.error(error_message)\n\n # Get current time\n time = datetime.now()\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\n # fill result object with the info from the http error\n test_results['test_finished'] = f'{time_str} CET'\n test_results['test_result'] = NOT_PASSED\n test_results['test_additional_info'] = error_message + \",\" + str(err)\n self.gaia.logout()\n return test_results","def test_updating_a_segment(self):\n pass","def test_add_asset_share_feed(self):\n pass","def test_data_source_soaps_id_put(self):\n pass","def test_update_hyperflex_server_model(self):\n pass","async def test_update(aresponses):\n aresponses.add(\n MATCH_HOST,\n \"/api/system/status\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"system-status.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n async with ClientSession() as session:\n client = Sonarr(HOST, API_KEY, session=session)\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)\n\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)","def test_update_pci_device(self):\n pass","def test_create_get_delete_update_node(self):\n node_dict_1 = {\n 'host_name': 'abc',\n 'local_router_id': '1.1.1.1',\n 'as_num': 100,\n 'bgpls_id': '0.0.0.0',\n 'igp_id': '0.0.0.0'\n }\n node_dict_2 = {\n 'host_name': 'def',\n 'local_router_id': '2.2.2.2',\n 'as_num': 100,\n 'bgpls_id': '0.0.0.0',\n 'igp_id': '0.0.0.0'\n }\n\n # create two objects\n node1 = Node(**node_dict_1)\n node2 = Node(**node_dict_2)\n Node.create_object(self.database, node1.__dict__)\n Node.create_object(self.database, node2.__dict__)\n self.assertEqual(2, Node.count(self.database))\n\n # get one object\n node1 = Node.get_object(self.database, host_name='abc')\n self.assertEqual(node_dict_1['local_router_id'], node1.get('local_router_id'))\n\n # get objects\n nodes = Node.get_objects(self.database, as_num=100)\n self.assertEqual(2, len(nodes))\n\n # update one object\n self.assertEqual(0, Node.count(self.database, local_router_id='3.3.3.3'))\n node_db_obj = Node.update_object(\n self.database, {'local_router_id': '3.3.3.3'}, host_name='abc')\n self.assertEqual('3.3.3.3', node_db_obj.get('local_router_id'))\n self.assertEqual(1, Node.count(self.database, local_router_id='3.3.3.3'))\n\n # update more than objects\n self.assertEqual(2, Node.count(self.database, as_num=100))\n update_count = Node.update_objects(\n self.database, {'as_num': 200}, igp_id='0.0.0.0')\n self.assertEqual(2, update_count)\n self.assertEqual(2, Node.count(self.database, as_num=200))\n\n # delete objects\n Node.delete_object(self.database, host_name='abc')\n self.assertEqual(1, Node.count(self.database))","def test_update_hyperflex_cluster_storage_policy(self):\n pass","def test_replace_cluster_network(self):\n pass","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def test_update_external_network(self):\n network_policies = [(self.qos_policies[1].id,\n {self.fips[1].id},\n {self.router_fips.id}),\n (None,\n {self.fips[1].id},\n {self.router_fips.id})]\n\n self.fips[0].qos_policy_id = self.qos_policies[0].id\n self.fips[0].update()\n for qos_policy_id, ref_fips, ref_routers in network_policies:\n self.fips_network.qos_policy_id = qos_policy_id\n self.fips_network.update()\n original_network = {'qos_policy_id': self.qos_policies[0]}\n _, reviewed_fips_ids, reviewed_router_ids = (\n self.qos_driver.update_network(\n mock.Mock(), self.fips_network, original_network))\n self.assertEqual(ref_fips, reviewed_fips_ids)\n self.assertEqual(ref_routers, reviewed_router_ids)","def test_update_node_driveconfig(self):\n pass","def test_update_sim():\n # Generate a random set of parameters, a random start date, and a Chromosome\n r_start_date, r_end_date = sga.generate_random_dates()\n r_param_ids = wp.flexible_generate()\n individual = sga.Chromosome(r_param_ids, fitness=100, start_date=r_start_date, end_date=r_end_date)\n # Put individual in the database\n db_conn = conn_to_db('optwrf_repeat.db')\n owp.insert_sim(individual, db_conn)\n print_database(db_conn)\n # Generate a new random start date and a Chromosome\n r_start_date, r_end_date = sga.generate_random_dates()\n individual = sga.Chromosome(r_param_ids, fitness=50, start_date=r_start_date, end_date=r_end_date)\n # Update the individual in the database database\n owp.update_sim(individual, db_conn)\n print_database(db_conn)","def share(source, dest, branch=None, revision=None):\n run_cmd(['hg', 'share', '-U', source, dest])\n return update(dest, branch=branch, revision=revision)","def dvs_update_network(self):\n self.show_step(1)\n self.env.revert_snapshot(\"dvs_vcenter_systest_setup\")\n\n cluster_id = self.fuel_web.get_last_created_cluster()\n\n self.show_step(2)\n os_ip = self.fuel_web.get_public_vip(cluster_id)\n os_conn = os_actions.OpenStackActions(\n os_ip, SERVTEST_USERNAME,\n SERVTEST_PASSWORD,\n SERVTEST_TENANT)\n\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\n\n net_1 = os_conn.create_network(\n network_name=self.net_data[0].keys()[0],\n tenant_id=tenant.id)['network']\n\n os_conn.create_subnet(\n subnet_name=net_1['name'],\n network_id=net_1['id'],\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\n ip_version=4)\n\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\n\n self.show_step(3)\n os_conn.neutron.update_network(net_1[\"id\"],\n {\"network\": {\"name\": 'net_2'}})\n\n assert_true(os_conn.get_network('net_2')['id'] == net_1['id'])\n\n self.show_step(4)\n default_net = os_conn.nova.networks.find(label=self.inter_net_name)\n os_conn.neutron.update_network(\n default_net.id, {\"network\": {\"name\": 'spring'}})\n\n assert_true(os_conn.get_network('spring')['id'] == default_net.id)","def allow_access_nfs(self, pool, project, share, access):\n if access['access_type'] != 'ip':\n reason = _('Only ip access type allowed.')\n raise exception.InvalidShareAccess(reason)\n\n ip = access['access_to']\n details = self.get_share(pool, project, share)\n sharenfs = details['sharenfs']\n\n if sharenfs == 'on' or sharenfs == 'rw':\n LOG.debug('Share %s has read/write permission '\n 'open to all.', share)\n return\n if sharenfs == 'off':\n sharenfs = 'sec=sys'\n if ip in sharenfs:\n LOG.debug('Access to share %(share)s via NFS '\n 'already granted to %(ip)s.',\n {'share': share,\n 'ip': ip})\n return\n\n entry = (',rw=@%s' % ip)\n if '/' not in ip:\n entry = \"%s/32\" % entry\n arg = {'sharenfs': sharenfs + entry}\n self.modify_share(pool, project, share, arg)","def test_update_instance_limit1(self):\n pass","def test_patch_cluster_network(self):\n pass","def sync_nas(self, users_from_db: Iterator):","def share(self, share):\n if share is None:\n raise ValueError(\"Invalid value for `share`, must not be `None`\") # noqa: E501\n\n self._share = share","def canShare(self):\n return False","def test_ap_anqp_sharing(dev, apdev):\n bssid = apdev[0]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n hostapd.add_ap(apdev[0]['ifname'], params)\n\n bssid2 = apdev[1]['bssid']\n params = hs20_ap_params()\n params['hessid'] = bssid\n params['nai_realm'] = [ \"0,example.com,13[5:6],21[2:4][5:7]\" ]\n hostapd.add_ap(apdev[1]['ifname'], params)\n\n dev[0].hs20_enable()\n id = dev[0].add_cred_values({ 'realm': \"example.com\", 'username': \"test\",\n 'password': \"secret\",\n 'domain': \"example.com\" })\n logger.info(\"Normal network selection with shared ANQP results\")\n interworking_select(dev[0], None, \"home\", freq=\"2412\")\n dev[0].dump_monitor()\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not shared between BSSes\")\n\n logger.info(\"Explicit ANQP request to unshare ANQP results\")\n dev[0].request(\"ANQP_GET \" + bssid + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n dev[0].request(\"ANQP_GET \" + bssid2 + \" 263\")\n ev = dev[0].wait_event([\"RX-ANQP\"], timeout=5)\n if ev is None:\n raise Exception(\"ANQP operation timed out\")\n\n res1 = dev[0].get_bss(bssid)\n res2 = dev[0].get_bss(bssid2)\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\n raise Exception(\"ANQP results were not unshared\")","def ft_syndicate_access():\n \n fake_user = FakeObject()\n fake_user.email = \"fakeuser@opencloud.us\"\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_user_exists(%s)\\n\" % fake_user.email\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\n\n fake_volume = FakeObject()\n fake_volume.name = \"fakevolume\"\n fake_volume.description = \"This is a fake volume, created for funtional testing\"\n fake_volume.blocksize = 1024\n fake_volume.cap_read_data = True \n fake_volume.cap_write_data = True \n fake_volume.cap_host_data = False\n fake_volume.archive = False\n fake_volume.private = True\n \n # test idempotency\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_exists(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_access_right_absent(%s,%s)\\n\" % (fake_user.email, fake_volume.name)\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n\n print \"\\nensure_user_absent(%s)\\n\" % fake_user.email\n ensure_user_absent( fake_user.email )\n \n \n \n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n \n print \"\\nensure_principal_exists(%s)\\n\" % fake_user.email\n ensure_principal_exists( fake_user.email, \"asdf\", is_admin=False, max_UGs=1100, max_RGs=1 )\n\n print \"\\nensure_volume_exists(%s)\\n\" % fake_volume.name\n ensure_volume_exists( fake_user.email, fake_volume )\n\n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nsetup_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name)\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \"abcdef\" )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nteardown_volume_access(%s, %s)\\n\" % (fake_user.email, fake_volume.name )\n teardown_volume_access( fake_user.email, fake_volume.name )\n \n print \"\\nensure_volume_absent(%s)\\n\" % fake_volume.name\n ensure_volume_absent( fake_volume.name )\n\n print \"\\nensure_principal_absent(%s)\\n\" % fake_user.email\n ensure_principal_absent( fake_user.email )","def test_update_software_asset(self):\n pass","def test_update_ban(self):\n pass","def test_update_device(self):\n pass","def test_update_device(self):\n pass","def test_empty_shared(self):\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\n is_admin=True)"],"string":"[\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_update_nas_share_by_pool(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_update_non_shareable(self):\\n self.create_common_users_and_groups()\\n sync = SyncUserAndGroups(\\n tsurl=TS_URL,\\n username=TS_USER,\\n password=TS_PASSWORD,\\n disable_ssl=True,\\n )\\n auag = sync.get_all_users_and_groups()\\n\\n # Need to remove the common users since they don't have emails.\\n auag.remove_user(\\\"guest\\\")\\n auag.remove_user(\\\"su\\\")\\n auag.remove_user(\\\"system\\\")\\n auag.remove_user(\\\"tsadmin\\\")\\n\\n # Change Group 1 and Group 2 and verify change took.\\n group1 = auag.get_group(\\\"Group 1\\\")\\n group1.visibility = Visibility.NON_SHAREABLE\\n group2 = auag.get_group(\\\"Group 2\\\")\\n group2.visibility = Visibility.DEFAULT\\n\\n # sync updates\\n sync.sync_users_and_groups(users_and_groups=auag)\\n\\n # verify changes\\n auag = sync.get_all_users_and_groups()\\n self.assertEqual(\\n auag.get_group(\\\"Group 1\\\").visibility, Visibility.NON_SHAREABLE\\n )\\n self.assertEqual(\\n auag.get_group(\\\"Group 2\\\").visibility, Visibility.DEFAULT\\n )\\n self.assertEqual(\\n auag.get_group('Group \\\"3\\\"').visibility, Visibility.NON_SHAREABLE\\n )\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"async def test_endpoint_edit_share_correct(self):\\n with self.patch_json_dump:\\n await edit_share_handler(self.mock_request)\\n self.json_mock.assert_called_once()\",\n \"def modify_share(self, pool, project, share, arg):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.put(svc, arg)\\n if ret.status != restclient.Status.ACCEPTED:\\n exception_msg = (_('Error modifying %(arg)s '\\n ' of share %(id)s.')\\n % {'arg': arg,\\n 'id': share})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def test_update_pci_link(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def test_remove_share(self):\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam\\\", status=400)\\n self.app.delete(url=\\\"/config/shares?share=80&destination=gsiftp://nowhere&vo=dteam&source=gsiftp://source\\\", status=204)\",\n \"def test_put_without_parent_datastore_nor_share_id(self):\\n\\n url = reverse('file')\\n\\n data = {\\n 'shard_id': self.shard1.id,\\n 'link_id': \\\"b8866161-0b1f-4a8e-acde-07047313ec8f\\\",\\n #'parent_datastore_id': str(self.test_datastore_obj.id),\\n 'chunk_count': 1,\\n 'size': 512,\\n }\\n\\n self.client.force_authenticate(user=self.test_user_obj)\\n response = self.client.put(url, data)\\n\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def createPublicNfsShare(self,sharepath=\\\"/opt\\\"):\\n self.prepareForSSODebug() \\n self.install(\\\"nfs-kernel-server\\\")\\n self.writeFile(\\\"/etc/exports\\\",\\\"/opt *(rw,sync,no_root_squash,no_subtree_check)\\\") \\n self.execute(\\\"echo '' > /etc/hosts.allow\\\",dieOnError=True)\\n self.execute(\\\"echo '' > /etc/hosts.deny\\\",dieOnError=True)\\n self.execute(\\\"exportfs -rav\\\")\",\n \"def test_dashboards_v2_list_shares(self):\\n pass\",\n \"def update_shares(self):\\n self.nb_shares = self.shares.count()\\n self.save()\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def test_share_01(self, mocker):\\n contributors = ['alice@gmail.com']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert not g.spreadsheet.share.called\",\n \"def share():\\n return True\",\n \"def ensure_share(self, context, share, share_server=None):\\n\\n volume_uuid = self._resolve_volume_name(share['name'],\\n share['project_id'])\\n\\n LOG.debug(\\\"Ensuring Quobyte share %s\\\", share['name'])\\n\\n if not volume_uuid:\\n raise (exception.ShareResourceNotFound(\\n share_id=share['id']))\\n\\n result = self.rpc.call('exportVolume', dict(\\n volume_uuid=volume_uuid,\\n protocol='NFS'))\\n\\n return self._build_share_export_string(result)\",\n \"def create_smb_share_with_path_tankrtacltest1share(driver, path):\\n assert wait_on_element(driver, 10, '//mat-list-item[@ix-auto=\\\"option__Shares\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-list-item[@ix-auto=\\\"option__Shares\\\"]').click()\\n assert wait_on_element(driver, 5, '//div[contains(.,\\\"Shares\\\")]')\\n assert wait_on_element(driver, 7, '//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]', 'clickable')\\n driver.find_element_by_xpath('//mat-card[contains(.,\\\"Windows (SMB) Shares\\\")]//button[contains(.,\\\"Add\\\")]').click()\\n assert wait_on_element(driver, 5, '//h3[contains(text(),\\\"Add SMB\\\")]')\\n global smb_path\\n smb_path = path\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__path\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__path\\\"]').send_keys(path)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'clickable')\\n checkbox_checked = attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n if not checkbox_checked:\\n driver.find_element_by_xpath('//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]').click()\\n assert attribute_value_exist(driver, '//mat-checkbox[@ix-auto=\\\"checkbox__Enabled\\\"]', 'class', 'mat-checkbox-checked')\\n time.sleep(1)\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Description\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Description\\\"]').send_keys(\\\"rt-test\\\")\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\\n assert wait_on_element_disappear(driver, 15, '//h6[contains(.,\\\"Please wait\\\")]')\\n if is_element_present(driver, '//h1[contains(., \\\"Enable service\\\")]'):\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__ENABLE SERVICE\\\"]').click()\\n assert wait_on_element(driver, 5, '//h1[contains(., \\\"SMB Service\\\")]')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__CLOSE\\\"]').click()\",\n \"def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:\\n ingest_shares = \\\"\\\"\\\"\\n UNWIND $shares_list as s\\n MERGE (share:AzureStorageFileShare{id: s.id})\\n ON CREATE SET share.firstseen = timestamp(), share.type = s.type\\n SET share.name = s.name,\\n share.lastupdated = $azure_update_tag,\\n share.lastmodifiedtime = s.last_modified_time,\\n share.sharequota = s.share_quota,\\n share.accesstier = s.access_tier,\\n share.deleted = s.deleted,\\n share.accesstierchangetime = s.access_tier_change_time,\\n share.accesstierstatus = s.access_tier_status,\\n share.deletedtime = s.deleted_time,\\n share.enabledprotocols = s.enabled_protocols,\\n share.remainingretentiondays = s.remaining_retention_days,\\n share.shareusagebytes = s.share_usage_bytes,\\n share.version = s.version\\n WITH share, s\\n MATCH (fs:AzureStorageFileService{id: s.service_id})\\n MERGE (fs)-[r:CONTAINS]->(share)\\n ON CREATE SET r.firstseen = timestamp()\\n SET r.lastupdated = $azure_update_tag\\n \\\"\\\"\\\"\\n\\n neo4j_session.run(\\n ingest_shares,\\n shares_list=shares,\\n azure_update_tag=update_tag,\\n )\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def _share_folder(self, nms, volume, folder):\\n path = '%s/%s' % (volume, folder.lstrip('/'))\\n share_opts = {\\n 'read_write': '*',\\n 'read_only': '',\\n 'root': 'nobody',\\n 'extra_options': 'anon=0',\\n 'recursive': 'true',\\n 'anonymous_rw': 'true',\\n }\\n LOG.debug('Sharing folder %s on Nexenta Store', folder)\\n nms.netstorsvc.share_folder('svc:/network/nfs/server:default', path,\\n share_opts)\",\n \"def test_synchronize_all_networks(self):\\n\\n # Store two tenants in a db and none on EOS.\\n # The sync should send details of all tenants to EOS\\n tenant_1_id = 'tenant-1'\\n tenant_1_net_1_id = 'ten-1-net-1'\\n tenant_1_net_1_seg_id = 11\\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id,\\n tenant_1_net_1_seg_id, 'segment_id_11')\\n\\n tenant_2_id = 'tenant-2'\\n tenant_2_net_1_id = 'ten-2-net-1'\\n tenant_2_net_1_seg_id = 21\\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id,\\n tenant_2_net_1_seg_id, 'segment_id_21')\\n\\n self.rpc.get_tenants.return_value = {}\\n\\n self.rpc.sync_start.return_value = True\\n self.rpc.sync_end.return_value = True\\n self.rpc.check_cvx_availability.return_value = True\\n\\n self.rpc._baremetal_supported.return_value = False\\n self.rpc.get_all_baremetal_hosts.return_value = {}\\n\\n self.sync_service.do_synchronize()\\n\\n expected_calls = [\\n mock.call.perform_sync_of_sg(self.sync_service._context),\\n mock.call.check_cvx_availability(),\\n mock.call.get_region_updated_time(),\\n mock.call.get_region_updated_time().__bool__(),\\n mock.call.sync_start(),\\n mock.call.register_with_eos(sync=True),\\n mock.call.check_supported_features(),\\n mock.call.get_tenants(),\\n\\n mock.call.create_network_bulk(\\n tenant_1_id,\\n [{'network_id': tenant_1_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n\\n mock.call.create_network_bulk(\\n tenant_2_id,\\n [{'network_id': tenant_2_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n mock.call.sync_end(),\\n mock.call.get_region_updated_time()\\n ]\\n\\n # The create_network_bulk() can be called in different order. So split\\n # it up. The first part checks if the initial set of methods are\\n # invoked.\\n idx = expected_calls.index(mock.call.get_tenants()) + 1\\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 1 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 2 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if the sync end methods are invoked.\\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\\n expected_calls[idx + 2:],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n\\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id)\\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_kyc_delete_legal_share_holder_natural(self):\\n pass\",\n \"def test_networking_project_network_update(self):\\n pass\",\n \"def test_update_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def is_nas_server_matched(nas_server, nfs_export_details):\\n\\n nas_id_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['id']\\n nas_name_from_details = \\\\\\n nfs_export_details['file_system']['nas_server']['name']\\n\\n if nfs_export_details and nas_server:\\n if utils.name_or_id(nas_server) == \\\"ID\\\" and \\\\\\n nas_id_from_details != nas_server:\\n return False\\n if utils.name_or_id(nas_server) == \\\"NAME\\\" and \\\\\\n nas_name_from_details != nas_server:\\n return False\\n return True\",\n \"def test_update_network(self):\\n policies_ports = [\\n (None, {self.ports[0].id}),\\n (self.qos_policies[1].id, {self.ports[0].id})]\\n\\n self.ports[1].qos_policy_id = self.qos_policies[0].id\\n self.ports[1].update()\\n self.ports[2].qos_policy_id = self.qos_policies[1].id\\n self.ports[2].update()\\n for qos_policy_id, reference_ports in policies_ports:\\n self.networks[0].qos_policy_id = qos_policy_id\\n self.networks[0].update()\\n original_network = {'qos_policy_id': self.qos_policies[0]}\\n reviewed_port_ids, _, _ = self.qos_driver.update_network(\\n mock.ANY, self.networks[0], original_network)\\n self.assertEqual(reference_ports, reviewed_port_ids)\\n calls = [mock.call(mock.ANY, self.ports[0].id,\\n self.ports[0].network_id, qos_policy_id,\\n None)]\\n self.mock_rules.assert_has_calls(calls)\\n self.mock_rules.reset_mock()\",\n \"def test_kyc_put_document_shareholder(self):\\n pass\",\n \"def test_056_netbios_name_change_check_sid(request):\\n depends(request, [\\\"service_cifs_running\\\"], scope=\\\"session\\\")\\n global new_sid\\n global old_netbiosname\\n\\n results = GET(\\\"/smb/\\\")\\n assert results.status_code == 200, results.text\\n old_netbiosname = results.json()[\\\"netbiosname\\\"]\\n old_sid = results.json()[\\\"cifs_SID\\\"]\\n\\n payload = {\\n \\\"netbiosname\\\": \\\"nb_new\\\",\\n }\\n results = PUT(\\\"/smb/\\\", payload)\\n assert results.status_code == 200, results.text\\n new_sid_resp = results.json()[\\\"cifs_SID\\\"]\\n assert old_sid != new_sid_resp, results.text\\n sleep(5)\\n\\n results = GET(\\\"/smb/\\\")\\n assert results.status_code == 200, results.text\\n new_sid = results.json()[\\\"cifs_SID\\\"]\\n assert new_sid != old_sid, results.text\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def share_replica_update(context, share_replica_id, values,\\n with_share_data=False, session=None):\\n session = session or get_session()\\n\\n with session.begin():\\n _ensure_availability_zone_exists(context, values, session,\\n strict=False)\\n updated_share_replica = _share_instance_update(\\n context, share_replica_id, values, session=session)\\n\\n if with_share_data:\\n updated_share_replica = _set_instances_share_data(\\n context, updated_share_replica, session)[0]\\n\\n return updated_share_replica\",\n \"def test_synchronize_one_network(self):\\n\\n # Store two tenants in a db and a single tenant in EOS.\\n # The sync should send details of the second tenant to EOS\\n tenant_1_id = 'tenant-1'\\n tenant_1_net_1_id = 'ten-1-net-1'\\n tenant_1_net_1_seg_id = 11\\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id,\\n tenant_1_net_1_seg_id, 'segment_id_11')\\n\\n tenant_2_id = 'tenant-2'\\n tenant_2_net_1_id = 'ten-2-net-1'\\n tenant_2_net_1_seg_id = 21\\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id,\\n tenant_2_net_1_seg_id, 'segment_id_21')\\n\\n self.rpc.get_tenants.return_value = {\\n tenant_1_id: {\\n 'tenantVmInstances': {},\\n 'tenantBaremetalInstances': {},\\n 'tenantNetworks': {\\n tenant_1_net_1_id: {\\n 'networkId': tenant_1_net_1_id,\\n 'shared': False,\\n 'networkName': 'Net1',\\n 'segmenationType': 'vlan',\\n 'segmentationTypeId': tenant_1_net_1_seg_id,\\n }\\n }\\n }\\n }\\n\\n self.rpc.sync_start.return_value = True\\n self.rpc.sync_end.return_value = True\\n self.rpc.check_cvx_availability.return_value = True\\n\\n self.rpc._baremetal_supported.return_value = False\\n self.rpc.get_all_baremetal_hosts.return_value = {}\\n\\n self.sync_service.do_synchronize()\\n\\n expected_calls = [\\n mock.call.perform_sync_of_sg(self.sync_service._context),\\n mock.call.check_cvx_availability(),\\n mock.call.get_region_updated_time(),\\n mock.call.get_region_updated_time().__bool__(),\\n mock.call.sync_start(),\\n mock.call.register_with_eos(sync=True),\\n mock.call.check_supported_features(),\\n mock.call.get_tenants(),\\n\\n mock.call.create_network_bulk(\\n tenant_2_id,\\n [{'network_id': tenant_2_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n\\n mock.call.sync_end(),\\n mock.call.get_region_updated_time()\\n ]\\n\\n self.assertTrue(self.rpc.mock_calls == expected_calls,\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n\\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id)\\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)\",\n \"async def test_endpoint_delete_share_correct(self):\\n with self.patch_json_dump:\\n resp = await delete_share_handler(self.mock_request)\\n self.assertEqual(resp.status, 204)\",\n \"def sendShare(self, program_counter, share):\\n self.sendData(program_counter, SHARE, hex(share.value))\",\n \"def test_auth_sharable_can_share(self):\\n self.do_sharable(True, 'pattieblack', FakeMembership(True),\\n tenant='froggy')\",\n \"def test_wrong_config_shares1(self):\\n config = {'source': 'gsiftp://source', 'destination': 'gsiftp://nowhere', 'vo': 'dteam', 'share': 80}\\n\\n for i in config:\\n k = config\\n k[i] = ''\\n print k\\n self.app.post_json(url=\\\"/config/shares\\\", params=k, status=400)\\n return config\",\n \"def test_sell_shares_success(self):\\n\\t\\texpected_response_code = 200\\n\\t\\tsymbol = \\\"DDD\\\" \\n\\t\\tquantity = 100\\n\\t\\t\\n\\t\\tdisplayName, email, password = (\\\"John Doe\\\", \\\"johndoe@test.com\\\", \\\"12345678\\\")\\n\\t\\tregistration_response = ApiFacade.register_user(displayName, email, password)\\n\\t\\tauthentication_response = ApiFacade.authenticate_user(email, password)\\n\\t\\ttoken = authentication_response.get_token()\\n\\n\\t\\t# get account id\\n\\t\\tviewdetails_response = ApiFacade.view_details(token)\\n\\t\\taccount_id = viewdetails_response.get_main_account_id()\\n\\n\\t\\t# buy shares first\\n\\t\\tbuyshare_response = ApiFacade.buy_share(token, account_id, symbol, int(quantity))\\n\\t\\t\\n\\t\\t# sell the shares\\n\\t\\tsellshare_response = ApiFacade.sell_share(token, account_id, symbol, int(quantity / 3))\\n\\n\\t\\tdeletion_response = ApiFacade.delete_user(token)\\n\\n\\t\\tself.assertEqual(sellshare_response.get_http_status(), expected_response_code, \\n\\t\\t\\tmsg = \\\"Expected HTTP{0}; got HTTP{1}\\\"\\n\\t\\t\\t.format(expected_response_code, sellshare_response.get_http_status()))\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_put_nveto_pmt_item(self):\\n pass\",\n \"def test_update_pci_switch(self):\\n pass\",\n \"def test_shared_table(self, test_info):\\n\\n test_results = test_info\\n\\n # execute request\\n try:\\n\\n # Step 1: Get the list of public tables\\n tables = self.gaia.load_tables(only_names=True)\\n # Now we will keep the number of results returned\\n n_public_tables = len(tables)\\n log.debug(f'N public tables is {n_public_tables}')\\n\\n # Step 2: Now we need to do login in to de Gaia Tap.\\n\\n # Now we can do the login()\\n self.gaia.login(user=credentials.USERNAME, password=credentials.PASSWORD)\\n\\n # Step 3: Now we are going to execute again 'load_tables' but now specifying that we also want to list\\n # the tables that we are sharing with other users from our user_schema.\\n all_tables = self.gaia.load_tables(only_names=True, include_shared_tables=True)\\n # Let's keep now the number of results returned\\n n_shared_tables = len(all_tables)\\n log.debug(f'N all tables is {n_shared_tables}')\\n\\n # Step 4: Finally we will do a logout from the system.\\n self.gaia.logout()\\n\\n # Get current time to complete our result object\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n test_results['test_finished'] = f'{time_str} CET'\\n\\n # Now let's have a look at the results for our test. If the number of tables returned as this second step\\n # is equal or higher than the number of public tables the test is correct.\\n if n_public_tables <= n_shared_tables:\\n # Test passed\\n test_results['test_result'] = PASSED\\n debug_message = f'The number of shared tables: {n_shared_tables} is major or equal than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n log.debug(debug_message)\\n test_results['test_additional_info'] = debug_message + \\\" Test PASSED!\\\"\\n else:\\n test_results['test_result'] = NOT_PASSED\\n error_message = f'The number of shared tables: {n_shared_tables} is less than the number ' \\\\\\n f'of public tables: {n_public_tables}'\\n test_results['test_additional_info'] = error_message\\n log.error(error_message)\\n raise ValueError(error_message)\\n self.gaia.logout()\\n return test_results\\n\\n except ValueError as err:\\n log.error(str(err))\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = str(err)\\n self.gaia.logout()\\n return test_results\\n except HTTPError as err:\\n\\n error_message = \\\"Error connecting TAP server\\\"\\n log.error(error_message)\\n\\n # Get current time\\n time = datetime.now()\\n time_str = time.strftime('%Y-%m-%d %H:%M:%S')\\n # fill result object with the info from the http error\\n test_results['test_finished'] = f'{time_str} CET'\\n test_results['test_result'] = NOT_PASSED\\n test_results['test_additional_info'] = error_message + \\\",\\\" + str(err)\\n self.gaia.logout()\\n return test_results\",\n \"def test_updating_a_segment(self):\\n pass\",\n \"def test_add_asset_share_feed(self):\\n pass\",\n \"def test_data_source_soaps_id_put(self):\\n pass\",\n \"def test_update_hyperflex_server_model(self):\\n pass\",\n \"async def test_update(aresponses):\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/system/status\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"system-status.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n async with ClientSession() as session:\\n client = Sonarr(HOST, API_KEY, session=session)\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\\n\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\",\n \"def test_update_pci_device(self):\\n pass\",\n \"def test_create_get_delete_update_node(self):\\n node_dict_1 = {\\n 'host_name': 'abc',\\n 'local_router_id': '1.1.1.1',\\n 'as_num': 100,\\n 'bgpls_id': '0.0.0.0',\\n 'igp_id': '0.0.0.0'\\n }\\n node_dict_2 = {\\n 'host_name': 'def',\\n 'local_router_id': '2.2.2.2',\\n 'as_num': 100,\\n 'bgpls_id': '0.0.0.0',\\n 'igp_id': '0.0.0.0'\\n }\\n\\n # create two objects\\n node1 = Node(**node_dict_1)\\n node2 = Node(**node_dict_2)\\n Node.create_object(self.database, node1.__dict__)\\n Node.create_object(self.database, node2.__dict__)\\n self.assertEqual(2, Node.count(self.database))\\n\\n # get one object\\n node1 = Node.get_object(self.database, host_name='abc')\\n self.assertEqual(node_dict_1['local_router_id'], node1.get('local_router_id'))\\n\\n # get objects\\n nodes = Node.get_objects(self.database, as_num=100)\\n self.assertEqual(2, len(nodes))\\n\\n # update one object\\n self.assertEqual(0, Node.count(self.database, local_router_id='3.3.3.3'))\\n node_db_obj = Node.update_object(\\n self.database, {'local_router_id': '3.3.3.3'}, host_name='abc')\\n self.assertEqual('3.3.3.3', node_db_obj.get('local_router_id'))\\n self.assertEqual(1, Node.count(self.database, local_router_id='3.3.3.3'))\\n\\n # update more than objects\\n self.assertEqual(2, Node.count(self.database, as_num=100))\\n update_count = Node.update_objects(\\n self.database, {'as_num': 200}, igp_id='0.0.0.0')\\n self.assertEqual(2, update_count)\\n self.assertEqual(2, Node.count(self.database, as_num=200))\\n\\n # delete objects\\n Node.delete_object(self.database, host_name='abc')\\n self.assertEqual(1, Node.count(self.database))\",\n \"def test_update_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_replace_cluster_network(self):\\n pass\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_update_external_network(self):\\n network_policies = [(self.qos_policies[1].id,\\n {self.fips[1].id},\\n {self.router_fips.id}),\\n (None,\\n {self.fips[1].id},\\n {self.router_fips.id})]\\n\\n self.fips[0].qos_policy_id = self.qos_policies[0].id\\n self.fips[0].update()\\n for qos_policy_id, ref_fips, ref_routers in network_policies:\\n self.fips_network.qos_policy_id = qos_policy_id\\n self.fips_network.update()\\n original_network = {'qos_policy_id': self.qos_policies[0]}\\n _, reviewed_fips_ids, reviewed_router_ids = (\\n self.qos_driver.update_network(\\n mock.Mock(), self.fips_network, original_network))\\n self.assertEqual(ref_fips, reviewed_fips_ids)\\n self.assertEqual(ref_routers, reviewed_router_ids)\",\n \"def test_update_node_driveconfig(self):\\n pass\",\n \"def test_update_sim():\\n # Generate a random set of parameters, a random start date, and a Chromosome\\n r_start_date, r_end_date = sga.generate_random_dates()\\n r_param_ids = wp.flexible_generate()\\n individual = sga.Chromosome(r_param_ids, fitness=100, start_date=r_start_date, end_date=r_end_date)\\n # Put individual in the database\\n db_conn = conn_to_db('optwrf_repeat.db')\\n owp.insert_sim(individual, db_conn)\\n print_database(db_conn)\\n # Generate a new random start date and a Chromosome\\n r_start_date, r_end_date = sga.generate_random_dates()\\n individual = sga.Chromosome(r_param_ids, fitness=50, start_date=r_start_date, end_date=r_end_date)\\n # Update the individual in the database database\\n owp.update_sim(individual, db_conn)\\n print_database(db_conn)\",\n \"def share(source, dest, branch=None, revision=None):\\n run_cmd(['hg', 'share', '-U', source, dest])\\n return update(dest, branch=branch, revision=revision)\",\n \"def dvs_update_network(self):\\n self.show_step(1)\\n self.env.revert_snapshot(\\\"dvs_vcenter_systest_setup\\\")\\n\\n cluster_id = self.fuel_web.get_last_created_cluster()\\n\\n self.show_step(2)\\n os_ip = self.fuel_web.get_public_vip(cluster_id)\\n os_conn = os_actions.OpenStackActions(\\n os_ip, SERVTEST_USERNAME,\\n SERVTEST_PASSWORD,\\n SERVTEST_TENANT)\\n\\n tenant = os_conn.get_tenant(SERVTEST_TENANT)\\n\\n net_1 = os_conn.create_network(\\n network_name=self.net_data[0].keys()[0],\\n tenant_id=tenant.id)['network']\\n\\n os_conn.create_subnet(\\n subnet_name=net_1['name'],\\n network_id=net_1['id'],\\n cidr=self.net_data[0][self.net_data[0].keys()[0]],\\n ip_version=4)\\n\\n assert_true(os_conn.get_network(net_1['name'])['id'] == net_1['id'])\\n\\n self.show_step(3)\\n os_conn.neutron.update_network(net_1[\\\"id\\\"],\\n {\\\"network\\\": {\\\"name\\\": 'net_2'}})\\n\\n assert_true(os_conn.get_network('net_2')['id'] == net_1['id'])\\n\\n self.show_step(4)\\n default_net = os_conn.nova.networks.find(label=self.inter_net_name)\\n os_conn.neutron.update_network(\\n default_net.id, {\\\"network\\\": {\\\"name\\\": 'spring'}})\\n\\n assert_true(os_conn.get_network('spring')['id'] == default_net.id)\",\n \"def allow_access_nfs(self, pool, project, share, access):\\n if access['access_type'] != 'ip':\\n reason = _('Only ip access type allowed.')\\n raise exception.InvalidShareAccess(reason)\\n\\n ip = access['access_to']\\n details = self.get_share(pool, project, share)\\n sharenfs = details['sharenfs']\\n\\n if sharenfs == 'on' or sharenfs == 'rw':\\n LOG.debug('Share %s has read/write permission '\\n 'open to all.', share)\\n return\\n if sharenfs == 'off':\\n sharenfs = 'sec=sys'\\n if ip in sharenfs:\\n LOG.debug('Access to share %(share)s via NFS '\\n 'already granted to %(ip)s.',\\n {'share': share,\\n 'ip': ip})\\n return\\n\\n entry = (',rw=@%s' % ip)\\n if '/' not in ip:\\n entry = \\\"%s/32\\\" % entry\\n arg = {'sharenfs': sharenfs + entry}\\n self.modify_share(pool, project, share, arg)\",\n \"def test_update_instance_limit1(self):\\n pass\",\n \"def test_patch_cluster_network(self):\\n pass\",\n \"def sync_nas(self, users_from_db: Iterator):\",\n \"def share(self, share):\\n if share is None:\\n raise ValueError(\\\"Invalid value for `share`, must not be `None`\\\") # noqa: E501\\n\\n self._share = share\",\n \"def canShare(self):\\n return False\",\n \"def test_ap_anqp_sharing(dev, apdev):\\n bssid = apdev[0]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n hostapd.add_ap(apdev[0]['ifname'], params)\\n\\n bssid2 = apdev[1]['bssid']\\n params = hs20_ap_params()\\n params['hessid'] = bssid\\n params['nai_realm'] = [ \\\"0,example.com,13[5:6],21[2:4][5:7]\\\" ]\\n hostapd.add_ap(apdev[1]['ifname'], params)\\n\\n dev[0].hs20_enable()\\n id = dev[0].add_cred_values({ 'realm': \\\"example.com\\\", 'username': \\\"test\\\",\\n 'password': \\\"secret\\\",\\n 'domain': \\\"example.com\\\" })\\n logger.info(\\\"Normal network selection with shared ANQP results\\\")\\n interworking_select(dev[0], None, \\\"home\\\", freq=\\\"2412\\\")\\n dev[0].dump_monitor()\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] != res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not shared between BSSes\\\")\\n\\n logger.info(\\\"Explicit ANQP request to unshare ANQP results\\\")\\n dev[0].request(\\\"ANQP_GET \\\" + bssid + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n dev[0].request(\\\"ANQP_GET \\\" + bssid2 + \\\" 263\\\")\\n ev = dev[0].wait_event([\\\"RX-ANQP\\\"], timeout=5)\\n if ev is None:\\n raise Exception(\\\"ANQP operation timed out\\\")\\n\\n res1 = dev[0].get_bss(bssid)\\n res2 = dev[0].get_bss(bssid2)\\n if res1['anqp_nai_realm'] == res2['anqp_nai_realm']:\\n raise Exception(\\\"ANQP results were not unshared\\\")\",\n \"def ft_syndicate_access():\\n \\n fake_user = FakeObject()\\n fake_user.email = \\\"fakeuser@opencloud.us\\\"\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_user_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_user_exists( fake_user.email, is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n fake_volume = FakeObject()\\n fake_volume.name = \\\"fakevolume\\\"\\n fake_volume.description = \\\"This is a fake volume, created for funtional testing\\\"\\n fake_volume.blocksize = 1024\\n fake_volume.cap_read_data = True \\n fake_volume.cap_write_data = True \\n fake_volume.cap_host_data = False\\n fake_volume.archive = False\\n fake_volume.private = True\\n \\n # test idempotency\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_exists(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_exists( fake_user.email, fake_volume.name, 31 )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_access_right_absent(%s,%s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n ensure_volume_access_right_absent( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n\\n print \\\"\\\\nensure_user_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_user_absent( fake_user.email )\\n \\n \\n \\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n \\n print \\\"\\\\nensure_principal_exists(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_exists( fake_user.email, \\\"asdf\\\", is_admin=False, max_UGs=1100, max_RGs=1 )\\n\\n print \\\"\\\\nensure_volume_exists(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_exists( fake_user.email, fake_volume )\\n\\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nsetup_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name)\\n setup_volume_access( fake_user.email, fake_volume.name, 31, 38800, \\\"abcdef\\\" )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nteardown_volume_access(%s, %s)\\\\n\\\" % (fake_user.email, fake_volume.name )\\n teardown_volume_access( fake_user.email, fake_volume.name )\\n \\n print \\\"\\\\nensure_volume_absent(%s)\\\\n\\\" % fake_volume.name\\n ensure_volume_absent( fake_volume.name )\\n\\n print \\\"\\\\nensure_principal_absent(%s)\\\\n\\\" % fake_user.email\\n ensure_principal_absent( fake_user.email )\",\n \"def test_update_software_asset(self):\\n pass\",\n \"def test_update_ban(self):\\n pass\",\n \"def test_update_device(self):\\n pass\",\n \"def test_update_device(self):\\n pass\",\n \"def test_empty_shared(self):\\n self.do_sharable(False, 'pattieblack', None, is_admin=True)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True),\\n is_admin=True)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.92568874","0.868185","0.8243654","0.8035217","0.79071957","0.7904033","0.7861192","0.7808969","0.75646436","0.75128955","0.749248","0.7425515","0.71185464","0.7093589","0.70677394","0.70360464","0.6987904","0.6672082","0.6565424","0.65342563","0.6251355","0.6204242","0.62037355","0.61409694","0.61137456","0.60878515","0.60003644","0.59876287","0.5979453","0.58014876","0.57767063","0.5765247","0.57590806","0.5752426","0.57499844","0.57487285","0.56572074","0.5632845","0.5629986","0.56296813","0.559014","0.5577319","0.55651253","0.55448455","0.5529983","0.5503671","0.5475324","0.5456383","0.5447113","0.54395854","0.54102284","0.5398019","0.53935516","0.53910035","0.5368328","0.53592545","0.53258324","0.5318741","0.529417","0.52872753","0.52838427","0.52795","0.5276246","0.5255975","0.5254881","0.5250297","0.5241474","0.52300614","0.52205443","0.52136946","0.51973116","0.51669085","0.51568085","0.51484054","0.513056","0.51282406","0.51252174","0.5118234","0.5110531","0.510891","0.5106072","0.5095922","0.50888306","0.5088388","0.5070004","0.5058177","0.50578296","0.5054825","0.50531095","0.50483793","0.5048063","0.50347114","0.5033477","0.5031594","0.50303847","0.5028308","0.5023666","0.5021966","0.5021966","0.5008347"],"string":"[\n \"0.92568874\",\n \"0.868185\",\n \"0.8243654\",\n \"0.8035217\",\n \"0.79071957\",\n \"0.7904033\",\n \"0.7861192\",\n \"0.7808969\",\n \"0.75646436\",\n \"0.75128955\",\n \"0.749248\",\n \"0.7425515\",\n \"0.71185464\",\n \"0.7093589\",\n \"0.70677394\",\n \"0.70360464\",\n \"0.6987904\",\n \"0.6672082\",\n \"0.6565424\",\n \"0.65342563\",\n \"0.6251355\",\n \"0.6204242\",\n \"0.62037355\",\n \"0.61409694\",\n \"0.61137456\",\n \"0.60878515\",\n \"0.60003644\",\n \"0.59876287\",\n \"0.5979453\",\n \"0.58014876\",\n \"0.57767063\",\n \"0.5765247\",\n \"0.57590806\",\n \"0.5752426\",\n \"0.57499844\",\n \"0.57487285\",\n \"0.56572074\",\n \"0.5632845\",\n \"0.5629986\",\n \"0.56296813\",\n \"0.559014\",\n \"0.5577319\",\n \"0.55651253\",\n \"0.55448455\",\n \"0.5529983\",\n \"0.5503671\",\n \"0.5475324\",\n \"0.5456383\",\n \"0.5447113\",\n \"0.54395854\",\n \"0.54102284\",\n \"0.5398019\",\n \"0.53935516\",\n \"0.53910035\",\n \"0.5368328\",\n \"0.53592545\",\n \"0.53258324\",\n \"0.5318741\",\n \"0.529417\",\n \"0.52872753\",\n \"0.52838427\",\n \"0.52795\",\n \"0.5276246\",\n \"0.5255975\",\n \"0.5254881\",\n \"0.5250297\",\n \"0.5241474\",\n \"0.52300614\",\n \"0.52205443\",\n \"0.52136946\",\n \"0.51973116\",\n \"0.51669085\",\n \"0.51568085\",\n \"0.51484054\",\n \"0.513056\",\n \"0.51282406\",\n \"0.51252174\",\n \"0.5118234\",\n \"0.5110531\",\n \"0.510891\",\n \"0.5106072\",\n \"0.5095922\",\n \"0.50888306\",\n \"0.5088388\",\n \"0.5070004\",\n \"0.5058177\",\n \"0.50578296\",\n \"0.5054825\",\n \"0.50531095\",\n \"0.50483793\",\n \"0.5048063\",\n \"0.50347114\",\n \"0.5033477\",\n \"0.5031594\",\n \"0.50303847\",\n \"0.5028308\",\n \"0.5023666\",\n \"0.5021966\",\n \"0.5021966\",\n \"0.5008347\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.95343274"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81389,"cells":{"query":{"kind":"string","value":"Test case for update_nas_share_by_pool"},"document":{"kind":"string","value":"def test_update_nas_share_by_pool(self):\n pass"},"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_update_nas_share_by_nas(self):\n pass","def test_update_nas_share(self):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def test_show_nas_share_by_pool(self):\n pass","def test_destroy_nas_share_by_pool(self):\n pass","def test_mount_status_nas_share_by_pool(self):\n pass","def test_test_nas_share(self):\n pass","def test_create_nas_share_by_nas(self):\n pass","def test_test_result_nas_share(self):\n pass","def test_destroy_nas_share_by_nas(self):\n pass","def test_index_nas_shares_by_nas(self):\n pass","def test_show_nas_share_by_nas(self):\n pass","def test_destroy_nas_share(self):\n pass","def test_show_nas_share(self):\n pass","def test_mount_status_nas_share_by_nas(self):\n pass","def test_index_nas_shares(self):\n pass","def test_share(self):\n\n # In the actual test, we'll want to confirm that an IP address\n # can be shared to a group\n\n # Try to share with the group--fails for now (operation not\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.share_ip, 1, '10.0.0.1', True)","def test_mount_status_nas_share(self):\n pass","def test_update_pool(self):\r\n resource = 'pool'\r\n cmd = pool.UpdatePool(test_cli20.MyApp(sys.stdout), None)\r\n self._test_update_resource(resource, cmd, 'myid',\r\n ['myid', '--name', 'newname'],\r\n {'name': 'newname', })","def test_share_38(self):\n with self.os_environ_get_patch, \\\n self.patch_push_share, \\\n self.patch_subprocess_call, \\\n self.sys_version_38_patch:\n self.inst.share(\n \"test-container\",\n \"test-recipient\",\n \"r\",\n \"w\"\n )\n self.subprocess_call_mock.assert_called_once()\n self.push_share_mock.assert_awaited_once()","def test_unshare(self):\n\n # In the actual test, we'll want to confirm that a shared IP\n # address can be unshared from a group\n\n # Try to unshare from the group--fails for now (operation not\n # implemented in nova); note: change '10.0.0.1' to IP\n dtutil.assert_raises(novaclient.OpenStackException,\n self.server.unshare_ip, '10.0.0.1')","def test_update_hyperflex_cluster_network_policy(self):\n pass","def test_kyc_put_legal_share_holder(self):\n pass","def test_edit_share(self, client):\n user = UserFactory(email='bob@gmail.com')\n client = self.get_auth_client(user)\n\n i1 = InstitutionFactory.get_institution()\n item = ItemFactory.get_item(user=user, institution=i1)\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\n item = ItemFactory.get_item(user=user, institution=i2)\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\n\n url = '/v1/accounts/edit_share'\n\n # ids not match\n dic = {\n 'id100': 50,\n 'id200': 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n return\n\n # The total sum not equal to 100\n dic = {\n 'id{}'.format(a1.id): 10,\n 'id{}'.format(a2.id): 20\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 400\n\n # success\n dic = {\n 'id{}'.format(a1.id): 50,\n 'id{}'.format(a2.id): 50\n }\n data = json.dumps(dic)\n response = client.put(url, data, content_type='application/json')\n assert response.status_code == 200\n\n a1.refresh_from_db()\n a2.refresh_from_db()\n\n assert a1.transfer_share == 50\n assert a1.transfer_share == 50","def test_update_hyperflex_cluster(self):\n pass","def test_share_distributor(self):\n\n # =================================================================\n # test: complete test, share distribution int\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\n StockOrderWrapper(self.order_12)]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_real_3 = result[0]\n order_real_4 = result[1]\n order_real_7 = result[2]\n order_real_8 = result[3]\n order_real_11 = result[4]\n order_real_12 = result[5]\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n\n order_exp_3 = StockOrderWrapper(self.order_3)\n order_exp_4 = StockOrderWrapper(self.order_4)\n order_exp_7 = StockOrderWrapper(self.order_7)\n order_exp_8 = StockOrderWrapper(self.order_8)\n order_exp_11 = StockOrderWrapper(self.order_11)\n order_exp_12 = StockOrderWrapper(self.order_12)\n\n order_exp_3.transaction_dict = sell_order_dict_1\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_2\n order_exp_11.transaction_dict = sell_order_dict_2\n order_exp_12.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 4\n order_exp_4.shares_left = 8\n order_exp_7.shares_left = 8\n order_exp_8.shares_left = 8\n order_exp_11.shares_left = 8\n order_exp_12.shares_left = 4\n\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\n\n # =================================================================\n # test: share distribution float easy\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 6\n buy_order_3.shares_left = 8 # 2.4 -> 3\n buy_order_4.shares_left = 4 # 1.2 -> 1\n buy_order_7.shares_left = 4 # 1.2 -> 1\n buy_order_8.shares_left = 4 # 1.2 -> 1\n buy_order_11.shares_left = 0 # 0.0 -> 0\n buy_order_12.shares_left = 0 # 0.0 -> 0\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[4]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_3 = {sell: 3}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_1\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n\n order_exp_3.shares_left = 5\n order_exp_4.shares_left = 3\n order_exp_7.shares_left = 3\n order_exp_8.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n\n # =================================================================\n # test: share distribution float complex (multiple float iterations)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 18\n sell.stock_order.order_status = DEFINITIVE\n\n self.order_3.order_status = DEFINITIVE\n self.order_4.order_status = DEFINITIVE\n self.order_7.order_status = DEFINITIVE\n self.order_8.order_status = DEFINITIVE\n self.order_11.order_status = DEFINITIVE\n self.order_12.order_status = DEFINITIVE\n\n buy_order_3.shares_left = 6 # 3.6 -> 4\n buy_order_4.shares_left = 4 # 2.4 -> 2\n buy_order_7.shares_left = 2 # 1.2 -> 1\n buy_order_8.shares_left = 2 # 1.2 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_2\n order_exp_7.transaction_dict = sell_order_dict_1\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 2\n order_exp_4.shares_left = 2\n order_exp_7.shares_left = 1\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution date (two stocks left after one float iteration)\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n sell.shares_left = 19\n\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n result_dict = {}\n\n for res in result:\n result_dict[res.stock_order.order_id] = res\n\n try:\n # noinspection PyUnusedLocal\n dummy = result[6]\n raise AssertionError(\"IndexError exception expected\")\n except IndexError:\n pass\n\n sell_order_dict_1 = {sell: 1}\n sell_order_dict_2 = {sell: 2}\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_5 = {sell: 5}\n\n order_exp_3.transaction_dict = sell_order_dict_3\n order_exp_4.transaction_dict = sell_order_dict_3\n order_exp_7.transaction_dict = sell_order_dict_2\n order_exp_8.transaction_dict = sell_order_dict_1\n order_exp_11.transaction_dict = sell_order_dict_5\n order_exp_12.transaction_dict = sell_order_dict_5\n\n order_exp_3.shares_left = 1\n order_exp_4.shares_left = 1\n order_exp_7.shares_left = 2\n order_exp_8.shares_left = 1\n order_exp_11.shares_left = 3\n order_exp_12.shares_left = 3\n\n order_exp_11.order_status = DEFINITIVE\n order_exp_12.order_status = DEFINITIVE\n\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\n\n # =================================================================\n # test: share distribution int sell shares left\n # =================================================================\n\n sell_list = [StockOrderWrapper(self.order_2)]\n sell = sell_list[0]\n\n sell.shares_left = 100\n\n buy_order_3 = StockOrderWrapper(self.order_3)\n buy_order_4 = StockOrderWrapper(self.order_4)\n buy_order_7 = StockOrderWrapper(self.order_7)\n buy_order_8 = StockOrderWrapper(self.order_8)\n buy_order_11 = StockOrderWrapper(self.order_11)\n buy_order_12 = StockOrderWrapper(self.order_12)\n\n buy_order_3.shares_left = 4\n buy_order_4.shares_left = 7\n buy_order_7.shares_left = 9\n buy_order_8.shares_left = 4\n buy_order_11.shares_left = 8\n buy_order_12.shares_left = 3\n\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\n\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\n\n order_exp_2 = StockOrderWrapper(self.order_2)\n order_exp_2.shares_left = 65\n\n self.is_equal_order_wrapper(result[0], order_exp_2)\n\n sell_order_dict_3 = {sell: 3}\n sell_order_dict_4 = {sell: 4}\n sell_order_dict_7 = {sell: 7}\n sell_order_dict_8 = {sell: 8}\n sell_order_dict_9 = {sell: 9}\n\n order_exp_3.transaction_dict = sell_order_dict_4\n order_exp_4.transaction_dict = sell_order_dict_7\n order_exp_7.transaction_dict = sell_order_dict_9\n order_exp_8.transaction_dict = sell_order_dict_4\n order_exp_11.transaction_dict = sell_order_dict_8\n order_exp_12.transaction_dict = sell_order_dict_3\n\n order_exp_3.shares_left = 0\n order_exp_4.shares_left = 0\n order_exp_7.shares_left = 0\n order_exp_8.shares_left = 0\n order_exp_11.shares_left = 0\n order_exp_12.shares_left = 0\n\n order_exp_3.order_status = PROCESSED\n order_exp_4.order_status = PROCESSED\n order_exp_7.order_status = PROCESSED\n order_exp_8.order_status = PROCESSED\n order_exp_11.order_status = PROCESSED\n order_exp_12.order_status = PROCESSED\n\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)","async def test_change_pools(self, setup, trusted_and_fee, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n pool_a_ph = receive_address[1]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_b_ph = await wallets[1].get_new_puzzlehash()\n full_node_api = full_nodes[0]\n\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n WAIT_SECS = 200\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n pool_a_ph, \"https://pool-a.org\", 5, f\"{self_hostname}:5000\", \"new\", \"FARMING_TO_POOL\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status.target is None\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n assert pw_info.current.pool_url == \"https://pool-a.org\"\n assert pw_info.current.relative_lock_height == 5\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_b_ph,\n \"https://pool-b.org\",\n 10,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n\n async def status_is_leaving():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving)\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n assert pw_info.current.pool_url == \"https://pool-b.org\"\n assert pw_info.current.relative_lock_height == 10\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_set_share(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=200\n )","async def test_change_pools_reorg(self, setup, trusted_and_fee, bt, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n pool_a_ph = receive_address[1]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_b_ph = await wallets[1].get_new_puzzlehash()\n full_node_api = full_nodes[0]\n WAIT_SECS = 30\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n pool_a_ph, \"https://pool-a.org\", 5, f\"{self_hostname}:5000\", \"new\", \"FARMING_TO_POOL\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status.target is None\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n assert pw_info.current.pool_url == \"https://pool-a.org\"\n assert pw_info.current.relative_lock_height == 5\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_b_ph,\n \"https://pool-b.org\",\n 10,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n join_pool_tx.spend_bundle,\n join_pool_tx.name,\n )\n await farm_blocks(full_node_api, our_ph, 1)\n\n async def status_is_leaving_no_blocks():\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n async def status_is_farming_to_pool_no_blocks():\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving_no_blocks)\n\n current_blocks = await full_node_api.get_all_full_blocks()\n more_blocks = full_node_api.bt.get_consecutive_blocks(\n 3,\n farmer_reward_puzzle_hash=pool_a_ph,\n pool_reward_puzzle_hash=pool_b_ph,\n block_list_input=current_blocks[:-1],\n force_overflow=True,\n guarantee_transaction_block=True,\n seed=32 * b\"4\",\n transaction_data=join_pool_tx.spend_bundle,\n )\n\n for block in more_blocks[-3:]:\n await full_node_api.full_node.respond_block(RespondBlock(block))\n\n await asyncio.sleep(5)\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving_no_blocks)\n\n # Eventually, leaves pool\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_update_hyperflex_cluster_storage_policy(self):\n pass","def test_thread_pool(self):\n self.assertIdentical(self.tx_client._pool, self.pool)","def modify_share(self, pool, project, share, arg):\n svc = self.share_path % (pool, project, share)\n ret = self.rclient.put(svc, arg)\n if ret.status != restclient.Status.ACCEPTED:\n exception_msg = (_('Error modifying %(arg)s '\n ' of share %(id)s.')\n % {'arg': arg,\n 'id': share})\n raise exception.ShareBackendException(msg=exception_msg)","def update_pool(self, pool, body=None):\r\n return self.put(self.pool_path % (pool), body=body)","def test_dashboards_v2_share(self):\n pass","def test_update_non_shareable(self):\n self.create_common_users_and_groups()\n sync = SyncUserAndGroups(\n tsurl=TS_URL,\n username=TS_USER,\n password=TS_PASSWORD,\n disable_ssl=True,\n )\n auag = sync.get_all_users_and_groups()\n\n # Need to remove the common users since they don't have emails.\n auag.remove_user(\"guest\")\n auag.remove_user(\"su\")\n auag.remove_user(\"system\")\n auag.remove_user(\"tsadmin\")\n\n # Change Group 1 and Group 2 and verify change took.\n group1 = auag.get_group(\"Group 1\")\n group1.visibility = Visibility.NON_SHAREABLE\n group2 = auag.get_group(\"Group 2\")\n group2.visibility = Visibility.DEFAULT\n\n # sync updates\n sync.sync_users_and_groups(users_and_groups=auag)\n\n # verify changes\n auag = sync.get_all_users_and_groups()\n self.assertEqual(\n auag.get_group(\"Group 1\").visibility, Visibility.NON_SHAREABLE\n )\n self.assertEqual(\n auag.get_group(\"Group 2\").visibility, Visibility.DEFAULT\n )\n self.assertEqual(\n auag.get_group('Group \"3\"').visibility, Visibility.NON_SHAREABLE\n )","def test_replace_cluster_resource_quota(self):\n pass","def csAddPool(self,pool,creatorid,nas=None):\n\n logger.debug(\"Attempting to create pool '\"+pool+\"'.\")\n\n localpath = \"/.\"+pool\n\n url = self.csurl + \"/polcentral/v1_0/pools/\"\n\n if nas == None:\n logger.debug(\"No NAS object provided, will create pool '\"+pool+\"' type 'MW'.\")\n pooltype = 'MW'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n else:\n logger.debug(\"NAS object provided, will create pool '\"+pool+\"' type 'PS'.\")\n pooltype = 'PS'\n subscribedevices = True\n deviceid = ''\n pathinpool = '/'\n servername = ''\n sharename = ''\n sharepath = ''\n creditname = ''\n overridewarnings = True\n\n payload = {\n \"name\": pool,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath\n }\n \"\"\"\n payload = {\n \"name\": poolname,\n \"description\":\"Pool added by testbot\",\n \"creatorid\": {\"$id\": creatorid},\n \"type\":pooltype,\n \"allowpiggybacks\":True,\n \"localpoolpath\": localpath,\n \"subscribedevices\":subscribedevices,\n \"deviceid\": deviceid,\n \"pathinpool\": pathinpool,\n \"servername\": servername,\n \"sharename\": sharename,\n \"sharepath\": sharepath,\n \"credsetname\": creditname,\n \"overridewarnings\": overridewarnings\n }\n \"\"\"\n\n try:\n r = requests.post(url, data=json.dumps(payload))\n except Exception:\n logger.error(\"Exception during api call to add pool.\")\n return 'Error'\n\n if r.status_code == 200:\n logger.debug(\"Pool '\"+pool+\"' was successfully created.\")\n poolid = r.json()['_id']\n return poolid['$id']\n else:\n logger.error(\"Pool '\"+pool+\"' was not created. Error code is \"+str(r.status_code)+\".\")\n return 'Error'","def _update_share_stats(self):\n\n # sanity check for gluster ctl mount\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\n smp = os.stat(self._get_mount_point_for_gluster_vol())\n if smpb.st_dev == smp.st_dev:\n raise exception.GlusterfsException(\n _(\"GlusterFS control mount is not available\")\n )\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\n\n data = dict(\n storage_protocol='NFS',\n vendor_name='Red Hat',\n share_backend_name=self.backend_name,\n reserved_percentage=self.configuration.reserved_share_percentage,\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\n super(GlusterfsShareDriver, self)._update_share_stats(data)","def test_cephfs_share(self):\n keyring = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\n conf = model.run_on_leader(\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\n # Spawn Servers\n instance_1, instance_2 = self.launch_guests(\n userdata=self.INSTANCE_USERDATA.format(\n _indent(conf, 8),\n _indent(keyring, 8)))\n\n # Write a file on instance_1\n def verify_setup(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\n username = guest.boot_tests['bionic']['username']\n password = guest.boot_tests['bionic'].get('password')\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\n\n for attempt in Retrying(\n stop=stop_after_attempt(3),\n wait=wait_exponential(multiplier=1, min=2, max=10)):\n with attempt:\n openstack_utils.ssh_command(\n username, fip_1, 'instance-1',\n 'sudo mount -a && '\n 'echo \"test\" | sudo tee /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify_setup)\n\n def verify(stdin, stdout, stderr):\n status = stdout.channel.recv_exit_status()\n self.assertEqual(status, 0)\n out = \"\"\n for line in iter(stdout.readline, \"\"):\n out += line\n self.assertEqual(out, \"test\\n\")\n\n openstack_utils.ssh_command(\n username, fip_2, 'instance-2',\n 'sudo mount -a && '\n 'sudo cat /mnt/cephfs/test',\n password=password, privkey=privkey, verify=verify)","def test_synchronize_all_networks(self):\n\n # Store two tenants in a db and none on EOS.\n # The sync should send details of all tenants to EOS\n tenant_1_id = 'tenant-1'\n tenant_1_net_1_id = 'ten-1-net-1'\n tenant_1_net_1_seg_id = 11\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id,\n tenant_1_net_1_seg_id, 'segment_id_11')\n\n tenant_2_id = 'tenant-2'\n tenant_2_net_1_id = 'ten-2-net-1'\n tenant_2_net_1_seg_id = 21\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id,\n tenant_2_net_1_seg_id, 'segment_id_21')\n\n self.rpc.get_tenants.return_value = {}\n\n self.rpc.sync_start.return_value = True\n self.rpc.sync_end.return_value = True\n self.rpc.check_cvx_availability.return_value = True\n\n self.rpc._baremetal_supported.return_value = False\n self.rpc.get_all_baremetal_hosts.return_value = {}\n\n self.sync_service.do_synchronize()\n\n expected_calls = [\n mock.call.perform_sync_of_sg(self.sync_service._context),\n mock.call.check_cvx_availability(),\n mock.call.get_region_updated_time(),\n mock.call.get_region_updated_time().__bool__(),\n mock.call.sync_start(),\n mock.call.register_with_eos(sync=True),\n mock.call.check_supported_features(),\n mock.call.get_tenants(),\n\n mock.call.create_network_bulk(\n tenant_1_id,\n [{'network_id': tenant_1_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n\n mock.call.create_network_bulk(\n tenant_2_id,\n [{'network_id': tenant_2_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n mock.call.sync_end(),\n mock.call.get_region_updated_time()\n ]\n\n # The create_network_bulk() can be called in different order. So split\n # it up. The first part checks if the initial set of methods are\n # invoked.\n idx = expected_calls.index(mock.call.get_tenants()) + 1\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 1 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if tenant 2 networks are created. It must be one of the two\n # methods.\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\n expected_calls[idx:idx + 2],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n # Check if the sync end methods are invoked.\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\n expected_calls[idx + 2:],\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id)\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)","def test_add_node_to_pool_with_large_ppseqno_diff_views(do_view_change, looper, txnPoolNodeSet, tconf, sdk_pool_handle,\n sdk_wallet_steward, tdir, allPluginsPath):\n\n ensure_several_view_change(looper, txnPoolNodeSet, do_view_change, custom_timeout=tconf.NEW_VIEW_TIMEOUT)\n\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\n big_ppseqno = cur_ppseqno + tconf.LOG_SIZE * 2 + 2300\n assert (big_ppseqno > cur_ppseqno)\n\n # ensure pool is working properly\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\n\n _set_ppseqno(txnPoolNodeSet, big_ppseqno)\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\n assert (big_ppseqno == cur_ppseqno)\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\n\n\n\n # Disable view change after adding new node as it will not be able to finish due to fake ppSeqNo set\n for n in txnPoolNodeSet:\n n.write_manager.node_reg_handler.internal_bus = None\n\n new_steward_name = \"testClientSteward\" + randomString(4)\n new_node_name = \"TestTheta\" + randomString(4)\n new_steward_wallet_handle, new_node = sdk_add_new_steward_and_node(\n looper, sdk_pool_handle, sdk_wallet_steward,\n new_steward_name, new_node_name, tdir, tconf,\n allPluginsPath=allPluginsPath)\n txnPoolNodeSet.append(new_node)\n looper.run(checkNodesConnected(txnPoolNodeSet))\n\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n new_steward_wallet_handle,\n sdk_pool_handle)\n\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\n\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\n sdk_wallet_steward,\n sdk_pool_handle)\n\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])","def test_new_share(self):\n \n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\n another_test_user_to_share = self.create_saved_test_user()\n \n data = {\"user_id\": test_user_with_checkpoint.user_obj.id,\n \"to_user_id\": another_test_user_to_share.user_obj.id,\n \"signature\": gen_signature(\"put\",\n \"share\",\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \n test_user_with_checkpoint.user_obj.id)),\n \"user_checkpoint_id\": test_user_with_checkpoint.user_checkpoint_obj.id\n }\n \n resp = self.client.put(\"/share/\", data=data)\n assert \"ok\" in resp.data\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \n another_test_user_to_share.user_obj, \n test_user_with_checkpoint.user_checkpoint_obj) is None","def test_sync_clear_mempool(self):\n logging.info(\">>> Entered : test_sync_clear_mempool \\n\")\n try:\n # clear out the mempool\n mostly_sync_mempools(self.nodes)\n for index1, n in enumerate(self.nodes):\n n.generate(2)\n sync_blocks(self.nodes)\n for index2, n in enumerate(self.nodes):\n while len(n.getrawmempool()):\n n.generate(1)\n sync_blocks(self.nodes)\n logging.info(\"cleared mempool: %s\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\n base = [x.getrawmempool() for x in self.nodes]\n assert_equal(base, [base[0]] * 4)\n except (Exception, JSONRPCException) as e1:\n logging.info(e1)\n exc_type, exc_obj, exc_tb = sys.exc_info()\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\n raise TestAssertionError({\"file_name\": fname, \"line_num\": exc_tb.tb_lineno, \\\n \"error_type\": exc_type.__name__, \"error_msg\": str( e1 ), \\\n \"n1\" : self.bins[index1], \"n2\" : self.bins[index2], \"amount\" : \"N/A\", \"numsig\" : \"N/A\"})","def pool_snps(parent1, parent2):","def test_claim_resources_success_resize_to_same_host_with_shared(self):\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\n # source host allocation held by the migration_uuid so it is not\n # not returned to the claim code as that asks for the instance_uuid\n # consumer\n get_current_allocations_resp_mock.json.return_value = {\n 'allocations': {},\n \"consumer_generation\": 1,\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\n put_allocations_resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\n consumer_uuid = uuids.consumer_uuid\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\n # are all being increased but on the same host. We also throw a custom\n # resource class in the new allocation to make sure it's not lost\n alloc_req = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'CUSTOM_FOO': 1\n }\n },\n uuids.shared_storage: {\n 'resources': {\n 'DISK_GB': 40,\n }\n },\n },\n # this allocation request comes from the scheduler therefore it\n # does not have consumer_generation in it.\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.claim_resources(self.context, consumer_uuid,\n alloc_req, project_id, user_id,\n allocation_request_version='1.28')\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n expected_payload = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'CUSTOM_FOO': 1\n }\n },\n uuids.shared_storage: {\n 'resources': {\n 'DISK_GB': 40,\n }\n },\n },\n # report client assumes a new consumer in this case\n 'consumer_generation': None,\n 'project_id': project_id,\n 'user_id': user_id}\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n\n self.assertTrue(res)","def test_volume_service_pool(self):\n self.assertEqual(\n ChangeStateScript()._deployer._volume_service._pool,\n StoragePool(reactor, b\"flocker\", FilePath(b\"/flocker\")))","def test_replace_cluster_network(self):\n pass","def test_networking_project_network_update(self):\n pass","def test_update_pci_link(self):\n pass","def update_minion_pool():\n pool = fetch_minion_pool()\n save_minion_pool(pool)\n return pool","async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\n\n trusted, fee = trusted_and_fee\n num_blocks = 4 # Num blocks to farm at a time\n total_blocks = 0 # Total blocks farmed so far\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n wallet_node_0 = wallet_nodes[0]\n our_ph = receive_address[0]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_node_0.config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_node_0.config[\"trusted_peers\"] = {}\n\n await wallet_node_0.server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\n total_block_rewards = await get_total_block_rewards(total_blocks)\n\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n assert total_block_rewards > 0\n\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5001\", \"new\", \"SELF_POOLING\", fee\n )\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx_2.spend_bundle,\n creation_tx_2.name,\n )\n\n for r in creation_tx.removals:\n assert r not in creation_tx_2.removals\n\n await farm_blocks(full_node_api, our_ph, 1)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 2\n wallet_id: int = summaries_response[0][\"id\"]\n wallet_id_2: int = summaries_response[1][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n assert status_2.target is None\n\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\n return fetched is not None and fetched.is_in_mempool()\n\n join_pool: Dict = await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 10,\n fee,\n )\n assert join_pool[\"success\"]\n join_pool_tx: TransactionRecord = join_pool[\"transaction\"]\n assert join_pool_tx is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\n\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \"https://pool.example.com\", 10, fee)\n assert join_pool_2[\"success\"]\n join_pool_tx_2: TransactionRecord = join_pool_2[\"transaction\"]\n for r in join_pool_tx.removals:\n assert r not in join_pool_tx_2.removals\n assert join_pool_tx_2 is not None\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is not None\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\n assert status_2.target is not None\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await farm_blocks(full_node_api, our_ph, 1)\n\n async def status_is_farming_to_pool(w_id: int):\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","def test_remove_provider_from_inst_alloc_no_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def test_rebuild_with_wrong_shared_storage(self, mock_remove_allocs):\n with mock.patch.object(self.compute.driver, 'instance_on_disk',\n side_effect=lambda x: True) as mock_inst:\n self.assertRaises(exception.InvalidSharedStorage,\n lambda: self._rebuild(on_shared_storage=False))\n\n # Should remain on original host\n instance = db.instance_get(self.context, self.inst.id)\n self.assertEqual(instance['host'], 'fake_host_2')\n self.assertTrue(mock_inst.called)\n mock_remove_allocs.assert_called_once_with(\n mock.ANY, instance.uuid, self.rt.compute_nodes[NODENAME].uuid)","def test_patch_cluster_network(self):\n pass","def test_remove_provider_from_inst_alloc_with_shared(self):\n get_resp_mock = mock.Mock(status_code=200)\n get_resp_mock.json.side_effect = [\n {\n 'allocations': {\n uuids.source: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': uuids.project_id,\n 'user_id': uuids.user_id,\n },\n # the second get is for resource providers in the compute tree,\n # return just the compute\n {\n \"resource_providers\": [\n {\n \"uuid\": uuids.source,\n },\n ]\n },\n ]\n self.ks_adap_mock.get.return_value = get_resp_mock\n resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = resp_mock\n consumer_uuid = uuids.consumer_uuid\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.remove_provider_tree_from_instance_allocation(\n self.context, consumer_uuid, uuids.source)\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n # New allocations should only include the destination...\n expected_payload = {\n 'allocations': {\n uuids.shared_storage: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'DISK_GB': 100,\n },\n },\n uuids.destination: {\n 'resource_provider_generation': 42,\n 'resources': {\n 'VCPU': 1,\n 'MEMORY_MB': 1024,\n },\n },\n },\n 'consumer_generation': 1,\n 'project_id': project_id,\n 'user_id': user_id\n }\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n\n self.assertTrue(res)","def test_update_hyperflex_cluster_profile(self):\n pass","def test_update_network(self):\n policies_ports = [\n (None, {self.ports[0].id}),\n (self.qos_policies[1].id, {self.ports[0].id})]\n\n self.ports[1].qos_policy_id = self.qos_policies[0].id\n self.ports[1].update()\n self.ports[2].qos_policy_id = self.qos_policies[1].id\n self.ports[2].update()\n for qos_policy_id, reference_ports in policies_ports:\n self.networks[0].qos_policy_id = qos_policy_id\n self.networks[0].update()\n original_network = {'qos_policy_id': self.qos_policies[0]}\n reviewed_port_ids, _, _ = self.qos_driver.update_network(\n mock.ANY, self.networks[0], original_network)\n self.assertEqual(reference_ports, reviewed_port_ids)\n calls = [mock.call(mock.ANY, self.ports[0].id,\n self.ports[0].network_id, qos_policy_id,\n None)]\n self.mock_rules.assert_has_calls(calls)\n self.mock_rules.reset_mock()","def verify_avail_space(self, pool, project, share, size):\n self.verify_project(pool, project)\n avail = self.get_project_stats(pool, project)\n if avail < size:\n exception_msg = (_('Error creating '\n 'share: %(share)s on '\n 'pool: %(pool)s. '\n 'Not enough space.')\n % {'share': share,\n 'pool': pool})\n raise exception.ShareBackendException(msg=exception_msg)","async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\n trusted, fee = trusted_and_fee\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\n our_ph = receive_address[0]\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\n pool_ph = receive_address[1]\n full_node_api = full_nodes[0]\n if trusted:\n wallet_nodes[0].config[\"trusted_peers\"] = {\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\n }\n else:\n wallet_nodes[0].config[\"trusted_peers\"] = {}\n\n await wallet_nodes[0].server.start_client(\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\n )\n\n try:\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\n\n async def have_chia():\n await farm_blocks(full_node_api, our_ph, 1)\n return (await wallets[0].get_confirmed_balance()) > 0\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\n our_ph, \"\", 0, f\"{self_hostname}:5000\", \"new\", \"SELF_POOLING\", fee\n )\n\n await time_out_assert(\n 10,\n full_node_api.full_node.mempool_manager.get_spendbundle,\n creation_tx.spend_bundle,\n creation_tx.name,\n )\n\n await farm_blocks(full_node_api, our_ph, 6)\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\n assert len(summaries_response) == 1\n wallet_id: int = summaries_response[0][\"id\"]\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.target is None\n\n join_pool_tx: TransactionRecord = (\n await client.pw_join_pool(\n wallet_id,\n pool_ph,\n \"https://pool.example.com\",\n 5,\n fee,\n )\n )[\"transaction\"]\n assert join_pool_tx is not None\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\n assert status.current.pool_url == \"\"\n assert status.current.relative_lock_height == 0\n assert status.current.state == 1\n assert status.current.version == 1\n\n assert status.target\n assert status.target.pool_url == \"https://pool.example.com\"\n assert status.target.relative_lock_height == 5\n assert status.target.state == 3\n assert status.target.version == 1\n\n async def status_is_farming_to_pool():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\n\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\n\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\n assert leave_pool_tx[\"transaction\"].wallet_id == wallet_id\n assert leave_pool_tx[\"transaction\"].amount == 1\n\n async def status_is_leaving():\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\n\n async def status_is_self_pooling():\n # Farm enough blocks to wait for relative_lock_height\n await farm_blocks(full_node_api, our_ph, 1)\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\n\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\n\n finally:\n client.close()\n await client.await_closed()\n await rpc_cleanup()","async def test_edit_sharing_data(container_requester):\n async with container_requester as requester:\n await requester(\n 'POST', '/db/guillotina', data=json.dumps({\n '@type': 'Item',\n 'id': 'foobar1'\n }))\n await requester(\n 'POST', '/db/guillotina', data=json.dumps({\n '@type': 'Item',\n 'id': 'foobar2'\n }))\n response, _ = await requester(\n 'POST',\n '/db/guillotina/@batch',\n data=json.dumps([{\n 'method': 'POST',\n 'endpoint': 'foobar1/@sharing',\n 'payload': {\n \"prinperm\": [{\n \"principal\": \"user1\",\n \"permission\": \"guillotina.AccessContent\",\n \"setting\": \"AllowSingle\"\n }]\n }\n }, {\n 'method': 'POST',\n 'endpoint': 'foobar2/@sharing',\n 'payload': {\n \"prinperm\": [{\n \"principal\": \"user1\",\n \"permission\": \"guillotina.AccessContent\",\n \"setting\": \"AllowSingle\"\n }]\n }\n }])\n )\n response, _ = await requester(\n 'POST',\n '/db/guillotina/@batch',\n data=json.dumps([{\n 'method': 'GET',\n 'endpoint': 'foobar1/@sharing'\n }, {\n 'method': 'GET',\n 'endpoint': 'foobar2/@sharing'\n }])\n )\n assert len(response) == 2\n assert response[0]['body']['local']['prinperm']['user1']['guillotina.AccessContent'] == 'AllowSingle'\n assert response[1]['body']['local']['prinperm']['user1']['guillotina.AccessContent'] == 'AllowSingle'","async def test_endpoint_edit_share_correct(self):\n with self.patch_json_dump:\n await edit_share_handler(self.mock_request)\n self.json_mock.assert_called_once()","def test_patch_cluster_resource_quota(self):\n pass","def test_update_pci_switch(self):\n pass","def ensure_share(self, context, share, share_server=None):\n pass","def ensure_share(self, context, share, share_server=None):\r\n LOG.debug(\"Ensure share.\")","def test_n_minus_f_pool_processes_attrib(looper, nodeSet,\n sdk_pool_handle,\n sdk_wallet_steward):\n make_pool_n_minus_f_nodes(looper, nodeSet)\n\n sdk_add_raw_attribute(looper, sdk_pool_handle, sdk_wallet_steward, 'foo', 'bar')","def test_anon_shared(self):\n self.do_sharable(False, 'pattieblack', None)\n self.do_sharable(False, 'pattieblack', FakeMembership(True))","def test_update_instance_limit1(self):\n pass","async def test_push_share_no_os_envars(self):\n with self.sys_exit_patch, \\\n self.patch_init_sharing_client_error, \\\n self.patch_get_address, \\\n self.os_environ_get_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )","def test_synchronize_one_network(self):\n\n # Store two tenants in a db and a single tenant in EOS.\n # The sync should send details of the second tenant to EOS\n tenant_1_id = 'tenant-1'\n tenant_1_net_1_id = 'ten-1-net-1'\n tenant_1_net_1_seg_id = 11\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id,\n tenant_1_net_1_seg_id, 'segment_id_11')\n\n tenant_2_id = 'tenant-2'\n tenant_2_net_1_id = 'ten-2-net-1'\n tenant_2_net_1_seg_id = 21\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id,\n tenant_2_net_1_seg_id, 'segment_id_21')\n\n self.rpc.get_tenants.return_value = {\n tenant_1_id: {\n 'tenantVmInstances': {},\n 'tenantBaremetalInstances': {},\n 'tenantNetworks': {\n tenant_1_net_1_id: {\n 'networkId': tenant_1_net_1_id,\n 'shared': False,\n 'networkName': 'Net1',\n 'segmenationType': 'vlan',\n 'segmentationTypeId': tenant_1_net_1_seg_id,\n }\n }\n }\n }\n\n self.rpc.sync_start.return_value = True\n self.rpc.sync_end.return_value = True\n self.rpc.check_cvx_availability.return_value = True\n\n self.rpc._baremetal_supported.return_value = False\n self.rpc.get_all_baremetal_hosts.return_value = {}\n\n self.sync_service.do_synchronize()\n\n expected_calls = [\n mock.call.perform_sync_of_sg(self.sync_service._context),\n mock.call.check_cvx_availability(),\n mock.call.get_region_updated_time(),\n mock.call.get_region_updated_time().__bool__(),\n mock.call.sync_start(),\n mock.call.register_with_eos(sync=True),\n mock.call.check_supported_features(),\n mock.call.get_tenants(),\n\n mock.call.create_network_bulk(\n tenant_2_id,\n [{'network_id': tenant_2_net_1_id,\n 'segments': [],\n 'network_name': '',\n 'shared': False}],\n sync=True),\n\n mock.call.sync_end(),\n mock.call.get_region_updated_time()\n ]\n\n self.assertTrue(self.rpc.mock_calls == expected_calls,\n \"Seen: %s\\nExpected: %s\" % (\n self.rpc.mock_calls,\n expected_calls,\n )\n )\n\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\n tenant_1_net_1_id)\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\n tenant_2_net_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)","def test_replace_cluster_resource_quota_status(self):\n pass","def test_update_instance_limit(self):\n pass","def test_dashboards_v2_delete_share(self):\n pass","def create_share(self, pool, project, share):\n self.verify_avail_space(pool, project, share, share['quota'])\n svc = self.share_path % (pool, project, share['name'])\n ret = self.rclient.get(svc)\n if ret.status != restclient.Status.OK:\n svc = self.shares_path % (pool, project)\n ret = self.rclient.post(svc, share)\n if ret.status != restclient.Status.CREATED:\n exception_msg = (_('Error creating '\n 'share: %(name)s '\n 'return code: %(ret.status)d '\n 'message: %(ret.data)s.')\n % {'name': share['name'],\n 'ret.status': ret.status,\n 'ret.data': ret.data})\n raise exception.ShareBackendException(msg=exception_msg)\n else:\n exception_msg = (_('Share with name %s already exists.')\n % share['name'])\n raise exception.ShareBackendException(msg=exception_msg)","def test_patch_hyperflex_cluster_network_policy(self):\n pass","def share():\n return True","def test_pool_dependence(self):\n ok_(id(CSVarPool.pool) == id(VarPool.pool), 'mem address of pools should be the same')\n\n var = 'foo'\n app = 'test'\n VarPool(app=app).set(var, 'bar')\n eq_(CSVarPool.get(var, app=app), 'bar')\n CSVarPool(app=app).set(var, 'foo')\n eq_(VarPool.get(var, app=app), 'foo')","def test_put_without_parent_datastore_nor_share_id(self):\n\n url = reverse('file')\n\n data = {\n 'shard_id': self.shard1.id,\n 'link_id': \"b8866161-0b1f-4a8e-acde-07047313ec8f\",\n #'parent_datastore_id': str(self.test_datastore_obj.id),\n 'chunk_count': 1,\n 'size': 512,\n }\n\n self.client.force_authenticate(user=self.test_user_obj)\n response = self.client.put(url, data)\n\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_kyc_post_legal_share_holder(self):\n pass","def test_wrong_config_shares2(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='dfgsdfsg',\n destination='gsiftp://nowhere',\n vo='dteam',\n share=80\n ),\n status=400\n )\n\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='klhjkhjk',\n vo='dteam',\n share=80\n ),\n status=400\n )","def test_set_hosts_storage_backing_equal(instance_backing, number_of_hosts):\n host_num_mapping = {\n 'zero': 0,\n 'one': 1,\n 'two': 2\n }\n number_of_hosts = host_num_mapping[number_of_hosts]\n LOG.tc_step(\"Calculate the hosts to be configured based on test params\")\n candidate_hosts = get_candidate_hosts(number_of_hosts=number_of_hosts)\n\n hosts_with_backing = \\\n host_helper.get_hosts_in_storage_backing(instance_backing)\n if len(hosts_with_backing) == number_of_hosts:\n LOG.info(\"Already have {} hosts in {} backing. Do \"\n \"nothing\".format(number_of_hosts, instance_backing))\n return\n\n elif len(hosts_with_backing) < number_of_hosts:\n backing_to_config = instance_backing\n number_to_config = number_of_hosts - len(hosts_with_backing)\n hosts_pool = list(set(candidate_hosts) - set(hosts_with_backing))\n else:\n backing_to_config = 'remote' if 'image' in instance_backing else \\\n 'local_image'\n number_to_config = len(hosts_with_backing) - number_of_hosts\n hosts_pool = hosts_with_backing\n\n LOG.tc_step(\"Delete vms if any to prepare for system configuration \"\n \"change with best effort\")\n vm_helper.delete_vms(fail_ok=True)\n\n hosts_to_config = hosts_pool[0:number_to_config]\n LOG.tc_step(\"Configure following hosts to {} backing: \"\n \"{}\".format(hosts_to_config, backing_to_config))\n\n for host in hosts_to_config:\n host_helper.set_host_storage_backing(host=host,\n inst_backing=backing_to_config,\n unlock=False,\n wait_for_configured=False)\n HostsToRecover.add(host)\n\n host_helper.unlock_hosts(hosts_to_config, check_hypervisor_up=True,\n fail_ok=False)\n\n LOG.tc_step(\"Waiting for hosts in {} aggregate\".format(backing_to_config))\n for host in hosts_to_config:\n host_helper.wait_for_host_in_instance_backing(\n host, storage_backing=backing_to_config)\n\n LOG.tc_step(\"Check number of {} hosts is {}\".format(instance_backing,\n number_of_hosts))\n assert number_of_hosts == \\\n len(host_helper.get_hosts_in_storage_backing(instance_backing)), \\\n \"Number of {} hosts is not {} after \" \\\n \"configuration\".format(instance_backing, number_of_hosts)","def test_fixed_ip_associate_pool_order(self):\n\n instance_uuid = self._create_instance()\n network = db.network_create_safe(self.ctxt, {})\n self.addCleanup(timeutils.clear_time_override)\n start = timeutils.utcnow()\n for i in range(1, 4):\n now = start - datetime.timedelta(hours=i)\n timeutils.set_time_override(now)\n address = self.create_fixed_ip(\n updated_at=now,\n address='10.1.0.%d' % i,\n network_id=network['id'])\n db.fixed_ip_associate_pool(self.ctxt, network['id'], instance_uuid)\n fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address)\n self.assertEqual(fixed_ip['instance_uuid'], instance_uuid)","def test_wrong_config_shares0(self):\n self.app.post_json(url=\"/config/shares\",\n params=dict(\n source='gsiftp://source',\n destination='gsiftp://nowhere',\n vo='dteam',\n share='dfdf'\n ),\n status=400\n )","def test_share_00(self, mocker):\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\n g.spreadsheet = Spreadsheet(None, None)\n g.spreadsheet.share = mocker.MagicMock()\n\n g.share()\n\n assert g.spreadsheet.share.call_count == len(contributors)","def update_device_pool(arn=None, name=None, description=None, rules=None):\n pass","def put(self, request, pool_id):\n kwargs = {'pool_id': pool_id}\n update_pool(request, **kwargs)","def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\n wallet = tt.Wallet(attach_to=node)\n\n wallet.create_account(\"goku1\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\n wallet.create_account(\"steem\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\n\n with wallet.in_single_transaction():\n wallet.api.delegate_vesting_shares(\"goku1\", \"steem\", tt.Asset.Vest(5))\n wallet.api.delegate_vesting_shares(\"steem\", \"goku1\", tt.Asset.Vest(10))\n\n assert get_hardfork_version(node) == \"0.22.0\"\n assert_account_resources(node, \"goku1\", operator.gt)\n assert_account_resources(node, \"steem\", operator.gt)\n\n __wait_for_hardfork_23_application(node)\n assert get_hardfork_version(node) == \"0.23.0\"\n\n assert_account_resources(node, \"goku1\", operator.eq)\n assert_account_resources(node, \"steem\", operator.eq)\n\n assert_cleared_resources_in_hardfork_hive_operation(node, \"goku1\")\n assert_cleared_resources_in_hardfork_hive_operation(node, \"steem\")","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_obj = RadosOrchestrator(node=cephadm)\n pool_obj = PoolFunctions(node=cephadm)\n scrub_obj = RadosScrubber(node=cephadm)\n\n pool_target_configs = config[\"verify_osd_omap_entries\"][\"configurations\"]\n omap_target_configs = config[\"verify_osd_omap_entries\"][\"omap_config\"]\n\n # Creating pools and starting the test\n for entry in pool_target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n method_should_succeed(\n rados_obj.create_pool,\n **entry,\n )\n\n log.debug(\n \"Created the pool. beginning to create large number of omap entries on the pool\"\n )\n\n # Creating omaps\n create_omap(pool_obj, pool_target_configs, omap_target_configs)\n\n omap_thread = Thread(\n target=create_omap, args=[pool_obj, pool_target_configs, omap_target_configs]\n )\n\n # Get the scrub and deep scrup time stamp before scrub and deep scrub execution\n before_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_scrub_stamp\")\n before_deep_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_deep_scrub_stamp\")\n\n # performing scrub and deep-scrub\n rados_obj.run_scrub()\n rados_obj.run_deep_scrub()\n scrub_status = 1\n deep_scrub_status = 1\n\n while scrub_status == 1 and deep_scrub_status == 1:\n # Scrub check for every 20 seconds\n time.sleep(20)\n after_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_scrub_stamp\")\n after_deep_scrub_log = scrub_obj.get_pg_dump(\"pgid\", \"last_deep_scrub_stamp\")\n scrub_status = scrub_obj.verify_scrub_deepscrub(\n before_scrub_log, after_scrub_log, \"scrub\"\n )\n deep_scrub_status = scrub_obj.verify_scrub_deepscrub(\n before_deep_scrub_log, after_deep_scrub_log, \"deepscrub\"\n )\n log.info(\"scrubbing and deep-scrubbing are in progress\")\n log.info(\"scrubbing and deep-scrubbing completed\")\n\n # Check for large omap massage\n ceph_status = rados_obj.run_ceph_command(cmd=\" ceph health\")\n if \"LARGE_OMAP_OBJECTS\" in ceph_status[\"checks\"]:\n log.info(\" Generated large omaps in the cluster\")\n else:\n log.error(\" Unable to generate the large omaps in the cluster\")\n return 1\n\n # verification of OSDs for 30 minutes\n verification_osd_thread = Thread(target=verification_osd, args=[rados_obj, 30])\n omap_thread.daemon = True\n omap_thread.start()\n verification_osd_thread.start()\n verification_osd_thread.join()\n omap_thread._delete()\n if result == 0:\n return 0\n else:\n return 1","def test_replace_cluster_policy(self):\n pass","def task(ctx, config):\n if config is None:\n config = {}\n assert isinstance(config, dict), \\\n 'Resolve stuck peering only accepts a dict for config'\n\n manager = ctx.managers['ceph']\n\n while len(manager.get_osd_status()['up']) < 3:\n time.sleep(10)\n\n\n manager.wait_for_clean()\n\n dummyfile = '/etc/fstab'\n dummyfile1 = '/etc/resolv.conf'\n\n #create 1 PG pool\n pool='foo'\n log.info('creating pool foo')\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\n\n #set min_size of the pool to 1\n #so that we can continue with I/O\n #when 2 osds are down\n manager.set_pool_property(pool, \"min_size\", 1)\n\n osds = [0, 1, 2]\n\n primary = manager.get_pg_primary('foo', 0)\n log.info(\"primary osd is %d\", primary)\n\n others = list(osds)\n others.remove(primary)\n\n log.info('writing initial objects')\n first_mon = teuthology.get_first_mon(ctx, config)\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\n #create few objects\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\n\n manager.wait_for_clean()\n\n #kill other osds except primary\n log.info('killing other osds except primary')\n for i in others:\n manager.kill_osd(i)\n for i in others:\n manager.mark_down_osd(i)\n\n\n for i in range(100):\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\n\n #kill primary osd\n manager.kill_osd(primary)\n manager.mark_down_osd(primary)\n\n #revive other 2 osds\n for i in others:\n manager.revive_osd(i)\n\n #make sure that pg is down\n #Assuming pg number for single pg pool will start from 0\n pgnum=0\n pgstr = manager.get_pgid(pool, pgnum)\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=60\n start=time.time()\n\n while 'down' not in stats['state']:\n assert time.time() - start < timeout, \\\n 'failed to reach down state before timeout expired'\n stats = manager.get_single_pg_stats(pgstr)\n\n #mark primary as lost\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\n '--yes-i-really-mean-it')\n\n\n #expect the pg status to be active+undersized+degraded\n #pg should recover and become active+clean within timeout\n stats = manager.get_single_pg_stats(pgstr)\n print(stats['state'])\n\n timeout=10\n start=time.time()\n\n while manager.get_num_down():\n assert time.time() - start < timeout, \\\n 'failed to recover before timeout expired'\n\n manager.revive_osd(primary)","def mostly_sync_mempools(rpc_connections, difference=50, wait=1, verbose=1):\n iterations = 0\n while True:\n iterations += 1\n pool = set(rpc_connections[0].getrawmempool())\n num_match = 1\n poolLen = [len(pool)]\n for i in range(1, len(rpc_connections)):\n tmp = set(rpc_connections[i].getrawmempool())\n if tmp == pool:\n num_match = num_match + 1\n if iterations > 10 and len(tmp.symmetric_difference(pool)) < difference:\n num_match = num_match + 1\n poolLen.append(len(tmp))\n if verbose:\n logging.info(\"sync mempool: \" + str(poolLen))\n if num_match == len(rpc_connections):\n break\n time.sleep(wait)","def test_update_external_network(self):\n network_policies = [(self.qos_policies[1].id,\n {self.fips[1].id},\n {self.router_fips.id}),\n (None,\n {self.fips[1].id},\n {self.router_fips.id})]\n\n self.fips[0].qos_policy_id = self.qos_policies[0].id\n self.fips[0].update()\n for qos_policy_id, ref_fips, ref_routers in network_policies:\n self.fips_network.qos_policy_id = qos_policy_id\n self.fips_network.update()\n original_network = {'qos_policy_id': self.qos_policies[0]}\n _, reviewed_fips_ids, reviewed_router_ids = (\n self.qos_driver.update_network(\n mock.Mock(), self.fips_network, original_network))\n self.assertEqual(ref_fips, reviewed_fips_ids)\n self.assertEqual(ref_routers, reviewed_router_ids)","async def test_push_share_no_envars(self):\n with self.sys_exit_patch:\n with self.assertRaises(SystemExit):\n await self.inst._push_share(\n \"test-container\",\n \"test-recipient\",\n [\"r\", \"w\"]\n )\n self.sys_exit_mock.assert_called_once()","def test_pooling(self):\n for width in range(2, 5):\n for width2 in range(1, width):\n matrix_size = (4, 5, width)\n matrix = get_random_test_tensor(size=matrix_size)\n pool_size = width2\n for stride in range(1, width2):\n for padding in range(2):\n reference = torch.nn.functional.avg_pool2d(\n matrix.unsqueeze(0), pool_size,\n stride=stride, padding=padding\n )\n\n encrypted_matrix = SharedTensor(matrix)\n encrypted_pool = encrypted_matrix.avg_pool2d(\n pool_size, stride=stride, padding=padding)\n self._check(\n encrypted_pool, reference[0], 'avg_pool2d failed')","def mover_put_data(outputpoolfcstring,\n pdsname,\n sitename,\n queuename,\n ub=\"outdated\", # to be removed\n analysisJob=False,\n testLevel=\"0\",\n pinitdir=\"\",\n proxycheck=True,\n spsetup=\"\",\n token=[],\n userid=\"\",\n prodSourceLabel=\"\",\n datasetDict=None,\n outputDir=\"\",\n jobId=None,\n jobDefId=\"\",\n jobWorkDir=None,\n DN=None,\n outputFileInfo=None,\n dispatchDBlockTokenForOut=None,\n jobCloud=\"\",\n logFile=\"\",\n cmtconfig=\"\",\n recoveryWorkDir=None,\n experiment=\"ATLAS\",\n stageoutTries=2,\n scopeOut=None,\n scopeLog=None,\n fileDestinationSE=None,\n logPath=\"\",\n eventService=False):\n\n fail = 0\n error = PilotErrors()\n pilotErrorDiag = \"\"\n\n # file info field used by job recovery\n fields = ['', '', '', '', '', '', '']\n\n # Alternative transfer counters (will be reported in jobMetrics, only relevant when alternative stage-out was used)\n N_filesNormalStageOut = 0\n N_filesAltStageOut = 0\n\n # note: the job work dir does not exist in the case of job recovery\n if recoveryWorkDir:\n workDir = recoveryWorkDir\n else:\n workDir = os.path.dirname(jobWorkDir)\n\n # setup the dictionary necessary for all instrumentation\n report = getInitialTracingReport(userid, sitename, pdsname, \"put_sm\", analysisJob, jobId, jobDefId, DN)\n\n # Remember that se can be a list where the first is used for output but any can be used for input\n listSEs = readpar('se').split(',')\n tolog(\"SE list: %s\" % str(listSEs))\n\n region = readpar('region')\n\n # Get the site information object and set the queuename\n si = getSiteInformation(experiment)\n si.setQueueName(queuename)\n\n # Get the copy tool\n copycmd, setup = getCopytool()\n\n tolog(\"Copy command: %s\" % (copycmd))\n tolog(\"Setup: %s\" % (setup))\n\n # Is this a transfer to an object store?\n if \"objectstore\" in copycmd:\n objectstore = True\n else:\n objectstore = False\n\n # Get the storage path, e.g.\n # ddm_storage_path = srm://uct2-dc1.uchicago.edu:8443/srm/managerv2?SFN=/pnfs/uchicago.edu/atlasuserdisk\n # Note: this ends up in the 'destination' variable inside the site mover's put_data() - which is mostly not used\n # It can be used for special purposes, like for the object store path which can be predetermined\n ddm_storage_path, pilotErrorDiag = getDDMStorage(ub, si, analysisJob, region, jobId, objectstore, isLogTransfer(logPath))\n if pilotErrorDiag != \"\":\n return error.ERR_NOSTORAGE, pilotErrorDiag, fields, None, N_filesNormalStageOut, N_filesAltStageOut\n\n # Get the site mover\n sitemover = getSiteMover(copycmd, setup)\n tolog(\"Got site mover: %s\" % str(sitemover))\n\n # get the file list from the PFC (DOM object list)\n file_list = getFileList(outputpoolfcstring)\n\n # number of output files (e.g. used by CMS site mover)\n nFiles = len(file_list)\n\n # create the scope dictionary\n # scope_dict = createZippedDictionary(file_list, job.scopeOut)\n\n # Get the experiment object\n thisExperiment = getExperiment(experiment)\n\n # get the list of space tokens\n token_list = getSpaceTokenList(token, listSEs, jobCloud, analysisJob, nFiles, si)\n alternativeTokenList = None\n\n # loop over all files to be staged in\n fail = 0\n file_nr = -1\n for thisfile in file_list:\n file_nr += 1\n\n # get the file names and guid\n # note: pfn is the source\n filename, lfn, pfn, guid = getFilenamesAndGuid(thisfile)\n\n # The file name is now known, let's add it to the storge path if the endpoint is on an objectstore\n if objectstore:\n ddm_storage_path = getHashedBucketEndpoint(ddm_storage_path, lfn)\n\n # note: pfn is the full path to the local file\n tolog(\"Preparing copy for %s to %s using %s\" % (pfn, ddm_storage_path, copycmd))\n\n # get the corresponding scope\n scope = getScope(lfn, logFile, file_nr, scopeOut, scopeLog)\n\n # update the current file state\n updateFileState(filename, workDir, jobId, mode=\"file_state\", state=\"not_transferred\")\n dumpFileStates(workDir, jobId)\n\n # get the dataset name (dsname_report is the same as dsname but might contain _subNNN parts)\n dsname, dsname_report = getDatasetName(sitemover, datasetDict, lfn, pdsname)\n\n # update tracing report\n report['dataset'] = dsname_report\n report['scope'] = scope\n\n # get the currect space token for the given file\n _token_file = getSpaceTokenForFile(filename, token_list, logFile, file_nr, nFiles)\n\n # get the file size and checksum if possible\n fsize, checksum = getFileSizeAndChecksum(lfn, outputFileInfo)\n\n s = 1\n _attempt = 0\n if stageoutTries > 0 and stageoutTries < 10:\n put_RETRY = stageoutTries\n else:\n tolog(\"!!WARNING!!1888!! Unreasonable number of stage-out tries: %d (reset to default)\" % (stageoutTries))\n put_RETRY = 2\n tolog(\"Number of stage-out tries: %d\" % (stageoutTries))\n\n # loop over put_data() to allow for multple stage-out attempts\n while s != 0 and _attempt < put_RETRY:\n _attempt += 1\n\n # if not first stage-out attempt, take a nap before next attempt\n if _attempt > 1:\n _rest = 10*60\n tolog(\"(Waiting %d seconds before next stage-out attempt)\" % (_rest))\n sleep(_rest)\n\n tolog(\"Put attempt %d/%d\" % (_attempt, put_RETRY))\n\n # perform the normal stage-out, unless we want to force alternative stage-out\n if not si.forceAlternativeStageOut(flag=analysisJob):\n s, pilotErrorDiag, r_gpfn, r_fsize, r_fchecksum, r_farch = sitemover_put_data(sitemover, error, workDir, jobId, pfn, ddm_storage_path, dsname,\\\n sitename, analysisJob, testLevel, pinitdir, proxycheck,\\\n _token_file, lfn, guid, spsetup, userid, report, cmtconfig,\\\n prodSourceLabel, outputDir, DN, fsize, checksum, logFile,\\\n _attempt, experiment, scope, fileDestinationSE, nFiles,\\\n logPath=logPath)\n # increase normal stage-out counter if file was staged out\n if s == 0:\n N_filesNormalStageOut += 1\n forceAltStageOut = False\n else:\n # first switch off allowAlternativeStageOut since it will not be needed\n # update queuedata (remove allow_alt_stageout from catchall field)\n catchall = readpar('catchall')\n if 'allow_alt_stageout' in catchall:\n catchall = catchall.replace('allow_alt_stageout','')\n ec = si.replaceQueuedataField(\"catchall\", catchall)\n tolog(\"(will force alt stage-out, s=%d)\" % (s))\n forceAltStageOut = True\n\n # attempt alternative stage-out if required\n if s != 0:\n # report stage-out problem to syslog\n sysLog(\"PanDA job %s failed to stage-out output file: %s\" % (jobId, pilotErrorDiag))\n #dumpSysLogTail()\n\n if forceAltStageOut:\n tolog(\"Forcing alternative stage-out\")\n useAlternativeStageOut = True\n _attempt = 2\n else:\n tolog('!!WARNING!!2999!! Error in copying (attempt %s): %s - %s' % (_attempt, s, pilotErrorDiag))\n\n # should alternative stage-out be attempted?\n # (not for special log file transfers to object stores)\n if logPath == \"\":\n useAlternativeStageOut = si.allowAlternativeStageOut(flag=analysisJob)\n else:\n useAlternativeStageOut = False\n\n if \"failed to remove file\" in pilotErrorDiag and not useAlternativeStageOut:\n tolog(\"Aborting stage-out retry since file could not be removed from storage/catalog\")\n break\n\n # perform alternative stage-out if required\n if useAlternativeStageOut and _attempt > 1:\n tolog(\"Attempting alternative stage-out (to the Tier-1 of the cloud the job belongs to)\")\n\n # download new queuedata and return the corresponding sitemover object\n alternativeSitemover = prepareAlternativeStageOut(sitemover, si, sitename, jobCloud)\n\n if alternativeSitemover:\n # update the space token?\n if not alternativeTokenList:\n # note: alt=True means that the queuedata file for the alternative SE will be used\n alternativeListSEs = readpar('se', alt=True).split(',')\n tolog(\"Alternative SE list: %s\" % str(alternativeListSEs))\n\n # which space token should be used? Primarily use the requested space token primarily (is it available at the alternative SE?)\n # otherwise use the default space token of the alternative SE\n alternativeTokenList = getSpaceTokenList(token, alternativeListSEs, jobCloud, analysisJob, nFiles, si, alt=True)\n tolog(\"Created alternative space token list: %s\" % str(alternativeTokenList))\n\n # get the currect space token for the given file\n _token_file = getSpaceTokenForFile(filename, alternativeTokenList, logFile, file_nr, nFiles)\n tolog(\"Using alternative space token: %s\" % (_token_file))\n\n # perform the stage-out\n tolog(\"Attempting stage-out to alternative SE\")\n _s, _pilotErrorDiag, r_gpfn, r_fsize, r_fchecksum, r_farch = sitemover_put_data(alternativeSitemover, error, workDir, jobId, pfn, ddm_storage_path, dsname,\\\n sitename, analysisJob, testLevel, pinitdir, proxycheck,\\\n _token_file, lfn, guid, spsetup, userid, report, cmtconfig,\\\n prodSourceLabel, outputDir, DN, fsize, checksum, logFile,\\\n _attempt, experiment, scope, fileDestinationSE, nFiles,\\\n alt=True)\n if _s == 0:\n # do no further stage-out (prevent another attempt, but allow e.g. chirp transfer below, as well as\n # return a zero error code from this function, also for job recovery returning s=0 will not cause job recovery\n # to think that the file has not been transferred)\n _attempt = 999\n s = 0\n\n # increase alternative stage-out counter\n N_filesAltStageOut += 1\n\n if \"failed to remove file\" in pilotErrorDiag:\n tolog(\"Aborting further stage-out retries since file could not be removed from storage/catalog\")\n break\n\n elif _attempt > 1:\n tolog(\"Stage-out to alternative SE not allowed\")\n\n if s == 0:\n # use special tool for ADLER32 registration if found\n if os.environ.has_key('SETADLER32'):\n performSpecialADRegistration(sitemover, r_fchecksum, r_gpfn)\n\n # should the file also be moved to a secondary storage?\n if dispatchDBlockTokenForOut:\n # verify that list has correct length\n\n s2 = None\n try:\n if filename == logFile:\n dDBlockTokenForOut = dispatchDBlockTokenForOut[-1]\n else:\n dDBlockTokenForOut = dispatchDBlockTokenForOut[file_nr]\n if dDBlockTokenForOut.startswith('chirp'):\n s2, pilotErrorDiag2 = chirp_put_data(pfn, ddm_storage_path, dsname=dsname, sitename=sitename,\\\n analysisJob=analysisJob, testLevel=testLevel, pinitdir=pinitdir,\\\n proxycheck=proxycheck, token=_token_file, timeout=DEFAULT_TIMEOUT, lfn=lfn,\\\n guid=guid, spsetup=spsetup, userid=userid, report=report,\\\n prodSourceLabel=prodSourceLabel, outputDir=outputDir, DN=DN,\\\n dispatchDBlockTokenForOut=dDBlockTokenForOut, logFile=logFile, experiment=experiment)\n except Exception, e:\n tolog(\"!!WARNING!!2998!! Exception caught in mover chirp put: %s\" % str(e))\n else:\n if s2:\n tolog(\"Mover chirp put finished successfully\")\n elif s2 == None:\n tolog(\"Skipped chirp transfer\")\n else:\n tolog(\"chirp transfer returned exit code: %d\" % (s2))\n else:\n tolog(\"dispatchDBlockTokenForOut not set (no chirp transfer)\")\n\n tolog(\"Return code: %d\" % (s))\n\n if logPath != \"\":\n tolog(\"No need to proceed with file registration for special log transfer\")\n break\n\n if s != 0:\n tolog('!!WARNING!!2999!! Failed to transfer %s: %s (%s)' % (os.path.basename(pfn), s, error.getErrorStr(s)))\n fail = s \n break\n\n # gpfn = ftpserv + destpfn\n # keep track of which files have been copied\n fields[0] += '%s+' % r_gpfn \n fields[1] += '%s+' % str(lfn) # Eddie added str, unicode protection\n fields[2] += '%s+' % guid\n fields[3] += '%s+' % r_fsize\n fields[4] += '%s+' % r_fchecksum\n fields[5] += '%s+' % r_farch\n fields[6] += '%s+' % pfn\n\n if fail == 0:\n # should the file be registered in a file catalog?\n _copytool = readpar(\"copytool\")\n _lfcregister = readpar('lfcregister')\n if _lfcregister == \"\":\n # update the current file state since the transfer was ok\n updateFileState(filename, workDir, jobId, mode=\"file_state\", state=\"transferred\")\n dumpFileStates(workDir, jobId)\n\n # Removed capability of pilot file registration (May 13, 2015, v 62a)\n tolog(\"!!WARNING!!2323!! File catalog registration not possible by pilot - should be done by server\")\n else:\n # update the current file states\n updateFileState(filename, workDir, jobId, mode=\"file_state\", state=\"transferred\")\n if _copytool != \"chirp\":\n updateFileState(filename, workDir, jobId, mode=\"reg_state\", state=\"registered\")\n dumpFileStates(workDir, jobId)\n tolog(\"No file catalog registration by the pilot\")\n\n if fail != 0:\n return fail, pilotErrorDiag, fields, None, N_filesNormalStageOut, N_filesAltStageOut\n\n # remove the trailing '+'-sign in each field\n fields[0] = fields[0][:-1]\n fields[1] = fields[1][:-1]\n fields[2] = fields[2][:-1]\n fields[3] = fields[3][:-1]\n fields[4] = fields[4][:-1]\n fields[5] = fields[5][:-1]\n\n tolog(\"Put successful\")\n return 0, pilotErrorDiag, fields, '1', N_filesNormalStageOut, N_filesAltStageOut","def test_sync_no_archive_to_transfer_failure(self):\n support = saltsupport.SaltSupportModule()\n support.archives = MagicMock(return_value=[])\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\n support.sync(\"group-name\", all=True)\n assert \"No archives found to transfer\" in str(err)","def test_claim_resources_success_resize_to_same_host_no_shared(self):\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\n # source host allocation held by the migration_uuid so it is not\n # not returned to the claim code as that asks for the instance_uuid\n # consumer\n get_current_allocations_resp_mock.json.return_value = {\n 'allocations': {},\n \"consumer_generation\": 1,\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\n put_allocations_resp_mock = mock.Mock(status_code=204)\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\n consumer_uuid = uuids.consumer_uuid\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\n # are all being increased but on the same host. We also throw a custom\n # resource class in the new allocation to make sure it's not lost\n alloc_req = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'DISK_GB': 40,\n 'CUSTOM_FOO': 1\n }\n },\n },\n # this allocation request comes from the scheduler therefore it\n # does not have consumer_generation in it.\n \"project_id\": uuids.project_id,\n \"user_id\": uuids.user_id\n }\n\n project_id = uuids.project_id\n user_id = uuids.user_id\n res = self.client.claim_resources(self.context, consumer_uuid,\n alloc_req, project_id, user_id,\n allocation_request_version='1.28')\n\n expected_url = \"/allocations/%s\" % consumer_uuid\n expected_payload = {\n 'allocations': {\n uuids.same_host: {\n 'resources': {\n 'VCPU': 2,\n 'MEMORY_MB': 2048,\n 'DISK_GB': 40,\n 'CUSTOM_FOO': 1\n }\n },\n },\n # report client assumes a new consumer in this case\n 'consumer_generation': None,\n 'project_id': project_id,\n 'user_id': user_id}\n self.ks_adap_mock.put.assert_called_once_with(\n expected_url, microversion='1.28', json=mock.ANY,\n global_request_id=self.context.global_id)\n # We have to pull the json body from the mock call_args to validate\n # it separately otherwise hash seed issues get in the way.\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\n self.assertEqual(expected_payload, actual_payload)\n\n self.assertTrue(res)","def run(ceph_cluster, **kw):\n log.info(run.__doc__)\n config = kw[\"config\"]\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\n rados_object = RadosOrchestrator(node=cephadm)\n mon_obj = MonConfigMethods(rados_obj=rados_object)\n ceph_nodes = kw.get(\"ceph_nodes\")\n osd_list = []\n total_osd_app_mem = {}\n\n for node in ceph_nodes:\n if node.role == \"osd\":\n node_osds = rados_object.collect_osd_daemon_ids(node)\n osd_list = osd_list + node_osds\n\n target_configs = config[\"cache_trim_max_skip_pinned\"][\"configurations\"]\n max_skip_pinned_value = int(\n mon_obj.get_config(section=\"osd\", param=\"bluestore_cache_trim_max_skip_pinned\")\n )\n\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\n if max_skip_pinned_value != 1000:\n log.error(\n \"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\"\n )\n raise Exception(\n \"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\"\n )\n\n # Creating pools and starting the test\n for entry in target_configs.values():\n log.debug(\n f\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\"\n )\n if entry.get(\"pool_type\", \"replicated\") == \"erasure\":\n method_should_succeed(\n rados_object.create_erasure_pool, name=entry[\"pool_name\"], **entry\n )\n else:\n method_should_succeed(\n rados_object.create_pool,\n **entry,\n )\n\n if not rados_object.bench_write(**entry):\n log.error(\"Failed to write objects into the EC Pool\")\n return 1\n rados_object.bench_read(**entry)\n log.info(\"Finished writing data into the pool\")\n\n # performing scrub and deep-scrub\n rados_object.run_scrub()\n rados_object.run_deep_scrub()\n time.sleep(10)\n\n rados_object.change_heap_profiler_state(osd_list, \"start\")\n # Executing tests for 45 minutes\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\n while datetime.datetime.now() < time_execution:\n # Get all OSDs heap dump\n heap_dump = rados_object.get_heap_dump(osd_list)\n # get the osd application used memory\n osd_app_mem = get_bytes_used_by_app(heap_dump)\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\n # wait for 10 seconds and collecting the memory\n time.sleep(10)\n for osd_id, mem_list in total_osd_app_mem.items():\n mem_growth = is_what_percent_mem(mem_list)\n if mem_growth > 80:\n log.error(\n f\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\"\n )\n raise Exception(\"No warning generated by PG Autoscaler\")\n log.info(f\"The relative memory growth for the osd.{osd_id} is {mem_growth} \")\n\n rados_object.change_heap_profiler_state(osd_list, \"stop\")\n\n # check fo the crashes in the cluster\n crash_list = rados_object.do_crash_ls()\n if not crash_list:\n return 0\n else:\n return 1","def share(observer, tid):\n try:\n manager = Actions()\n manager.share_task(observer, tid)\n except Exception as e:\n click.echo(e)","def test_autocreate_licensepool(self):\n identifier = self._identifier()\n assert [] == identifier.licensed_through\n provider = AlwaysSuccessfulCollectionCoverageProvider(\n self._default_collection\n )\n pool = provider.license_pool(identifier)\n assert [pool] == identifier.licensed_through\n assert pool.data_source == provider.data_source\n assert pool.identifier == identifier\n assert pool.collection == provider.collection\n\n # Calling license_pool again finds the same LicensePool\n # as before.\n pool2 = provider.license_pool(identifier)\n assert pool == pool2\n\n # It's possible for a CollectionCoverageProvider to create a\n # LicensePool for a different DataSource than the one\n # associated with the Collection. Only the metadata wrangler\n # needs to do this -- it's so a CoverageProvider for a\n # third-party DataSource can create an 'Internal Processing'\n # LicensePool when some other part of the metadata wrangler\n # failed to do this earlier.\n\n # If a working pool already exists, it's returned and no new\n # pool is created.\n same_pool = provider.license_pool(\n identifier, DataSource.INTERNAL_PROCESSING\n )\n assert same_pool == pool2\n assert provider.data_source == same_pool.data_source\n\n # A new pool is only created if no working pool can be found.\n identifier2 = self._identifier()\n new_pool = provider.license_pool(\n identifier2, DataSource.INTERNAL_PROCESSING\n )\n assert new_pool.data_source.name == DataSource.INTERNAL_PROCESSING\n assert new_pool.identifier == identifier2\n assert new_pool.collection == provider.collection"],"string":"[\n \"def test_update_nas_share_by_nas(self):\\n pass\",\n \"def test_update_nas_share(self):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def test_show_nas_share_by_pool(self):\\n pass\",\n \"def test_destroy_nas_share_by_pool(self):\\n pass\",\n \"def test_mount_status_nas_share_by_pool(self):\\n pass\",\n \"def test_test_nas_share(self):\\n pass\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def test_test_result_nas_share(self):\\n pass\",\n \"def test_destroy_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares_by_nas(self):\\n pass\",\n \"def test_show_nas_share_by_nas(self):\\n pass\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_show_nas_share(self):\\n pass\",\n \"def test_mount_status_nas_share_by_nas(self):\\n pass\",\n \"def test_index_nas_shares(self):\\n pass\",\n \"def test_share(self):\\n\\n # In the actual test, we'll want to confirm that an IP address\\n # can be shared to a group\\n\\n # Try to share with the group--fails for now (operation not\\n # implemented in nova); note: change 1 to group, '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.share_ip, 1, '10.0.0.1', True)\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def test_update_pool(self):\\r\\n resource = 'pool'\\r\\n cmd = pool.UpdatePool(test_cli20.MyApp(sys.stdout), None)\\r\\n self._test_update_resource(resource, cmd, 'myid',\\r\\n ['myid', '--name', 'newname'],\\r\\n {'name': 'newname', })\",\n \"def test_share_38(self):\\n with self.os_environ_get_patch, \\\\\\n self.patch_push_share, \\\\\\n self.patch_subprocess_call, \\\\\\n self.sys_version_38_patch:\\n self.inst.share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n \\\"r\\\",\\n \\\"w\\\"\\n )\\n self.subprocess_call_mock.assert_called_once()\\n self.push_share_mock.assert_awaited_once()\",\n \"def test_unshare(self):\\n\\n # In the actual test, we'll want to confirm that a shared IP\\n # address can be unshared from a group\\n\\n # Try to unshare from the group--fails for now (operation not\\n # implemented in nova); note: change '10.0.0.1' to IP\\n dtutil.assert_raises(novaclient.OpenStackException,\\n self.server.unshare_ip, '10.0.0.1')\",\n \"def test_update_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_edit_share(self, client):\\n user = UserFactory(email='bob@gmail.com')\\n client = self.get_auth_client(user)\\n\\n i1 = InstitutionFactory.get_institution()\\n item = ItemFactory.get_item(user=user, institution=i1)\\n a1 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n i2 = Institution.objects.filter(~Q(plaid_id=i1.plaid_id)).first()\\n item = ItemFactory.get_item(user=user, institution=i2)\\n a2 = AccountFactory.get_account(item=item, type=Account.CREDIT)\\n\\n url = '/v1/accounts/edit_share'\\n\\n # ids not match\\n dic = {\\n 'id100': 50,\\n 'id200': 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n return\\n\\n # The total sum not equal to 100\\n dic = {\\n 'id{}'.format(a1.id): 10,\\n 'id{}'.format(a2.id): 20\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 400\\n\\n # success\\n dic = {\\n 'id{}'.format(a1.id): 50,\\n 'id{}'.format(a2.id): 50\\n }\\n data = json.dumps(dic)\\n response = client.put(url, data, content_type='application/json')\\n assert response.status_code == 200\\n\\n a1.refresh_from_db()\\n a2.refresh_from_db()\\n\\n assert a1.transfer_share == 50\\n assert a1.transfer_share == 50\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def test_share_distributor(self):\\n\\n # =================================================================\\n # test: complete test, share distribution int\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n buy_orders = [StockOrderWrapper(self.order_3), StockOrderWrapper(self.order_4), StockOrderWrapper(self.order_7),\\n StockOrderWrapper(self.order_8), StockOrderWrapper(self.order_11),\\n StockOrderWrapper(self.order_12)]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_real_3 = result[0]\\n order_real_4 = result[1]\\n order_real_7 = result[2]\\n order_real_8 = result[3]\\n order_real_11 = result[4]\\n order_real_12 = result[5]\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n\\n order_exp_3 = StockOrderWrapper(self.order_3)\\n order_exp_4 = StockOrderWrapper(self.order_4)\\n order_exp_7 = StockOrderWrapper(self.order_7)\\n order_exp_8 = StockOrderWrapper(self.order_8)\\n order_exp_11 = StockOrderWrapper(self.order_11)\\n order_exp_12 = StockOrderWrapper(self.order_12)\\n\\n order_exp_3.transaction_dict = sell_order_dict_1\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_2\\n order_exp_11.transaction_dict = sell_order_dict_2\\n order_exp_12.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 4\\n order_exp_4.shares_left = 8\\n order_exp_7.shares_left = 8\\n order_exp_8.shares_left = 8\\n order_exp_11.shares_left = 8\\n order_exp_12.shares_left = 4\\n\\n self.is_equal_order_wrapper(order_real_3, order_exp_3)\\n self.is_equal_order_wrapper(order_real_4, order_exp_4)\\n self.is_equal_order_wrapper(order_real_7, order_exp_7)\\n self.is_equal_order_wrapper(order_real_8, order_exp_8)\\n self.is_equal_order_wrapper(order_real_11, order_exp_11)\\n self.is_equal_order_wrapper(order_real_12, order_exp_12)\\n\\n # =================================================================\\n # test: share distribution float easy\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 6\\n buy_order_3.shares_left = 8 # 2.4 -> 3\\n buy_order_4.shares_left = 4 # 1.2 -> 1\\n buy_order_7.shares_left = 4 # 1.2 -> 1\\n buy_order_8.shares_left = 4 # 1.2 -> 1\\n buy_order_11.shares_left = 0 # 0.0 -> 0\\n buy_order_12.shares_left = 0 # 0.0 -> 0\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[4]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_3 = {sell: 3}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_1\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n\\n order_exp_3.shares_left = 5\\n order_exp_4.shares_left = 3\\n order_exp_7.shares_left = 3\\n order_exp_8.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n\\n # =================================================================\\n # test: share distribution float complex (multiple float iterations)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 18\\n sell.stock_order.order_status = DEFINITIVE\\n\\n self.order_3.order_status = DEFINITIVE\\n self.order_4.order_status = DEFINITIVE\\n self.order_7.order_status = DEFINITIVE\\n self.order_8.order_status = DEFINITIVE\\n self.order_11.order_status = DEFINITIVE\\n self.order_12.order_status = DEFINITIVE\\n\\n buy_order_3.shares_left = 6 # 3.6 -> 4\\n buy_order_4.shares_left = 4 # 2.4 -> 2\\n buy_order_7.shares_left = 2 # 1.2 -> 1\\n buy_order_8.shares_left = 2 # 1.2 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_2\\n order_exp_7.transaction_dict = sell_order_dict_1\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 2\\n order_exp_4.shares_left = 2\\n order_exp_7.shares_left = 1\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution date (two stocks left after one float iteration)\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n sell.shares_left = 19\\n\\n buy_order_3.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_4.shares_left = 4 # 2.4 -> 2 -> 3\\n buy_order_7.shares_left = 4 # 2.4 -> 2 -> 2\\n buy_order_8.shares_left = 2 # 1.2 -> 1 -> 1\\n buy_order_11.shares_left = 8 # 4.8 -> 5 -> 5\\n buy_order_12.shares_left = 8 # 4.8 -> 5 -> 5\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n result_dict = {}\\n\\n for res in result:\\n result_dict[res.stock_order.order_id] = res\\n\\n try:\\n # noinspection PyUnusedLocal\\n dummy = result[6]\\n raise AssertionError(\\\"IndexError exception expected\\\")\\n except IndexError:\\n pass\\n\\n sell_order_dict_1 = {sell: 1}\\n sell_order_dict_2 = {sell: 2}\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_5 = {sell: 5}\\n\\n order_exp_3.transaction_dict = sell_order_dict_3\\n order_exp_4.transaction_dict = sell_order_dict_3\\n order_exp_7.transaction_dict = sell_order_dict_2\\n order_exp_8.transaction_dict = sell_order_dict_1\\n order_exp_11.transaction_dict = sell_order_dict_5\\n order_exp_12.transaction_dict = sell_order_dict_5\\n\\n order_exp_3.shares_left = 1\\n order_exp_4.shares_left = 1\\n order_exp_7.shares_left = 2\\n order_exp_8.shares_left = 1\\n order_exp_11.shares_left = 3\\n order_exp_12.shares_left = 3\\n\\n order_exp_11.order_status = DEFINITIVE\\n order_exp_12.order_status = DEFINITIVE\\n\\n self.is_equal_order_wrapper(result_dict.get(3), order_exp_3)\\n self.is_equal_order_wrapper(result_dict.get(4), order_exp_4)\\n self.is_equal_order_wrapper(result_dict.get(7), order_exp_7)\\n self.is_equal_order_wrapper(result_dict.get(8), order_exp_8)\\n self.is_equal_order_wrapper(result_dict.get(11), order_exp_11)\\n self.is_equal_order_wrapper(result_dict.get(12), order_exp_12)\\n\\n # =================================================================\\n # test: share distribution int sell shares left\\n # =================================================================\\n\\n sell_list = [StockOrderWrapper(self.order_2)]\\n sell = sell_list[0]\\n\\n sell.shares_left = 100\\n\\n buy_order_3 = StockOrderWrapper(self.order_3)\\n buy_order_4 = StockOrderWrapper(self.order_4)\\n buy_order_7 = StockOrderWrapper(self.order_7)\\n buy_order_8 = StockOrderWrapper(self.order_8)\\n buy_order_11 = StockOrderWrapper(self.order_11)\\n buy_order_12 = StockOrderWrapper(self.order_12)\\n\\n buy_order_3.shares_left = 4\\n buy_order_4.shares_left = 7\\n buy_order_7.shares_left = 9\\n buy_order_8.shares_left = 4\\n buy_order_11.shares_left = 8\\n buy_order_12.shares_left = 3\\n\\n buy_orders = [buy_order_3, buy_order_4, buy_order_7, buy_order_8, buy_order_11, buy_order_12]\\n\\n result = self.bidding_round_manager.share_distributor(sell_orders=sell_list, buy_orders=buy_orders)\\n\\n order_exp_2 = StockOrderWrapper(self.order_2)\\n order_exp_2.shares_left = 65\\n\\n self.is_equal_order_wrapper(result[0], order_exp_2)\\n\\n sell_order_dict_3 = {sell: 3}\\n sell_order_dict_4 = {sell: 4}\\n sell_order_dict_7 = {sell: 7}\\n sell_order_dict_8 = {sell: 8}\\n sell_order_dict_9 = {sell: 9}\\n\\n order_exp_3.transaction_dict = sell_order_dict_4\\n order_exp_4.transaction_dict = sell_order_dict_7\\n order_exp_7.transaction_dict = sell_order_dict_9\\n order_exp_8.transaction_dict = sell_order_dict_4\\n order_exp_11.transaction_dict = sell_order_dict_8\\n order_exp_12.transaction_dict = sell_order_dict_3\\n\\n order_exp_3.shares_left = 0\\n order_exp_4.shares_left = 0\\n order_exp_7.shares_left = 0\\n order_exp_8.shares_left = 0\\n order_exp_11.shares_left = 0\\n order_exp_12.shares_left = 0\\n\\n order_exp_3.order_status = PROCESSED\\n order_exp_4.order_status = PROCESSED\\n order_exp_7.order_status = PROCESSED\\n order_exp_8.order_status = PROCESSED\\n order_exp_11.order_status = PROCESSED\\n order_exp_12.order_status = PROCESSED\\n\\n self.is_equal_order_wrapper(buy_order_3, order_exp_3)\\n self.is_equal_order_wrapper(buy_order_4, order_exp_4)\\n self.is_equal_order_wrapper(buy_order_7, order_exp_7)\\n self.is_equal_order_wrapper(buy_order_8, order_exp_8)\\n self.is_equal_order_wrapper(buy_order_11, order_exp_11)\\n self.is_equal_order_wrapper(buy_order_12, order_exp_12)\",\n \"async def test_change_pools(self, setup, trusted_and_fee, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n pool_a_ph = receive_address[1]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_b_ph = await wallets[1].get_new_puzzlehash()\\n full_node_api = full_nodes[0]\\n\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n WAIT_SECS = 200\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n pool_a_ph, \\\"https://pool-a.org\\\", 5, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"FARMING_TO_POOL\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status.target is None\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n assert pw_info.current.pool_url == \\\"https://pool-a.org\\\"\\n assert pw_info.current.relative_lock_height == 5\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_b_ph,\\n \\\"https://pool-b.org\\\",\\n 10,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n\\n async def status_is_leaving():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving)\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n assert pw_info.current.pool_url == \\\"https://pool-b.org\\\"\\n assert pw_info.current.relative_lock_height == 10\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_set_share(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=200\\n )\",\n \"async def test_change_pools_reorg(self, setup, trusted_and_fee, bt, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n pool_a_ph = receive_address[1]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_b_ph = await wallets[1].get_new_puzzlehash()\\n full_node_api = full_nodes[0]\\n WAIT_SECS = 30\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n pool_a_ph, \\\"https://pool-a.org\\\", 5, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"FARMING_TO_POOL\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status.target is None\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n\\n pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n assert pw_info.current.pool_url == \\\"https://pool-a.org\\\"\\n assert pw_info.current.relative_lock_height == 5\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_b_ph,\\n \\\"https://pool-b.org\\\",\\n 10,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n join_pool_tx.spend_bundle,\\n join_pool_tx.name,\\n )\\n await farm_blocks(full_node_api, our_ph, 1)\\n\\n async def status_is_leaving_no_blocks():\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n async def status_is_farming_to_pool_no_blocks():\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving_no_blocks)\\n\\n current_blocks = await full_node_api.get_all_full_blocks()\\n more_blocks = full_node_api.bt.get_consecutive_blocks(\\n 3,\\n farmer_reward_puzzle_hash=pool_a_ph,\\n pool_reward_puzzle_hash=pool_b_ph,\\n block_list_input=current_blocks[:-1],\\n force_overflow=True,\\n guarantee_transaction_block=True,\\n seed=32 * b\\\"4\\\",\\n transaction_data=join_pool_tx.spend_bundle,\\n )\\n\\n for block in more_blocks[-3:]:\\n await full_node_api.full_node.respond_block(RespondBlock(block))\\n\\n await asyncio.sleep(5)\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving_no_blocks)\\n\\n # Eventually, leaves pool\\n await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_update_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def test_thread_pool(self):\\n self.assertIdentical(self.tx_client._pool, self.pool)\",\n \"def modify_share(self, pool, project, share, arg):\\n svc = self.share_path % (pool, project, share)\\n ret = self.rclient.put(svc, arg)\\n if ret.status != restclient.Status.ACCEPTED:\\n exception_msg = (_('Error modifying %(arg)s '\\n ' of share %(id)s.')\\n % {'arg': arg,\\n 'id': share})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def update_pool(self, pool, body=None):\\r\\n return self.put(self.pool_path % (pool), body=body)\",\n \"def test_dashboards_v2_share(self):\\n pass\",\n \"def test_update_non_shareable(self):\\n self.create_common_users_and_groups()\\n sync = SyncUserAndGroups(\\n tsurl=TS_URL,\\n username=TS_USER,\\n password=TS_PASSWORD,\\n disable_ssl=True,\\n )\\n auag = sync.get_all_users_and_groups()\\n\\n # Need to remove the common users since they don't have emails.\\n auag.remove_user(\\\"guest\\\")\\n auag.remove_user(\\\"su\\\")\\n auag.remove_user(\\\"system\\\")\\n auag.remove_user(\\\"tsadmin\\\")\\n\\n # Change Group 1 and Group 2 and verify change took.\\n group1 = auag.get_group(\\\"Group 1\\\")\\n group1.visibility = Visibility.NON_SHAREABLE\\n group2 = auag.get_group(\\\"Group 2\\\")\\n group2.visibility = Visibility.DEFAULT\\n\\n # sync updates\\n sync.sync_users_and_groups(users_and_groups=auag)\\n\\n # verify changes\\n auag = sync.get_all_users_and_groups()\\n self.assertEqual(\\n auag.get_group(\\\"Group 1\\\").visibility, Visibility.NON_SHAREABLE\\n )\\n self.assertEqual(\\n auag.get_group(\\\"Group 2\\\").visibility, Visibility.DEFAULT\\n )\\n self.assertEqual(\\n auag.get_group('Group \\\"3\\\"').visibility, Visibility.NON_SHAREABLE\\n )\",\n \"def test_replace_cluster_resource_quota(self):\\n pass\",\n \"def csAddPool(self,pool,creatorid,nas=None):\\n\\n logger.debug(\\\"Attempting to create pool '\\\"+pool+\\\"'.\\\")\\n\\n localpath = \\\"/.\\\"+pool\\n\\n url = self.csurl + \\\"/polcentral/v1_0/pools/\\\"\\n\\n if nas == None:\\n logger.debug(\\\"No NAS object provided, will create pool '\\\"+pool+\\\"' type 'MW'.\\\")\\n pooltype = 'MW'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n else:\\n logger.debug(\\\"NAS object provided, will create pool '\\\"+pool+\\\"' type 'PS'.\\\")\\n pooltype = 'PS'\\n subscribedevices = True\\n deviceid = ''\\n pathinpool = '/'\\n servername = ''\\n sharename = ''\\n sharepath = ''\\n creditname = ''\\n overridewarnings = True\\n\\n payload = {\\n \\\"name\\\": pool,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath\\n }\\n \\\"\\\"\\\"\\n payload = {\\n \\\"name\\\": poolname,\\n \\\"description\\\":\\\"Pool added by testbot\\\",\\n \\\"creatorid\\\": {\\\"$id\\\": creatorid},\\n \\\"type\\\":pooltype,\\n \\\"allowpiggybacks\\\":True,\\n \\\"localpoolpath\\\": localpath,\\n \\\"subscribedevices\\\":subscribedevices,\\n \\\"deviceid\\\": deviceid,\\n \\\"pathinpool\\\": pathinpool,\\n \\\"servername\\\": servername,\\n \\\"sharename\\\": sharename,\\n \\\"sharepath\\\": sharepath,\\n \\\"credsetname\\\": creditname,\\n \\\"overridewarnings\\\": overridewarnings\\n }\\n \\\"\\\"\\\"\\n\\n try:\\n r = requests.post(url, data=json.dumps(payload))\\n except Exception:\\n logger.error(\\\"Exception during api call to add pool.\\\")\\n return 'Error'\\n\\n if r.status_code == 200:\\n logger.debug(\\\"Pool '\\\"+pool+\\\"' was successfully created.\\\")\\n poolid = r.json()['_id']\\n return poolid['$id']\\n else:\\n logger.error(\\\"Pool '\\\"+pool+\\\"' was not created. Error code is \\\"+str(r.status_code)+\\\".\\\")\\n return 'Error'\",\n \"def _update_share_stats(self):\\n\\n # sanity check for gluster ctl mount\\n smpb = os.stat(self.configuration.glusterfs_mount_point_base)\\n smp = os.stat(self._get_mount_point_for_gluster_vol())\\n if smpb.st_dev == smp.st_dev:\\n raise exception.GlusterfsException(\\n _(\\\"GlusterFS control mount is not available\\\")\\n )\\n smpv = os.statvfs(self._get_mount_point_for_gluster_vol())\\n\\n data = dict(\\n storage_protocol='NFS',\\n vendor_name='Red Hat',\\n share_backend_name=self.backend_name,\\n reserved_percentage=self.configuration.reserved_share_percentage,\\n total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,\\n free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)\\n super(GlusterfsShareDriver, self)._update_share_stats(data)\",\n \"def test_cephfs_share(self):\\n keyring = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.client.admin.keyring')['Stdout']\\n conf = model.run_on_leader(\\n 'ceph-mon', 'cat /etc/ceph/ceph.conf')['Stdout']\\n # Spawn Servers\\n instance_1, instance_2 = self.launch_guests(\\n userdata=self.INSTANCE_USERDATA.format(\\n _indent(conf, 8),\\n _indent(keyring, 8)))\\n\\n # Write a file on instance_1\\n def verify_setup(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n\\n fip_1 = neutron_tests.floating_ips_from_instance(instance_1)[0]\\n fip_2 = neutron_tests.floating_ips_from_instance(instance_2)[0]\\n username = guest.boot_tests['bionic']['username']\\n password = guest.boot_tests['bionic'].get('password')\\n privkey = openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME)\\n\\n for attempt in Retrying(\\n stop=stop_after_attempt(3),\\n wait=wait_exponential(multiplier=1, min=2, max=10)):\\n with attempt:\\n openstack_utils.ssh_command(\\n username, fip_1, 'instance-1',\\n 'sudo mount -a && '\\n 'echo \\\"test\\\" | sudo tee /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify_setup)\\n\\n def verify(stdin, stdout, stderr):\\n status = stdout.channel.recv_exit_status()\\n self.assertEqual(status, 0)\\n out = \\\"\\\"\\n for line in iter(stdout.readline, \\\"\\\"):\\n out += line\\n self.assertEqual(out, \\\"test\\\\n\\\")\\n\\n openstack_utils.ssh_command(\\n username, fip_2, 'instance-2',\\n 'sudo mount -a && '\\n 'sudo cat /mnt/cephfs/test',\\n password=password, privkey=privkey, verify=verify)\",\n \"def test_synchronize_all_networks(self):\\n\\n # Store two tenants in a db and none on EOS.\\n # The sync should send details of all tenants to EOS\\n tenant_1_id = 'tenant-1'\\n tenant_1_net_1_id = 'ten-1-net-1'\\n tenant_1_net_1_seg_id = 11\\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id,\\n tenant_1_net_1_seg_id, 'segment_id_11')\\n\\n tenant_2_id = 'tenant-2'\\n tenant_2_net_1_id = 'ten-2-net-1'\\n tenant_2_net_1_seg_id = 21\\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id,\\n tenant_2_net_1_seg_id, 'segment_id_21')\\n\\n self.rpc.get_tenants.return_value = {}\\n\\n self.rpc.sync_start.return_value = True\\n self.rpc.sync_end.return_value = True\\n self.rpc.check_cvx_availability.return_value = True\\n\\n self.rpc._baremetal_supported.return_value = False\\n self.rpc.get_all_baremetal_hosts.return_value = {}\\n\\n self.sync_service.do_synchronize()\\n\\n expected_calls = [\\n mock.call.perform_sync_of_sg(self.sync_service._context),\\n mock.call.check_cvx_availability(),\\n mock.call.get_region_updated_time(),\\n mock.call.get_region_updated_time().__bool__(),\\n mock.call.sync_start(),\\n mock.call.register_with_eos(sync=True),\\n mock.call.check_supported_features(),\\n mock.call.get_tenants(),\\n\\n mock.call.create_network_bulk(\\n tenant_1_id,\\n [{'network_id': tenant_1_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n\\n mock.call.create_network_bulk(\\n tenant_2_id,\\n [{'network_id': tenant_2_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n mock.call.sync_end(),\\n mock.call.get_region_updated_time()\\n ]\\n\\n # The create_network_bulk() can be called in different order. So split\\n # it up. The first part checks if the initial set of methods are\\n # invoked.\\n idx = expected_calls.index(mock.call.get_tenants()) + 1\\n self.assertTrue(self.rpc.mock_calls[:idx] == expected_calls[:idx],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 1 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if tenant 2 networks are created. It must be one of the two\\n # methods.\\n self.assertTrue(self.rpc.mock_calls[idx + 1] in\\n expected_calls[idx:idx + 2],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n # Check if the sync end methods are invoked.\\n self.assertTrue(self.rpc.mock_calls[idx + 2:] ==\\n expected_calls[idx + 2:],\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n\\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id)\\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)\",\n \"def test_add_node_to_pool_with_large_ppseqno_diff_views(do_view_change, looper, txnPoolNodeSet, tconf, sdk_pool_handle,\\n sdk_wallet_steward, tdir, allPluginsPath):\\n\\n ensure_several_view_change(looper, txnPoolNodeSet, do_view_change, custom_timeout=tconf.NEW_VIEW_TIMEOUT)\\n\\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\\n big_ppseqno = cur_ppseqno + tconf.LOG_SIZE * 2 + 2300\\n assert (big_ppseqno > cur_ppseqno)\\n\\n # ensure pool is working properly\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\\n\\n _set_ppseqno(txnPoolNodeSet, big_ppseqno)\\n cur_ppseqno = get_pp_seq_no(txnPoolNodeSet)\\n assert (big_ppseqno == cur_ppseqno)\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n\\n assert (cur_ppseqno < get_pp_seq_no(txnPoolNodeSet))\\n\\n\\n\\n # Disable view change after adding new node as it will not be able to finish due to fake ppSeqNo set\\n for n in txnPoolNodeSet:\\n n.write_manager.node_reg_handler.internal_bus = None\\n\\n new_steward_name = \\\"testClientSteward\\\" + randomString(4)\\n new_node_name = \\\"TestTheta\\\" + randomString(4)\\n new_steward_wallet_handle, new_node = sdk_add_new_steward_and_node(\\n looper, sdk_pool_handle, sdk_wallet_steward,\\n new_steward_name, new_node_name, tdir, tconf,\\n allPluginsPath=allPluginsPath)\\n txnPoolNodeSet.append(new_node)\\n looper.run(checkNodesConnected(txnPoolNodeSet))\\n\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n new_steward_wallet_handle,\\n sdk_pool_handle)\\n\\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\\n\\n sdk_ensure_pool_functional(looper, txnPoolNodeSet,\\n sdk_wallet_steward,\\n sdk_pool_handle)\\n\\n waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])\",\n \"def test_new_share(self):\\n \\n test_user_with_checkpoint = self.create_saved_test_user_with_checkpoint()\\n another_test_user_to_share = self.create_saved_test_user()\\n \\n data = {\\\"user_id\\\": test_user_with_checkpoint.user_obj.id,\\n \\\"to_user_id\\\": another_test_user_to_share.user_obj.id,\\n \\\"signature\\\": gen_signature(\\\"put\\\",\\n \\\"share\\\",\\n gen_api_key(test_user_with_checkpoint.user_obj.access_token, \\n test_user_with_checkpoint.user_obj.id)),\\n \\\"user_checkpoint_id\\\": test_user_with_checkpoint.user_checkpoint_obj.id\\n }\\n \\n resp = self.client.put(\\\"/share/\\\", data=data)\\n assert \\\"ok\\\" in resp.data\\n assert not get_share_w_attr(test_user_with_checkpoint.user_obj, \\n another_test_user_to_share.user_obj, \\n test_user_with_checkpoint.user_checkpoint_obj) is None\",\n \"def test_sync_clear_mempool(self):\\n logging.info(\\\">>> Entered : test_sync_clear_mempool \\\\n\\\")\\n try:\\n # clear out the mempool\\n mostly_sync_mempools(self.nodes)\\n for index1, n in enumerate(self.nodes):\\n n.generate(2)\\n sync_blocks(self.nodes)\\n for index2, n in enumerate(self.nodes):\\n while len(n.getrawmempool()):\\n n.generate(1)\\n sync_blocks(self.nodes)\\n logging.info(\\\"cleared mempool: %s\\\" % str([len(x) for x in [y.getrawmempool() for y in self.nodes]]))\\n base = [x.getrawmempool() for x in self.nodes]\\n assert_equal(base, [base[0]] * 4)\\n except (Exception, JSONRPCException) as e1:\\n logging.info(e1)\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\\n raise TestAssertionError({\\\"file_name\\\": fname, \\\"line_num\\\": exc_tb.tb_lineno, \\\\\\n \\\"error_type\\\": exc_type.__name__, \\\"error_msg\\\": str( e1 ), \\\\\\n \\\"n1\\\" : self.bins[index1], \\\"n2\\\" : self.bins[index2], \\\"amount\\\" : \\\"N/A\\\", \\\"numsig\\\" : \\\"N/A\\\"})\",\n \"def pool_snps(parent1, parent2):\",\n \"def test_claim_resources_success_resize_to_same_host_with_shared(self):\\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\\n # source host allocation held by the migration_uuid so it is not\\n # not returned to the claim code as that asks for the instance_uuid\\n # consumer\\n get_current_allocations_resp_mock.json.return_value = {\\n 'allocations': {},\\n \\\"consumer_generation\\\": 1,\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\\n put_allocations_resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\\n # are all being increased but on the same host. We also throw a custom\\n # resource class in the new allocation to make sure it's not lost\\n alloc_req = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n uuids.shared_storage: {\\n 'resources': {\\n 'DISK_GB': 40,\\n }\\n },\\n },\\n # this allocation request comes from the scheduler therefore it\\n # does not have consumer_generation in it.\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.claim_resources(self.context, consumer_uuid,\\n alloc_req, project_id, user_id,\\n allocation_request_version='1.28')\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n expected_payload = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n uuids.shared_storage: {\\n 'resources': {\\n 'DISK_GB': 40,\\n }\\n },\\n },\\n # report client assumes a new consumer in this case\\n 'consumer_generation': None,\\n 'project_id': project_id,\\n 'user_id': user_id}\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n\\n self.assertTrue(res)\",\n \"def test_volume_service_pool(self):\\n self.assertEqual(\\n ChangeStateScript()._deployer._volume_service._pool,\\n StoragePool(reactor, b\\\"flocker\\\", FilePath(b\\\"/flocker\\\")))\",\n \"def test_replace_cluster_network(self):\\n pass\",\n \"def test_networking_project_network_update(self):\\n pass\",\n \"def test_update_pci_link(self):\\n pass\",\n \"def update_minion_pool():\\n pool = fetch_minion_pool()\\n save_minion_pool(pool)\\n return pool\",\n \"async def test_self_pooling_to_pooling(self, setup, trusted_and_fee, self_hostname):\\n\\n trusted, fee = trusted_and_fee\\n num_blocks = 4 # Num blocks to farm at a time\\n total_blocks = 0 # Total blocks farmed so far\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n wallet_node_0 = wallet_nodes[0]\\n our_ph = receive_address[0]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_node_0.config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_node_0.server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n total_blocks += await farm_blocks(full_node_api, our_ph, num_blocks)\\n total_block_rewards = await get_total_block_rewards(total_blocks)\\n\\n await time_out_assert(20, wallets[0].get_unconfirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_confirmed_balance, total_block_rewards)\\n await time_out_assert(20, wallets[0].get_spendable_balance, total_block_rewards)\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n assert total_block_rewards > 0\\n\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5001\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx_2.spend_bundle,\\n creation_tx_2.name,\\n )\\n\\n for r in creation_tx.removals:\\n assert r not in creation_tx_2.removals\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n await time_out_assert(20, wallet_is_synced, True, wallet_node_0, full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 2\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n wallet_id_2: int = summaries_response[1][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n assert status_2.target is None\\n\\n async def tx_is_in_mempool(wid, tx: TransactionRecord):\\n fetched: Optional[TransactionRecord] = await client.get_transaction(wid, tx.name)\\n return fetched is not None and fetched.is_in_mempool()\\n\\n join_pool: Dict = await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 10,\\n fee,\\n )\\n assert join_pool[\\\"success\\\"]\\n join_pool_tx: TransactionRecord = join_pool[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id, join_pool_tx)\\n\\n join_pool_2: Dict = await client.pw_join_pool(wallet_id_2, pool_ph, \\\"https://pool.example.com\\\", 10, fee)\\n assert join_pool_2[\\\"success\\\"]\\n join_pool_tx_2: TransactionRecord = join_pool_2[\\\"transaction\\\"]\\n for r in join_pool_tx.removals:\\n assert r not in join_pool_tx_2.removals\\n assert join_pool_tx_2 is not None\\n await time_out_assert(5, tx_is_in_mempool, True, wallet_id_2, join_pool_tx_2)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n status_2: PoolWalletInfo = (await client.pw_status(wallet_id_2))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is not None\\n assert status.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n assert status_2.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status_2.target is not None\\n assert status_2.target.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await farm_blocks(full_node_api, our_ph, 1)\\n\\n async def status_is_farming_to_pool(w_id: int):\\n pw_status: PoolWalletInfo = (await client.pw_status(w_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id)\\n await time_out_assert(20, status_is_farming_to_pool, True, wallet_id_2)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"def test_remove_provider_from_inst_alloc_no_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def test_rebuild_with_wrong_shared_storage(self, mock_remove_allocs):\\n with mock.patch.object(self.compute.driver, 'instance_on_disk',\\n side_effect=lambda x: True) as mock_inst:\\n self.assertRaises(exception.InvalidSharedStorage,\\n lambda: self._rebuild(on_shared_storage=False))\\n\\n # Should remain on original host\\n instance = db.instance_get(self.context, self.inst.id)\\n self.assertEqual(instance['host'], 'fake_host_2')\\n self.assertTrue(mock_inst.called)\\n mock_remove_allocs.assert_called_once_with(\\n mock.ANY, instance.uuid, self.rt.compute_nodes[NODENAME].uuid)\",\n \"def test_patch_cluster_network(self):\\n pass\",\n \"def test_remove_provider_from_inst_alloc_with_shared(self):\\n get_resp_mock = mock.Mock(status_code=200)\\n get_resp_mock.json.side_effect = [\\n {\\n 'allocations': {\\n uuids.source: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': uuids.project_id,\\n 'user_id': uuids.user_id,\\n },\\n # the second get is for resource providers in the compute tree,\\n # return just the compute\\n {\\n \\\"resource_providers\\\": [\\n {\\n \\\"uuid\\\": uuids.source,\\n },\\n ]\\n },\\n ]\\n self.ks_adap_mock.get.return_value = get_resp_mock\\n resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.remove_provider_tree_from_instance_allocation(\\n self.context, consumer_uuid, uuids.source)\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n # New allocations should only include the destination...\\n expected_payload = {\\n 'allocations': {\\n uuids.shared_storage: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'DISK_GB': 100,\\n },\\n },\\n uuids.destination: {\\n 'resource_provider_generation': 42,\\n 'resources': {\\n 'VCPU': 1,\\n 'MEMORY_MB': 1024,\\n },\\n },\\n },\\n 'consumer_generation': 1,\\n 'project_id': project_id,\\n 'user_id': user_id\\n }\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n\\n self.assertTrue(res)\",\n \"def test_update_hyperflex_cluster_profile(self):\\n pass\",\n \"def test_update_network(self):\\n policies_ports = [\\n (None, {self.ports[0].id}),\\n (self.qos_policies[1].id, {self.ports[0].id})]\\n\\n self.ports[1].qos_policy_id = self.qos_policies[0].id\\n self.ports[1].update()\\n self.ports[2].qos_policy_id = self.qos_policies[1].id\\n self.ports[2].update()\\n for qos_policy_id, reference_ports in policies_ports:\\n self.networks[0].qos_policy_id = qos_policy_id\\n self.networks[0].update()\\n original_network = {'qos_policy_id': self.qos_policies[0]}\\n reviewed_port_ids, _, _ = self.qos_driver.update_network(\\n mock.ANY, self.networks[0], original_network)\\n self.assertEqual(reference_ports, reviewed_port_ids)\\n calls = [mock.call(mock.ANY, self.ports[0].id,\\n self.ports[0].network_id, qos_policy_id,\\n None)]\\n self.mock_rules.assert_has_calls(calls)\\n self.mock_rules.reset_mock()\",\n \"def verify_avail_space(self, pool, project, share, size):\\n self.verify_project(pool, project)\\n avail = self.get_project_stats(pool, project)\\n if avail < size:\\n exception_msg = (_('Error creating '\\n 'share: %(share)s on '\\n 'pool: %(pool)s. '\\n 'Not enough space.')\\n % {'share': share,\\n 'pool': pool})\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"async def test_leave_pool(self, setup, trusted_and_fee, self_hostname):\\n trusted, fee = trusted_and_fee\\n full_nodes, wallet_nodes, receive_address, client, rpc_cleanup = setup\\n our_ph = receive_address[0]\\n wallets = [wallet_n.wallet_state_manager.main_wallet for wallet_n in wallet_nodes]\\n pool_ph = receive_address[1]\\n full_node_api = full_nodes[0]\\n if trusted:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {\\n full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()\\n }\\n else:\\n wallet_nodes[0].config[\\\"trusted_peers\\\"] = {}\\n\\n await wallet_nodes[0].server.start_client(\\n PeerInfo(self_hostname, uint16(full_node_api.full_node.server._port)), None\\n )\\n\\n try:\\n assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0\\n\\n async def have_chia():\\n await farm_blocks(full_node_api, our_ph, 1)\\n return (await wallets[0].get_confirmed_balance()) > 0\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=have_chia)\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n creation_tx: TransactionRecord = await client.create_new_pool_wallet(\\n our_ph, \\\"\\\", 0, f\\\"{self_hostname}:5000\\\", \\\"new\\\", \\\"SELF_POOLING\\\", fee\\n )\\n\\n await time_out_assert(\\n 10,\\n full_node_api.full_node.mempool_manager.get_spendbundle,\\n creation_tx.spend_bundle,\\n creation_tx.name,\\n )\\n\\n await farm_blocks(full_node_api, our_ph, 6)\\n assert full_node_api.full_node.mempool_manager.get_spendbundle(creation_tx.name) is None\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)\\n assert len(summaries_response) == 1\\n wallet_id: int = summaries_response[0][\\\"id\\\"]\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.target is None\\n\\n join_pool_tx: TransactionRecord = (\\n await client.pw_join_pool(\\n wallet_id,\\n pool_ph,\\n \\\"https://pool.example.com\\\",\\n 5,\\n fee,\\n )\\n )[\\\"transaction\\\"]\\n assert join_pool_tx is not None\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n assert status.current.state == PoolSingletonState.SELF_POOLING.value\\n assert status.current.pool_url == \\\"\\\"\\n assert status.current.relative_lock_height == 0\\n assert status.current.state == 1\\n assert status.current.version == 1\\n\\n assert status.target\\n assert status.target.pool_url == \\\"https://pool.example.com\\\"\\n assert status.target.relative_lock_height == 5\\n assert status.target.state == 3\\n assert status.target.version == 1\\n\\n async def status_is_farming_to_pool():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_farming_to_pool)\\n\\n await time_out_assert(20, wallet_is_synced, True, wallet_nodes[0], full_node_api)\\n\\n status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n\\n leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, fee)\\n assert leave_pool_tx[\\\"transaction\\\"].wallet_id == wallet_id\\n assert leave_pool_tx[\\\"transaction\\\"].amount == 1\\n\\n async def status_is_leaving():\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_leaving)\\n\\n async def status_is_self_pooling():\\n # Farm enough blocks to wait for relative_lock_height\\n await farm_blocks(full_node_api, our_ph, 1)\\n pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]\\n return pw_status.current.state == PoolSingletonState.SELF_POOLING.value\\n\\n await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)\\n assert len(await wallets[0].wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0\\n\\n finally:\\n client.close()\\n await client.await_closed()\\n await rpc_cleanup()\",\n \"async def test_edit_sharing_data(container_requester):\\n async with container_requester as requester:\\n await requester(\\n 'POST', '/db/guillotina', data=json.dumps({\\n '@type': 'Item',\\n 'id': 'foobar1'\\n }))\\n await requester(\\n 'POST', '/db/guillotina', data=json.dumps({\\n '@type': 'Item',\\n 'id': 'foobar2'\\n }))\\n response, _ = await requester(\\n 'POST',\\n '/db/guillotina/@batch',\\n data=json.dumps([{\\n 'method': 'POST',\\n 'endpoint': 'foobar1/@sharing',\\n 'payload': {\\n \\\"prinperm\\\": [{\\n \\\"principal\\\": \\\"user1\\\",\\n \\\"permission\\\": \\\"guillotina.AccessContent\\\",\\n \\\"setting\\\": \\\"AllowSingle\\\"\\n }]\\n }\\n }, {\\n 'method': 'POST',\\n 'endpoint': 'foobar2/@sharing',\\n 'payload': {\\n \\\"prinperm\\\": [{\\n \\\"principal\\\": \\\"user1\\\",\\n \\\"permission\\\": \\\"guillotina.AccessContent\\\",\\n \\\"setting\\\": \\\"AllowSingle\\\"\\n }]\\n }\\n }])\\n )\\n response, _ = await requester(\\n 'POST',\\n '/db/guillotina/@batch',\\n data=json.dumps([{\\n 'method': 'GET',\\n 'endpoint': 'foobar1/@sharing'\\n }, {\\n 'method': 'GET',\\n 'endpoint': 'foobar2/@sharing'\\n }])\\n )\\n assert len(response) == 2\\n assert response[0]['body']['local']['prinperm']['user1']['guillotina.AccessContent'] == 'AllowSingle'\\n assert response[1]['body']['local']['prinperm']['user1']['guillotina.AccessContent'] == 'AllowSingle'\",\n \"async def test_endpoint_edit_share_correct(self):\\n with self.patch_json_dump:\\n await edit_share_handler(self.mock_request)\\n self.json_mock.assert_called_once()\",\n \"def test_patch_cluster_resource_quota(self):\\n pass\",\n \"def test_update_pci_switch(self):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\n pass\",\n \"def ensure_share(self, context, share, share_server=None):\\r\\n LOG.debug(\\\"Ensure share.\\\")\",\n \"def test_n_minus_f_pool_processes_attrib(looper, nodeSet,\\n sdk_pool_handle,\\n sdk_wallet_steward):\\n make_pool_n_minus_f_nodes(looper, nodeSet)\\n\\n sdk_add_raw_attribute(looper, sdk_pool_handle, sdk_wallet_steward, 'foo', 'bar')\",\n \"def test_anon_shared(self):\\n self.do_sharable(False, 'pattieblack', None)\\n self.do_sharable(False, 'pattieblack', FakeMembership(True))\",\n \"def test_update_instance_limit1(self):\\n pass\",\n \"async def test_push_share_no_os_envars(self):\\n with self.sys_exit_patch, \\\\\\n self.patch_init_sharing_client_error, \\\\\\n self.patch_get_address, \\\\\\n self.os_environ_get_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\",\n \"def test_synchronize_one_network(self):\\n\\n # Store two tenants in a db and a single tenant in EOS.\\n # The sync should send details of the second tenant to EOS\\n tenant_1_id = 'tenant-1'\\n tenant_1_net_1_id = 'ten-1-net-1'\\n tenant_1_net_1_seg_id = 11\\n db_lib.remember_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id,\\n tenant_1_net_1_seg_id, 'segment_id_11')\\n\\n tenant_2_id = 'tenant-2'\\n tenant_2_net_1_id = 'ten-2-net-1'\\n tenant_2_net_1_seg_id = 21\\n db_lib.remember_tenant(self.admin_ctx, tenant_2_id)\\n db_lib.remember_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id,\\n tenant_2_net_1_seg_id, 'segment_id_21')\\n\\n self.rpc.get_tenants.return_value = {\\n tenant_1_id: {\\n 'tenantVmInstances': {},\\n 'tenantBaremetalInstances': {},\\n 'tenantNetworks': {\\n tenant_1_net_1_id: {\\n 'networkId': tenant_1_net_1_id,\\n 'shared': False,\\n 'networkName': 'Net1',\\n 'segmenationType': 'vlan',\\n 'segmentationTypeId': tenant_1_net_1_seg_id,\\n }\\n }\\n }\\n }\\n\\n self.rpc.sync_start.return_value = True\\n self.rpc.sync_end.return_value = True\\n self.rpc.check_cvx_availability.return_value = True\\n\\n self.rpc._baremetal_supported.return_value = False\\n self.rpc.get_all_baremetal_hosts.return_value = {}\\n\\n self.sync_service.do_synchronize()\\n\\n expected_calls = [\\n mock.call.perform_sync_of_sg(self.sync_service._context),\\n mock.call.check_cvx_availability(),\\n mock.call.get_region_updated_time(),\\n mock.call.get_region_updated_time().__bool__(),\\n mock.call.sync_start(),\\n mock.call.register_with_eos(sync=True),\\n mock.call.check_supported_features(),\\n mock.call.get_tenants(),\\n\\n mock.call.create_network_bulk(\\n tenant_2_id,\\n [{'network_id': tenant_2_net_1_id,\\n 'segments': [],\\n 'network_name': '',\\n 'shared': False}],\\n sync=True),\\n\\n mock.call.sync_end(),\\n mock.call.get_region_updated_time()\\n ]\\n\\n self.assertTrue(self.rpc.mock_calls == expected_calls,\\n \\\"Seen: %s\\\\nExpected: %s\\\" % (\\n self.rpc.mock_calls,\\n expected_calls,\\n )\\n )\\n\\n db_lib.forget_network_segment(self.admin_ctx, tenant_1_id,\\n tenant_1_net_1_id)\\n db_lib.forget_network_segment(self.admin_ctx, tenant_2_id,\\n tenant_2_net_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_1_id)\\n db_lib.forget_tenant(self.admin_ctx, tenant_2_id)\",\n \"def test_replace_cluster_resource_quota_status(self):\\n pass\",\n \"def test_update_instance_limit(self):\\n pass\",\n \"def test_dashboards_v2_delete_share(self):\\n pass\",\n \"def create_share(self, pool, project, share):\\n self.verify_avail_space(pool, project, share, share['quota'])\\n svc = self.share_path % (pool, project, share['name'])\\n ret = self.rclient.get(svc)\\n if ret.status != restclient.Status.OK:\\n svc = self.shares_path % (pool, project)\\n ret = self.rclient.post(svc, share)\\n if ret.status != restclient.Status.CREATED:\\n exception_msg = (_('Error creating '\\n 'share: %(name)s '\\n 'return code: %(ret.status)d '\\n 'message: %(ret.data)s.')\\n % {'name': share['name'],\\n 'ret.status': ret.status,\\n 'ret.data': ret.data})\\n raise exception.ShareBackendException(msg=exception_msg)\\n else:\\n exception_msg = (_('Share with name %s already exists.')\\n % share['name'])\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def test_patch_hyperflex_cluster_network_policy(self):\\n pass\",\n \"def share():\\n return True\",\n \"def test_pool_dependence(self):\\n ok_(id(CSVarPool.pool) == id(VarPool.pool), 'mem address of pools should be the same')\\n\\n var = 'foo'\\n app = 'test'\\n VarPool(app=app).set(var, 'bar')\\n eq_(CSVarPool.get(var, app=app), 'bar')\\n CSVarPool(app=app).set(var, 'foo')\\n eq_(VarPool.get(var, app=app), 'foo')\",\n \"def test_put_without_parent_datastore_nor_share_id(self):\\n\\n url = reverse('file')\\n\\n data = {\\n 'shard_id': self.shard1.id,\\n 'link_id': \\\"b8866161-0b1f-4a8e-acde-07047313ec8f\\\",\\n #'parent_datastore_id': str(self.test_datastore_obj.id),\\n 'chunk_count': 1,\\n 'size': 512,\\n }\\n\\n self.client.force_authenticate(user=self.test_user_obj)\\n response = self.client.put(url, data)\\n\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_wrong_config_shares2(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='dfgsdfsg',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\\n\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='klhjkhjk',\\n vo='dteam',\\n share=80\\n ),\\n status=400\\n )\",\n \"def test_set_hosts_storage_backing_equal(instance_backing, number_of_hosts):\\n host_num_mapping = {\\n 'zero': 0,\\n 'one': 1,\\n 'two': 2\\n }\\n number_of_hosts = host_num_mapping[number_of_hosts]\\n LOG.tc_step(\\\"Calculate the hosts to be configured based on test params\\\")\\n candidate_hosts = get_candidate_hosts(number_of_hosts=number_of_hosts)\\n\\n hosts_with_backing = \\\\\\n host_helper.get_hosts_in_storage_backing(instance_backing)\\n if len(hosts_with_backing) == number_of_hosts:\\n LOG.info(\\\"Already have {} hosts in {} backing. Do \\\"\\n \\\"nothing\\\".format(number_of_hosts, instance_backing))\\n return\\n\\n elif len(hosts_with_backing) < number_of_hosts:\\n backing_to_config = instance_backing\\n number_to_config = number_of_hosts - len(hosts_with_backing)\\n hosts_pool = list(set(candidate_hosts) - set(hosts_with_backing))\\n else:\\n backing_to_config = 'remote' if 'image' in instance_backing else \\\\\\n 'local_image'\\n number_to_config = len(hosts_with_backing) - number_of_hosts\\n hosts_pool = hosts_with_backing\\n\\n LOG.tc_step(\\\"Delete vms if any to prepare for system configuration \\\"\\n \\\"change with best effort\\\")\\n vm_helper.delete_vms(fail_ok=True)\\n\\n hosts_to_config = hosts_pool[0:number_to_config]\\n LOG.tc_step(\\\"Configure following hosts to {} backing: \\\"\\n \\\"{}\\\".format(hosts_to_config, backing_to_config))\\n\\n for host in hosts_to_config:\\n host_helper.set_host_storage_backing(host=host,\\n inst_backing=backing_to_config,\\n unlock=False,\\n wait_for_configured=False)\\n HostsToRecover.add(host)\\n\\n host_helper.unlock_hosts(hosts_to_config, check_hypervisor_up=True,\\n fail_ok=False)\\n\\n LOG.tc_step(\\\"Waiting for hosts in {} aggregate\\\".format(backing_to_config))\\n for host in hosts_to_config:\\n host_helper.wait_for_host_in_instance_backing(\\n host, storage_backing=backing_to_config)\\n\\n LOG.tc_step(\\\"Check number of {} hosts is {}\\\".format(instance_backing,\\n number_of_hosts))\\n assert number_of_hosts == \\\\\\n len(host_helper.get_hosts_in_storage_backing(instance_backing)), \\\\\\n \\\"Number of {} hosts is not {} after \\\" \\\\\\n \\\"configuration\\\".format(instance_backing, number_of_hosts)\",\n \"def test_fixed_ip_associate_pool_order(self):\\n\\n instance_uuid = self._create_instance()\\n network = db.network_create_safe(self.ctxt, {})\\n self.addCleanup(timeutils.clear_time_override)\\n start = timeutils.utcnow()\\n for i in range(1, 4):\\n now = start - datetime.timedelta(hours=i)\\n timeutils.set_time_override(now)\\n address = self.create_fixed_ip(\\n updated_at=now,\\n address='10.1.0.%d' % i,\\n network_id=network['id'])\\n db.fixed_ip_associate_pool(self.ctxt, network['id'], instance_uuid)\\n fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address)\\n self.assertEqual(fixed_ip['instance_uuid'], instance_uuid)\",\n \"def test_wrong_config_shares0(self):\\n self.app.post_json(url=\\\"/config/shares\\\",\\n params=dict(\\n source='gsiftp://source',\\n destination='gsiftp://nowhere',\\n vo='dteam',\\n share='dfdf'\\n ),\\n status=400\\n )\",\n \"def test_share_00(self, mocker):\\n contributors = ['alice@gmail.com:user:writer', 'alice@gmail.com:user:reader']\\n g = GSheets(self.fake.file_path(depth=1, category=None, extension='json'), contributors)\\n g.spreadsheet = Spreadsheet(None, None)\\n g.spreadsheet.share = mocker.MagicMock()\\n\\n g.share()\\n\\n assert g.spreadsheet.share.call_count == len(contributors)\",\n \"def update_device_pool(arn=None, name=None, description=None, rules=None):\\n pass\",\n \"def put(self, request, pool_id):\\n kwargs = {'pool_id': pool_id}\\n update_pool(request, **kwargs)\",\n \"def test_reset_data_provided_by_hardfork_hive_operation_generated_between_hf_22_and_hf_23(node: tt.InitNode):\\n wallet = tt.Wallet(attach_to=node)\\n\\n wallet.create_account(\\\"goku1\\\", hives=tt.Asset.Test(50) , hbds=tt.Asset.Tbd(50), vests=tt.Asset.Test(50))\\n wallet.create_account(\\\"steem\\\", hives=tt.Asset.Test(100) , hbds=tt.Asset.Tbd(100) , vests=tt.Asset.Test(100))\\n\\n with wallet.in_single_transaction():\\n wallet.api.delegate_vesting_shares(\\\"goku1\\\", \\\"steem\\\", tt.Asset.Vest(5))\\n wallet.api.delegate_vesting_shares(\\\"steem\\\", \\\"goku1\\\", tt.Asset.Vest(10))\\n\\n assert get_hardfork_version(node) == \\\"0.22.0\\\"\\n assert_account_resources(node, \\\"goku1\\\", operator.gt)\\n assert_account_resources(node, \\\"steem\\\", operator.gt)\\n\\n __wait_for_hardfork_23_application(node)\\n assert get_hardfork_version(node) == \\\"0.23.0\\\"\\n\\n assert_account_resources(node, \\\"goku1\\\", operator.eq)\\n assert_account_resources(node, \\\"steem\\\", operator.eq)\\n\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"goku1\\\")\\n assert_cleared_resources_in_hardfork_hive_operation(node, \\\"steem\\\")\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_obj = RadosOrchestrator(node=cephadm)\\n pool_obj = PoolFunctions(node=cephadm)\\n scrub_obj = RadosScrubber(node=cephadm)\\n\\n pool_target_configs = config[\\\"verify_osd_omap_entries\\\"][\\\"configurations\\\"]\\n omap_target_configs = config[\\\"verify_osd_omap_entries\\\"][\\\"omap_config\\\"]\\n\\n # Creating pools and starting the test\\n for entry in pool_target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n method_should_succeed(\\n rados_obj.create_pool,\\n **entry,\\n )\\n\\n log.debug(\\n \\\"Created the pool. beginning to create large number of omap entries on the pool\\\"\\n )\\n\\n # Creating omaps\\n create_omap(pool_obj, pool_target_configs, omap_target_configs)\\n\\n omap_thread = Thread(\\n target=create_omap, args=[pool_obj, pool_target_configs, omap_target_configs]\\n )\\n\\n # Get the scrub and deep scrup time stamp before scrub and deep scrub execution\\n before_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_scrub_stamp\\\")\\n before_deep_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_deep_scrub_stamp\\\")\\n\\n # performing scrub and deep-scrub\\n rados_obj.run_scrub()\\n rados_obj.run_deep_scrub()\\n scrub_status = 1\\n deep_scrub_status = 1\\n\\n while scrub_status == 1 and deep_scrub_status == 1:\\n # Scrub check for every 20 seconds\\n time.sleep(20)\\n after_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_scrub_stamp\\\")\\n after_deep_scrub_log = scrub_obj.get_pg_dump(\\\"pgid\\\", \\\"last_deep_scrub_stamp\\\")\\n scrub_status = scrub_obj.verify_scrub_deepscrub(\\n before_scrub_log, after_scrub_log, \\\"scrub\\\"\\n )\\n deep_scrub_status = scrub_obj.verify_scrub_deepscrub(\\n before_deep_scrub_log, after_deep_scrub_log, \\\"deepscrub\\\"\\n )\\n log.info(\\\"scrubbing and deep-scrubbing are in progress\\\")\\n log.info(\\\"scrubbing and deep-scrubbing completed\\\")\\n\\n # Check for large omap massage\\n ceph_status = rados_obj.run_ceph_command(cmd=\\\" ceph health\\\")\\n if \\\"LARGE_OMAP_OBJECTS\\\" in ceph_status[\\\"checks\\\"]:\\n log.info(\\\" Generated large omaps in the cluster\\\")\\n else:\\n log.error(\\\" Unable to generate the large omaps in the cluster\\\")\\n return 1\\n\\n # verification of OSDs for 30 minutes\\n verification_osd_thread = Thread(target=verification_osd, args=[rados_obj, 30])\\n omap_thread.daemon = True\\n omap_thread.start()\\n verification_osd_thread.start()\\n verification_osd_thread.join()\\n omap_thread._delete()\\n if result == 0:\\n return 0\\n else:\\n return 1\",\n \"def test_replace_cluster_policy(self):\\n pass\",\n \"def task(ctx, config):\\n if config is None:\\n config = {}\\n assert isinstance(config, dict), \\\\\\n 'Resolve stuck peering only accepts a dict for config'\\n\\n manager = ctx.managers['ceph']\\n\\n while len(manager.get_osd_status()['up']) < 3:\\n time.sleep(10)\\n\\n\\n manager.wait_for_clean()\\n\\n dummyfile = '/etc/fstab'\\n dummyfile1 = '/etc/resolv.conf'\\n\\n #create 1 PG pool\\n pool='foo'\\n log.info('creating pool foo')\\n manager.raw_cluster_cmd('osd', 'pool', 'create', '%s' % pool, '1')\\n\\n #set min_size of the pool to 1\\n #so that we can continue with I/O\\n #when 2 osds are down\\n manager.set_pool_property(pool, \\\"min_size\\\", 1)\\n\\n osds = [0, 1, 2]\\n\\n primary = manager.get_pg_primary('foo', 0)\\n log.info(\\\"primary osd is %d\\\", primary)\\n\\n others = list(osds)\\n others.remove(primary)\\n\\n log.info('writing initial objects')\\n first_mon = teuthology.get_first_mon(ctx, config)\\n (mon,) = ctx.cluster.only(first_mon).remotes.keys()\\n #create few objects\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'existing_%d' % i, dummyfile])\\n\\n manager.wait_for_clean()\\n\\n #kill other osds except primary\\n log.info('killing other osds except primary')\\n for i in others:\\n manager.kill_osd(i)\\n for i in others:\\n manager.mark_down_osd(i)\\n\\n\\n for i in range(100):\\n rados(ctx, mon, ['-p', 'foo', 'put', 'new_%d' % i, dummyfile1])\\n\\n #kill primary osd\\n manager.kill_osd(primary)\\n manager.mark_down_osd(primary)\\n\\n #revive other 2 osds\\n for i in others:\\n manager.revive_osd(i)\\n\\n #make sure that pg is down\\n #Assuming pg number for single pg pool will start from 0\\n pgnum=0\\n pgstr = manager.get_pgid(pool, pgnum)\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=60\\n start=time.time()\\n\\n while 'down' not in stats['state']:\\n assert time.time() - start < timeout, \\\\\\n 'failed to reach down state before timeout expired'\\n stats = manager.get_single_pg_stats(pgstr)\\n\\n #mark primary as lost\\n manager.raw_cluster_cmd('osd', 'lost', '%d' % primary,\\\\\\n '--yes-i-really-mean-it')\\n\\n\\n #expect the pg status to be active+undersized+degraded\\n #pg should recover and become active+clean within timeout\\n stats = manager.get_single_pg_stats(pgstr)\\n print(stats['state'])\\n\\n timeout=10\\n start=time.time()\\n\\n while manager.get_num_down():\\n assert time.time() - start < timeout, \\\\\\n 'failed to recover before timeout expired'\\n\\n manager.revive_osd(primary)\",\n \"def mostly_sync_mempools(rpc_connections, difference=50, wait=1, verbose=1):\\n iterations = 0\\n while True:\\n iterations += 1\\n pool = set(rpc_connections[0].getrawmempool())\\n num_match = 1\\n poolLen = [len(pool)]\\n for i in range(1, len(rpc_connections)):\\n tmp = set(rpc_connections[i].getrawmempool())\\n if tmp == pool:\\n num_match = num_match + 1\\n if iterations > 10 and len(tmp.symmetric_difference(pool)) < difference:\\n num_match = num_match + 1\\n poolLen.append(len(tmp))\\n if verbose:\\n logging.info(\\\"sync mempool: \\\" + str(poolLen))\\n if num_match == len(rpc_connections):\\n break\\n time.sleep(wait)\",\n \"def test_update_external_network(self):\\n network_policies = [(self.qos_policies[1].id,\\n {self.fips[1].id},\\n {self.router_fips.id}),\\n (None,\\n {self.fips[1].id},\\n {self.router_fips.id})]\\n\\n self.fips[0].qos_policy_id = self.qos_policies[0].id\\n self.fips[0].update()\\n for qos_policy_id, ref_fips, ref_routers in network_policies:\\n self.fips_network.qos_policy_id = qos_policy_id\\n self.fips_network.update()\\n original_network = {'qos_policy_id': self.qos_policies[0]}\\n _, reviewed_fips_ids, reviewed_router_ids = (\\n self.qos_driver.update_network(\\n mock.Mock(), self.fips_network, original_network))\\n self.assertEqual(ref_fips, reviewed_fips_ids)\\n self.assertEqual(ref_routers, reviewed_router_ids)\",\n \"async def test_push_share_no_envars(self):\\n with self.sys_exit_patch:\\n with self.assertRaises(SystemExit):\\n await self.inst._push_share(\\n \\\"test-container\\\",\\n \\\"test-recipient\\\",\\n [\\\"r\\\", \\\"w\\\"]\\n )\\n self.sys_exit_mock.assert_called_once()\",\n \"def test_pooling(self):\\n for width in range(2, 5):\\n for width2 in range(1, width):\\n matrix_size = (4, 5, width)\\n matrix = get_random_test_tensor(size=matrix_size)\\n pool_size = width2\\n for stride in range(1, width2):\\n for padding in range(2):\\n reference = torch.nn.functional.avg_pool2d(\\n matrix.unsqueeze(0), pool_size,\\n stride=stride, padding=padding\\n )\\n\\n encrypted_matrix = SharedTensor(matrix)\\n encrypted_pool = encrypted_matrix.avg_pool2d(\\n pool_size, stride=stride, padding=padding)\\n self._check(\\n encrypted_pool, reference[0], 'avg_pool2d failed')\",\n \"def mover_put_data(outputpoolfcstring,\\n pdsname,\\n sitename,\\n queuename,\\n ub=\\\"outdated\\\", # to be removed\\n analysisJob=False,\\n testLevel=\\\"0\\\",\\n pinitdir=\\\"\\\",\\n proxycheck=True,\\n spsetup=\\\"\\\",\\n token=[],\\n userid=\\\"\\\",\\n prodSourceLabel=\\\"\\\",\\n datasetDict=None,\\n outputDir=\\\"\\\",\\n jobId=None,\\n jobDefId=\\\"\\\",\\n jobWorkDir=None,\\n DN=None,\\n outputFileInfo=None,\\n dispatchDBlockTokenForOut=None,\\n jobCloud=\\\"\\\",\\n logFile=\\\"\\\",\\n cmtconfig=\\\"\\\",\\n recoveryWorkDir=None,\\n experiment=\\\"ATLAS\\\",\\n stageoutTries=2,\\n scopeOut=None,\\n scopeLog=None,\\n fileDestinationSE=None,\\n logPath=\\\"\\\",\\n eventService=False):\\n\\n fail = 0\\n error = PilotErrors()\\n pilotErrorDiag = \\\"\\\"\\n\\n # file info field used by job recovery\\n fields = ['', '', '', '', '', '', '']\\n\\n # Alternative transfer counters (will be reported in jobMetrics, only relevant when alternative stage-out was used)\\n N_filesNormalStageOut = 0\\n N_filesAltStageOut = 0\\n\\n # note: the job work dir does not exist in the case of job recovery\\n if recoveryWorkDir:\\n workDir = recoveryWorkDir\\n else:\\n workDir = os.path.dirname(jobWorkDir)\\n\\n # setup the dictionary necessary for all instrumentation\\n report = getInitialTracingReport(userid, sitename, pdsname, \\\"put_sm\\\", analysisJob, jobId, jobDefId, DN)\\n\\n # Remember that se can be a list where the first is used for output but any can be used for input\\n listSEs = readpar('se').split(',')\\n tolog(\\\"SE list: %s\\\" % str(listSEs))\\n\\n region = readpar('region')\\n\\n # Get the site information object and set the queuename\\n si = getSiteInformation(experiment)\\n si.setQueueName(queuename)\\n\\n # Get the copy tool\\n copycmd, setup = getCopytool()\\n\\n tolog(\\\"Copy command: %s\\\" % (copycmd))\\n tolog(\\\"Setup: %s\\\" % (setup))\\n\\n # Is this a transfer to an object store?\\n if \\\"objectstore\\\" in copycmd:\\n objectstore = True\\n else:\\n objectstore = False\\n\\n # Get the storage path, e.g.\\n # ddm_storage_path = srm://uct2-dc1.uchicago.edu:8443/srm/managerv2?SFN=/pnfs/uchicago.edu/atlasuserdisk\\n # Note: this ends up in the 'destination' variable inside the site mover's put_data() - which is mostly not used\\n # It can be used for special purposes, like for the object store path which can be predetermined\\n ddm_storage_path, pilotErrorDiag = getDDMStorage(ub, si, analysisJob, region, jobId, objectstore, isLogTransfer(logPath))\\n if pilotErrorDiag != \\\"\\\":\\n return error.ERR_NOSTORAGE, pilotErrorDiag, fields, None, N_filesNormalStageOut, N_filesAltStageOut\\n\\n # Get the site mover\\n sitemover = getSiteMover(copycmd, setup)\\n tolog(\\\"Got site mover: %s\\\" % str(sitemover))\\n\\n # get the file list from the PFC (DOM object list)\\n file_list = getFileList(outputpoolfcstring)\\n\\n # number of output files (e.g. used by CMS site mover)\\n nFiles = len(file_list)\\n\\n # create the scope dictionary\\n # scope_dict = createZippedDictionary(file_list, job.scopeOut)\\n\\n # Get the experiment object\\n thisExperiment = getExperiment(experiment)\\n\\n # get the list of space tokens\\n token_list = getSpaceTokenList(token, listSEs, jobCloud, analysisJob, nFiles, si)\\n alternativeTokenList = None\\n\\n # loop over all files to be staged in\\n fail = 0\\n file_nr = -1\\n for thisfile in file_list:\\n file_nr += 1\\n\\n # get the file names and guid\\n # note: pfn is the source\\n filename, lfn, pfn, guid = getFilenamesAndGuid(thisfile)\\n\\n # The file name is now known, let's add it to the storge path if the endpoint is on an objectstore\\n if objectstore:\\n ddm_storage_path = getHashedBucketEndpoint(ddm_storage_path, lfn)\\n\\n # note: pfn is the full path to the local file\\n tolog(\\\"Preparing copy for %s to %s using %s\\\" % (pfn, ddm_storage_path, copycmd))\\n\\n # get the corresponding scope\\n scope = getScope(lfn, logFile, file_nr, scopeOut, scopeLog)\\n\\n # update the current file state\\n updateFileState(filename, workDir, jobId, mode=\\\"file_state\\\", state=\\\"not_transferred\\\")\\n dumpFileStates(workDir, jobId)\\n\\n # get the dataset name (dsname_report is the same as dsname but might contain _subNNN parts)\\n dsname, dsname_report = getDatasetName(sitemover, datasetDict, lfn, pdsname)\\n\\n # update tracing report\\n report['dataset'] = dsname_report\\n report['scope'] = scope\\n\\n # get the currect space token for the given file\\n _token_file = getSpaceTokenForFile(filename, token_list, logFile, file_nr, nFiles)\\n\\n # get the file size and checksum if possible\\n fsize, checksum = getFileSizeAndChecksum(lfn, outputFileInfo)\\n\\n s = 1\\n _attempt = 0\\n if stageoutTries > 0 and stageoutTries < 10:\\n put_RETRY = stageoutTries\\n else:\\n tolog(\\\"!!WARNING!!1888!! Unreasonable number of stage-out tries: %d (reset to default)\\\" % (stageoutTries))\\n put_RETRY = 2\\n tolog(\\\"Number of stage-out tries: %d\\\" % (stageoutTries))\\n\\n # loop over put_data() to allow for multple stage-out attempts\\n while s != 0 and _attempt < put_RETRY:\\n _attempt += 1\\n\\n # if not first stage-out attempt, take a nap before next attempt\\n if _attempt > 1:\\n _rest = 10*60\\n tolog(\\\"(Waiting %d seconds before next stage-out attempt)\\\" % (_rest))\\n sleep(_rest)\\n\\n tolog(\\\"Put attempt %d/%d\\\" % (_attempt, put_RETRY))\\n\\n # perform the normal stage-out, unless we want to force alternative stage-out\\n if not si.forceAlternativeStageOut(flag=analysisJob):\\n s, pilotErrorDiag, r_gpfn, r_fsize, r_fchecksum, r_farch = sitemover_put_data(sitemover, error, workDir, jobId, pfn, ddm_storage_path, dsname,\\\\\\n sitename, analysisJob, testLevel, pinitdir, proxycheck,\\\\\\n _token_file, lfn, guid, spsetup, userid, report, cmtconfig,\\\\\\n prodSourceLabel, outputDir, DN, fsize, checksum, logFile,\\\\\\n _attempt, experiment, scope, fileDestinationSE, nFiles,\\\\\\n logPath=logPath)\\n # increase normal stage-out counter if file was staged out\\n if s == 0:\\n N_filesNormalStageOut += 1\\n forceAltStageOut = False\\n else:\\n # first switch off allowAlternativeStageOut since it will not be needed\\n # update queuedata (remove allow_alt_stageout from catchall field)\\n catchall = readpar('catchall')\\n if 'allow_alt_stageout' in catchall:\\n catchall = catchall.replace('allow_alt_stageout','')\\n ec = si.replaceQueuedataField(\\\"catchall\\\", catchall)\\n tolog(\\\"(will force alt stage-out, s=%d)\\\" % (s))\\n forceAltStageOut = True\\n\\n # attempt alternative stage-out if required\\n if s != 0:\\n # report stage-out problem to syslog\\n sysLog(\\\"PanDA job %s failed to stage-out output file: %s\\\" % (jobId, pilotErrorDiag))\\n #dumpSysLogTail()\\n\\n if forceAltStageOut:\\n tolog(\\\"Forcing alternative stage-out\\\")\\n useAlternativeStageOut = True\\n _attempt = 2\\n else:\\n tolog('!!WARNING!!2999!! Error in copying (attempt %s): %s - %s' % (_attempt, s, pilotErrorDiag))\\n\\n # should alternative stage-out be attempted?\\n # (not for special log file transfers to object stores)\\n if logPath == \\\"\\\":\\n useAlternativeStageOut = si.allowAlternativeStageOut(flag=analysisJob)\\n else:\\n useAlternativeStageOut = False\\n\\n if \\\"failed to remove file\\\" in pilotErrorDiag and not useAlternativeStageOut:\\n tolog(\\\"Aborting stage-out retry since file could not be removed from storage/catalog\\\")\\n break\\n\\n # perform alternative stage-out if required\\n if useAlternativeStageOut and _attempt > 1:\\n tolog(\\\"Attempting alternative stage-out (to the Tier-1 of the cloud the job belongs to)\\\")\\n\\n # download new queuedata and return the corresponding sitemover object\\n alternativeSitemover = prepareAlternativeStageOut(sitemover, si, sitename, jobCloud)\\n\\n if alternativeSitemover:\\n # update the space token?\\n if not alternativeTokenList:\\n # note: alt=True means that the queuedata file for the alternative SE will be used\\n alternativeListSEs = readpar('se', alt=True).split(',')\\n tolog(\\\"Alternative SE list: %s\\\" % str(alternativeListSEs))\\n\\n # which space token should be used? Primarily use the requested space token primarily (is it available at the alternative SE?)\\n # otherwise use the default space token of the alternative SE\\n alternativeTokenList = getSpaceTokenList(token, alternativeListSEs, jobCloud, analysisJob, nFiles, si, alt=True)\\n tolog(\\\"Created alternative space token list: %s\\\" % str(alternativeTokenList))\\n\\n # get the currect space token for the given file\\n _token_file = getSpaceTokenForFile(filename, alternativeTokenList, logFile, file_nr, nFiles)\\n tolog(\\\"Using alternative space token: %s\\\" % (_token_file))\\n\\n # perform the stage-out\\n tolog(\\\"Attempting stage-out to alternative SE\\\")\\n _s, _pilotErrorDiag, r_gpfn, r_fsize, r_fchecksum, r_farch = sitemover_put_data(alternativeSitemover, error, workDir, jobId, pfn, ddm_storage_path, dsname,\\\\\\n sitename, analysisJob, testLevel, pinitdir, proxycheck,\\\\\\n _token_file, lfn, guid, spsetup, userid, report, cmtconfig,\\\\\\n prodSourceLabel, outputDir, DN, fsize, checksum, logFile,\\\\\\n _attempt, experiment, scope, fileDestinationSE, nFiles,\\\\\\n alt=True)\\n if _s == 0:\\n # do no further stage-out (prevent another attempt, but allow e.g. chirp transfer below, as well as\\n # return a zero error code from this function, also for job recovery returning s=0 will not cause job recovery\\n # to think that the file has not been transferred)\\n _attempt = 999\\n s = 0\\n\\n # increase alternative stage-out counter\\n N_filesAltStageOut += 1\\n\\n if \\\"failed to remove file\\\" in pilotErrorDiag:\\n tolog(\\\"Aborting further stage-out retries since file could not be removed from storage/catalog\\\")\\n break\\n\\n elif _attempt > 1:\\n tolog(\\\"Stage-out to alternative SE not allowed\\\")\\n\\n if s == 0:\\n # use special tool for ADLER32 registration if found\\n if os.environ.has_key('SETADLER32'):\\n performSpecialADRegistration(sitemover, r_fchecksum, r_gpfn)\\n\\n # should the file also be moved to a secondary storage?\\n if dispatchDBlockTokenForOut:\\n # verify that list has correct length\\n\\n s2 = None\\n try:\\n if filename == logFile:\\n dDBlockTokenForOut = dispatchDBlockTokenForOut[-1]\\n else:\\n dDBlockTokenForOut = dispatchDBlockTokenForOut[file_nr]\\n if dDBlockTokenForOut.startswith('chirp'):\\n s2, pilotErrorDiag2 = chirp_put_data(pfn, ddm_storage_path, dsname=dsname, sitename=sitename,\\\\\\n analysisJob=analysisJob, testLevel=testLevel, pinitdir=pinitdir,\\\\\\n proxycheck=proxycheck, token=_token_file, timeout=DEFAULT_TIMEOUT, lfn=lfn,\\\\\\n guid=guid, spsetup=spsetup, userid=userid, report=report,\\\\\\n prodSourceLabel=prodSourceLabel, outputDir=outputDir, DN=DN,\\\\\\n dispatchDBlockTokenForOut=dDBlockTokenForOut, logFile=logFile, experiment=experiment)\\n except Exception, e:\\n tolog(\\\"!!WARNING!!2998!! Exception caught in mover chirp put: %s\\\" % str(e))\\n else:\\n if s2:\\n tolog(\\\"Mover chirp put finished successfully\\\")\\n elif s2 == None:\\n tolog(\\\"Skipped chirp transfer\\\")\\n else:\\n tolog(\\\"chirp transfer returned exit code: %d\\\" % (s2))\\n else:\\n tolog(\\\"dispatchDBlockTokenForOut not set (no chirp transfer)\\\")\\n\\n tolog(\\\"Return code: %d\\\" % (s))\\n\\n if logPath != \\\"\\\":\\n tolog(\\\"No need to proceed with file registration for special log transfer\\\")\\n break\\n\\n if s != 0:\\n tolog('!!WARNING!!2999!! Failed to transfer %s: %s (%s)' % (os.path.basename(pfn), s, error.getErrorStr(s)))\\n fail = s \\n break\\n\\n # gpfn = ftpserv + destpfn\\n # keep track of which files have been copied\\n fields[0] += '%s+' % r_gpfn \\n fields[1] += '%s+' % str(lfn) # Eddie added str, unicode protection\\n fields[2] += '%s+' % guid\\n fields[3] += '%s+' % r_fsize\\n fields[4] += '%s+' % r_fchecksum\\n fields[5] += '%s+' % r_farch\\n fields[6] += '%s+' % pfn\\n\\n if fail == 0:\\n # should the file be registered in a file catalog?\\n _copytool = readpar(\\\"copytool\\\")\\n _lfcregister = readpar('lfcregister')\\n if _lfcregister == \\\"\\\":\\n # update the current file state since the transfer was ok\\n updateFileState(filename, workDir, jobId, mode=\\\"file_state\\\", state=\\\"transferred\\\")\\n dumpFileStates(workDir, jobId)\\n\\n # Removed capability of pilot file registration (May 13, 2015, v 62a)\\n tolog(\\\"!!WARNING!!2323!! File catalog registration not possible by pilot - should be done by server\\\")\\n else:\\n # update the current file states\\n updateFileState(filename, workDir, jobId, mode=\\\"file_state\\\", state=\\\"transferred\\\")\\n if _copytool != \\\"chirp\\\":\\n updateFileState(filename, workDir, jobId, mode=\\\"reg_state\\\", state=\\\"registered\\\")\\n dumpFileStates(workDir, jobId)\\n tolog(\\\"No file catalog registration by the pilot\\\")\\n\\n if fail != 0:\\n return fail, pilotErrorDiag, fields, None, N_filesNormalStageOut, N_filesAltStageOut\\n\\n # remove the trailing '+'-sign in each field\\n fields[0] = fields[0][:-1]\\n fields[1] = fields[1][:-1]\\n fields[2] = fields[2][:-1]\\n fields[3] = fields[3][:-1]\\n fields[4] = fields[4][:-1]\\n fields[5] = fields[5][:-1]\\n\\n tolog(\\\"Put successful\\\")\\n return 0, pilotErrorDiag, fields, '1', N_filesNormalStageOut, N_filesAltStageOut\",\n \"def test_sync_no_archive_to_transfer_failure(self):\\n support = saltsupport.SaltSupportModule()\\n support.archives = MagicMock(return_value=[])\\n with pytest.raises(salt.exceptions.SaltInvocationError) as err:\\n support.sync(\\\"group-name\\\", all=True)\\n assert \\\"No archives found to transfer\\\" in str(err)\",\n \"def test_claim_resources_success_resize_to_same_host_no_shared(self):\\n get_current_allocations_resp_mock = mock.Mock(status_code=200)\\n # source host allocation held by the migration_uuid so it is not\\n # not returned to the claim code as that asks for the instance_uuid\\n # consumer\\n get_current_allocations_resp_mock.json.return_value = {\\n 'allocations': {},\\n \\\"consumer_generation\\\": 1,\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n self.ks_adap_mock.get.return_value = get_current_allocations_resp_mock\\n put_allocations_resp_mock = mock.Mock(status_code=204)\\n self.ks_adap_mock.put.return_value = put_allocations_resp_mock\\n consumer_uuid = uuids.consumer_uuid\\n # This is the resize-up allocation where VCPU, MEMORY_MB and DISK_GB\\n # are all being increased but on the same host. We also throw a custom\\n # resource class in the new allocation to make sure it's not lost\\n alloc_req = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'DISK_GB': 40,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n },\\n # this allocation request comes from the scheduler therefore it\\n # does not have consumer_generation in it.\\n \\\"project_id\\\": uuids.project_id,\\n \\\"user_id\\\": uuids.user_id\\n }\\n\\n project_id = uuids.project_id\\n user_id = uuids.user_id\\n res = self.client.claim_resources(self.context, consumer_uuid,\\n alloc_req, project_id, user_id,\\n allocation_request_version='1.28')\\n\\n expected_url = \\\"/allocations/%s\\\" % consumer_uuid\\n expected_payload = {\\n 'allocations': {\\n uuids.same_host: {\\n 'resources': {\\n 'VCPU': 2,\\n 'MEMORY_MB': 2048,\\n 'DISK_GB': 40,\\n 'CUSTOM_FOO': 1\\n }\\n },\\n },\\n # report client assumes a new consumer in this case\\n 'consumer_generation': None,\\n 'project_id': project_id,\\n 'user_id': user_id}\\n self.ks_adap_mock.put.assert_called_once_with(\\n expected_url, microversion='1.28', json=mock.ANY,\\n global_request_id=self.context.global_id)\\n # We have to pull the json body from the mock call_args to validate\\n # it separately otherwise hash seed issues get in the way.\\n actual_payload = self.ks_adap_mock.put.call_args[1]['json']\\n self.assertEqual(expected_payload, actual_payload)\\n\\n self.assertTrue(res)\",\n \"def run(ceph_cluster, **kw):\\n log.info(run.__doc__)\\n config = kw[\\\"config\\\"]\\n cephadm = CephAdmin(cluster=ceph_cluster, **config)\\n rados_object = RadosOrchestrator(node=cephadm)\\n mon_obj = MonConfigMethods(rados_obj=rados_object)\\n ceph_nodes = kw.get(\\\"ceph_nodes\\\")\\n osd_list = []\\n total_osd_app_mem = {}\\n\\n for node in ceph_nodes:\\n if node.role == \\\"osd\\\":\\n node_osds = rados_object.collect_osd_daemon_ids(node)\\n osd_list = osd_list + node_osds\\n\\n target_configs = config[\\\"cache_trim_max_skip_pinned\\\"][\\\"configurations\\\"]\\n max_skip_pinned_value = int(\\n mon_obj.get_config(section=\\\"osd\\\", param=\\\"bluestore_cache_trim_max_skip_pinned\\\")\\n )\\n\\n # Check the default value of the bluestore_cache_trim_max_skip_pinned value\\n if max_skip_pinned_value != 1000:\\n log.error(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned not equal to 1000\\\"\\n )\\n raise Exception(\\n \\\"The default value of bluestore_cache_trim_max_skip_pinned is not 1000\\\"\\n )\\n\\n # Creating pools and starting the test\\n for entry in target_configs.values():\\n log.debug(\\n f\\\"Creating {entry['pool_type']} pool on the cluster with name {entry['pool_name']}\\\"\\n )\\n if entry.get(\\\"pool_type\\\", \\\"replicated\\\") == \\\"erasure\\\":\\n method_should_succeed(\\n rados_object.create_erasure_pool, name=entry[\\\"pool_name\\\"], **entry\\n )\\n else:\\n method_should_succeed(\\n rados_object.create_pool,\\n **entry,\\n )\\n\\n if not rados_object.bench_write(**entry):\\n log.error(\\\"Failed to write objects into the EC Pool\\\")\\n return 1\\n rados_object.bench_read(**entry)\\n log.info(\\\"Finished writing data into the pool\\\")\\n\\n # performing scrub and deep-scrub\\n rados_object.run_scrub()\\n rados_object.run_deep_scrub()\\n time.sleep(10)\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"start\\\")\\n # Executing tests for 45 minutes\\n time_execution = datetime.datetime.now() + datetime.timedelta(minutes=45)\\n while datetime.datetime.now() < time_execution:\\n # Get all OSDs heap dump\\n heap_dump = rados_object.get_heap_dump(osd_list)\\n # get the osd application used memory\\n osd_app_mem = get_bytes_used_by_app(heap_dump)\\n total_osd_app_mem = mergeDictionary(total_osd_app_mem, osd_app_mem)\\n # wait for 10 seconds and collecting the memory\\n time.sleep(10)\\n for osd_id, mem_list in total_osd_app_mem.items():\\n mem_growth = is_what_percent_mem(mem_list)\\n if mem_growth > 80:\\n log.error(\\n f\\\"The osd.{osd_id} consuming more memory with the relative memory growth {mem_growth}\\\"\\n )\\n raise Exception(\\\"No warning generated by PG Autoscaler\\\")\\n log.info(f\\\"The relative memory growth for the osd.{osd_id} is {mem_growth} \\\")\\n\\n rados_object.change_heap_profiler_state(osd_list, \\\"stop\\\")\\n\\n # check fo the crashes in the cluster\\n crash_list = rados_object.do_crash_ls()\\n if not crash_list:\\n return 0\\n else:\\n return 1\",\n \"def share(observer, tid):\\n try:\\n manager = Actions()\\n manager.share_task(observer, tid)\\n except Exception as e:\\n click.echo(e)\",\n \"def test_autocreate_licensepool(self):\\n identifier = self._identifier()\\n assert [] == identifier.licensed_through\\n provider = AlwaysSuccessfulCollectionCoverageProvider(\\n self._default_collection\\n )\\n pool = provider.license_pool(identifier)\\n assert [pool] == identifier.licensed_through\\n assert pool.data_source == provider.data_source\\n assert pool.identifier == identifier\\n assert pool.collection == provider.collection\\n\\n # Calling license_pool again finds the same LicensePool\\n # as before.\\n pool2 = provider.license_pool(identifier)\\n assert pool == pool2\\n\\n # It's possible for a CollectionCoverageProvider to create a\\n # LicensePool for a different DataSource than the one\\n # associated with the Collection. Only the metadata wrangler\\n # needs to do this -- it's so a CoverageProvider for a\\n # third-party DataSource can create an 'Internal Processing'\\n # LicensePool when some other part of the metadata wrangler\\n # failed to do this earlier.\\n\\n # If a working pool already exists, it's returned and no new\\n # pool is created.\\n same_pool = provider.license_pool(\\n identifier, DataSource.INTERNAL_PROCESSING\\n )\\n assert same_pool == pool2\\n assert provider.data_source == same_pool.data_source\\n\\n # A new pool is only created if no working pool can be found.\\n identifier2 = self._identifier()\\n new_pool = provider.license_pool(\\n identifier2, DataSource.INTERNAL_PROCESSING\\n )\\n assert new_pool.data_source.name == DataSource.INTERNAL_PROCESSING\\n assert new_pool.identifier == identifier2\\n assert new_pool.collection == provider.collection\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8472414","0.83880275","0.82184863","0.8195564","0.81169623","0.80361986","0.74852073","0.74578637","0.7348537","0.7070271","0.7059347","0.70257837","0.6890321","0.68191767","0.68162924","0.6728974","0.6446969","0.6397714","0.6347254","0.616938","0.60866654","0.59918517","0.5901386","0.58719593","0.58368284","0.5770311","0.5682584","0.5658106","0.56527543","0.56448907","0.558194","0.55724347","0.5549785","0.5537517","0.55019677","0.5499852","0.5481518","0.5476245","0.5471106","0.54371345","0.5428306","0.5422268","0.54122174","0.5407232","0.54002154","0.53723335","0.5362425","0.53564876","0.5356031","0.53404653","0.5340398","0.533537","0.532237","0.53204966","0.53150946","0.53141654","0.53129923","0.5307006","0.5306832","0.52930176","0.5285716","0.528307","0.52726686","0.5251745","0.52441853","0.5236148","0.52343136","0.523218","0.52002907","0.51964134","0.519187","0.51853484","0.518433","0.5182846","0.5181203","0.5179609","0.51634896","0.5161328","0.5159669","0.5154983","0.5154077","0.51528883","0.51441675","0.5135398","0.5124718","0.5122612","0.51204765","0.5113124","0.50980705","0.5092422","0.50718325","0.50685346","0.5068183","0.50668794","0.50662684","0.5064336","0.5062978","0.5062261","0.5052875","0.50527585"],"string":"[\n \"0.8472414\",\n \"0.83880275\",\n \"0.82184863\",\n \"0.8195564\",\n \"0.81169623\",\n \"0.80361986\",\n \"0.74852073\",\n \"0.74578637\",\n \"0.7348537\",\n \"0.7070271\",\n \"0.7059347\",\n \"0.70257837\",\n \"0.6890321\",\n \"0.68191767\",\n \"0.68162924\",\n \"0.6728974\",\n \"0.6446969\",\n \"0.6397714\",\n \"0.6347254\",\n \"0.616938\",\n \"0.60866654\",\n \"0.59918517\",\n \"0.5901386\",\n \"0.58719593\",\n \"0.58368284\",\n \"0.5770311\",\n \"0.5682584\",\n \"0.5658106\",\n \"0.56527543\",\n \"0.56448907\",\n \"0.558194\",\n \"0.55724347\",\n \"0.5549785\",\n \"0.5537517\",\n \"0.55019677\",\n \"0.5499852\",\n \"0.5481518\",\n \"0.5476245\",\n \"0.5471106\",\n \"0.54371345\",\n \"0.5428306\",\n \"0.5422268\",\n \"0.54122174\",\n \"0.5407232\",\n \"0.54002154\",\n \"0.53723335\",\n \"0.5362425\",\n \"0.53564876\",\n \"0.5356031\",\n \"0.53404653\",\n \"0.5340398\",\n \"0.533537\",\n \"0.532237\",\n \"0.53204966\",\n \"0.53150946\",\n \"0.53141654\",\n \"0.53129923\",\n \"0.5307006\",\n \"0.5306832\",\n \"0.52930176\",\n \"0.5285716\",\n \"0.528307\",\n \"0.52726686\",\n \"0.5251745\",\n \"0.52441853\",\n \"0.5236148\",\n \"0.52343136\",\n \"0.523218\",\n \"0.52002907\",\n \"0.51964134\",\n \"0.519187\",\n \"0.51853484\",\n \"0.518433\",\n \"0.5182846\",\n \"0.5181203\",\n \"0.5179609\",\n \"0.51634896\",\n \"0.5161328\",\n \"0.5159669\",\n \"0.5154983\",\n \"0.5154077\",\n \"0.51528883\",\n \"0.51441675\",\n \"0.5135398\",\n \"0.5124718\",\n \"0.5122612\",\n \"0.51204765\",\n \"0.5113124\",\n \"0.50980705\",\n \"0.5092422\",\n \"0.50718325\",\n \"0.50685346\",\n \"0.5068183\",\n \"0.50668794\",\n \"0.50662684\",\n \"0.5064336\",\n \"0.5062978\",\n \"0.5062261\",\n \"0.5052875\",\n \"0.50527585\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.96373075"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81390,"cells":{"query":{"kind":"string","value":"For evaluating vhb we extract labels for vhb instead of sao2"},"document":{"kind":"string","value":"def preprocess_vhb(batch, nr_samples=None, snr=None,\n magnification=None, bands_to_sortout=None):\n X, y = preprocess2(batch, nr_samples, snr,\n magnification, bands_to_sortout)\n\n return X, y[\"vhb\"].values"},"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 labels_b_v(self):\n return self._labels_b_v","def labels_b_v_all(self):\n return self._labels_b_v_all","def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jets choosean by simple, the dijet\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\n\n assert len(chain_parts) == 1\n scenario = chain_parts[0]['hypoScenario']\n assert scenario.startswith('vbenf')\n args = _args_from_scenario(scenario)\n if not args:\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \n arg_res = [\n re.compile(r'(?P<lo>\\d*)(?P<key>fbet)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>mass)(?P<hi>\\d*)'),\n re.compile(r'(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)'),\n ]\n\n defaults = {\n 'et': ('101', 'inf'),\n 'mass': ('800', 'inf'),\n 'fbet': ('501', 'inf'),\n }\n\n argvals = {}\n while args:\n assert len(args) == len(arg_res)\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = defaults[key][0]\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = defaults[key][1]\n argvals[key+'hi'] = hi\n\n assert len(args) == len(arg_res)\n assert len(args) == 0\n\n return \"\"\"\n and\n (\n []\n simple\n (\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\n )\n combgen\n (\n [(10et, 0eta320)]\n dijet\n (\n [(%(masslo).0fdjmass, 26djdphi)]\n ) \n simple\n (\n [(10et, 0eta320)(20et, 0eta320)]\n )\n )\n )\"\"\" % argvals","def one_v_all(description):\n label = [0, 0, 0]\n for raw in description.split(\"|\")[4:]:\n line = raw.strip()\n if \"midbrain\" in line:\n label[0] = 1\n if \"forebrain\" in line:\n label[1] = 1\n if \"hindbrain\" in line:\n label[2] = 1\n return label","def hbnb():\n return \"HBNB\"","def hbnb():\n return \"HBNB\"","def _get_labels(self, ind):\n pass","def hbnb():\n return 'HBNB'","def labels_b(self):\n return self._labels_b","def one_v_all(d):\n label = [0, 0, 0, 0]\n for raw in d.split(\"|\")[4:]:\n line = raw.strip()\n if \"brain\" in line:\n label[0] = 1\n if \"limb\" in line:\n label[1] = 1\n if \"heart\" in line:\n label[2] = 1\n if \"neural\" in line:\n label[3] = 1\n return label","def array2(self):\n print \"array2\"\n msgbox(whoami())\n #research\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\n labelnode=slicer.mrmlScene.GetNodeByID(inputLabelID)\n i = labelnode.GetImageData()\n shape = list(i.GetDimensions())\n shape.reverse()\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\n labels=[]\n val=[[0,0,0] for i in range(a.max()+1)]\n for i in xrange(2,a.max()+1):\n w =numpy.transpose(numpy.where(a==i))\n # labels.append(w.mean(axis=0))\n val[i]=[0,0,0]\n val[i][0]=w[int(round(w.shape[0]/2))][2]\n val[i][1]=w[int(round(w.shape[0]/2))][1]\n val[i][2]=w[int(round(w.shape[0]/2))][0]\n if val[i] not in self.previousValues:\n labels.append(val[i])\n self.previousValues.append(val[i])\n return labels","def test_labels(self):\n self.compliance_tester.test_labels(self.oi)","def SAMT_labels(self):\n \t\t#find basic labels\n \t\tlabels_basic = self.dependency_labels()\n \t\tlabels = Labels(labels_basic)\n \t\treturn labels.SAMT_labels()","def cvpr2018_labels():\n\n return {\n 0: 'others',\n 33: 'car',\n 34: 'motorcycle',\n 35: 'bicycle',\n 36: 'pedestrian',\n 38: 'truck',\n 39: 'bus',\n 40: 'tricycle'\n }","def HBNB():\n return 'HBNB'","def labels(self):\n\n param=self\n\n l=len(param)\n\n sweep_label=[]\n\n for index,name in enumerate(param.names):\n\n sweep_label.append((\\\n ''.join([c for c in name if c.isupper()]))\\\n .replace(\"IDT\",\"\")\\\n .replace(\"S\",\"\")\\\n .replace(\"M\",\"\"))\n\n stringout=[]\n\n unique={name:list(dict.fromkeys(values)) for name,values in zip(param.names,param.values)}\n\n for i in range(l):\n\n tmp_lab=''\n\n for lab,name in zip(sweep_label,self.names):\n\n tmp_lab=tmp_lab+lab+str(unique[name].index(param()[name][i]))\n\n stringout.append(tmp_lab)\n\n return stringout","def getLabel2(*args):","def getLabel2(*args):","def get_labels(self):\r\n raise NotImplementedError()","def reagent_label_data(bcl_step):\n\n define_step = None\n indexes = {}\n flowcell_total_reads = 0\n\n for inp, outp in bcl_step.input_output_maps:\n pre_bcl_steps = MASTER_STEPS_UDFS['reagent_labels']['steps']['pre_bcl']\n if inp['parent-process'].type.name not in pre_bcl_steps:\n continue\n\n if outp['output-generation-type'] != 'PerReagentLabel':\n continue\n\n lane = inp['uri']\n art = outp['uri']\n\n index_reads = art.udf.get(\n MASTER_STEPS_UDFS['reagent_labels']['udfs']['reads'])\n\n if index_reads is None or art.qc_flag == 'FAILED':\n continue\n\n flowcell_total_reads += index_reads\n\n sample = art.samples[0] # Will always be only one sample in the list\n application_tag = sample.udf.get('Sequencing Analysis')\n\n if application_tag[0:2] in MASTER_STEPS_UDFS['reagent_labels'][\n 'exclue_tags']:\n continue\n\n if not define_step:\n define_step_outputs, flowcell_target_reads, define_step = get_define_step_data(\n lane)\n\n if not sample.id in define_step_outputs:\n LOG.info('This sample whas put as a pool into the define step: ' +\n sample.id + ' ' + application_tag)\n continue\n\n index = art.reagent_labels[0]\n\n container, lane_nr = lane.location\n if index not in indexes:\n indexes[index] = {\n '_id': '_'.join([index, container.name]),\n 'url': index.replace(' ', ''),\n 'index_total_reads': index_reads,\n 'index_target_reads': define_step_outputs[sample.id],\n 'flowcell_target_reads': flowcell_target_reads,\n 'index': index,\n 'sample': sample.id,\n 'lanes': {\n lane_nr: dict(art.udf.items())\n },\n 'flowcell_id': container.name,\n 'flowcell_type': container.type.name,\n 'define_step_udfs': dict(define_step.udf.items()),\n 'define_step_id': define_step.id,\n 'bcl_step_id': bcl_step.id\n }\n else:\n indexes[index]['lanes'][lane_nr] = dict(art.udf.items())\n indexes[index]['index_total_reads'] += index_reads\n\n for index, data in indexes.items():\n data['flowcell_total_reads'] = flowcell_total_reads\n indexes[index] = filter_none(data)\n\n return indexes","def process_label(intents, w2v,class_id_startpoint=0):\n class_dict = {}\n label_vec = []\n class_id = class_id_startpoint\n \n for line in intents:\n # check whether all the words in w2v dict\n line=line[0]\n label = line.split(' ')\n for w in label:\n if not w in w2v.vocab:\n print('not in w2v dict', w)\n\n # compute label vec\n label_sum = np.sum([w2v[w] for w in label], axis = 0)\n label_vec.append(label_sum)\n # store class names => index\n class_dict[' '.join(label)] = class_id\n class_id = class_id + 1\n #print('=====label vec', label_vec)\n return class_dict, np.asarray(label_vec)","def get_labels():\n return if_found(dao.get_labels())","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def labelingLVQ(self):\n numLabels = len(np.unique(self.y))\n for i, x in enumerate(self.x):\n w = self.find_closest(x)[0]\n for nl in range(numLabels):\n if self.y[i] == nl:\n self.labels[nl, w[0], w[1]] += 1\n return self.labels","def get_vtep_label(cls, client_object, switch_vni=None):\n header_keys = ['VTEP Label']\n nsxa_socket = cls._get_nsxa_socket(client_object)\n cmd = ('%s -t %s vni/vtep_list %s' %\n (cls.CLI, nsxa_socket, switch_vni))\n out = client_object.connection.request(cmd).response_data\n horizontal_parser = horizontal_table_parser.HorizontalTableParser()\n # Skip the VNI number in the output.\n return horizontal_parser.get_parsed_data(\n out, header_keys=header_keys, skip_head=1)","def _GenerateLabels(self, hash_information):\n response_code = hash_information['response_code']\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_NOT_PRESENT:\n return ['virustotal_not_present']\n\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_PRESENT:\n positives = hash_information['positives']\n if positives > 0:\n return [f'virustotal_detections_{positives:d}']\n\n return ['virustotal_no_detections']\n\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_ANALYSIS_PENDING:\n return ['virustotal_analysis_pending']\n\n logger.error(f'VirusTotal returned unknown response code {response_code!s}')\n\n return [f'virustotal_unknown_response_code_{response_code:d}']","def get_labels():\n return {\"contradiction\": 0, \"neutral\": 1, \"entailment\": 2}","def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\n labeled_volumes = dict()\n labeled_cells = dict()\n #Use global density and reduce the size of gt_dataset here\n global_density = labeling_params[\"global_density\"]\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\n #Label in the order specified in the configuration\n layers = sorted(labeling_params.keys())\n #Remove global_density\n layers.remove(\"global_density\")\n for layer in layers:\n print \"Labeling {}\".format(layer)\n fluorophore = labeling_params[layer]['fluorophore']\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\n if fluorophore in labeled_volumes:\n labeled_volumes[fluorophore] += volume\n labeled_cells[fluorophore] |= cells\n else:\n labeled_volumes[fluorophore] = volume\n labeled_cells[fluorophore] = cells\n return labeled_volumes, labeled_cells","def get_val_labels(self):\n raise NotImplementedError","def array2(self):\r\n profbox(whoami())\r\n # research\r\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\r\n labelnode = slicer.mrmlScene.GetNodeByID(inputLabelID)\r\n i = labelnode.GetImageData()\r\n shape = list(i.GetDimensions())\r\n shape.reverse()\r\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\r\n labels = []\r\n val = [[0, 0, 0] for i in range(a.max() + 1)]\r\n for i in xrange(2, a.max() + 1):\r\n w = numpy.transpose(numpy.where(a == i))\r\n # labels.append(w.mean(axis=0))\r\n val[i] = [0, 0, 0]\r\n val[i][0] = w[int(round(w.shape[0] / 2))][2]\r\n val[i][1] = w[int(round(w.shape[0] / 2))][1]\r\n val[i][2] = w[int(round(w.shape[0] / 2))][0]\r\n if val[i] not in self.previousValues:\r\n labels.append(val[i])\r\n self.previousValues.append(val[i])\r\n return labels","def test_intent_classifier_get_labels(self):\n pass","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def label_extraction(self) -> None:\n self.df[\"label\"] = self.df[\"y\"]","def test_text_classifier_get_labels(self):\n pass","def get_labels(self):\r\n return None","def get_labels(self):\n\t\traise NotImplementedError()","def getLabels(self):\n return self.numToLabel","def get_labels(rf_pipeline):\n return rf_pipeline.stages[0].labels","def get_upos_1h_labels() -> Dict[str, List[int]]:\n global upos_1h_labels\n if upos_1h_labels is not None:\n return upos_1h_labels\n else:\n # Use pandas library to generate upos one-hort encoded values\n upos_1h = pd.get_dummies(UPOS_TAGS).values\n upos_1h_labels: Dict[str, List[int]] = {UPOS_TAGS[i]: v for (i, v) in enumerate(upos_1h)}\n return upos_1h_labels","def _get_label(self):\n if self.model.name == '':\n return \"KPI\"\n return \"KPI: {} ({})\".format(self.model.name, self.model.objective)","def GenerateLabels(self, hash_information):\n response_code = hash_information['response_code']\n if response_code == self._VIRUSTOTAL_NOT_PRESENT_RESPONSE_CODE:\n return ['virustotal_not_present']\n\n if response_code == self._VIRUSTOTAL_PRESENT_RESPONSE_CODE:\n positives = hash_information['positives']\n if positives > 0:\n return ['virustotal_detections_{0:d}'.format(positives)]\n\n return ['virsutotal_no_detections']\n\n if response_code == self._VIRUSTOTAL_ANALYSIS_PENDING_RESPONSE_CODE:\n return ['virustotal_analysis_pending']\n\n logger.error(\n 'VirusTotal returned unknown response code {0!s}'.format(\n response_code))\n return ['virustotal_unknown_response_code_{0:d}'.format(response_code)]","def _get_vrf_label(self):\n return self.__vrf_label","def make_labels(self, ilines):\n\n llist = []\n for lind, lstr in enumerate(ilines):\n # get label and value list\n rv, label, vals = self.get_label_vals(lstr)\n if rv < 1: continue\n\n nvals = len(vals)\n\n # label = self.find_parent_label(label)\n\n if self.verb > 2: print('++ label: %s, %d val(s)' % (label, nvals))\n\n llist.append(label)\n self.maxcounts[label] = nvals\n self.subjcounts[label] = 0\n\n if not UTIL.vals_are_unique(llist):\n print('** warning: labels are not unique, will use only last values')\n llist = UTIL.get_unique_sublist(llist)\n\n return 0, llist","def vggface2_labels(self):\n id_meta = pd.read_csv(\"loki/static/models/vggface2/identity_meta.csv\",\n sep=\"\\n\")\n id_meta = id_meta[\n 'Class_ID, Name, Sample_Num, Flag, Gender'].str\\\n .split(',', expand=True)\n\n id_meta.columns = [\n 'Class_ID', 'Name', 'Sample_Num', 'Flag', 'Gender', 'None']\n id_meta.drop(columns=['None'], inplace=True)\n\n vgg_names = id_meta.drop(columns=[\n 'Sample_Num', 'Flag', 'Gender']).set_index('Class_ID')\n\n return vgg_names","def svm():","def _labels_of_sentence(self, sentence, split):\n #print(self.label_vocab)\n self.category_int_of_label_string('O')\n bioes_tags = self._string_labels_of_sentence(sentence)\n labels = torch.zeros(len(sentence))\n for index, label in enumerate(bioes_tags):\n labels[index] = self.category_int_of_label_string(label)\n return labels","def labels(self):\n return self._labels","def _get_labels(self, label_vector):\n return () if label_vector is None else \\\n list(OrderedDict.fromkeys([label for term in label_vector \\\n for label, power in term if power != 0]))","def label(self):\r\n raise NotImplementedError","def label_data(data):\n if data == 'cat': return [1, 0]\n elif data == 'dog': return [0, 1]","def get_labels(self):\n raise NotImplementedError","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def get_labels(self):\r\n raise NotImplementedError()","def __get_labels(self):\n\n uncertain_pairs_index = self.__query_pairs()\n\n to_label_raw = self.all_raw_data.loc[uncertain_pairs_index]\n to_label_features = self.all_features.loc[uncertain_pairs_index]\n\n # Remove uncertain pairs from the candidate pool\n self.all_features.drop(uncertain_pairs_index, axis=0, inplace=True)\n\n labels_list = []\n for index, row in to_label_raw.iterrows():\n\n print(\"\\n{0:30}\\t{1}\\n{2:30}\\t{3}\\n{4:30}\\t{5}\\n{6:30}\\t{7}\\n\".format(row.name_a, row.name_b,\n row.address_a, row.address_b,\n row.zip_a, row.zip_b,\n row.city_a, row.city_b))\n\n\n label = self.__user_input(\"Is this a match? (0/1)\")\n labels_list.append((index, label))\n\n labels_index = [index for index, label in labels_list]\n labels_values = [label for index, label in labels_list]\n\n # Create dataframe with index and labels\n add_labels = pd.Series(labels_values, index=labels_index, name='label')\n\n # Union the new training set to the full training set\n self.labeled_features = pd.concat([self.labeled_features, to_label_features], axis = 0, ignore_index=False)\n self.labeled_labels = pd.concat([self.labeled_labels, add_labels], axis = 0, ignore_index=False)\n\n return self","def get_predefined_labels(self):\n raise NotImplementedError","def provide_label(self):\n return [(k, v.shape) for k, v in self.label]","def verbalize_labels(label_dictionary: Dictionary) -> List[Sentence]:\n verbalized_labels = []\n for byte_label, idx in label_dictionary.item2idx.items():\n str_label = byte_label.decode(\"utf-8\")\n if label_dictionary.span_labels:\n # verbalize BIOES labels\n if str_label == \"O\":\n verbalized_labels.append(\"outside\")\n elif str_label.startswith(\"B-\"):\n verbalized_labels.append(\"begin \" + str_label.split(\"-\")[1])\n elif str_label.startswith(\"I-\"):\n verbalized_labels.append(\"inside \" + str_label.split(\"-\")[1])\n elif str_label.startswith(\"E-\"):\n verbalized_labels.append(\"ending \" + str_label.split(\"-\")[1])\n elif str_label.startswith(\"S-\"):\n verbalized_labels.append(\"single \" + str_label.split(\"-\")[1])\n # if label is not BIOES, use label itself\n else:\n verbalized_labels.append(str_label)\n else:\n verbalized_labels.append(str_label)\n return list(map(Sentence, verbalized_labels))","def get_labels(info):\n return info.features[\"labels\"].names","def get_labels(info):\n return info.features[\"labels\"].names","def return_histogram_labels():\n return list(labels)","def _make_ht_label(chain_parts):\n\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\n scenario = chain_parts[0]['hypoScenario']\n \n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\n\n arg_res = [\n re.compile(r'^(?P<lo>\\d*)(?P<key>ht)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>et)(?P<hi>\\d*)$'),\n re.compile(r'^(?P<lo>\\d*)(?P<key>eta)(?P<hi>\\d*)$'),\n ]\n\n defaults = {\n 'ht': ('0', 'inf'),\n 'et': ('0', 'inf'),\n 'eta': ('0', 'inf'),\n }\n\n\n args = _args_from_scenario(scenario)\n argvals = {}\n nargs = len(args)\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\n len(arg_res))\n\n # obtain argument values frrom scenario\n while args:\n arg = args.pop()\n for r in arg_res:\n m = r.match(arg)\n if m is not None:\n arg_res.remove(r)\n gd = m.groupdict()\n key = gd['key']\n\n try:\n lo = float(gd['lo'])\n except ValueError:\n lo = float(defaults[key][0])\n argvals[key+'lo'] = lo \n try:\n hi = float(gd['hi'])\n except ValueError:\n hi = float(defaults[key][1])\n argvals[key+'hi'] = hi\n\n print (argvals)\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\n\n print ('sent 100')\n result = \"\"\"\n ht([(%(htlo).0fht) \n (%(etlo).0fet)\n (%(etalo).0feta%(etahi).0f)\n ])\"\"\" % argvals\n print (result)\n return result","def labels(self):\n return self.label(self.p_y_given_x)","def _get_l2_label(self):\n return self.__l2_label","def get_labels(self):\r\n return [\"X\", \"O\", \"B-a\", \"I-a\", \"B-b\", \"I-b\", \"B-c\", \"I-c\", \"S-a\", \"S-b\", \"S-c\", \"[CLS]\", \"[SEP]\"]","def _get_bbox_regression_labels(bbox_target_data, num_classes):\r\n\r\n clss = bbox_target_data[:, 0]\r\n # print (\"===============class size: \" + str(clss))\r\n bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32) #clss.size = 128 ---> bbox_targets = 128 * 84, moi roi la 1*84 dimesion\r\n bbox_inside_weights = np.zeros(bbox_targets.shape, dtype=np.float32)\r\n inds = np.where(clss > 0)[0]\r\n for ind in inds:\r\n cls = clss[ind]\r\n start = 4 * cls\r\n end = start + 4\r\n start=int(start)\r\n\tend=int(end)\r\n\tbbox_targets[ind, start:end] = bbox_target_data[ind, 1:] #gan gia tri tai class tuong ung la bbox_target_data, con lai la so 0\r\n bbox_inside_weights[ind, start:end] = cfg.TRAIN.BBOX_INSIDE_WEIGHTS\r\n return bbox_targets, bbox_inside_weights","def _labels_of_sentence(self, sentence, split):\n labels = torch.ones(1)\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\n return labels","def get_label(urs):\n return assign_term(urs)[1]","def extract_labels(filename,tag,one_hot):\n print('Extracting labels',filename)\n return extractdb_labels(filename,tag,one_hot=one_hot)","def test_labels(self):\n return self._test_labels","def convert_label(self, user_label: str) -> Tuple[str]:\n user_label = re.sub(string=user_label, pattern=\"(?<=\\w)\\/(?=\\w)\", repl=\" \", count=1)\n final_label_tokens = nltk.word_tokenize(text=user_label, language=\"english\", preserve_line=False)\n for i, token in enumerate(final_label_tokens):\n token = token.lower()\n if token == \"v\" or token == \"v.\" or token == \"vs\" or token == \"vs.\":\n final_label_tokens[i] = \"versus\"\n if self.semantic_clustering:\n tagged_label = [t_tag for t_tag in nltk.pos_tag(tokens=final_label_tokens, lang=\"eng\", tagset=\"universal\")\n if t_tag[0] not in setStopWords]\n tagged_label.reverse()\n final_label_tokens = [t_tag[0] for t_tag in tagged_label if t_tag[1] == \"NOUN\"] + \\\n [t_tag[0] for t_tag in tagged_label if t_tag[1] == \"VERB\"] + \\\n [t_tag[0] for t_tag in tagged_label if t_tag[1] not in [\"NOUN\", \"VERB\"]]\n logger.debug(\"Converted the user label \\\"{}\\\" to \\\"{}\\\"\", user_label, \" \".join(final_label_tokens))\n if len(final_label_tokens) > 4:\n logger.warning(\"The label {} has more than 4 tokens: {}. Discard {}\", final_label_tokens,\n len(final_label_tokens), final_label_tokens[4:])\n final_label_tokens = final_label_tokens[:4]\n elif len(final_label_tokens) == 0:\n logger.warning(\"We receive an preprocessed user label which is empty!\")\n final_label_tokens = [\"<pad>\"] * 4\n elif len(final_label_tokens) == 1:\n final_label_tokens = final_label_tokens * 4\n elif len(final_label_tokens) == 2:\n final_label_tokens = final_label_tokens * 2\n elif len(final_label_tokens) == 3:\n final_label_tokens.append(final_label_tokens[0])\n\n return tuple(final_label_tokens)","def label_vector(self):\n return self._label_vector","def _label_generation(self, indexes):\n data = self.data.iloc[indexes]\n return np.array(data['peak_flux'])","def label(efo):\n url = 'https://www.ebi.ac.uk/ols/api/ontologies/efo/terms?iri=http://www.ebi.ac.uk/efo/'+efo\n try:\n response = requests.get(url).json()\n except:\n return \"\"\n if 'error' in response.keys():\n return \"\"\n return response['_embedded']['terms'][0]['label']","def parse_label(self):\n # TODO: make this work with attached labels as well as\n # stand alone labels.\n # Save the RAW full text of the label to self._raw\n input_stream = FileStream(self.infile)\n lexer = ODLv21Lexer(input_stream)\n tokens = CommonTokenStream(lexer)\n\n parser = ODLv21Parser(tokens)\n parse_tree = parser.label()\n self._parse_tree = parse_tree\n visitor = Pds3LabelVisitor()\n visitor.visit(parse_tree)\n return visitor.root_dict","def eidb_label(\n model: str, scenario: str, year: int, version: str, system_model: str = \"cutoff\"\n) -> str:\n return f\"ecoinvent_{system_model}_{version}_{model}_{scenario}_{year}\"","def get_test_labels(self):\n raise NotImplementedError","def test_issue_get_labels(self):\n pass","def predict_label(self, src): # real signature unknown; restored from __doc__\n pass","def provide_label(self):\r\n return [(k, tuple([1] + list(v.shape[1:]))) for k, v in self.label]","def test_basic_labeling(self):\n # data with only 1 feature\n data = array([[-1], [1], [0.5], [0.25], [-0.33], [0]])\n # give 1 if feature value >= 0; otherwise 0\n labels = array([0, 1, 1, 1, 0, 1])\n cdata = LabeledCData(data, labels)\n\n # ensure that labelling is correct\n assert array_equal(cdata.labels, labels)","def _string_labels_of_sentence(self, sentence):\n label_strings = []\n ongoing_label = 'O'\n for token_index, token_attribute_list in enumerate(sentence):\n raw_label_string = token_attribute_list[self.task_label_index].strip('*')\n if '(' in raw_label_string:\n ongoing_label = raw_label_string.strip('(').strip(')')\n beginning = True\n #labels[token_index] = self.category_int_of_label_string(ongoing_label)\n if ongoing_label == 'O':\n label_strings.append(ongoing_label)\n else:\n label_strings.append('{}-{}'.format('B' if beginning else 'I', ongoing_label))\n beginning = False\n if ')' in raw_label_string:\n ongoing_label = 'O'\n #bioes_tags = bio2_to_bioes(label_strings)\n bioes_tags = label_strings\n return bioes_tags","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()"],"string":"[\n \"def labels_b_v(self):\\n return self._labels_b_v\",\n \"def labels_b_v_all(self):\\n return self._labels_b_v_all\",\n \"def _make_vbenf_label(chain_parts):\\n\\n # toy label for development: run simple and dijet independently.\\n # simple makes Et cuts on two jets. Independently (sharing possible)\\n # of jets choosean by simple, the dijet\\n # scenario requires a dijet of mass > 900, and opening angle in phi > 2.6\\n\\n assert len(chain_parts) == 1\\n scenario = chain_parts[0]['hypoScenario']\\n assert scenario.startswith('vbenf')\\n args = _args_from_scenario(scenario)\\n if not args:\\n return 'and([]simple([(50et)(70et)])combgen([(2)] dijet([(900djmass, 26djdphi)])))' \\n arg_res = [\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>fbet)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>mass)(?P<hi>\\\\d*)'),\\n re.compile(r'(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)'),\\n ]\\n\\n defaults = {\\n 'et': ('101', 'inf'),\\n 'mass': ('800', 'inf'),\\n 'fbet': ('501', 'inf'),\\n }\\n\\n argvals = {}\\n while args:\\n assert len(args) == len(arg_res)\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = defaults[key][0]\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = defaults[key][1]\\n argvals[key+'hi'] = hi\\n\\n assert len(args) == len(arg_res)\\n assert len(args) == 0\\n\\n return \\\"\\\"\\\"\\n and\\n (\\n []\\n simple\\n (\\n [(%(etlo).0fet, 500neta)(%(etlo).0fet, peta500)]\\n )\\n combgen\\n (\\n [(10et, 0eta320)]\\n dijet\\n (\\n [(%(masslo).0fdjmass, 26djdphi)]\\n ) \\n simple\\n (\\n [(10et, 0eta320)(20et, 0eta320)]\\n )\\n )\\n )\\\"\\\"\\\" % argvals\",\n \"def one_v_all(description):\\n label = [0, 0, 0]\\n for raw in description.split(\\\"|\\\")[4:]:\\n line = raw.strip()\\n if \\\"midbrain\\\" in line:\\n label[0] = 1\\n if \\\"forebrain\\\" in line:\\n label[1] = 1\\n if \\\"hindbrain\\\" in line:\\n label[2] = 1\\n return label\",\n \"def hbnb():\\n return \\\"HBNB\\\"\",\n \"def hbnb():\\n return \\\"HBNB\\\"\",\n \"def _get_labels(self, ind):\\n pass\",\n \"def hbnb():\\n return 'HBNB'\",\n \"def labels_b(self):\\n return self._labels_b\",\n \"def one_v_all(d):\\n label = [0, 0, 0, 0]\\n for raw in d.split(\\\"|\\\")[4:]:\\n line = raw.strip()\\n if \\\"brain\\\" in line:\\n label[0] = 1\\n if \\\"limb\\\" in line:\\n label[1] = 1\\n if \\\"heart\\\" in line:\\n label[2] = 1\\n if \\\"neural\\\" in line:\\n label[3] = 1\\n return label\",\n \"def array2(self):\\n print \\\"array2\\\"\\n msgbox(whoami())\\n #research\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\n labelnode=slicer.mrmlScene.GetNodeByID(inputLabelID)\\n i = labelnode.GetImageData()\\n shape = list(i.GetDimensions())\\n shape.reverse()\\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\\n labels=[]\\n val=[[0,0,0] for i in range(a.max()+1)]\\n for i in xrange(2,a.max()+1):\\n w =numpy.transpose(numpy.where(a==i))\\n # labels.append(w.mean(axis=0))\\n val[i]=[0,0,0]\\n val[i][0]=w[int(round(w.shape[0]/2))][2]\\n val[i][1]=w[int(round(w.shape[0]/2))][1]\\n val[i][2]=w[int(round(w.shape[0]/2))][0]\\n if val[i] not in self.previousValues:\\n labels.append(val[i])\\n self.previousValues.append(val[i])\\n return labels\",\n \"def test_labels(self):\\n self.compliance_tester.test_labels(self.oi)\",\n \"def SAMT_labels(self):\\n \\t\\t#find basic labels\\n \\t\\tlabels_basic = self.dependency_labels()\\n \\t\\tlabels = Labels(labels_basic)\\n \\t\\treturn labels.SAMT_labels()\",\n \"def cvpr2018_labels():\\n\\n return {\\n 0: 'others',\\n 33: 'car',\\n 34: 'motorcycle',\\n 35: 'bicycle',\\n 36: 'pedestrian',\\n 38: 'truck',\\n 39: 'bus',\\n 40: 'tricycle'\\n }\",\n \"def HBNB():\\n return 'HBNB'\",\n \"def labels(self):\\n\\n param=self\\n\\n l=len(param)\\n\\n sweep_label=[]\\n\\n for index,name in enumerate(param.names):\\n\\n sweep_label.append((\\\\\\n ''.join([c for c in name if c.isupper()]))\\\\\\n .replace(\\\"IDT\\\",\\\"\\\")\\\\\\n .replace(\\\"S\\\",\\\"\\\")\\\\\\n .replace(\\\"M\\\",\\\"\\\"))\\n\\n stringout=[]\\n\\n unique={name:list(dict.fromkeys(values)) for name,values in zip(param.names,param.values)}\\n\\n for i in range(l):\\n\\n tmp_lab=''\\n\\n for lab,name in zip(sweep_label,self.names):\\n\\n tmp_lab=tmp_lab+lab+str(unique[name].index(param()[name][i]))\\n\\n stringout.append(tmp_lab)\\n\\n return stringout\",\n \"def getLabel2(*args):\",\n \"def getLabel2(*args):\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def reagent_label_data(bcl_step):\\n\\n define_step = None\\n indexes = {}\\n flowcell_total_reads = 0\\n\\n for inp, outp in bcl_step.input_output_maps:\\n pre_bcl_steps = MASTER_STEPS_UDFS['reagent_labels']['steps']['pre_bcl']\\n if inp['parent-process'].type.name not in pre_bcl_steps:\\n continue\\n\\n if outp['output-generation-type'] != 'PerReagentLabel':\\n continue\\n\\n lane = inp['uri']\\n art = outp['uri']\\n\\n index_reads = art.udf.get(\\n MASTER_STEPS_UDFS['reagent_labels']['udfs']['reads'])\\n\\n if index_reads is None or art.qc_flag == 'FAILED':\\n continue\\n\\n flowcell_total_reads += index_reads\\n\\n sample = art.samples[0] # Will always be only one sample in the list\\n application_tag = sample.udf.get('Sequencing Analysis')\\n\\n if application_tag[0:2] in MASTER_STEPS_UDFS['reagent_labels'][\\n 'exclue_tags']:\\n continue\\n\\n if not define_step:\\n define_step_outputs, flowcell_target_reads, define_step = get_define_step_data(\\n lane)\\n\\n if not sample.id in define_step_outputs:\\n LOG.info('This sample whas put as a pool into the define step: ' +\\n sample.id + ' ' + application_tag)\\n continue\\n\\n index = art.reagent_labels[0]\\n\\n container, lane_nr = lane.location\\n if index not in indexes:\\n indexes[index] = {\\n '_id': '_'.join([index, container.name]),\\n 'url': index.replace(' ', ''),\\n 'index_total_reads': index_reads,\\n 'index_target_reads': define_step_outputs[sample.id],\\n 'flowcell_target_reads': flowcell_target_reads,\\n 'index': index,\\n 'sample': sample.id,\\n 'lanes': {\\n lane_nr: dict(art.udf.items())\\n },\\n 'flowcell_id': container.name,\\n 'flowcell_type': container.type.name,\\n 'define_step_udfs': dict(define_step.udf.items()),\\n 'define_step_id': define_step.id,\\n 'bcl_step_id': bcl_step.id\\n }\\n else:\\n indexes[index]['lanes'][lane_nr] = dict(art.udf.items())\\n indexes[index]['index_total_reads'] += index_reads\\n\\n for index, data in indexes.items():\\n data['flowcell_total_reads'] = flowcell_total_reads\\n indexes[index] = filter_none(data)\\n\\n return indexes\",\n \"def process_label(intents, w2v,class_id_startpoint=0):\\n class_dict = {}\\n label_vec = []\\n class_id = class_id_startpoint\\n \\n for line in intents:\\n # check whether all the words in w2v dict\\n line=line[0]\\n label = line.split(' ')\\n for w in label:\\n if not w in w2v.vocab:\\n print('not in w2v dict', w)\\n\\n # compute label vec\\n label_sum = np.sum([w2v[w] for w in label], axis = 0)\\n label_vec.append(label_sum)\\n # store class names => index\\n class_dict[' '.join(label)] = class_id\\n class_id = class_id + 1\\n #print('=====label vec', label_vec)\\n return class_dict, np.asarray(label_vec)\",\n \"def get_labels():\\n return if_found(dao.get_labels())\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def labelingLVQ(self):\\n numLabels = len(np.unique(self.y))\\n for i, x in enumerate(self.x):\\n w = self.find_closest(x)[0]\\n for nl in range(numLabels):\\n if self.y[i] == nl:\\n self.labels[nl, w[0], w[1]] += 1\\n return self.labels\",\n \"def get_vtep_label(cls, client_object, switch_vni=None):\\n header_keys = ['VTEP Label']\\n nsxa_socket = cls._get_nsxa_socket(client_object)\\n cmd = ('%s -t %s vni/vtep_list %s' %\\n (cls.CLI, nsxa_socket, switch_vni))\\n out = client_object.connection.request(cmd).response_data\\n horizontal_parser = horizontal_table_parser.HorizontalTableParser()\\n # Skip the VNI number in the output.\\n return horizontal_parser.get_parsed_data(\\n out, header_keys=header_keys, skip_head=1)\",\n \"def _GenerateLabels(self, hash_information):\\n response_code = hash_information['response_code']\\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_NOT_PRESENT:\\n return ['virustotal_not_present']\\n\\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_PRESENT:\\n positives = hash_information['positives']\\n if positives > 0:\\n return [f'virustotal_detections_{positives:d}']\\n\\n return ['virustotal_no_detections']\\n\\n if response_code == self._VIRUSTOTAL_RESPONSE_CODE_ANALYSIS_PENDING:\\n return ['virustotal_analysis_pending']\\n\\n logger.error(f'VirusTotal returned unknown response code {response_code!s}')\\n\\n return [f'virustotal_unknown_response_code_{response_code:d}']\",\n \"def get_labels():\\n return {\\\"contradiction\\\": 0, \\\"neutral\\\": 1, \\\"entailment\\\": 2}\",\n \"def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\\n labeled_volumes = dict()\\n labeled_cells = dict()\\n #Use global density and reduce the size of gt_dataset here\\n global_density = labeling_params[\\\"global_density\\\"]\\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\\n #Label in the order specified in the configuration\\n layers = sorted(labeling_params.keys())\\n #Remove global_density\\n layers.remove(\\\"global_density\\\")\\n for layer in layers:\\n print \\\"Labeling {}\\\".format(layer)\\n fluorophore = labeling_params[layer]['fluorophore']\\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\\n if fluorophore in labeled_volumes:\\n labeled_volumes[fluorophore] += volume\\n labeled_cells[fluorophore] |= cells\\n else:\\n labeled_volumes[fluorophore] = volume\\n labeled_cells[fluorophore] = cells\\n return labeled_volumes, labeled_cells\",\n \"def get_val_labels(self):\\n raise NotImplementedError\",\n \"def array2(self):\\r\\n profbox(whoami())\\r\\n # research\\r\\n inputLabelID = self.__needleLabelSelector.currentNode().GetID()\\r\\n labelnode = slicer.mrmlScene.GetNodeByID(inputLabelID)\\r\\n i = labelnode.GetImageData()\\r\\n shape = list(i.GetDimensions())\\r\\n shape.reverse()\\r\\n a = vtk.util.numpy_support.vtk_to_numpy(i.GetPointData().GetScalars()).reshape(shape)\\r\\n labels = []\\r\\n val = [[0, 0, 0] for i in range(a.max() + 1)]\\r\\n for i in xrange(2, a.max() + 1):\\r\\n w = numpy.transpose(numpy.where(a == i))\\r\\n # labels.append(w.mean(axis=0))\\r\\n val[i] = [0, 0, 0]\\r\\n val[i][0] = w[int(round(w.shape[0] / 2))][2]\\r\\n val[i][1] = w[int(round(w.shape[0] / 2))][1]\\r\\n val[i][2] = w[int(round(w.shape[0] / 2))][0]\\r\\n if val[i] not in self.previousValues:\\r\\n labels.append(val[i])\\r\\n self.previousValues.append(val[i])\\r\\n return labels\",\n \"def test_intent_classifier_get_labels(self):\\n pass\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def label_extraction(self) -> None:\\n self.df[\\\"label\\\"] = self.df[\\\"y\\\"]\",\n \"def test_text_classifier_get_labels(self):\\n pass\",\n \"def get_labels(self):\\r\\n return None\",\n \"def get_labels(self):\\n\\t\\traise NotImplementedError()\",\n \"def getLabels(self):\\n return self.numToLabel\",\n \"def get_labels(rf_pipeline):\\n return rf_pipeline.stages[0].labels\",\n \"def get_upos_1h_labels() -> Dict[str, List[int]]:\\n global upos_1h_labels\\n if upos_1h_labels is not None:\\n return upos_1h_labels\\n else:\\n # Use pandas library to generate upos one-hort encoded values\\n upos_1h = pd.get_dummies(UPOS_TAGS).values\\n upos_1h_labels: Dict[str, List[int]] = {UPOS_TAGS[i]: v for (i, v) in enumerate(upos_1h)}\\n return upos_1h_labels\",\n \"def _get_label(self):\\n if self.model.name == '':\\n return \\\"KPI\\\"\\n return \\\"KPI: {} ({})\\\".format(self.model.name, self.model.objective)\",\n \"def GenerateLabels(self, hash_information):\\n response_code = hash_information['response_code']\\n if response_code == self._VIRUSTOTAL_NOT_PRESENT_RESPONSE_CODE:\\n return ['virustotal_not_present']\\n\\n if response_code == self._VIRUSTOTAL_PRESENT_RESPONSE_CODE:\\n positives = hash_information['positives']\\n if positives > 0:\\n return ['virustotal_detections_{0:d}'.format(positives)]\\n\\n return ['virsutotal_no_detections']\\n\\n if response_code == self._VIRUSTOTAL_ANALYSIS_PENDING_RESPONSE_CODE:\\n return ['virustotal_analysis_pending']\\n\\n logger.error(\\n 'VirusTotal returned unknown response code {0!s}'.format(\\n response_code))\\n return ['virustotal_unknown_response_code_{0:d}'.format(response_code)]\",\n \"def _get_vrf_label(self):\\n return self.__vrf_label\",\n \"def make_labels(self, ilines):\\n\\n llist = []\\n for lind, lstr in enumerate(ilines):\\n # get label and value list\\n rv, label, vals = self.get_label_vals(lstr)\\n if rv < 1: continue\\n\\n nvals = len(vals)\\n\\n # label = self.find_parent_label(label)\\n\\n if self.verb > 2: print('++ label: %s, %d val(s)' % (label, nvals))\\n\\n llist.append(label)\\n self.maxcounts[label] = nvals\\n self.subjcounts[label] = 0\\n\\n if not UTIL.vals_are_unique(llist):\\n print('** warning: labels are not unique, will use only last values')\\n llist = UTIL.get_unique_sublist(llist)\\n\\n return 0, llist\",\n \"def vggface2_labels(self):\\n id_meta = pd.read_csv(\\\"loki/static/models/vggface2/identity_meta.csv\\\",\\n sep=\\\"\\\\n\\\")\\n id_meta = id_meta[\\n 'Class_ID, Name, Sample_Num, Flag, Gender'].str\\\\\\n .split(',', expand=True)\\n\\n id_meta.columns = [\\n 'Class_ID', 'Name', 'Sample_Num', 'Flag', 'Gender', 'None']\\n id_meta.drop(columns=['None'], inplace=True)\\n\\n vgg_names = id_meta.drop(columns=[\\n 'Sample_Num', 'Flag', 'Gender']).set_index('Class_ID')\\n\\n return vgg_names\",\n \"def svm():\",\n \"def _labels_of_sentence(self, sentence, split):\\n #print(self.label_vocab)\\n self.category_int_of_label_string('O')\\n bioes_tags = self._string_labels_of_sentence(sentence)\\n labels = torch.zeros(len(sentence))\\n for index, label in enumerate(bioes_tags):\\n labels[index] = self.category_int_of_label_string(label)\\n return labels\",\n \"def labels(self):\\n return self._labels\",\n \"def _get_labels(self, label_vector):\\n return () if label_vector is None else \\\\\\n list(OrderedDict.fromkeys([label for term in label_vector \\\\\\n for label, power in term if power != 0]))\",\n \"def label(self):\\r\\n raise NotImplementedError\",\n \"def label_data(data):\\n if data == 'cat': return [1, 0]\\n elif data == 'dog': return [0, 1]\",\n \"def get_labels(self):\\n raise NotImplementedError\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def get_labels(self):\\r\\n raise NotImplementedError()\",\n \"def __get_labels(self):\\n\\n uncertain_pairs_index = self.__query_pairs()\\n\\n to_label_raw = self.all_raw_data.loc[uncertain_pairs_index]\\n to_label_features = self.all_features.loc[uncertain_pairs_index]\\n\\n # Remove uncertain pairs from the candidate pool\\n self.all_features.drop(uncertain_pairs_index, axis=0, inplace=True)\\n\\n labels_list = []\\n for index, row in to_label_raw.iterrows():\\n\\n print(\\\"\\\\n{0:30}\\\\t{1}\\\\n{2:30}\\\\t{3}\\\\n{4:30}\\\\t{5}\\\\n{6:30}\\\\t{7}\\\\n\\\".format(row.name_a, row.name_b,\\n row.address_a, row.address_b,\\n row.zip_a, row.zip_b,\\n row.city_a, row.city_b))\\n\\n\\n label = self.__user_input(\\\"Is this a match? (0/1)\\\")\\n labels_list.append((index, label))\\n\\n labels_index = [index for index, label in labels_list]\\n labels_values = [label for index, label in labels_list]\\n\\n # Create dataframe with index and labels\\n add_labels = pd.Series(labels_values, index=labels_index, name='label')\\n\\n # Union the new training set to the full training set\\n self.labeled_features = pd.concat([self.labeled_features, to_label_features], axis = 0, ignore_index=False)\\n self.labeled_labels = pd.concat([self.labeled_labels, add_labels], axis = 0, ignore_index=False)\\n\\n return self\",\n \"def get_predefined_labels(self):\\n raise NotImplementedError\",\n \"def provide_label(self):\\n return [(k, v.shape) for k, v in self.label]\",\n \"def verbalize_labels(label_dictionary: Dictionary) -> List[Sentence]:\\n verbalized_labels = []\\n for byte_label, idx in label_dictionary.item2idx.items():\\n str_label = byte_label.decode(\\\"utf-8\\\")\\n if label_dictionary.span_labels:\\n # verbalize BIOES labels\\n if str_label == \\\"O\\\":\\n verbalized_labels.append(\\\"outside\\\")\\n elif str_label.startswith(\\\"B-\\\"):\\n verbalized_labels.append(\\\"begin \\\" + str_label.split(\\\"-\\\")[1])\\n elif str_label.startswith(\\\"I-\\\"):\\n verbalized_labels.append(\\\"inside \\\" + str_label.split(\\\"-\\\")[1])\\n elif str_label.startswith(\\\"E-\\\"):\\n verbalized_labels.append(\\\"ending \\\" + str_label.split(\\\"-\\\")[1])\\n elif str_label.startswith(\\\"S-\\\"):\\n verbalized_labels.append(\\\"single \\\" + str_label.split(\\\"-\\\")[1])\\n # if label is not BIOES, use label itself\\n else:\\n verbalized_labels.append(str_label)\\n else:\\n verbalized_labels.append(str_label)\\n return list(map(Sentence, verbalized_labels))\",\n \"def get_labels(info):\\n return info.features[\\\"labels\\\"].names\",\n \"def get_labels(info):\\n return info.features[\\\"labels\\\"].names\",\n \"def return_histogram_labels():\\n return list(labels)\",\n \"def _make_ht_label(chain_parts):\\n\\n assert len(chain_parts) == 1, '_make_ht_label, no. of chain parts != 1'\\n scenario = chain_parts[0]['hypoScenario']\\n \\n assert scenario.startswith('HT'), '_make_ht_label(): scenario does not start with HT'\\n\\n arg_res = [\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>ht)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>et)(?P<hi>\\\\d*)$'),\\n re.compile(r'^(?P<lo>\\\\d*)(?P<key>eta)(?P<hi>\\\\d*)$'),\\n ]\\n\\n defaults = {\\n 'ht': ('0', 'inf'),\\n 'et': ('0', 'inf'),\\n 'eta': ('0', 'inf'),\\n }\\n\\n\\n args = _args_from_scenario(scenario)\\n argvals = {}\\n nargs = len(args)\\n assert len(args) <= len(arg_res), 'bad num of args %d, expected < %d' % (len(args),\\n len(arg_res))\\n\\n # obtain argument values frrom scenario\\n while args:\\n arg = args.pop()\\n for r in arg_res:\\n m = r.match(arg)\\n if m is not None:\\n arg_res.remove(r)\\n gd = m.groupdict()\\n key = gd['key']\\n\\n try:\\n lo = float(gd['lo'])\\n except ValueError:\\n lo = float(defaults[key][0])\\n argvals[key+'lo'] = lo \\n try:\\n hi = float(gd['hi'])\\n except ValueError:\\n hi = float(defaults[key][1])\\n argvals[key+'hi'] = hi\\n\\n print (argvals)\\n assert len(argvals) == 2*nargs, 'no of args: %d, expected %d' % (len(argvals), 2*nargs)\\n\\n print ('sent 100')\\n result = \\\"\\\"\\\"\\n ht([(%(htlo).0fht) \\n (%(etlo).0fet)\\n (%(etalo).0feta%(etahi).0f)\\n ])\\\"\\\"\\\" % argvals\\n print (result)\\n return result\",\n \"def labels(self):\\n return self.label(self.p_y_given_x)\",\n \"def _get_l2_label(self):\\n return self.__l2_label\",\n \"def get_labels(self):\\r\\n return [\\\"X\\\", \\\"O\\\", \\\"B-a\\\", \\\"I-a\\\", \\\"B-b\\\", \\\"I-b\\\", \\\"B-c\\\", \\\"I-c\\\", \\\"S-a\\\", \\\"S-b\\\", \\\"S-c\\\", \\\"[CLS]\\\", \\\"[SEP]\\\"]\",\n \"def _get_bbox_regression_labels(bbox_target_data, num_classes):\\r\\n\\r\\n clss = bbox_target_data[:, 0]\\r\\n # print (\\\"===============class size: \\\" + str(clss))\\r\\n bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32) #clss.size = 128 ---> bbox_targets = 128 * 84, moi roi la 1*84 dimesion\\r\\n bbox_inside_weights = np.zeros(bbox_targets.shape, dtype=np.float32)\\r\\n inds = np.where(clss > 0)[0]\\r\\n for ind in inds:\\r\\n cls = clss[ind]\\r\\n start = 4 * cls\\r\\n end = start + 4\\r\\n start=int(start)\\r\\n\\tend=int(end)\\r\\n\\tbbox_targets[ind, start:end] = bbox_target_data[ind, 1:] #gan gia tri tai class tuong ung la bbox_target_data, con lai la so 0\\r\\n bbox_inside_weights[ind, start:end] = cfg.TRAIN.BBOX_INSIDE_WEIGHTS\\r\\n return bbox_targets, bbox_inside_weights\",\n \"def _labels_of_sentence(self, sentence, split):\\n labels = torch.ones(1)\\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\\n return labels\",\n \"def get_label(urs):\\n return assign_term(urs)[1]\",\n \"def extract_labels(filename,tag,one_hot):\\n print('Extracting labels',filename)\\n return extractdb_labels(filename,tag,one_hot=one_hot)\",\n \"def test_labels(self):\\n return self._test_labels\",\n \"def convert_label(self, user_label: str) -> Tuple[str]:\\n user_label = re.sub(string=user_label, pattern=\\\"(?<=\\\\w)\\\\/(?=\\\\w)\\\", repl=\\\" \\\", count=1)\\n final_label_tokens = nltk.word_tokenize(text=user_label, language=\\\"english\\\", preserve_line=False)\\n for i, token in enumerate(final_label_tokens):\\n token = token.lower()\\n if token == \\\"v\\\" or token == \\\"v.\\\" or token == \\\"vs\\\" or token == \\\"vs.\\\":\\n final_label_tokens[i] = \\\"versus\\\"\\n if self.semantic_clustering:\\n tagged_label = [t_tag for t_tag in nltk.pos_tag(tokens=final_label_tokens, lang=\\\"eng\\\", tagset=\\\"universal\\\")\\n if t_tag[0] not in setStopWords]\\n tagged_label.reverse()\\n final_label_tokens = [t_tag[0] for t_tag in tagged_label if t_tag[1] == \\\"NOUN\\\"] + \\\\\\n [t_tag[0] for t_tag in tagged_label if t_tag[1] == \\\"VERB\\\"] + \\\\\\n [t_tag[0] for t_tag in tagged_label if t_tag[1] not in [\\\"NOUN\\\", \\\"VERB\\\"]]\\n logger.debug(\\\"Converted the user label \\\\\\\"{}\\\\\\\" to \\\\\\\"{}\\\\\\\"\\\", user_label, \\\" \\\".join(final_label_tokens))\\n if len(final_label_tokens) > 4:\\n logger.warning(\\\"The label {} has more than 4 tokens: {}. Discard {}\\\", final_label_tokens,\\n len(final_label_tokens), final_label_tokens[4:])\\n final_label_tokens = final_label_tokens[:4]\\n elif len(final_label_tokens) == 0:\\n logger.warning(\\\"We receive an preprocessed user label which is empty!\\\")\\n final_label_tokens = [\\\"<pad>\\\"] * 4\\n elif len(final_label_tokens) == 1:\\n final_label_tokens = final_label_tokens * 4\\n elif len(final_label_tokens) == 2:\\n final_label_tokens = final_label_tokens * 2\\n elif len(final_label_tokens) == 3:\\n final_label_tokens.append(final_label_tokens[0])\\n\\n return tuple(final_label_tokens)\",\n \"def label_vector(self):\\n return self._label_vector\",\n \"def _label_generation(self, indexes):\\n data = self.data.iloc[indexes]\\n return np.array(data['peak_flux'])\",\n \"def label(efo):\\n url = 'https://www.ebi.ac.uk/ols/api/ontologies/efo/terms?iri=http://www.ebi.ac.uk/efo/'+efo\\n try:\\n response = requests.get(url).json()\\n except:\\n return \\\"\\\"\\n if 'error' in response.keys():\\n return \\\"\\\"\\n return response['_embedded']['terms'][0]['label']\",\n \"def parse_label(self):\\n # TODO: make this work with attached labels as well as\\n # stand alone labels.\\n # Save the RAW full text of the label to self._raw\\n input_stream = FileStream(self.infile)\\n lexer = ODLv21Lexer(input_stream)\\n tokens = CommonTokenStream(lexer)\\n\\n parser = ODLv21Parser(tokens)\\n parse_tree = parser.label()\\n self._parse_tree = parse_tree\\n visitor = Pds3LabelVisitor()\\n visitor.visit(parse_tree)\\n return visitor.root_dict\",\n \"def eidb_label(\\n model: str, scenario: str, year: int, version: str, system_model: str = \\\"cutoff\\\"\\n) -> str:\\n return f\\\"ecoinvent_{system_model}_{version}_{model}_{scenario}_{year}\\\"\",\n \"def get_test_labels(self):\\n raise NotImplementedError\",\n \"def test_issue_get_labels(self):\\n pass\",\n \"def predict_label(self, src): # real signature unknown; restored from __doc__\\n pass\",\n \"def provide_label(self):\\r\\n return [(k, tuple([1] + list(v.shape[1:]))) for k, v in self.label]\",\n \"def test_basic_labeling(self):\\n # data with only 1 feature\\n data = array([[-1], [1], [0.5], [0.25], [-0.33], [0]])\\n # give 1 if feature value >= 0; otherwise 0\\n labels = array([0, 1, 1, 1, 0, 1])\\n cdata = LabeledCData(data, labels)\\n\\n # ensure that labelling is correct\\n assert array_equal(cdata.labels, labels)\",\n \"def _string_labels_of_sentence(self, sentence):\\n label_strings = []\\n ongoing_label = 'O'\\n for token_index, token_attribute_list in enumerate(sentence):\\n raw_label_string = token_attribute_list[self.task_label_index].strip('*')\\n if '(' in raw_label_string:\\n ongoing_label = raw_label_string.strip('(').strip(')')\\n beginning = True\\n #labels[token_index] = self.category_int_of_label_string(ongoing_label)\\n if ongoing_label == 'O':\\n label_strings.append(ongoing_label)\\n else:\\n label_strings.append('{}-{}'.format('B' if beginning else 'I', ongoing_label))\\n beginning = False\\n if ')' in raw_label_string:\\n ongoing_label = 'O'\\n #bioes_tags = bio2_to_bioes(label_strings)\\n bioes_tags = label_strings\\n return bioes_tags\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67501473","0.6568259","0.6314509","0.62052965","0.59897834","0.59897834","0.5946092","0.59377635","0.58991873","0.5809695","0.5798361","0.5797039","0.57916325","0.57773614","0.57766294","0.5765343","0.57443243","0.57443243","0.5742162","0.57366246","0.5728176","0.57232755","0.5705911","0.5705911","0.5705911","0.5666036","0.5641114","0.56330955","0.56150115","0.5602925","0.56026596","0.5595962","0.5584939","0.5555304","0.5555304","0.5555304","0.5554058","0.5548525","0.55428237","0.5508137","0.55068535","0.5502669","0.55022204","0.54869014","0.54747576","0.5467993","0.54581296","0.54323804","0.54164","0.5397383","0.53930914","0.53849727","0.5374093","0.53740835","0.5369268","0.5362438","0.5362438","0.5362438","0.5362438","0.5362438","0.5362438","0.5362438","0.5362438","0.53576416","0.5344008","0.5342407","0.53404677","0.5336223","0.5336223","0.53316224","0.53308594","0.53292257","0.5324069","0.5310535","0.5310431","0.5309442","0.5306925","0.5297405","0.52971524","0.52914405","0.52693707","0.5268583","0.5266352","0.52630806","0.52559423","0.5254293","0.52454805","0.5237979","0.5235507","0.52336067","0.5229498","0.5229314","0.5229314","0.5229314","0.5229314","0.5229314","0.5229314","0.5229314","0.5229314","0.5229314"],"string":"[\n \"0.67501473\",\n \"0.6568259\",\n \"0.6314509\",\n \"0.62052965\",\n \"0.59897834\",\n \"0.59897834\",\n \"0.5946092\",\n \"0.59377635\",\n \"0.58991873\",\n \"0.5809695\",\n \"0.5798361\",\n \"0.5797039\",\n \"0.57916325\",\n \"0.57773614\",\n \"0.57766294\",\n \"0.5765343\",\n \"0.57443243\",\n \"0.57443243\",\n \"0.5742162\",\n \"0.57366246\",\n \"0.5728176\",\n \"0.57232755\",\n \"0.5705911\",\n \"0.5705911\",\n \"0.5705911\",\n \"0.5666036\",\n \"0.5641114\",\n \"0.56330955\",\n \"0.56150115\",\n \"0.5602925\",\n \"0.56026596\",\n \"0.5595962\",\n \"0.5584939\",\n \"0.5555304\",\n \"0.5555304\",\n \"0.5555304\",\n \"0.5554058\",\n \"0.5548525\",\n \"0.55428237\",\n \"0.5508137\",\n \"0.55068535\",\n \"0.5502669\",\n \"0.55022204\",\n \"0.54869014\",\n \"0.54747576\",\n \"0.5467993\",\n \"0.54581296\",\n \"0.54323804\",\n \"0.54164\",\n \"0.5397383\",\n \"0.53930914\",\n \"0.53849727\",\n \"0.5374093\",\n \"0.53740835\",\n \"0.5369268\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.5362438\",\n \"0.53576416\",\n \"0.5344008\",\n \"0.5342407\",\n \"0.53404677\",\n \"0.5336223\",\n \"0.5336223\",\n \"0.53316224\",\n \"0.53308594\",\n \"0.53292257\",\n \"0.5324069\",\n \"0.5310535\",\n \"0.5310431\",\n \"0.5309442\",\n \"0.5306925\",\n \"0.5297405\",\n \"0.52971524\",\n \"0.52914405\",\n \"0.52693707\",\n \"0.5268583\",\n \"0.5266352\",\n \"0.52630806\",\n \"0.52559423\",\n \"0.5254293\",\n \"0.52454805\",\n \"0.5237979\",\n \"0.5235507\",\n \"0.52336067\",\n \"0.5229498\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\",\n \"0.5229314\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5693916"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":81391,"cells":{"query":{"kind":"string","value":"Our standard method to evaluate the data. It will fill a DataFrame df which saves the errors for each evaluated setup"},"document":{"kind":"string","value":"def evaluate_data(df_train, w_train, df_test, w_test,\n evaluation_setups=None, preprocessing=None):\n if evaluation_setups is None:\n evaluation_setups = standard_evaluation_setups\n if preprocessing is None:\n preprocessing = preprocess\n if (\"weights\" in df_train) and df_train[\"weights\"].size > 0:\n weights = df_train[\"weights\"].as_matrix().squeeze()\n else:\n weights = np.ones(df_train.shape[0])\n\n # create a new dataframe which will hold all the generated errors\n df = pd.DataFrame()\n for one_w_train, one_w_test in zip(w_train, w_test):\n # setup testing function\n X_test, y_test = preprocessing(df_test, snr=one_w_test)\n # extract noisy data\n X_train, y_train = preprocessing(df_train, snr=one_w_train)\n for e in evaluation_setups:\n regressor = e.regressor\n regressor.fit(X_train, y_train, weights)\n y_pred = regressor.predict(X_test)\n # save results to a dataframe\n errors = np.abs(y_pred - y_test)\n errors = errors.reshape(len(errors), 1)\n current_df = DataFrame(errors * 100,\n columns=[\"Errors\"])\n current_df[\"Method\"] = e.name\n current_df[\"SNR\"] = int(one_w_test)\n df = pd.concat([df, current_df], ignore_index=True)\n\n return df"},"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 evaluate_df(self, df):\n ## Check invariant; model inputs must be subset of df columns\n var_diff = set(self.var).difference(set(df.columns))\n if len(var_diff) != 0:\n raise ValueError(\n \"Model inputs not a subset of given columns;\\n\"\n + \"missing var = {}\".format(var_diff)\n )\n\n df_tmp = df.copy().drop(self.out, axis=1, errors=\"ignore\")\n ## Evaluate each function\n for func in self.functions:\n ## Concatenate to make intermediate results available\n df_tmp = concat((df_tmp, func.eval(df_tmp)), axis=1)\n\n return df_tmp[self.out]","def compute_error(self):\n \n self.error = pd.DataFrame()\n \n for name in self.conf[\"w_sizes\"].keys():\n \n self.error[f\"mae {name}\"] = self.predict[[name, \"test\"]].apply(lambda x: mae(x), axis=1)\n self.error[f\"mape {name}\"] = self.predict[[name, \"test\"]].apply(lambda x: MAPE(x[0], x[1]), axis=1)\n \n self.predict['error'] = self.error.filter(like='mae').apply(lambda r: tuple(r), axis=1).apply(np.array)","def run(self):\n\n # In case there's no exogenous\n if len(self.demand.columns) == 1:\n forecast, model, error = self.run_model()\n best = pd.DataFrame([[forecast, model, error, None]],\n columns=['forecast', 'model', 'error_predictions','additional_features'])\n\n else:\n # Define external variables to be iteratively included\n # Possibilities: 'sales', 'marketing', 'macroeconomics', 'stock',...\n exogenous = self.demand.drop(columns=\"y\")\n features_list = list(exogenous.columns)\n\n # Build all possible combinations of external features. Order is not relevant\n features_combinations = []\n for i in range(1, len(features_list) + 1):\n features_combinations += list(itertools.combinations(features_list, i))\n\n # Create a model per set of external features\n results = list()\n for f in features_combinations:\n forecast, model, error = self.run_model(additional_features=f)\n results.append((forecast, model, error, '_'.join(f)))\n\n results_df = pd.DataFrame(results)\n results_df.columns = ['forecast', 'model', 'error_predictions','additional_features']\n best = self.check_best(results_df)\n\n return best.iloc[0], best['error_predictions'].values[0] < self.error_target","def _eval_regressor(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n rmse_baseline = self._rmse(y_label_baseline, y_pred_baseline)\n mae_baseline = mean_absolute_error(y_label_baseline, y_pred_baseline)\n r2_baseline = r2_score(y_label_baseline, y_pred_baseline)\n\n rmse_sample = self._rmse(y_label_sample, y_pred_sample)\n mae_sample = mean_absolute_error(y_label_sample, y_pred_sample)\n r2_sample = r2_score(y_label_sample, y_pred_sample)\n\n metrics_df = pd.DataFrame(\n {\n \"RMSE\": [rmse_baseline, rmse_sample],\n \"MAE\": [mae_baseline, mae_sample],\n \"R2\": [r2_baseline, r2_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def evaluated_data(self) -> Dict:\n if not self.eval_data:\n raise Exception(\"Evaluation Failed\")\n\n statistics = [stat['statistics'] for stat in self.eval_data]\n for count, stat in enumerate(statistics):\n if stat:\n eval_data = stat.split(\"=\")\n char_error = re.findall(r\"\\d+\\.\\d+\", eval_data[-2])[0]\n word_error = eval_data[-1]\n\n self.eval_data[count]['character_error'] = float(char_error)\n self.eval_data[count]['word_error'] = float(word_error)\n del self.eval_data[count]['statistics']\n\n return self.eval_data","def evaluate(self, dataset):\n\t\tpass","def run_test(self):\n self.output_analytics = self.run_inference()\n self.output_df = pd.DataFrame(self.output_analytics)","def calc(self) -> pd.DataFrame:\n raise NotImplementedError","def evaluate():\n log.info('Loading dev data...')\n if args.version_2:\n dev_data = SQuAD('dev', version='2.0')\n else:\n dev_data = SQuAD('dev', version='1.1')\n (_, _), (data_file_name, _) \\\n = dev_data._data_file[dev_data._version][dev_data._segment]\n dev_data_path = os.path.join(dev_data._root, data_file_name)\n\n if args.debug:\n sampled_data = [dev_data[0], dev_data[1], dev_data[2]]\n dev_data = mx.gluon.data.SimpleDataset(sampled_data)\n log.info('Number of records in dev data: %d', len(dev_data))\n\n dev_data_features = preprocess_dataset(\n tokenizer, dev_data, vocab=vocab, max_seq_length=args.max_seq_length,\n doc_stride=args.doc_stride, num_workers=args.num_workers,\n max_query_length=args.max_query_length, load_from_pickle=args.load_pickle,\n feature_file=args.dev_dataset_file)\n\n dev_data_input = convert_full_features_to_input_features(dev_data_features)\n log.info('The number of examples after preprocessing: %d', len(dev_data_input))\n\n dev_dataloader = mx.gluon.data.DataLoader(dev_data_input, batchify_fn=batchify_fn,\n num_workers=4, batch_size=args.test_batch_size,\n shuffle=False, last_batch='keep')\n\n log.info('start prediction')\n\n all_results = collections.defaultdict(list)\n\n epoch_tic = time.time()\n total_num = 0\n for (batch_id, data) in enumerate(dev_dataloader):\n data_list = list(split_and_load(data, ctx))\n for splited_data in data_list:\n example_ids, inputs, token_types, valid_length, p_mask, _, _, _ = splited_data\n total_num += len(inputs)\n outputs = net_eval(inputs, token_types, valid_length, p_mask=p_mask)\n example_ids = example_ids.asnumpy().tolist()\n for c, example_ids in enumerate(example_ids):\n result = RawResultExtended(start_top_log_probs=outputs[0][c].asnumpy().tolist(),\n start_top_index=outputs[1][c].asnumpy().tolist(),\n end_top_log_probs=outputs[2][c].asnumpy().tolist(),\n end_top_index=outputs[3][c].asnumpy().tolist(),\n cls_logits=outputs[4][c].asnumpy().tolist())\n all_results[example_ids].append(result)\n if batch_id % args.log_interval == 0:\n log.info('Batch: %d/%d', batch_id + 1, len(dev_dataloader))\n\n epoch_toc = time.time()\n log.info('Time cost=%2f s, Thoughput=%.2f samples/s', epoch_toc - epoch_tic,\n total_num / (epoch_toc - epoch_tic))\n\n log.info('Get prediction results...')\n\n all_predictions = collections.OrderedDict()\n all_nbest_json = collections.OrderedDict()\n scores_diff_json = collections.OrderedDict()\n for features in dev_data_features:\n results = all_results[features[0].example_id]\n example_qas_id = features[0].qas_id\n score_diff, best_non_null_entry, nbest_json = predict_extended(\n features=features, results=results, n_best_size=args.n_best_size,\n max_answer_length=args.max_answer_length, start_n_top=args.start_top_n,\n end_n_top=args.end_top_n)\n scores_diff_json[example_qas_id] = score_diff\n all_predictions[example_qas_id] = best_non_null_entry\n all_nbest_json[example_qas_id] = nbest_json\n\n output_prediction_file = os.path.join(args.output_dir, 'predictions.json')\n output_nbest_file = os.path.join(args.output_dir, 'nbest_predictions.json')\n output_null_log_odds_file = os.path.join(args.output_dir, 'null_odds.json')\n\n with open(output_prediction_file, 'w') as writer:\n writer.write(json.dumps(all_predictions, indent=4) + '\\n')\n with open(output_nbest_file, 'w') as writer:\n writer.write(json.dumps(all_nbest_json, indent=4) + '\\n')\n with open(output_null_log_odds_file, 'w') as writer:\n writer.write(json.dumps(scores_diff_json, indent=4) + '\\n')\n\n if os.path.exists(sys.path[0] + '/evaluate-v2.0.py'):\n arguments = [\n dev_data_path, output_prediction_file, '--na-prob-thresh',\n str(args.null_score_diff_threshold)\n ]\n if args.version_2:\n arguments += ['--na-prob-file', output_null_log_odds_file]\n subprocess.call([sys.executable, sys.path[0] + '/evaluate-v2.0.py'] + arguments)\n else:\n log.info('Please download evaluate-v2.0.py to get evaluation results for SQuAD. '\n 'Check index.rst for the detail.')","def evaluate(directory: str,\n y_hat: Union[pd.DataFrame, str],\n validation: bool = False) -> pd.DataFrame:\n if isinstance(y_hat, str):\n y_hat = M5Evaluation.load_benchmark(directory, y_hat, validation)\n\n M5.download(directory)\n path = f'{directory}/m5/datasets'\n if validation:\n weights = pd.read_csv(f'{path}/weights_validation.csv')\n sales = pd.read_csv(f'{path}/sales_train_vaidation.csv')\n y_test = pd.read_csv(f'{path}/sales_test_vaidation.csv')\n else:\n weights = pd.read_csv(f'{path}/weights_evaluation.csv')\n sales = pd.read_csv(f'{path}/sales_train_evaluation.csv')\n y_test = pd.read_csv(f'{path}/sales_test_evaluation.csv')\n\n # sales\n sales = M5Evaluation.aggregate_levels(sales)\n def scale(x):\n x = x.values\n x = x[np.argmax(x!=0):]\n scale = ((x[1:] - x[:-1]) ** 2).mean()\n return scale\n scales = sales.agg(scale, 1).rename('scale').reset_index()\n\n # y_test\n y_test = M5Evaluation.aggregate_levels(y_test)\n\n #y_hat\n y_hat = M5Evaluation.aggregate_levels(y_hat)\n\n score = (y_test - y_hat) ** 2\n score = score.mean(1)\n score = score.rename('rmse').reset_index()\n score = score.merge(weights, how='left',\n on=['Level_id', 'Agg_Level_1', 'Agg_Level_2'])\n score = score.merge(scales, how='left',\n on=['Level_id', 'Agg_Level_1', 'Agg_Level_2'])\n score['wrmsse'] = (score['rmse'] / score['scale']).pow(1 / 2) * score['weight']\n score = score.groupby('Level_id')[['wrmsse']].sum()\n score = score.loc[M5Evaluation.levels.keys()]\n total = score.mean().rename('Total').to_frame().T\n score = pd.concat([total, score])\n\n return score","def validate(self):\n self.set_model_mode('eval')\n self.evaluator.reset()\n losses = MetricMeter()\n\n print('Do evaluation on {} set'.format('valid set'))\n data_loader = self.val_loader\n assert data_loader is not None\n for batch_idx, batch in enumerate(data_loader):\n input, label = self.parse_batch_test(batch)\n loss = self.forward_backward(batch, backprob=False)\n losses.update(loss)\n # total_loss += loss['loss']\n output = self.model_inference(input)\n self.evaluator.process(output, label)\n\n results = self.evaluator.evaluate()\n total_loss = losses.meters['loss_x'].avg\n\n for k, v in results.items():\n tag = '{}/{}'.format('validation', k)\n self.write_scalar(tag, v, self.epoch)\n # if full_results:\n return [total_loss,losses.dict_results(),results]\n # return total_loss","def _fit(self, df):\n return df","def fit_evalute_fn(df, fn_string, symbols):\n fn = process_fn(fn_string, symbols)\n\n rmse, y_pred, y_true, c = test_fn(df, fn)\n return rmse, y_pred, y_true, c","def eval(self, df):\n ## Check invariant; model inputs must be subset of df columns\n if not set(self.var).issubset(set(df.columns)):\n raise ValueError(\n \"Model function `{}` var not a subset of given columns\".format(\n self.name\n )\n )\n\n ## Set up output\n n_rows = df.shape[0]\n results = zeros((n_rows, len(self.out)))\n\n for ind in range(n_rows):\n results[ind] = self.func(*df.loc[ind, self.var])\n\n ## Package output as DataFrame\n return DataFrame(data=results, columns=self.out)","def test_y_multi_col_df_error(self):\n\n df = d.create_df_1()\n\n x = BaseTransformer(columns=\"a\")\n\n with pytest.raises(ValueError):\n\n x.fit(X=df, y=df)","def Evaluate():\n global reg\n reg = ModelRegression()\n \n # Retrieve dataset files\n data_fls, ref_fls = LoadTroikaDataset()\n errs, confs = [], []\n for data_fl, ref_fl in zip(data_fls, ref_fls):\n # Run the pulse rate algorithm on each trial in the dataset\n errors, confidence = RunPulseRateAlgorithm(data_fl, ref_fl)\n errs.append(errors)\n confs.append(confidence)\n # Compute aggregate error metric\n errs = np.hstack(errs)\n confs = np.hstack(confs)\n return AggregateErrorMetric(errs, confs)","def run():\n\n import matplotlib.pyplot as plt\n\n anomalies_t = []\n anomalies_v = []\n anomalies_c = []\n\n all_t = []\n all_v = []\n\n rows = []\n for i, row in dataSet.iterrows():\n\n inputData = row.to_dict()\n\n detectorValues = handleRecord(inputData)\n\n if (detectorValues[0] > 0.65):\n anomalies_t.append(inputData[\"timestamp\"])\n anomalies_v.append(inputData[\"value\"])\n anomalies_c.append(detectorValues[0])\n\n all_t.append(inputData[\"timestamp\"])\n all_v.append(inputData[\"value\"])\n\n outputRow = list(row) + list(detectorValues)\n\n rows.append(outputRow)\n\n # Progress report\n if (i % 1000) == 0:\n print \".\",\n sys.stdout.flush()\n\n fig, ax = plt.subplots()\n\n ax.plot(all_t, all_v)\n ax.plot(anomalies_t, anomalies_v, 'ro')\n\n plt.show()\n\n ans = pandas.DataFrame(rows)\n return ans","def eval(self, df):\n df_res = self.func(df)\n return df_res[self.out]","def eval(self, df):\n return self.ev(self.model, df)","def clean_qa_data(df) -> pd.DataFrame:\n date_column = \"sample date\"\n # The final table column names and corresponding types\n column_names = [date_column, \"gene\", \"stdev/avg\", \"single 1\", \"single 2\", \"single 3\", \"single 4\", \"single 5\", \"single 6\", \"avg\", \"stdev\", \"unit\"]\n column_types = [\"date\", \"text\", \"number\", \"number\", \"number\", \"number\", \"number\", \"number\", \"number\", \"number\", \"number\", \"text\"]\n # Drop any row where all columns in drop_ifna are None\n drop_ifna = [\"single 1\", \"single 2\", \"single 3\", \"single 4\", \"single 5\", \"single 6\"]\n\n # The lab sheet has 6 tables, arranged in a 2x3 (v x h) grid, split them up and stack them into a single table\n # Each new table begins with the a column named date_column, split into 3 tables\n splits = [idx for idx in range(len(df.columns)) if df.columns[idx].lower().startswith(date_column)]\n splits.append(len(df.columns))\n tables = [df[df.columns[splits[i]:splits[i+1]]].copy() for i in range(len(splits)-1)]\n\n # Horizontally, the three tables are for \"gcPMMoV\", \"gcGs\", and\"gcL\".\n for table, unit in zip(tables, [\"gcPMMoV\", \"gcGs\", \"gcL\"]):\n table.columns = column_names\n table[date_column] = pd.to_datetime(table[date_column], errors=\"coerce\")\n table.dropna(subset=[date_column], inplace=True)\n\n table[drop_ifna] = table[drop_ifna].applymap(lambda x: float(x) if (isinstance(x, float) and not math.isnan(x)) else None)\n # applymap (from above) will sometimes force a None object into a float(\"nan\"), so set them as None here\n table[drop_ifna] = table[drop_ifna].where(pd.notnull(table[drop_ifna]), None)\n\n table.dropna(subset=[\"single 1\", \"single 2\", \"single 3\", \"single 4\", \"single 5\", \"single 6\"], how=\"all\", inplace=True)\n table[\"unit\"] = unit\n\n # Merge tables\n df = pd.concat(tables, axis=0)\n\n # Add the types column (ie. date, text, number)\n df.loc[-1] = column_types\n df.index = df.index + 1\n df = df.sort_index()\n df.index = list(range(len(df.index)))\n\n return df","def evaluate(self):\n # define start index test set\n start_test_set = int(len(self.X) * 2 / 3)\n\n # Different methods for cummulativa vs day-ahead forecasting\n if self.forecast_horizon == 1:\n # In sample\n lin_residuals_in_sample = self.y - (self.betas[0] + np.dot(self.X, self.betas[1]))\n self.rmse_in_sample = np.mean(lin_residuals_in_sample ** 2) ** 0.5\n self.var_in_sample = np.var(self.y)\n\n # Out of sample\n # Calculate MSE of wls-ev prediction\n self.mse_wlsev = np.mean((self.y[start_test_set:] - self.ols_predict()) ** 2)\n # Calculate MSE of benchmark prediction\n self.mse_benchmark = np.mean((self.y[start_test_set:] - self.benchmark_predict()) ** 2)\n else:\n # In Sample with betas estimated on full time series\n lin_residuals_in_sample = rolling_sum(self.y, self.forecast_horizon) - (\n self.betas[0] + np.dot(self.X[:-(self.forecast_horizon-1)], self.betas[1]))\n self.rmse_in_sample = np.mean(lin_residuals_in_sample ** 2) ** 0.5\n self.var_in_sample = np.var(rolling_sum(self.y, self.forecast_horizon))\n\n # Out of sample\n # calculate realized cummulative returns over forecast horizon sequences\n cum_rets_realized = rolling_sum(self.y[start_test_set:], self.forecast_horizon)\n # Calculate MSE of wls-ev prediction, only where realized values are available\n self.mse_wlsev = np.mean((cum_rets_realized - self.ols_predict()[:-(self.forecast_horizon-1)]) ** 2)\n # Calculate MSE of benchmark prediction, only where realized values are available\n self.mse_benchmark = np.mean(\n (cum_rets_realized - self.benchmark_predict()[:-(self.forecast_horizon-1)]) ** 2)\n\n # Calculate out of sample r-squared\n self.oos_r_squared = 1 - (self.mse_wlsev / self.mse_benchmark)\n # Calculate in sample r-squared\n self.in_sample_r_squared = 1.0 - (self.rmse_in_sample ** 2) / self.var_in_sample","def _evaluate_model(\n run_id: str, dataset_filename: str, dataset_sampling_column: str = None\n):\n fix_multiprocessing_with_keras_on_macos()\n\n run = _get_run(run_id)\n hyperparameters = run.config\n\n # no need to run this on a gpu since it's 1 epoch\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"-1\"\n\n with ModelBestH5File(run) as model_h5_filepath:\n model = _load_untrainable_model(hyperparameters, model_h5_filepath)\n\n model_name = run.config[\"model_name\"]\n x, y = _get_prepared_dataset(\n model_name, hyperparameters, dataset_filename, dataset_sampling_column\n )\n\n wandb.init(\n config={\n \"run_id\": run_id,\n \"dataset_filename\": dataset_filename,\n \"dataset_sampling_column\": dataset_sampling_column,\n },\n tags=[\"model-evaluation\"],\n )\n\n batch_size = hyperparameters[\"batch_size\"]\n label_scale_factor_mmhg = hyperparameters[\"label_scale_factor_mmhg\"]\n acceptable_error_mg_l = hyperparameters[\"acceptable_error_mg_l\"]\n acceptable_fraction_outside_error = hyperparameters[\n \"acceptable_fraction_outside_error\"\n ]\n\n # we're using fit() instead of evaluate() to get the functionality of these callbacks\n # training performance in the results should be ignored, as it can be affected by some\n # training-only layers such as dropout\n model.fit(\n x,\n y,\n batch_size=batch_size,\n epochs=1,\n verbose=2,\n validation_data=(x, y),\n callbacks=[\n ThresholdValMeanAbsoluteErrorOnCustomMetric(\n acceptable_fraction_outside_error=acceptable_fraction_outside_error,\n acceptable_error_mg_l=acceptable_error_mg_l,\n ),\n WandbCallback(verbose=1, monitor=\"val_adjusted_mean_absolute_error\"),\n LogPredictionsAndWeights(\n metric=\"val_adjusted_mean_absolute_error\",\n dataset=([], [], x, y),\n label_scale_factor_mmhg=label_scale_factor_mmhg,\n ),\n ],\n )\n\n # returning model and dataset for use in jupyter notebooks\n return model, (x, y)","def set_data(self):\n # take care of samples\n patients = self.samples.iloc[:,1].tolist()\n samples = self.samples.iloc[:,0].tolist()\n self.samples = pd.DataFrame(patients,index = samples,columns = ['patient']) # indexed by sample\n #\n # take care of expression data\n cols = self.expression.SYMBOL.tolist() # set new column names to transposed expression_data \n \n new_exp = self.expression.T.ix[1:,:] # transpose\n new_exp.columns = cols\n self.expression = new_exp # add columns\n self.data = pd.merge(self.expression,self.samples,left_index = True,right_index=True) # merged data sets\n #pd.merge(df1,df2,how = 'left',left_index=True,right_index=True) # do a left join","def run_and_evaluate():\n tsp_problems = read_all_problems()\n # Empty list of metrics\n results = []\n for problem in tqdm.tqdm(tsp_problems):\n # As random factors are involved repeat experiments a couple of times\n best_routes_base = []\n best_routes_af = []\n best_routes_ms = []\n base_times = []\n af_times = []\n ms_times = []\n for i in range(10):\n # Base solution\n start_time = timeit.default_timer()\n best_route_base = solve_tsp_basic(problem)\n base_time = timeit.default_timer() - start_time\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\n base_times.append(base_time)\n\n # AF clustering solution\n start_time = timeit.default_timer()\n best_route_af = solve_tsp_affinity_propagation(problem)\n af_time = timeit.default_timer() - start_time\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\n af_times.append(af_time)\n\n # MS solution\n start_time = timeit.default_timer()\n best_route_ms = solve_mean_shift(problem)\n ms_time = timeit.default_timer() - start_time\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\n ms_times.append(ms_time)\n\n results.append(\n {\n \"problem name\": problem.name,\n \"optimal solution\": find_route_optimal_route_length(problem),\n \"baseline tour length\": mean(best_routes_base),\n \"af clustering tour length\": mean(best_routes_af),\n \"ms clustering tour length\": mean(best_routes_ms),\n \"baseline algorithm time\": mean(base_times),\n \"af clustering algorithm time\": mean(af_times),\n \"ms clustering algorithm time\": mean(ms_times),\n }\n )\n # Create dataframe and safe results\n df = pd.DataFrame(results)\n df.to_csv(\"results.csv\", index=False)\n return df","def eda_base():\n ######################################\n # Missing Values\n ######################################\n # cat_cols, num_cols, cat_but_car, num_but_cat = grab_col_names(df)\n # Observations: 356255\n # Variables: 122\n # cat_cols: 15\n # num_cols: 67\n # cat_but_car: 1\n # num_but_cat: 39\n global train, test, df\n train = pd.read_csv('datasets/home-credit-default-risk/application_train.csv')\n test = pd.read_csv('datasets/home-credit-default-risk/application_test.csv')\n df = train.append(test).reset_index(drop=True)\n\n df.isnull().sum()\n df.isnull().sum().sum() # 10670198\n df.shape\n # df.dropna(inplace=True)\n # msno.matrix(df.sample(250))\n # plt.show()\n\n df = df[df['CODE_GENDER'] != 'XNA']\n df['DAYS_EMPLOYED'].replace(365243, np.nan, inplace=True)\n\n df[df.columns[df.isnull().any()]]\n\n cat_cols, num_cols, cat_but_car, num_but_cat = grab_col_names(df)\n\n na_cols_cat = [col for col in cat_cols if df[col].isnull().sum() > 0]\n df[na_cols_cat] = df[na_cols_cat].apply(lambda x: x.fillna(x.mode()), axis=0)\n\n na_cols_num = [col for col in num_cols if df[col].isnull().sum() > 0 and \"TARGET\" not in col]\n df[na_cols_num] = df[na_cols_num].apply(lambda x: x.fillna(x.median()), axis=0)\n\n na_cols_cat_but_car = [col for col in cat_but_car if df[col].isnull().sum() > 0]\n df[na_cols_cat_but_car] = df[na_cols_cat_but_car].apply(lambda x: x.fillna(x.mode()), axis=0)\n\n na_cols_num_but_cat = [col for col in num_but_cat if df[col].isnull().sum() > 0 and \"TARGET\" not in col]\n df[na_cols_num_but_cat] = df[na_cols_num_but_cat].apply(lambda x: x.fillna(x.median()), axis=0)\n\n df['OCCUPATION_TYPE'] = df['OCCUPATION_TYPE'].fillna(df['OCCUPATION_TYPE'].mode()[0])\n\n ######################################\n # Feature Engineering\n ######################################\n\n #############################################\n # Outliers\n #############################################\n\n #############################################\n # Label Encoding\n #############################################\n\n #############################################\n # Rare Encoding\n #############################################\n\n #############################################\n # One-Hot Encoding\n #############################################\n df = pd.get_dummies(df, dummy_na=True)\n df.shape\n #############################################\n # Standart Scaler\n #############################################\n\n ######################################\n # Modeling\n ######################################\n global train_df, test_df\n train_df = df[df['TARGET'].notnull()]\n test_df = df[df['TARGET'].isnull()].drop(\"TARGET\", axis=1)\n\n global X, y, X_train, X_test, y_train, y_test\n y = train_df[\"TARGET\"]\n X = train_df.drop([\"SK_ID_CURR\", \"TARGET\"], axis=1)\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)","def evaluate(cfg: DictConfig):\n\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\n fixed_t0 = cfg.get('fixed_t0', False)\n ext = '_fixedT0' if fixed_t0 else ''\n\n base_dir = cfg.device.root\n datasource = cfg.datasource.name\n\n if experiments == 'ablations':\n models = {\n 'FluxRGNN': ['final',\n 'final_without_encoder',\n 'final_without_boundary'],\n 'LocalLSTM': ['final']\n }\n elif experiments == 'final':\n models = {\n 'FluxRGNN': ['final'],\n 'GAM': ['final'],\n 'HA': ['final'],\n 'GBT': ['final']\n }\n else:\n m = cfg.model.name\n year = cfg.datasource.test_year\n\n # find all experiments available for this model, datasource and test year\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\n models = {\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\n }\n\n\n # thresholds for binary classification metrics\n if cfg.datasource.name == 'abm':\n thresholds = [0.0019, 0.0207]\n else:\n thresholds = [0, 10, 20]\n\n rmse_per_hour = []\n mae_per_hour = []\n pcc_per_hour = []\n bin_per_hour = []\n\n rmse_per_night = []\n mae_per_night = []\n\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\n os.makedirs(output_dir, exist_ok=True)\n\n counter = 0\n\n for m, dirs in models.items():\n print(f'evaluate {m}')\n\n for d in dirs:\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\n\n # check if directory exists\n if os.path.isdir(result_dir):\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\n\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\n f'{model_cfg[\"t_unit\"]}_{model_cfg[\"model\"][\"edge_type\"]}_ndummy={model_cfg[\"datasource\"][\"n_dummy_radars\"]}',\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\n\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n\n if fixed_t0:\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n\n # compute binary classification measures\n for thr in thresholds:\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\n\n counter += 1\n\n else:\n print(f'Experiment \"{d}\" for model \"{m}\" and datasource \"{datasource}\" is not available. '\n f'Use \"run_experiments.py model={m} datasource={datasource} +experiment={d}\" to run this experiment.')\n\n if counter > 0:\n rmse_per_hour = pd.concat(rmse_per_hour)\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\n\n mae_per_hour = pd.concat(mae_per_hour)\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\n\n pcc_per_hour = pd.concat(pcc_per_hour)\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\n\n bin_per_hour = pd.concat(bin_per_hour)\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\n\n if fixed_t0:\n rmse_per_night = pd.concat(rmse_per_night)\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\n\n mae_per_night = pd.concat(mae_per_night)\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))","def calc_errors(y_panel_df, y_insample_df, seasonality, benchmark_model='Naive2'):\n\n assert benchmark_model in y_panel_df.columns\n\n y_panel = y_panel_df[['unique_id', 'ds', 'y']]\n y_hat_panel_fun = lambda model_name: y_panel_df[['unique_id', 'ds', model_name]].rename(columns={model_name: 'y_hat'})\n\n model_names = set(y_panel_df.columns) - set(y_panel.columns)\n\n errors_smape = y_panel[['unique_id']].drop_duplicates().reset_index(drop=True)\n errors_mase = errors_smape.copy()\n\n for model_name in model_names:\n errors_smape[model_name] = None\n errors_mase[model_name] = None\n y_hat_panel = y_hat_panel_fun(model_name)\n\n errors_smape[model_name] = evaluate_panel(y_panel, y_hat_panel, smape)\n errors_mase[model_name] = evaluate_panel(y_panel, y_hat_panel, mase, y_insample_df, seasonality)\n\n mean_smape_benchmark = errors_smape[benchmark_model].mean()\n mean_mase_benchmark = errors_mase[benchmark_model].mean()\n\n errors_smape = errors_smape.drop(columns=benchmark_model).set_index('unique_id')\n errors_mase = errors_mase.drop(columns=benchmark_model).set_index('unique_id')\n\n errors = errors_smape/mean_mase_benchmark + errors_mase/mean_smape_benchmark\n errors = 0.5*errors\n errors = errors\n\n return errors","def report_creation(data_all_df, pred_start):\n data_all_df[\"HD MM/GSD\"] = np.where(data_all_df.MM.str.contains(\"HD\"), \"HD MM\", \"GSD\")\n \n\n select_cols = [\"IDV_LEAD_MNTS_Pred\", \"IDV_HELPER_MNTS_Pred\",\"IDV_HELPER_OVR_Pred\",\n \"IDV_LD_UNCLAIMED_Pred\", \"IDV_HP_UNCLAIMED_Pred\", \"IDV_HPN_UNCLAIMED_Pred\",\n \"IDV_LD_DRIVE_Pred\", \"IDV_HP_DRIVE_Pred\", \"IDV_HPN_DRIVE_Pred\"]\n\n for col in select_cols:\n data_all_df[col.replace('MNTS','HRS')] = round(data_all_df[col]/60,1)\n \n \n data_all_df[\"Lead Hrs/Appnt\"] = data_all_df[\"IDV_LEAD_HRS_Pred\"]/data_all_df[\"IDV_APPT_ID_Pred\"]\n data_all_df[\"Helper Hrs/Appnt\"] = data_all_df[\"IDV_HELPER_HRS_Pred\"]/data_all_df[\"IDV_APPT_ID_Pred\"]\n \n res_cols = [\"MM\", \"HD MM/GSD\", \"FISC_WK_OF_MTH_ID\", \"RSS\",\n \"Prediction_Trf\", \"Lead Hrs/Appnt\",\n \"IDV_LEAD_HRS_Pred\", \"IDV_HELPER_HRS_Pred\", \"Helper Hrs/Appnt\", \n \"IDV_HELPER_OVR_Pred\",\n \"IDV_LD_UNCLAIMED_Pred\", \"IDV_HP_UNCLAIMED_Pred\", \"IDV_HPN_UNCLAIMED_Pred\",\n \"IDV_LD_DRIVE_Pred\", \"IDV_HP_DRIVE_Pred\", \"IDV_HPN_DRIVE_Pred\"]\n data_result = data_all_df[res_cols]\n data_result = data_result[data_result.FISC_WK_OF_MTH_ID >= pred_start]\n data_result.columns = [\"MM\", \"HD MM/GSD\", \"FISCAL_WK_ID\", \"RSS\",\n \"Order Lines\", \"Lead Hrs/Appnt\",\n \"Lead Hrs\", \"Helper Hrs\", \"Helper Hrs/Appnt\",\n \"Helper Hrs Float\",\n \"Unclaimed Lead\", \"Unclaimed Helper\", \"Unclaimed Helper Hrs Float\",\n \"Lead Drive Time\", \"Helper Drive Time\", \"Helper Hrs Float Drive Time\"]\n data_result['FISCAL_WK_ID'] = data_result['FISCAL_WK_ID'].astype(int)\n return data_result","def run_calculation(self) -> pd.DataFrame:\n\n initial_switcher, initial_geo_coords = self.get_placeholder_values(self.parsed_log)\n\n calculated_distances = self.process_log(log=self.parsed_log,\n placeholder_switcher=initial_switcher,\n placeholder_geo=initial_geo_coords)\n\n distance_report = self.generate_report(calculated_distances)\n\n self.monitor.info(distance_report)\n\n return distance_report","def test_evaluate(self):\n # Check build does not raise errors\n dataset = KDDCupDataset()\n dataset.create_fixed_samples(\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\n dataset.set_current_sample(0)\n model = self.MODEL(dataset, **self.model_arguments)\n model.fit(training_epochs=50)\n metric = model.evaluate('test')\n self.assertLessEqual(0, metric)\n self.assertGreaterEqual(1, metric)","def ml_df(df, parameters, t_size, model = DecisionTreeRegressor()):\n ndf = df[parameters]\n x = ndf.loc[:, ndf.columns != 'T_exp']\n y = ndf['T_exp']\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=t_size)\n model = model\n p = PolynomialFeatures(degree = 2)\n X_poly = p.fit_transform(x_train)\n X_poly_test = p.fit_transform(x_test)\n model.fit(X_poly,y_train)\n y_train_pred = model.predict(X_poly)\n y_test_pred = model.predict(X_poly_test)\n result = pd.DataFrame()\n result['T_exp'] = y_test\n result['T_prd'] = y_test_pred\n result['ratio'] = result['T_exp']/result['T_prd']\n return result","def _prepare_evaluate(self):\n labels = list()\n labels += ['num_procs', 'num_periods', 'is_debug', 'seed_emax', 'seed_sim']\n labels += ['num_draws_emax', 'num_agents_sim', 'num_types', 'edu_spec', 'version']\n labels += ['num_draws_prob', 'seed_prob']\n num_procs, num_periods, is_debug, seed_emax, seed_sim, num_draws_emax, num_agents_sim, \\\n num_types, edu_spec, version, num_draws_prob, seed_prob = \\\n dist_class_attributes(self.respy_base, *labels)\n\n periods_draws_emax = create_draws(num_periods, num_draws_emax, seed_emax, is_debug)\n periods_draws_sims = create_draws(num_periods, num_agents_sim, seed_sim, is_debug)\n\n disturbances = (periods_draws_emax, periods_draws_sims)\n\n # We want to maintain a pure PYTHON version for testing purposes.\n args = list()\n args += [num_periods, num_types, edu_spec['start'], edu_spec['max'], edu_spec['max'] + 1]\n state_space_info = respy_f2py.wrapper_create_state_space(*args)\n if self.mpi_setup == MISSING_INT:\n slavecomm = self.mpi_setup\n else:\n slavecomm = self.mpi_setup.py2f()\n self.set_up_baseline(periods_draws_emax, None)\n\n initial_conditions = get_initial_conditions(self.respy_base)\n\n args = (smm_sample_f2py, state_space_info, initial_conditions, disturbances, slavecomm)\n self.simulate_sample = partial(*args)","def evaluate(self):\n\n\t\t## We should be evaluating on dev dataset as well, so commenting x_test\n\t\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\n\t\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\n\t\t##Saving atucal vs predicted predictions\n\t\t##np.argmax returns the index where it see's 1 in the row\n\t\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\n\t\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\n\n\t\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\n\t\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\n\t\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\n\t\toutputFile = self.resultDir + \"/outputPredict.csv\" \n\t\tnp.savetxt(outputFile, output_predict, fmt=\"%5.0f\", delimiter=\",\")\n\n\t\t##Error Analysis of the prediction\n\t\terrorAnalysis(outputFile)\n\n\t\treturn self.model_score","def perform_analysis(self):\n analysis_type = self._analysis_type_variable.get()\n self.parent.set_analysis_type(analysis_type)\n\n # Validates the appropriateness of the data for regression\n if analysis_type == 'Regression':\n num_cols = []\n for col in list(self._df.columns.values):\n data_type = self._df.dtypes[col]\n if data_type == np.int64 or data_type == np.float64:\n num_cols.append(col)\n\n if len(num_cols) < 2:\n messagebox.showerror('Error', 'Data is not appropriate for simple linear regression')\n return\n\n self.parent.select_columns()","def evaluate(self):\n\n rew_rl = []\n for ckpt_path in self._config.eval_ckpt_paths:\n self._load_ckpt(ckpt_path, self._config.ckpt_num)\n\n logger.info(\n \"Run %d evaluations for %d environments\",\n self._config.num_eval,\n len(self._envs),\n )\n rollouts, info = self._evaluate(record_video=self._config.record_video)\n\n info_stat = info.get_stat()\n\n rew_rl.append(np.mean(info[\"rew_rl\"]))\n\n logger.info(\"All Eval Rew Values: %s\", rew_rl)\n logger.info(\"Eval Rew RL Average: %f, Std: %f\", np.mean(rew_rl), np.std(rew_rl))\n\n os.makedirs(\"result\", exist_ok=True)\n with h5py.File(\"result/{}.hdf5\".format(self._config.run_name), \"w\") as hf:\n for k, v in info.items():\n hf.create_dataset(k, data=info[k])\n with open(\"result/{}.txt\".format(self._config.run_name), \"w\") as f:\n for k, v in info_stat.items():\n f.write(\"{}\\t{:.03f} $\\\\pm$ {:.03f}\\n\".format(k, v[0], v[1]))","def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\n r_temp = {}\n for metric_name in self.metrics:\n r_temp.update({f\"{metric_name}_Model\": name, f\"{metric_name}_Sum\": 0,\n f\"{metric_name}_Min\": 1000000, f\"{metric_name}_Max\": 0})\n\n for i in range(self.repetitions):\n is_nan = True\n while (is_nan):\n model = self.get_model(train_x.shape[1], n_targets)\n model.fit(train_x, train_y, **self.fit_kwargs)\n result = model.predict(test_x)\n is_nan = np.any(np.isnan(result))\n del model\n\n for metric_name in self.metrics:\n metric = self.get_metrics(metric_name)\n value = metric(result, test_y)\n r_temp[f\"{metric_name}_Sum\"] += value\n if r_temp[f\"{metric_name}_Min\"] > value:\n r_temp[f\"{metric_name}_Min\"] = value\n if r_temp[f\"{metric_name}_Max\"] < value:\n r_temp[f\"{metric_name}_Max\"] = value\n keras.backend.clear_session()\n for metric_name in self.metrics:\n r_temp[f\"{metric_name}_Mean\"] = r_temp[f\"{metric_name}_Sum\"] / self.repetitions\n return r_temp","def metrics(true, predictions):\n metrics = pd.DataFrame(columns=['Metric Value'])\n metrics.loc['MAE'] = mean_absolute_error(true, predictions)\n metrics.loc['RMSE'] = rmse(true, predictions)\n metrics.loc['R2'] = r2_score(true, predictions)\n metrics.loc['MAPE'] = mape(true, predictions)\n metrics.loc['sMAPE'] = smape(true, predictions)\n \n return metrics","def run(self, orig_target_df):\n\n # For each fold\n for fold_idx, (fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df) in enumerate(self._generate_validation_fold()):\n train_test_date_split = fold_training_set_df[\"date\"].max()\n eval_start_date = train_test_date_split - timedelta(days = self.test_nb_days)\n date_to_predict = train_test_date_split + timedelta(days = 1)\n print(\"Warning: date_to_predict offset should be computed dynamically. Currently fixed to 1.\")\n\n # For each prediction method\n for process, process_name in zip(self.process_lst, self.process_names_lst):\n print(\"Running validation for process:\", process_name, \"on fold:\", fold_idx, \"...\")\n\n # Train the model\n with open(self.data_cache_path_str + \"data_bkp.pkl\", \"wb\") as f:\n pickle.dump((fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df), f)\n\n y_train = fold_target_df[\"demand\"].reset_index(drop = True)\n model = process(train_test_date_split, eval_start_date)\n model.fit(fold_training_set_df, y_train)\n\n # Generate predictions for validation set\n preds = model.predict(fold_testing_set_df, date_to_predict)\n preds[\"demand\"] = (orig_target_df[\"shifted_demand\"] + preds[\"demand\"]).apply(np.expm1)\n\n # Score the predictions\n preds2 = preds.copy()\n preds2.columns = [\"id\", \"date\", \"preds\"]\n preds_rmse_by_date_df = preds2.merge(fold_truth_df, how = \"left\", on = [\"id\", \"date\"])\n preds_rmse_by_date_df = preds_rmse_by_date_df[[\"date\", \"preds\", \"demand\"]].groupby(\"date\").apply(lambda x: self._rmse(x[\"demand\"], x[\"preds\"])).reset_index()\n preds_rmse_by_date_df.columns = [\"date\", \"preds_rmse\"]\n\n best_preds_piv = preds[[\"id\", \"date\", \"demand\"]].pivot(index = \"id\", columns = \"date\", values = \"demand\").reset_index()\n truth_piv = fold_truth_df[[\"id\", \"date\", \"demand\"]].pivot(index = \"id\", columns = \"date\", values = \"demand\").reset_index()\n truth_piv.set_index(\"id\", inplace = True)\n best_preds_piv.set_index(\"id\", inplace = True)\n best_preds_piv.columns = [\"F\" + str(i) for i in range(1, 29)]\n truth_piv.columns = [\"F\" + str(i) for i in range(1, 29)]\n validation_WRMSSE = round(model.evaluator.wrmsse(best_preds_piv, truth_piv, score_only = True), 6)\n\n # Save result for later use\n self.scores[process_name].append((fold_idx, preds_rmse_by_date_df, validation_WRMSSE))\n \n if self.verbose == True: \n print(process_name, \"had a score of\", validation_WRMSSE, \"on validation period\", fold_testing_set_df[\"date\"].min(), \"to\", fold_testing_set_df[\"date\"].max())\n\n metrics_lst = []\n for process_name, content in self.scores.items():\n for fold_idx, preds_rmse_by_date_df, validation_WRMSSE in content:\n preds_rmse_by_date_df[\"process_name\"] = process_name\n preds_rmse_by_date_df[\"fold_idx\"] = fold_idx\n preds_rmse_by_date_df[\"WRMSSE\"] = validation_WRMSSE\n metrics_lst.append(preds_rmse_by_date_df)\n\n metrics_df = pd.concat(metrics_lst, axis = 0)\n metrics_df.set_index(\"date\", inplace = True)\n\n return metrics_df","def mgcEval(self):\n import numpy as np\n def report_to_df(report):\n\n \"\"\"\n function to convert classification report to dataframe (for visualisation plot)\n \"\"\"\n\n report = re.sub(r\" +\", \" \", report).replace(\"avg / total\", \"avg/total\").replace(\"\\n \", \"\\n\")\n # update this due to sklearn classification report output change\n report = re.sub(r\" +\", \" \", report).replace(\"micro avg\", \"micro_avg\").replace(\"macro avg\", \"macro_avg\").replace(\"weighted avg\", \"weighted_avg\").replace(\"\\n \", \"\\n\")\n report_df = pd.read_csv(StringIO(\"Classes\" + report), sep=' ', index_col=0) \n return(report_df)\n \n #txt report to df\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\n df_report = report_to_df(class_rpttop1)\n\n df_report = df_report.iloc[:self.nb_classes, :].copy()\n df_report.index = df_report.index.astype(int)\n \n\n # classifier prediction metrics\n def classMetrics(averagex):\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\n \n return(\n print(''), \n print('-------------{0:}--------------------'.format(averagex)), \n print('precision: {0:.4f}'.format(precision)),\n print('recall: {0:.4f}'.format(recall)),\n print('fscore: {0:.4f}'.format(fscore)),\n print(''),\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\n \n def predSamp():\n\n correct = np.nonzero(self.y_pred==self.y_true)[0]\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\n\n # quick check of the number of correct prediction from validation set\n print(\"\")\n print(\"correct/total = {0: .4f}\".format(len(correct)/(len(correct)+len(incorrect))))\n print(\"total correct sample = {0: .0f}\".format(len(correct)))\n print('------------------------------------------------------------------')\n \n def classReport():\n print('----------------------------- Classfication Report -------------------------------')\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\n \n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\n \n self.classMetricsMac = classMetrics(\"macro\")\n self.classMetricsMic = classMetrics(\"micro\")\n self.predSample = predSamp()\n self.class_rptTop1 = classReport()\n \n return self","def run(self):\n # Convert the dataset, index: Recovered, column: log10(Susceptible)\n sr_df = self.sr_df.copy()\n sr_df[self.S] = np.log10(sr_df[self.S].astype(np.float64))\n df = sr_df.pivot_table(index=self.R, values=self.S, aggfunc=\"last\")\n # Convert index to serial numbers\n serial_df = pd.DataFrame(np.arange(1, df.index.max() + 1, 1))\n serial_df.index += 1\n df = pd.merge(\n df, serial_df, left_index=True, right_index=True, how=\"outer\"\n )\n series = df.reset_index(drop=True).iloc[:, 0]\n series = series.interpolate(limit_direction=\"both\")\n # Sampling to reduce run-time of Ruptures\n samples = np.linspace(\n 0, series.index.max(), len(self.sr_df), dtype=np.int64\n )\n series = series[samples]\n # Detection with Ruptures\n algorithm = rpt.Pelt(model=\"rbf\", jump=2, min_size=self.min_size)\n results = algorithm.fit_predict(series.values, pen=0.5)\n # Convert index values to Susceptible values\n reset_series = series.reset_index(drop=True)\n reset_series.index += 1\n susceptible_df = reset_series[results].reset_index()\n # Convert Susceptible values to dates\n df = pd.merge_asof(\n susceptible_df.sort_values(self.S),\n sr_df.reset_index().sort_values(self.S),\n on=self.S, direction=\"nearest\"\n )\n found_list = df[self.DATE].sort_values()[:-1]\n # Only use dates when the previous phase has more than {min_size + 1} days\n delta_days = timedelta(days=self.min_size)\n first_obj = self.to_date_obj(self.dates[0])\n last_obj = self.to_date_obj(self.dates[-1])\n effective_list = [first_obj]\n for found in found_list:\n if effective_list[-1] + delta_days < found:\n effective_list.append(found)\n # The last change date must be under the last date of records {- min_size} days\n if effective_list[-1] >= last_obj - delta_days:\n effective_list = effective_list[:-1]\n # Set change points\n self._change_dates = [\n date.strftime(self.DATE_FORMAT) for date in effective_list[1:]\n ]\n return self","def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\n all_predictions_table: pd.DataFrame) -> Dict:\n\n viewed = viewed_table.to_numpy()\n predictions = predictions_table.to_numpy()\n all_predictions = all_predictions_table.to_numpy()\n ratings = ratings_table.to_numpy()\n test = test_table.to_numpy(copy=True)\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\n\n result = dict()\n\n # Test set evaluation\n test_predictions = np.multiply(all_predictions, test_set)\n diff = np.subtract(test_predictions, test_demeaned)\n rmse = np.sqrt(np.mean(np.square(diff)))\n result.update({\"RMSE\": rmse})\n mae = np.mean(np.absolute(diff))\n result.update({\"MAE\": mae})\n\n # overall evaluation\n movies_recommended = set()\n i = 0\n for index, row in predictions_table.iterrows():\n if i > 10000: break\n else: i += 1\n\n labels = row.nlargest(20).keys().tolist()\n for movie in labels:\n movies_recommended.update(movie)\n\n result.update({\"Coverage\": len(movies_recommended)})\n\n return result","def regression_evaluation(self, test_set, predicted_values):\r\n\r\n MAE = self.mean_absolute_error(test_set, predicted_values)\r\n MSE = self.mean_square_error(test_set, predicted_values)\r\n print(f\"Mean Percent Error:\\t{MAE:.2f}\")\r\n print(f\"Mean Square Error:\\t{MSE:.2f}\")","def test_df_contents(self):\n df_out = annualize(dat, period_label=\"fqtr\", period_val=4)\n\n assert all(df_out['fqtr'] == 4), \"Error, the DataFrame has data from the wrong period.\"","def evaluate(self, start=0):\n\n if self.valmode and self.meta['nests'] > 0:\n # new nested eval, doesn't require special evaluation procedure\n # by modules. instead, all the remapping and collecting of val\n # data from each nest handled inside this evaluation function.\n\n # 2017-09-08- still something not quite right.\n # 2017-10-06- working finally. this is new norm for cross-val\n stack = self\n\n try:\n xval_idx = ut.utils.find_modules(stack, 'est_val.crossval')[0]\n except BaseException:\n xval_idx = 1\n\n try:\n mse_idx = ut.utils.find_modules(stack, 'metrics.mean_square_error')\n mse_idx = int(mse_idx[0])\n except BaseException:\n mse_idx = len(self.modules)\n\n log.info(\"Evaluating nested validation data: xvidx={0} mseidx={1}\"\n .format(xval_idx, mse_idx))\n\n # evaluate up to xval module (if necessary)\n if start > xval_idx:\n start = xval_idx\n for ii in range(start, xval_idx):\n log.info(\"eval {0} in valmode\".format(ii))\n stack.modules[ii].evaluate()\n\n # go through each nest and evaluate stack, saving data stack to\n # a placeholder (d_save). copy all keys from data stack except\n # known metadata listed in exclude_keys. this allows for arbitrary\n # new data elements to be created (stim2, etc)\n exclude_keys = ['avgresp', 'poststim', 'fs', 'isolation', 'stimparam', 'filestate',\n 'prestim', 'duration', 'est', 'stimFs', 'respFs',\n 'resp_raw', 'pupil_raw']\n include_keys = {}\n d_save = {}\n for cv_counter in range(0, stack.meta['nests']):\n # for cv_counter in range(0,1):\n stack.meta['cv_counter'] = cv_counter\n\n # load in parameters for appropriate nested fit\n st = 0\n for midx in stack.fitted_modules:\n phi_old = stack.modules[midx].parms2phi()\n s = phi_old.shape\n # stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st+np.prod(s))])\n stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st + np.prod(s))])\n st += np.prod(s)\n\n # evaluate stack for this nest up to before error metric\n # modules\n for ii in range(xval_idx, mse_idx):\n log.info(\"nest={0}, eval {1} in valmode\".format(cv_counter, ii))\n stack.modules[ii].evaluate()\n\n # append data from this (nest,module) onto d_save\n # placeholders:\n if cv_counter == 0:\n include_keys[ii] = stack.modules[ii].d_out[0].keys() - exclude_keys\n d_save[ii] = copy.deepcopy(stack.modules[ii].d_out)\n log.info(include_keys[ii])\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\n if not d['est'] and cv_counter > 0:\n for k in include_keys[ii]:\n if d[k] is None or d[k] == []:\n pass\n elif k == 'pupil' and d[k].ndim == 3 and d['resp'].shape[1] != d[k].shape[1]:\n d2[k] = np.append(d2[k], d[k], axis=2)\n elif d[k].ndim == 3:\n d2[k] = np.append(d2[k], d[k], axis=1)\n else:\n d2[k] = np.append(d2[k], d[k], axis=0)\n\n # save accumulated data stack back to main data stack\n\n # figure out mapping to get val data back into original order\n for ii in range(xval_idx, mse_idx):\n jj = -1\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\n if not d['est']:\n jj += 1 # count validation files only\n validx = np.concatenate(\n stack.modules[xval_idx].validx_sets[jj])\n mapidx = np.argsort(validx)\n for k in include_keys[ii]:\n if d2[k] is None or d[k] == []:\n d[k] = d2[k]\n elif k == 'pupil' and d[k].ndim == 3 and d2['resp'].shape[1] != d2[k].shape[1]:\n d[k] = d2[k][:, :, mapidx]\n elif d[k].ndim == 3:\n d[k] = d2[k][:, mapidx, :]\n elif d[k].ndim == 2:\n d[k] = d2[k][mapidx, :]\n else:\n d[k] = d2[k][mapidx]\n\n # continue standard evaluation of later stack elements\n for ii in range(mse_idx, len(self.modules)):\n log.info(\"eval {0} in valmode\".format(ii))\n self.modules[ii].evaluate()\n\n else:\n # standard evaluation when not using nested cross-validation\n for ii in range(start, len(self.modules)):\n self.modules[ii].evaluate()","def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\n\n model = algorithm(train)\n\n test_labels = test['Labels']\n\n predictions = predict_data(test, model)\n\n error = mean_square_error(predictions, test_labels)\n\n acc = accuracy(predictions, test_labels)\n\n return acc, error","def _test_all(\n data: pd.Series,\n data_name: Optional[str] = None,\n alpha: float = 0.05,\n data_kwargs: Optional[Dict] = None,\n) -> pd.DataFrame:\n result_summary_stats = _summary_stats(\n data=data, data_name=data_name, data_kwargs=data_kwargs\n )\n result_wn = _is_white_noise(\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\n )\n result_adf = _is_stationary_adf(\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\n )\n result_kpss = _is_stationary_kpss(\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\n )\n result_normality = _is_gaussian(\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\n )\n\n all_dfs = [\n result_summary_stats,\n result_wn[1],\n result_adf[1],\n result_kpss[1],\n result_normality[1],\n ]\n final = pd.concat(all_dfs)\n return final","def model_performance_summary(df, data_all_df, cov_buck, fisc_calender, mod_start, pred_start, summ_start, summ_end):\n var = \"pv_yr\" \n agg_col = \"LINE_ORDERS\"\n select_cols = [ \"LINE_ORDERS_ACT\", \"Prediction_Trf\", \"LEAD_MNTS_ACT\", \"LD_UNCLAIMED_ACT\", \"LD_DRIVE_ACT\", \n \"IDV_LEAD_MNTS_Pred\", \"IDV_LD_UNCLAIMED_Pred\", \"IDV_LD_DRIVE_Pred\",\n \"IDV_LEAD_MNTS_ACT\", \"IDV_LD_UNCLAIMED_ACT\", \"IDV_LD_DRIVE_ACT\",\n \"HELPER_MNTS_ACT\", \"HP_UNCLAIMED_ACT\", \"HP_DRIVE_ACT\",\n \"IDV_HELPER_MNTS_Pred\", \"IDV_HP_UNCLAIMED_Pred\", \"IDV_HP_DRIVE_Pred\",\n \"IDV_HELPER_MNTS_ACT\", \"IDV_HP_UNCLAIMED_ACT\", \"IDV_HP_DRIVE_ACT\",\n \"HELPER_OVR_ACT\", \"HPN_UNCLAIMED_ACT\", \"HPN_DRIVE_ACT\",\n \"IDV_HELPER_OVR_Pred\", \"IDV_HPN_UNCLAIMED_Pred\", \"IDV_HPN_DRIVE_Pred\",\n \"IDV_HELPER_OVR_ACT\", \"IDV_HPN_UNCLAIMED_ACT\", \"IDV_HPN_DRIVE_ACT\"\n ]\n\n for i in select_cols:\n if str(i) not in data_all_df.columns:\n data_all_df[str(i)] = np.nan\n\n cov_grp_mm = dp.cov_check(\"RSS_MM\", df, cov_buck, agg_col, fisc_calender, summ_start, summ_end)\n cov_mm = dp.cov_check(\"MM\", df, cov_buck, agg_col, fisc_calender, summ_start, summ_end)\n \n sample = data_all_df[data_all_df.Variable_Type == var].copy()\n sample = pd.merge(sample, cov_grp_mm[[\"RSS_MM\", \"CAT\"]])\n sample.CAT = sample.CAT.astype(int)\n sample[\"MAPE\"] = abs(sample[\"LINE_ORDERS_ACT\"]-sample[\"Prediction_Trf\"])/sample[\"LINE_ORDERS_ACT\"]\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\n labels = [1, 2, 3, 4, 5, 6, 7]\n sample[\"MAPE_BIN\"] = pd.cut(sample['MAPE'], bins=bins, labels=labels)\n wk_list = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID >= pred_start].FISC_WK_OF_MTH_ID.unique()\n ly_start = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID == wk_list[4]].LY_FISC_WK_OF_MTH_ID.values\n ly_end = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID == wk_list[16]].LY_FISC_WK_OF_MTH_ID.values\n train = sample[((sample.FISC_WK_OF_MTH_ID >= mod_start) & (sample.FISC_WK_OF_MTH_ID < pred_start))]\n test_in_train = sample[((sample.FISC_WK_OF_MTH_ID >= ly_start[0]) & (sample.FISC_WK_OF_MTH_ID <= ly_end[0]))]\n # The 4 th index of the list has the prediction start date after excluding the 4 week hold out period\n # for analysis purpose we are considereing only 13 weeks of test period\n test = sample[((sample.FISC_WK_OF_MTH_ID >= wk_list[4]) & (sample.FISC_WK_OF_MTH_ID <= wk_list[16]))]\n fy20 = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\n \n ####################################################################################\n \n df_grp_summary = fy20.groupby([\"RSS\"]).sum()[\"LINE_ORDERS_ACT\"].reset_index()\n df_grp_summary[\"LINE_ORDERS_PERC\"] = df_grp_summary[\"LINE_ORDERS_ACT\"]/df_grp_summary[\"LINE_ORDERS_ACT\"].sum()\n ####################################################################################\n \n df_sample_list = []\n df_sample_list = cu.mape_stability(train, \"Train CAT\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n df_sample_list = cu.mape_stability(test_in_train, \"Test_in_train CAT\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n df_sample_list = cu.mape_stability(test, \"Test CAT\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n df_sample_list = cu.mape_stability(fy20, \"FY20 CAT\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n stability = pd.concat(df_sample_list)\n stability.reset_index(inplace = True)\n ####################################################################################\n \n df_sample_res = cu.mape_stability_2d(fy20, \"FISC_MTH_NBR\", \"CAT\")\n grp_sum = fy20.groupby(\"FISC_MTH_NBR\").sum()[\"LINE_ORDERS_ACT\"].reset_index()\n monthly_stability_check = df_sample_res.merge(grp_sum)\n ####################################################################################\n \n mape_cov = cu.mape_stability_2d(fy20, \"CAT\", \"MAPE_BIN\")\n ####################################################################################\n \n mape_grp = cu.mape_stability_2d(fy20, \"RSS\", \"MAPE_BIN\")\n mape_grp[\"TYPE\"] = \"MAPE Buckets\"\n ####################################################################################\n \n mape_cov_grp = cu.mape_stability_2d(fy20, \"RSS\", \"CAT\")\n mape_cov_grp[\"TYPE\"] = \"Covariance Category\"\n ####################################################################################\n \n fy20 = cu.sh_mape(fy20)\n \n sh_summary = []\n for grp in fy20[\"RSS\"].unique():\n sample_df = fy20[fy20[\"RSS\"] == grp]\n\n sh_summary = cu.mape_stability(sample_df, grp, \"MAPE_LD_BIN\", \"MAPE_LD\", \"TOTAL_LEAD_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, grp, \"MAPE_HP_BIN\", \"MAPE_HP\", \"TOTAL_HELPER_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, grp, \"MAPE_HPN_BIN\", \"MAPE_HPN\", \"TOTAL_HELPERN_ACT\", sh_summary)\n sh_summary_grp = pd.concat(sh_summary)\n sh_summary_grp.reset_index(inplace = True)\n\n ####################################################################################\n\n sh_summary = []\n var_list = [\"pv_yr\", \"pv_roll_5wk\"]\n for var in var_list:\n sample_df = data_all_df[data_all_df.Variable_Type == var].groupby([\"FISC_WK_OF_MTH_ID\", \"FISC_YR_NBR\", \"MM\"]).sum()[select_cols].reset_index()\n sample_df = pd.merge(sample_df, cov_mm[[\"MM\", \"CAT\"]])\n sample_df = sample_df[sample_df.CAT>0]\n sample_df = sample_df[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\n sample_df = cu.sh_mape(sample_df)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_LDA_BIN\", \"MAPE_LD_ACT\", \"TOTAL_LEAD_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HPA_BIN\", \"MAPE_HP_ACT\", \"TOTAL_HELPER_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HPNA_BIN\", \"MAPE_HPN_ACT\", \"TOTAL_HELPERN_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_LD_BIN\", \"MAPE_LD\", \"TOTAL_LEAD_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HP_BIN\", \"MAPE_HP\", \"TOTAL_HELPER_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HPN_BIN\", \"MAPE_HPN\", \"TOTAL_HELPERN_ACT\", sh_summary)\n sh_mm_summary_df = pd.concat(sh_summary)\n sh_mm_summary_df.reset_index(inplace = True)\n\n ####################################################################################\n\n sh_summary = []\n for var in data_all_df.Variable_Type.unique():\n sample_df = data_all_df[data_all_df.Variable_Type == var].groupby([\"FISC_WK_OF_MTH_ID\", \"FISC_YR_NBR\", \"MM\"]).sum()[select_cols].reset_index()\n sample_df[select_cols] = sample_df[select_cols].replace({0:np.nan})\n sample_df = pd.merge(sample_df, cov_mm[[\"MM\", \"CAT\"]])\n sample_df = sample_df[sample_df.CAT>0]\n sample_df = sample_df[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\n sample_df = cu.sh_mape(sample_df)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_LDAP_BIN\", \"MAPE_LD_ACT_PRED\", \"TOTAL_LEAD_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HPAP_BIN\", \"MAPE_HP_ACT_PRED\", \"TOTAL_HELPER_ACT\", sh_summary)\n sh_summary = cu.mape_stability(sample_df, var, \"MAPE_HPNAP_BIN\", \"MAPE_HPN_ACT_PRED\", \"TOTAL_HELPERN_ACT\", sh_summary)\n sh_prop_summary = pd.concat(sh_summary)\n sh_prop_summary.reset_index(inplace = True)\n \n best_mthd = sh_prop_summary.groupby(['IDENTIFIER']).mean()['WEIGHTED MAPE'].reset_index().sort_values(by = [\"WEIGHTED MAPE\"], ascending = True)\n var_list = best_mthd[\"IDENTIFIER\"][:2].to_list()\n ####################################################################################\n\n sample_df = fy20.copy()\n sample_df = sample_df[sample_df.MM.str.contains(\"HD\")]\n sample_df = sample_df.groupby([\"FISC_WK_OF_MTH_ID\", \"MM\"]).sum()[[\"LINE_ORDERS_ACT\", \"Prediction_Trf\"]].reset_index()\n df_grp_all = sample_df.copy()\n df_grp_all[[\"LINE_ORDERS_ACT\"]] = df_grp_all[[\n \"LINE_ORDERS_ACT\"]].replace({0:np.nan})\n df_grp_all[\"MAPE_TA\"] = abs(df_grp_all[\"LINE_ORDERS_ACT\"]-df_grp_all[\"Prediction_Trf\"])/df_grp_all[\"LINE_ORDERS_ACT\"]\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\n labels = [1, 2, 3, 4, 5, 6, 7]\n df_grp_all[\"MAPE_TA_BIN\"] = pd.cut(df_grp_all['MAPE_TA'], bins=bins, labels=labels)\n\n var = \"pv_yr\" \n sample = data_all_df[data_all_df.Variable_Type == var].copy()\n \n sample = sample.merge(cov_grp_mm[[\"RSS_MM\", \"CAT\"]])\n sample = sample[sample.CAT > 0]\n sample = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\n \n \n sample = data_all_df[data_all_df.Variable_Type == var].copy()\n sample = pd.merge(sample, cov_mm[[\"MM\", \"CAT\"]])\n sample = sample[sample.CAT > 0]\n sample = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\n fy20_mm = sample.groupby([\"FISC_WK_OF_MTH_ID\", \"MM\", \"CAT\"]).sum()[[\"LINE_ORDERS_ACT\", \"Prediction_Trf\"]].reset_index()\n fy20_mm[[\"LINE_ORDERS_ACT\" ]] = fy20_mm[[\"LINE_ORDERS_ACT\"]].replace({0:np.nan})\n fy20_mm[\"MAPE\"] = abs(fy20_mm[\"LINE_ORDERS_ACT\"]-fy20_mm[\"Prediction_Trf\"])/fy20_mm[\"LINE_ORDERS_ACT\"]\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\n labels = [1, 2, 3, 4, 5, 6, 7]\n fy20_mm[\"MAPE_BIN\"] = pd.cut(fy20_mm['MAPE'], bins=bins, labels=labels)\n \n df_sample_list = []\n df_sample_list = cu.mape_stability(fy20, \"FY20 RSS_MM\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n df_sample_list = cu.mape_stability(fy20_mm, \"FY20 MM\", \"CAT\", \"MAPE\", \"LINE_ORDERS_ACT\", df_sample_list)\n df_overall_summay = pd.concat(df_sample_list)\n df_overall_summay.reset_index(inplace = True)\n return df_grp_summary, stability, monthly_stability_check, mape_cov, mape_cov_grp, mape_grp, sh_mm_summary_df, sh_summary_grp, sh_prop_summary, df_overall_summay, var_list","def test_input_pandas(multiple_linear_regression_data):\n X, y = multiple_linear_regression_data\n x = pd.DataFrame(X)\n y = pd.DataFrame(y)\n out = multiple_linear_regression(x, y)\n assert out[\"SE\"] == approx(0.03206, abs=1e-5)","def evaluate1patient(df, patient):\n test_1pat = df[df['Patient_number']==patient]\n x_test, y_test, target_unique = prepTestSet(test_1pat)\n remaining_pateients = df[df['Patient_number']!=patient]\n x_train, y_train = prepTrain(remaining_pateients)\n label = remaining_pateients.Output_label.values\n class_weights = class_weight.compute_class_weight('balanced', np.unique(label), label)\n class_weights = class_weights/min(class_weights)\n class_weights = [round(class_weight) for class_weight in class_weights]\n model = build_model_cnn(x_train, n=32, d=0.25, k=5)\n history=fitModel(model, x_train, y_train, class_weights)\n return_array, cm = modelEvaluator(x_test, y_test, model, target_unique)\n return history, return_array, cm","def apply_evaluation(x, label_true, params, names, database_name):\n rows = []\n\n for i in range(0, len(names)):\n act_name = names[i]\n act_data = x[i]\n\n algorithm = KMeans(k=params['k'], seed=params['seed'], max_it=params['max_it'], tol=params['tol'])\n labels = algorithm.fit_predict(act_data)\n\n unsupervised = evaluate_unsupervised_internal(act_data, labels)\n supervised = evaluate_supervised_external(label_true, labels)\n\n row = {**dict(Names=act_name), **supervised, **unsupervised}\n rows.append(row)\n df_results = pd.DataFrame(rows)\n set_output(df_results, 'pca_analysis_'+database_name)","def prep_data_fn(self, st_train_dt, end_train_dt, st_val_dt, end_val_dt, st_test_dt, end_test_dt):\n df = self.get_prep_data()\n train = df[(df['ft_data_dt'] >= st_train_dt) & (df['ft_data_dt'] <= end_train_dt)]\n val = df[(df['ft_data_dt'] >= st_val_dt) & (df['ft_data_dt'] <= end_val_dt)].sample(frac=0.4, random_state=2021)\n test = df[(df['ft_data_dt'] >= st_test_dt) & (df['ft_data_dt'] <= end_test_dt)]\n print(f'----train----')\n print(train[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\n print(f'----validation----')\n print(val[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\n print(f'----test----')\n print(test[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\n self.set_train(train)\n self.set_validation(val)\n self.set_test(test)\n train_X = train[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\n train_y = train['target']\n val_X = val[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\n val_y = val['target']\n test_X = test[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\n test_y = test['target']\n self.set_train_X(train_X)\n self.set_train_y(train_y)\n self.set_val_X(val_X)\n self.set_val_y(val_y)\n self.set_test_X(test_X)\n self.set_test_y(test_y)","def train(self): \n start_time = time()\n\n # reset previous results\n self.best_result = pd.DataFrame()\n self.result = pd.DataFrame()\n\n # Generate dictionaries of all posible parameter permutations\n keys, values = zip(*self.params.items())\n self.permutations_dict = [dict(zip(keys, v)) for v in itertools.product(*values)] \n\n # Run through all models in parallel threads\n with Pool(self.thread_cnt) as p:\n result = p.map(self.analyze_model, self.permutations_dict)\n\n\n # wrap up results\n if self.classes_names: # acts as trigger for computation of cms\n for i, dic in enumerate(result):\n dic[\"id\"] = i\n self.cms = [(dic[\"id\"] ,dic.pop(\"cm\")) for dic in result]\n\n self.result = pd.DataFrame(result)\n self.best_result = self.result.iloc[self.result[\"score\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"f1_score\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"recall\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"precision\"].argmax()] # store row with the best score\n end_time = time()\n print(\"Finished evaluation\")\n print(\"Best parameteters found with:\", self.best_parameter_set())\n print(\"score=\", self.best_score())\n #print(\"f1_score=\", self.best_f1_score())\n #print(\"recall_score=\", self.best_recall_score())\n #print(\"precision_score=\", self.best_precision_score())\n print(\"Total evaluation time = {:.2f}s\".format(end_time-start_time))\n\n return self.best_parameter_set(), self.best_score()","def test_X_non_df_error(self):\n\n x = BaseTransformer(columns=\"a\")\n\n with pytest.raises(ValueError):\n\n x.fit(\"a\")","def create_dataframe(euctr_cond):\n def f(x):\n d = {}\n d['number_of_countries'] = x.eudract_number_with_country.nunique()\n d['min_end_date'] = x.date_of_the_global_end_of_the_trial.min()\n d['max_end_date'] = x.date_of_the_global_end_of_the_trial.max()\n d['comp_date'] = np.where(pd.notnull(x.date_of_the_global_end_of_the_trial),1,0).sum()\n d['has_results'] = x.trial_results.sum()\n d['includes_pip'] = x.trial_is_part_of_a_paediatric_investigation_plan.sum()\n d['single_blind'] = x.trial_single_blind.sum()\n d['not_single_blind'] = x.not_single_blind.sum()\n d['rare_disease'] = x.trial_condition_being_studied_is_a_rare_disease.sum()\n d['not_rare_disease'] = x.not_rare_disease.sum()\n d['rare_disease_blank'] = x.rare_disease_blank.sum()\n d['completed'] = np.where(x.end_of_trial_status == 'Completed', 1, 0).sum()\n d['ongoing'] = np.where((x.end_of_trial_status == 'Ongoing') | (x.end_of_trial_status == 'Restarted'), 1, 0).sum()\n d['terminated'] = np.where(x.end_of_trial_status == 'Prematurely Ended', 1, 0).sum()\n d['suspended'] = np.where((x.end_of_trial_status == 'Temporarily Halted') | (x.end_of_trial_status == 'Suspended by CA'), 1, 0).sum()\n d['other_status'] = np.where((x.end_of_trial_status == 'Not Authorised') | (x.end_of_trial_status == 'Prohibited by CA'), 1, 0).sum()\n d['no_status'] = np.where(pd.isnull(x.end_of_trial_status),1,0).sum()\n d['phase_1'] = x.trial_human_pharmacology_phase_i.sum()\n d['phase_2'] = x.trial_therapeutic_exploratory_phase_ii.sum()\n d['phase_3'] = x.trial_therapeutic_confirmatory_phase_iii.sum()\n d['phase_4'] = x.trial_therapeutic_use_phase_iv.sum()\n d['bioequivalence'] = x.trial_bioequivalence_study.sum()\n d['not_bioequivalence'] = x.not_bioequivalence_study.sum()\n d['healthy_volunteers'] = x.subject_healthy_volunteers.sum()\n d['not_healthy_volunteers'] = x.not_healthy_volunteers.sum()\n d['full_title'] = x.full_title.astype('str').min()\n d['abbreviated_title'] = x.abbreviated_title.astype('str').max()\n d['non_eu'] = x.non_eu.sum()\n return pd.Series(d)\n\n return euctr_cond.groupby('eudract_number').apply(f).reset_index()","def run_tests():\n with open(FILENAME) as file:\n # Loads testing parameters from the yaml file.\n tests = yaml.safe_load(file)\n\n # create a dataframe to keep the results\n test_dict = tests['Tests']\n results = pd.DataFrame(test_dict)\n results['Last Average Score'] = \"\"\n results['No of Q-Learning episodes'] = \"\"\n\n # run experiments:\n for i, test in enumerate(test_dict):\n grid = Rooms(test[\"env_size\"], testing=True)\n learning = QLearning(grid, test[\"gamma\"], test[\"alpha\"], test[\"agent_start_pos\"])\n e_greedy = Policy(\"e-greedy\", test[\"epsilon\"], test[\"decay\"])\n greedy = Policy(policy_type=\"greedy\")\n experiment = Experiments(grid, learning, greedy, test[\"iters\"],\n test[\"agent_start_pos\"], test[\"test_no\"])\n\n for session in range(test[\"iters\"]):\n learning.run_multiple_episodes(test[\"batch_episodes\"], e_greedy)\n mean_reward = experiment.run_experiments(test[\"exp_per_batch\"])\n\n results.loc[i,'Last Average Score'] = mean_reward\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\"batch_episodes\"]\n\n # save results to csv file\n filename = 'results/' + 'test_table.csv'\n results.to_csv(filename)\n\n # plot & save graphs\n experiment.generate_results(test[\"test_no\"], test)\n\n return results","def force_fix():\n df = force_test_data()\n return df","def evaluate(self, epoch, exploration_paths):\n logger.log(\"Collecting samples for evaluation\")\n paths = self._sample_eval_paths(epoch)\n statistics = OrderedDict()\n\n statistics.update(self._statistics_from_paths(paths, \"Test\"))\n statistics.update(self._get_other_statistics())\n statistics.update(self._statistics_from_paths(exploration_paths,\n \"Exploration\"))\n\n statistics['AverageReturn'] = get_average_returns(paths)\n statistics['Epoch'] = epoch\n\n for key, value in statistics.items():\n logger.record_tabular(key, value)\n\n self.log_diagnostics(paths)","def run(self):\n\n # TODO try/catch to ensure proper shutdown even if error encountered\n\n params = self._get_params_for_run()\n result_rows = []\n\n # Check for valid configuration\n if self._test_docs is None and self._k_folds == 0:\n self._logger.error(\"Explicit test set or number of cross-validation folds must be specified.\")\n metrics = Metrics()\n result_row = {**params, **metrics.get_scores_as_dict()}\n result_rows.append(result_row)\n return result_rows\n\n # Continue while there are configured parameter settings to evaluate\n while params is not None:\n\n # Get collection of training and test sets for current run\n data_sets = self._get_training_and_test_sets()\n for set_index, (training_docs, test_docs) in enumerate(data_sets):\n\n # Retrieve an encoder module trained with the specified configuration\n self._encoder = self._get_encoder(params)\n\n set_index += 1 # Only used for user output, so start index at 1\n\n num_sets = len(data_sets)\n if num_sets > 1:\n self._logger.info(\"Training and evaluating fold {} of {}.\".format(set_index, num_sets))\n\n start = time.time()\n self._train_and_evaluate(params, self._encoder, training_docs, test_docs)\n runtime = time.time() - start\n self._logger.info(\n \"Trained and evaluated fold {} of sequence model in {} seconds.\".format(set_index, runtime))\n\n # Combine run parameters with evaluation results and store\n result_row = {**params, **self._evaluator.get_score_as_dict()}\n result_rows.append(result_row)\n\n # Check if model should be saved\n if self._is_model_saving_enabled():\n\n operator = self._evaluator.get_operator()\n current_score = self._evaluator.get_score()\n\n best_model = self._get_best_model()\n if best_model is not None:\n (best_metric, _) = best_model\n if not operator(best_metric, current_score):\n self._set_best_model(current_score, (params, self._encoder, self._sequence_learner))\n else:\n # New model is the best one if no previous existed\n self._set_best_model(current_score, (params, self._encoder, self._sequence_learner))\n\n # Invoke optimizer callback to report on results of this run\n if self._optimizer is not None:\n self._optimizer.process_run_result(params=params,\n score=self._evaluator.get_score_as_dict(),\n encoder=self._encoder,\n sequence_learner=self._sequence_learner)\n\n # Check if there are additional runs to execute\n if self._optimizer is not None:\n params = self._optimizer.get_next_params()\n else:\n params = None\n\n # Store best model, if configured\n if self._is_model_saving_enabled():\n path, name = self._get_model_save_path_and_name()\n try:\n self.save(path, name)\n except Exception:\n self._logger.error(\"Failed to save model, clearing Keras session and trying again.\")\n self._sequence_learner.clear_session()\n self.save(path, name)\n\n # Clear Keras/Tensorflow models # TODO why a second time?\n if self._sequence_learner is not None:\n self._sequence_learner.clear_session()\n\n return pd.DataFrame(result_rows)","def optimizer() -> pd.DataFrame:\n global iteration, coefs_all\n\n X_train, X_test, y_train, y_test = train_test()\n\n # Number of observations in train & test set\n n_train = len(X_train)\n n_test = len(X_test)\n n_coefs = X_train.shape[1]\n\n # Initialize coefficients\n coefs_init = np.random.normal(\n loc=conf.coef_mu, \n scale=conf.coef_sigma, \n size=n_coefs\n )\n coefs_all = coefs_init.copy()\n\n # Coefficients shall be bounded\n bounds = [conf.coef_bounds] * n_coefs\n iteration = 0\n\n # Run optimization\n result = minimize( \n fun=lambda x: loss_func(x, X_train, y_train, n_train),\n callback=lambda x: callback_func(x, X_train, y_train, n_train),\n x0=coefs_init,\n bounds=bounds\n )\n # Collect optimal coefficients\n coefs = pd.Series(data=result.x, index=X_train.columns, name=\"coefs\")\n coefs_df = pd.DataFrame(data=coefs_all, columns=X_train.columns).T\n coefs_df.index.name = \"area\"\n\n rmse_train = result.fun\n rmse_test = loss_func(\n coefs=coefs, \n X=X_test, \n y=y_test, \n n=n_test, \n )\n print(\"\\n\")\n print (f\"Train RMSE: {rmse_train:.4f}\")\n print (f\"Test RMSE: {rmse_test:.4f}\")\n\n return coefs_df","def test_error_metrics(self, whp_pandas):\n test_class = Slug_Forecasting(whp_pandas.copy())\n test_class.stationarity_check()\n test_class.split_data()\n test_class.ARIMA_model(1, 0, 1, show=False)\n\n # Test error metrics parameter entry\n assert test_class.error_metrics(error=\"other\", verbose=False) == None, \"Nothing is returned\"\n\n # Test values returned for fitting regression\n assert len(test_class.error_metrics(error=\"fit\", verbose=False)) == 4, \\\n \"Three variables must be returned in this example\"\n mape, mse, rmse, r2 = test_class.error_metrics(error=\"fit\", verbose=False)\n\n # test stats:\n assert r2 < 1.0, \"Coefficient of Determination r2 should be less than 1\"\n assert np.isclose(math.sqrt(mse), rmse, atol=0.01), \\\n \"Square rooted mean squared error should equal root mean squared error\"\n\n test_class.ARIMA_pred(pred_time=60, show=False) # Forecast values\n\n # Test values returned for forecasting regression\n assert len(test_class.error_metrics(error=\"pred\", verbose=False)) == 4, \\\n \"Three variables must be returned in this example\"\n mape, mse, rmse, r2 = test_class.error_metrics(error=\"pred\", verbose=False)\n\n # test stats:\n assert r2 < 1.0, \"Coefficient of Determination r2 should be less than 1\"\n assert np.isclose(math.sqrt(mse), rmse, atol=0.01), \\\n \"Square rooted mean squared error should equal root mean squared error\"","def gen_df_err_extend(cur_data, cur_mod, random_assignment=False, rand_seed=0):\n if random_assignment:\n np.random.seed(rand_seed)\n clust_list = (cur_mod.z).copy()\n np.random.permutation(clust_list) \n \n df_err_extend = pd.DataFrame(columns=['full_id', 'id', 'proj', 'idx', 'clust', 'err'])\n\n for i in range(0,len(cur_data['SI'])):\n cur_x = cur_data['XA'][i]\n cur_x = cur_x[~np.isnan(cur_x)]\n cur_y = cur_data['YA'][i]\n cur_y = cur_y[~np.isnan(cur_y)]\n full_cur_id = cur_data['SI'][i]\n cur_id = cur_data['SI'][i].split('_')[0]\n cur_proj = cur_data['SI'][i].split('_')[1]\n\n if random_assignment:\n clust_assign = clust_list[i]\n else:\n rank_clust, _ = utils.rank_cluster_prediction(cur_mod, cur_x, cur_y)\n clust_assign = rank_clust[0]\n \n y_pred_mean = calc_y_pred_model(cur_mod, cur_x, clust_assign)\n err = calc_error(cur_y, y_pred_mean)\n df_err_extend = df_err_extend.append({'full_id':full_cur_id, 'id':cur_id, 'proj':cur_proj, 'idx':i, 'clust':clust_assign, 'err': err}, ignore_index=True)\n \n return df_err_extend","def evaluate(self, ind, filename=\"\"):\n start = dt.now()\n # rule_set = self._generator.create_rule_set(ind)\n rule_set, indicators = self._generator.create_rule_set(ind)\n data_selected = self._data[indicators]\n\n # Calculate the signals according to the fuzzy rule set\n decision = fuzzy.DecisionMaker(rule_set, data_selected)\n\n # signals = pd.DataFrame([0.5, -0.4, 0.2, 0.4, 0.1, -0.2, -0.3, 0.2, 0.3, 0.1], index=self._data.index,columns=['Signal'])\n\n signals = []\n # signals = decision.defuzzify(self._data) #signal is a dataframe\n for row_index, data_row in zip(range(len(data_selected)), data_selected.iterrows()):\n dictionary = dict(data_row[1])\n signal = decision.defuzzify(dictionary)\n signals.append(signal)\n\n self._data['Signal'] = signals\n print(\"::::: [evaluator] Calculate signals \", dt.now() - start, \":::::\")\n\n start = dt.now()\n # Calculate the fitness value according to the trading signals\n Hold = 0\n Money = 10000000\n Fortune = []\n for i, row in self._data.iterrows():\n Hold, Money, fortune = self.trade(row, Hold, Money)\n Fortune.append(fortune)\n self._data['Fortune'] = Fortune\n # self._data['Operation'] = 0\n # self._data.Operation[self._data.Signal > 0] = 1\n # self._data.Operation[self._data.Signal < 0] = -1\n fit_val = self._data.iloc[-1]['Fortune']\n\n print(\"::::: [evaluator] Calculate fitness value\", dt.now() - start, \":::::\")\n return fit_val","def train_and_eval():\n # train_file_name = 'adult.data'\n # test_file_name = 'adult.test'\n train_file_name = 'poker-hand-testing.data'\n test_file_name = 'poker-hand-training-true.data'\n #test_file_name = maybe_download()\n df_train = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n df_test = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n\n #df_train[LABEL_COLUMN] = (df_train[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n #df_test[LABEL_COLUMN] = (df_test[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n\n model_dir = tempfile.mkdtemp() if not FLAGS.model_dir else FLAGS.model_dir\n print(\"model directory = %s\" % model_dir)\n m = build_estimator(model_dir)\n print(m)\n m.fit(input_fn=lambda: input_fn(df_train), steps=FLAGS.train_steps)\n results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1)\n for key in sorted(results):\n print(\"%s: %s\" % (key, results[key]))","def run(self, action: str = 'evaluate') -> Union[\n pd.DataFrame, List[Dict[str, Dict[str, Union[Union[float, str], Any]]]]]:\n model = VAR(endog=self.train)\n model_fit = model.fit()\n if action == 'predict':\n # Use full dataset to get prediction\n model_full = VAR(endog=self.df)\n model_fit_full = model_full.fit()\n return pd.DataFrame(model_fit.forecast(model_fit_full.y, steps=2), index=['2008', '2009'],\n columns=[self.df.columns])\n else:\n tmp = []\n for col in self.df.columns:\n tmp.append({col: {'rmse_val': sqrt(\n mean_squared_error(self.valid[col], self._prediction(model_fit, self.valid)[[col]])),\n 'mae_val': mean_absolute_error(self.valid[col],\n self._prediction(model_fit, self.valid)[[col]]),\n 'mape_val': f'{self.mean_absolute_percentage_error(self.valid[col], self._prediction(model_fit, self.valid)[[col]])} %'}})\n\n return tmp","def stepwise_regression(train_per_list, cut_off_list, C_list,\n factors,non_factors, data_path, executable_path):\n sql_table = 'aggregated_ctr' #Data table\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\n # remove cross terms\n\n factors+=['campaign_id','ad_account_id','pub_account_id', \n 'campaign_id*site', 'ad*pub_account_id']\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\n 'user':'readonly','passwd':'z0q909TVZj'}\n con_dict_dse={'host':'db.lqm.io','db':'dse','user':'dse','passwd':'dSe@lQm'}\n rtb_flag=[0,1]\n \n test_per_list= map(lambda x: ( add_hour(x[1], 1), add_hour(x[1], 3)), train_per_list)\n \n # test period is next 3 hours after end of training period\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\n MySQL_save_data_loop(con_dict_dse, sql_table,\n train_per_list, sql_features, rtb_flag, data_path)\n MySQL_save_data_loop(con_dict_dse, sql_table,\n test_per_list, sql_features, rtb_flag, data_path)\n \n model_type=0\n has_intercept = True # bias term in LR\n tol = 0.00000001\n\n # NB these filenames are HARDCODED in write_sparse routines\n weights_file = 'train_ais.txt'\n train_file = 'train_svm.txt'\n test_file = 'test_svm.txt'\n probability_file = 'preds_SummModel_py.txt'\n\n \n res_df_list=[]\n trial_factors=[]\n remaining_factors=factors[:]\n while len(remaining_factors):\n results = [] \n # we assume we cannot load all the data in memory\n # so we have to reload for every step of stepwise selection\n for train_per, test_per in zip(train_per_list, test_per_list):\n \n train_df=load_data(data_path,train_per)\n test_df=load_data(data_path,test_per)\n \n sc, click_no_click_df, weights, targets \\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\n \n for cut_off in cut_off_list:\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\n sparse_test_all = sc.transform(test_df)\n for fac in remaining_factors:\n trial_factors.append(fac)\n trial_factors.sort(key=lambda x: sc.factors.index(x))\n # libsvm expects the indices in ascending order\n print (trial_factors) \n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\n\n for C in C_list:\n model_file = \\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\n start=date_name(train_per[0]),\n stop=date_name(train_per[1]),\n cut_off=cut_off, C=C)\n fit(executable_path, data_path, train_file,\n model_file, weights_file, model_type, reg_param=C, tol=tol,\n has_intercept=has_intercept)\n \n pCTR = libLinear_functions.predict(\n executable_path, data_path, test_file,\n model_file, probability_file)\n if type(pCTR) is pd.Series:\n amounts = pd.DataFrame({\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\n 'clicks':test_df['clicks']})\n mean_log_loss, weighted_log_loss =\\\n libLinear_functions.log_loss_weighted(pCTR, amounts)\n results.append([train_per[:], tuple(trial_factors),fac, cut_off, C, mean_log_loss])\n # what to do if ERROR?\n trial_factors.remove(fac)\n res_df=pd.DataFrame(results,columns=['train_per','factors','add_factor','cut_off','C','mean_log_loss'])\n res_avg=res_df.groupby(['factors','add_factor','cut_off','C']).agg([np.mean,np.std])\n best_params=res_avg['mean_log_loss','mean'].argmin()\n best_fac=best_params[1]\n remaining_factors.remove(best_fac)\n trial_factors.append(best_fac)\n res_df_list.append(res_df)\n results_df=pd.concat(res_df_list)\n return results_df","def evaluate(self):\n # Method variables definition\n X_train, X_test, y_train, y_test = dm.reshape_y_set_split_data(self.datasetManager)\n featureScaleDependentVariables = self.datasetManager.params.featureScaleDependentVariables\n\n # Feature Scaling\n X_scaler, X_train = dm.do_feature_scaling(X_train)\n if featureScaleDependentVariables:\n y_scaler, y_train = dm.do_feature_scaling(y_train)\n else:\n y_scaler = None\n y_train = self.datasetManager.y_train\n \n self.X_scaler = X_scaler\n self.y_scaler = y_scaler\n\n # Training the SVR model on the training set\n regressor = SVR(kernel = 'rbf')\n regressor.fit(X_train, y_train.ravel())\n self.regressor = regressor\n\n # Predicting the Test set results\n self.y_pred = y_scaler.inverse_transform(regressor.predict(X_scaler.transform(X_test))) if featureScaleDependentVariables else regressor.predict(X_test)\n \n # Returning the process result : the regression type and the predicted dependent variables set\n return [\"Support Vector Regression\", self.get_r2_score(y_test, self.y_pred)]","def concat_all_evaluation_results(list_of_folders):\n\n\n train_eval_df_list = []\n val_eval_df_list = []\n train_val_eval_df_list = []\n\n\n for item in list_of_folders:\n path_to_eval_folder = os.path.join(EMBEDDING_DEST, item)\n files = os.listdir(path_to_eval_folder)\n\n for f in files:\n\n # for each evaluation result csv file, see whether it is from training set, or validation set, or training+validation\n if f.endswith(\"image_level_evaluation_result_top_tri.csv\"):\n\n if \"random\" in f:\n if \"random_training_validation\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n train_val_eval_df_list.append(df)\n\n elif \"random_training\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n train_eval_df_list.append(df)\n\n\n elif \"random_validation\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n val_eval_df_list.append(df)\n\n\n else:\n if \"triplet\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n train_val_eval_df_list.append(df)\n\n elif \"training\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n train_eval_df_list.append(df)\n\n elif \"validation\" in f:\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\n val_eval_df_list.append(df)\n\n\n # add 'training_' or 'validation_' to the column names of evaluation results coming from training and validation sets.\n # This is to be able to distinguish them in the final general csv file.\n\n columns = list(train_val_eval_df_list[0])\n train_columns = [\"training_\"+item for item in columns[1:]]\n train_columns = [columns[0]] + train_columns\n train_columns_dict ={}\n \n val_columns = [\"validation_\"+item for item in columns[1:]]\n val_columns = [columns[0]] + val_columns\n val_columns_dict ={}\n\n #train_and_val_columns = [\"train_and_validation_\"+item for item in columns[1:]]\n #train_and_val_columns = [columns[0]] + train_and_val_columns\n #train_and_val_columns_dict ={}\n\n\n for i in range(len(columns)):\n train_columns_dict[columns[i]] = train_columns[i]\n val_columns_dict[columns[i]] = val_columns[i]\n #train_and_val_columns_dict[columns[i]] = train_and_val_columns[i]\n\n\n concatenated_training_df = pd.concat(train_eval_df_list, sort=False)\n concatenated_training_df = concatenated_training_df.rename(columns=train_columns_dict)\n\n concatenated_validation_df = pd.concat(val_eval_df_list, sort=False)\n concatenated_validation_df = concatenated_validation_df.rename(columns=val_columns_dict)\n \n concatenated_train_and_validation_df = pd.concat(train_val_eval_df_list, sort=False)\n #concatenated_train_and_validation_df = concatenated_train_and_validation_df.rename(columns=train_and_val_columns_dict)\n\n\n concatenated_training_df.to_csv(os.path.join(EMBEDDING_DEST,\"compare_with_no_sz\", \"training_all_evaluation_result_top_tri.csv\"),index=None)\n concatenated_validation_df.to_csv(os.path.join(EMBEDDING_DEST, \"compare_with_no_sz\", \"validation_all_evaluation_result_top_tri.csv\"),index=None)\n concatenated_train_and_validation_df.to_csv(os.path.join(EMBEDDING_DEST,\"compare_with_no_sz\",\"training_and_validation_all_evaluation_result_top_tri.csv\"), index=None)\n\n # ---------\n # If you have columns on arguments, keep them in training but drop them in validation and train_and_val to prevent duplicates\n list_of_cols_in_validation_df = list(concatenated_validation_df)\n list_of_cols_in_train_val_df = list(concatenated_train_and_validation_df)\n args_cols = get_json_argument_list()\n\n args_cols_val = [\"validation_\"+item for item in args_cols]\n \n if len(list_of_cols_in_train_val_df) == len(list_of_cols_in_validation_df) and len(list_of_cols_in_train_val_df) > 7:\n concatenated_validation_df = concatenated_validation_df.drop(args_cols_val, axis=1, errors='ignore')\n concatenated_train_and_validation_df = concatenated_train_and_validation_df.drop(args_cols, axis=1, errors='ignore')\n\n\n # ---------\n\n all_three_df_list = [concatenated_training_df, concatenated_validation_df, concatenated_train_and_validation_df]\n concatenated_all_df = pd.concat(all_three_df_list, axis=1)\n concatenated_all_df.to_csv(os.path.join(EMBEDDING_DEST,\"compare_with_no_sz\", \"all_evaluation_result_top_tri.csv\"), index=None)","def supplement_data(df, test, store, dept):\n\n df_s = pd.DataFrame({'Store': store,\n 'Dept': dept,\n 'Date': all_date,\n 'Weekly_Sales': 0,\n 'check': str(store) + '_' + str(dept)})\n return df_s","def evaluate_regression(x, t, w, basis, degree):\n \t# TO DO:: Compute t_est and err \n #w_tranpose=w.T\n\n\n # My logic goes as follows:\n # Definition of test error is when you run the trained\n # model against a dataset that it hasn't been exposed to\n # this dataset is known as the testset \n\n # As such the basic algorithm goes as follows:\n # We do not need to recompute the weights but we need to recompute\n # phi for our test data\n\n # As such, we are interested in how well our trained weights\n # estimate against the test data so we matrix multiply our\n # weights against the phi from our test data\n # thus t_est = w_train.T*phi(x) since we want to know how well our\n # trained model estimates against the training data\n # but in implementation we do phi(x)*w_train\n # to match array dimensions \n\n\n #Compute design matrix from test data \n phi=design_matrix(x,basis,degree)\n phi_cross=np.linalg.pinv(phi)\n\n # Compute testing weights // just in case we require this variable\n #if(t is not None):\n #w_test=phi_cross.dot(t)\n #w_test=phi_cross.dot(t)\n\n # We want to be able to index into our target vector\n\n #t_est=phi.dot(w_test)\n #if (t is not None):\n # testing_estimate=phi.dot(w_test)\n #testing_estimate=phi.dot(w_test)\n\n # Estimate of our targets according to test data against learned \n # coefficients\n t_est=phi.dot(w)\n #print(\"t_est\",t_est)\n #t_est = None\n\n # We calculate the RMS error as follows\n # Take equation 3.12 of PRML and modify as follows\n # My logic:\n # The equation given in PRML gives the SSE (sum of squares error)\n # By definition the MSE (mean squared error) takes the SSE and divides \n # it by population size, we also preserve the 1/2 constant \n # throughout our calcuations \n # Afterwards we take our MSE and square root it.\n\n # Compute difference between target and estimate\n\n if(t is not None):\n \n diff=t-t_est\n # Square all observations\n diff_squared=np.power(diff,2)\n # Sum up all the observations in our vector\n sig_squared=diff_squared.sum()\n half_sig_squared=0.5*(sig_squared)\n # Calculate population size\n population_size=t.shape[0]\n rmse=np.sqrt(half_sig_squared/population_size)\n err=rmse\n else:\n err=None\n\n #diff=t-t_est\n\n\n # Square all observations \n #diff_squared=np.power(diff,2)\n\n # Sum up all the observations in our vector\n #sig_squared=diff_squared.sum()\n\n #half_sig_squared=0.5*(sig_squared)\n\n # Calculate population size\n #population_size=t.shape[0]\n\n #rmse=np.sqrt(half_sig_squared/population_size)\n #err = rmse\n #print(\"err inside function\",err)\n #err=rmse\n return (t_est, err)","def dependent_error_exp(data, weak_signal_data, num_weak_signal):\n\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\n\n training_data = data['training_data'][0].T\n training_labels = data['training_data'][1]\n val_data, val_labels = data['validation_data']\n val_data = val_data.T\n test_data = data['test_data'][0].T\n test_labels = data['test_data'][1]\n\n num_features, num_data_points = training_data.shape\n\n weak_signal_ub = w_model['error_bounds']\n weak_signal_probabilities = w_model['probabilities']\n weak_test_accuracy = w_model['test_accuracy']\n\n weights = np.zeros(num_features)\n\n print(\"Running tests...\")\n\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\n\n # calculate test probabilities\n test_probabilities = probability(test_data, optimized_weights)\n # calculate test accuracy\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\n\n print(\"\")\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n print(\"Experiment %d\"%num_weak_signal)\n print(\"We trained %d learnable classifiers with %d weak signals\" %(1, num_weak_signal))\n print(\"The accuracy of the model on the test data is\", test_accuracy)\n print(\"The accuracy of weak signal(s) on the test data is\", weak_test_accuracy)\n print(\"\")\n\n # calculate ge criteria\n print(\"Running tests on ge criteria...\")\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\n print(\"The accuracy of ge criteria on test data is\", ge_test_accuracy)\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n\n # calculate baseline\n print(\"Running tests on the baselines...\")\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\n print(\"The accuracy of the baseline models on test data is\", b_test_accuracy)\n print(\"\")\n\n output = {}\n output['ALL'] = test_accuracy\n output['WS'] = w_model['test_accuracy'][-1]\n output['GE'] = ge_test_accuracy\n output['AVG'] = b_test_accuracy[-1]\n\n return output","def evaluate(self, test_data, test_labels):\n raise NotImplementedError","def general_analysis(df):\n pass","def update_error_plot_values(self):\n check_is_dir(\"mp_plotdata\")\n check_is_dir(\"mp_plotdata/\"+self.name)\n\n data_train = self.get_data.evaluate_on_train_data(n_samples=50)\n data_validation = self.get_data.evaluate_on_validation_data(n_samples=50)\n\n for data, _set in zip([data_train, data_validation], [\"train\", \"validation\"]):\n object_real_samples = data[\"object_real_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n object_imag_samples = data[\"object_imag_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n diffraction_samples = data[\"diffraction_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n\n filename = \"mp_plotdata/\"+self.name+\"/\"+_set+\"_log.dat\"\n if not os.path.exists(filename):\n with open(filename, \"w\") as file:\n file.write(\"# time[s] epoch real_loss imag_loss reconstruction_loss\\n\")\n\n # real loss\n real_loss = self.sess.run(self.nn_nodes[\"real_loss\"],\n feed_dict={self.x:diffraction_samples,\n self.real_actual:object_real_samples})\n\n # imaginary loss\n imag_loss = self.sess.run(self.nn_nodes[\"imag_loss\"],\n feed_dict={self.x:diffraction_samples,\n self.imag_actual:object_imag_samples})\n\n # reconstruction\n reconstruction_loss = self.sess.run(self.nn_nodes[\"reconstruction_loss\"],\n feed_dict={self.x:diffraction_samples})\n\n datastring = \"\"\n datastring+= str(time.time())\n datastring+= \" \"\n datastring+= str(self.epoch)\n datastring+= \" \"\n datastring+= str(real_loss)\n datastring+= \" \"\n datastring+= str(imag_loss)\n datastring+= \" \"\n datastring+= str(reconstruction_loss)\n datastring+= \"\\n\"\n\n with open(filename, \"a\") as file:\n file.write(datastring)\n\n\n for key in self.experimental_traces.keys():\n trace = self.experimental_traces[key]\n\n # reconstruction\n reconstruction_loss = self.sess.run(self.nn_nodes[\"reconstruction_loss\"],\n feed_dict={self.x:trace})\n\n logger_name = key+\"_reconstructed\"\n filename = \"mp_plotdata/\"+self.name+\"/\"+logger_name+\".dat\"\n if not os.path.exists(filename):\n with open(filename, \"w\") as file:\n file.write(\"# time[s] epoch reconstruction_loss\\n\")\n\n datastring = \"\"\n datastring+= str(time.time())\n datastring+= \" \"\n datastring+= str(self.epoch)\n datastring+= \" \"\n datastring+= str(reconstruction_loss)\n datastring+= \"\\n\"\n with open(filename, \"a\") as file:\n file.write(datastring)","def fit(self, df):\n self.df_std = df.std(axis=0, skipna=True)\n self.df_mean = df.mean(axis=0, skipna=True)\n return self","def create_evaluation_df(predictions, test_inputs, H, scaler):\n eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, H+1)])\n eval_df['timestamp'] = test_inputs.dataframe.index\n eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')\n eval_df['actual'] = np.transpose(test_inputs['target']).ravel()\n eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])\n return eval_df","def filldf(df, response, sorted_selection, params_selection, constant=True, verbose=True):\n selections_iter = iter(sorted_selection)\n params_iter = iter(params_selection)\n idxmissing = df[response][df[response].isnull() == True].index # slect where their is missing data\n\n print(\"Filling .... \")\n\n while len(idxmissing) > 0:\n print(\"Their is [\" + str(len(idxmissing)) + \"] events missing\")\n\n try: # Try if their is still other stations to fill with\n selection = next(selections_iter)\n param = next(params_iter)\n except StopIteration:\n print(\"NO MORE SELECTED STATIONS\")\n break\n\n try:\n Y = df.loc[:, response]\n X1 = df.loc[:, selection[0]]\n X2 = df.loc[:, selection[1]]\n select = pd.concat([X1, X2], keys=['X1', 'X2'], axis=1, join='inner').dropna()\n if constant:\n newdata = param[0] + param[1] * select['X1'] + param[2] * select['X2'] # reconstruct the data\n else:\n newdata = param[0] * select['X1'] + param[1] * select['X2'] # reconstruct the data\n\n df.loc[idxmissing, response] = newdata.loc[idxmissing]\n idxmissing = df[response][df[response].isnull() == True].index # slect where their is missing data\n except KeyError:\n if verbose:\n print('Selected stations ' + str(selection) + 'did not fill any events')\n else:\n pass\n\n except ValueError:\n if verbose:\n print('The variable ' + var + \"Does not exist or no data to do the multilinear regression \")\n else:\n pass\n\n return df.loc[:, response]","def run(self):\n dataset_train = np.hstack(self.hstacK_generator(self.train))\n dataset_valid = np.hstack(self.hstacK_generator(self.valid_arb))\n\n X_train, y_train = self.split_sequences(dataset_train, self.n_steps_in, self.n_steps_out)\n X_valid, y_valid = self.split_sequences(dataset_valid, self.n_steps_in, self.n_steps_out)\n\n model = self.make_model(X_train.shape[2])\n model.fit(X_train, y_train, epochs=200, verbose=0,\n callbacks=[tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)],\n validation_data=(X_valid, y_valid))\n\n pred_valid = model.predict(X_valid, verbose=0)\n pred_train = model.predict(X_train, verbose=0)\n\n tmp = []\n for j, col in enumerate(self.df.columns):\n tmp.append({col: {'rmse_train': sqrt(mean_squared_error([y_train[i][0][j] for i in range(0, len(y_train))],\n [pred_train[i][0][j] for i in\n range(0, len(pred_train))])),\n 'rmse_val': sqrt(mean_squared_error([y_valid[i][0][j] for i in range(0, len(y_valid))],\n [pred_valid[i][0][j] for i in\n range(0, len(pred_valid))])),\n 'mae_train': mean_absolute_error([y_train[i][0][j] for i in range(0, len(y_train))],\n [pred_train[i][0][j] for i in\n range(0, len(pred_train))]),\n 'mae_val': mean_absolute_error([y_valid[i][0][j] for i in range(0, len(y_valid))],\n [pred_valid[i][0][j] for i in range(0, len(pred_valid))]),\n 'mape_train': f'{self.mean_absolute_percentage_error([y_train[i][0][j] for i in range(0, len(y_train))], [pred_train[i][0][j] for i in range(0, len(pred_train))])} %',\n 'mape_val': f'{self.mean_absolute_percentage_error([y_valid[i][0][j] for i in range(0, len(y_valid))], [pred_train[i][0][j] for i in range(0, len(pred_valid))])} %'}})\n\n return tmp","def runStats(df):\n\tpass","def error_data(url):\n \n idr = id_from_url(url)\n xml = get_poll_lxml(idr)\n \n colors = plot_colors(xml)\n if len(colors) == 0:\n return pd.DataFrame()\n \n df = rcp_poll_data(xml)\n result = race_result(url)\n \n #remove non-letter characters from columns\n df = df.rename(columns={c: _strip(c) for c in df.columns})\n for k, v in list(result.items()):\n result[_strip(k)] = v \n \n candidates = [c for c in df.columns if c is not 'date']\n \n #turn into a timeseries...\n df.index = df.date\n \n #...so that we can resample at regular, daily intervals\n df = df.resample('D',convention='start').asfreq()\n df = df.dropna()\n \n #compute forecast length in days\n #(assuming that last forecast happens on the day of the election, for simplicity)\n forecast_length = (df.date.max() - df.date).values\n forecast_length = forecast_length / np.timedelta64(1, 'D') # convert to number of days\n \n #compute forecast error\n errors = {}\n normalized = {}\n poll_lead = {}\n\n \n for c in candidates:\n #turn raw percentage into percentage of poll votes\n \n corr = (df[c].astype('float64') / df[candidates].astype('float64').sum(axis=1))*100.\n \n err = corr - result[_strip(c)]\n \n \n normalized[c] = corr\n errors[c] = err\n \n n = forecast_length.size\n \n result = {}\n result['percentage'] = np.hstack(normalized[c] for c in candidates)\n result['error'] = np.hstack(errors[c] for c in candidates)\n result['candidate'] = np.hstack(np.repeat(c, n) for c in candidates)\n result['party'] = np.hstack(np.repeat(party_from_color(colors[_strip(c)]), n) for c in candidates)\n result['forecast_length'] = np.hstack(forecast_length for _ in candidates)\n \n result = pd.DataFrame(result)\n \n return result","def test_non_pd_type_error(self):\n\n df = d.create_df_1()\n\n x = BaseTransformer(columns=\"a\")\n\n with pytest.raises(ValueError):\n\n x.fit(X=df, y=[1, 2, 3, 4, 5, 6])","def makedata():\n # train\n print('Clean Train Dataset and separate questions')\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\n t = df.shape[0] * 2\n print t\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\n # test\n\n print('Clean Test Dataset and separate questions')\n df = pd.read_csv(TEST_DATASET).fillna(' ')\n t1 = df.shape[0] * 2\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\n\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\n print len(overallquestions), t1 + t","def evaluate_old(self, start=0):\n\n if self.valmode and self.nests > 0:\n # evaluate using the old nesting scheme devised by Noah\n # this section is deprecated and should be deleted\n\n log.info('Evaluating nested validation data')\n mse_idx = ut.utils.find_modules(self, 'metrics.mean_square_error')\n mse_idx = int(mse_idx[0])\n try:\n xval_idx = ut.utils.find_modules(self, 'est_val.crossval')[0]\n except BaseException:\n xval_idx = 1\n\n if start > xval_idx:\n start = xval_idx\n for ii in range(start, xval_idx + 1):\n self.modules[ii].evaluate()\n\n start = xval_idx + 1\n for ii in range(start, mse_idx):\n for cv_counter in range(0, self.nests):\n log.info(\"Eval %d in valmode, nest=%d\", cv_counter, ii)\n st = 0\n for m in self.fitted_modules:\n phi_old = self.modules[m].parms2phi()\n s = phi_old.shape\n self.modules[m].phi2parms(\n self.parm_fits[cv_counter][st:(st + np.prod(s))])\n st += np.prod(s)\n self.modules[ii].evaluate(nest=cv_counter)\n ut.utils.concatenate_helper(\n self, start=xval_idx + 1, end=mse_idx + 1)\n\n for ii in range(mse_idx, len(self.modules)):\n self.modules[ii].evaluate()\n\n elif self.valmode and self.meta['nests'] > 0:\n # new nested eval, doesn't require special evaluation procedure\n # by modules. instead, all the remapping and collecting of val\n # data from each nest handled inside this evaluation function.\n\n # 2017-09-08- still something not quite right.\n # 2017-10-06- working finally. this is new norm for cross-val\n stack = self\n\n try:\n xval_idx = ut.utils.find_modules(stack, 'est_val.crossval')[0]\n except BaseException:\n xval_idx = 1\n\n try:\n mse_idx = ut.utils.find_modules(\n stack, 'metrics.mean_square_error')\n mse_idx = int(mse_idx[0])\n except BaseException:\n mse_idx = len(self.modules)\n\n log.info(\"Evaluating nested validation data: xvidx={0} mseidx={1}\"\n .format(xval_idx, mse_idx))\n\n # evaluate up to xval module (if necessary)\n if start > xval_idx:\n start = xval_idx\n for ii in range(start, xval_idx):\n log.info(\"eval {0} in valmode\".format(ii))\n stack.modules[ii].evaluate()\n\n # go through each nest and evaluate stack, saving data stack to\n # a placeholder (d_save). copy all keys from data stack except\n # known metadata listed in exclude_keys. this allows for arbitrary\n # new data elements to be created (stim2, etc)\n exclude_keys = ['avgresp', 'poststim', 'fs', 'isolation', 'stimparam', 'filestate',\n 'prestim', 'duration', 'est', 'stimFs', 'respFs',\n 'resp_raw', 'pupil_raw']\n include_keys = {}\n d_save = {}\n for cv_counter in range(0, stack.meta['nests']):\n # for cv_counter in range(0,1):\n stack.meta['cv_counter'] = cv_counter\n\n # load in parameters for appropriate nested fit\n st = 0\n for midx in stack.fitted_modules:\n phi_old = stack.modules[midx].parms2phi()\n s = phi_old.shape\n # stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st+np.prod(s))])\n stack.modules[midx].phi2parms(\n stack.parm_fits[cv_counter][st:(st + np.prod(s))])\n st += np.prod(s)\n\n # evaluate stack for this nest up to before error metric\n # modules\n for ii in range(xval_idx, mse_idx):\n log.info(\"nest={0}, eval {1} in valmode\"\n .format(cv_counter, ii))\n stack.modules[ii].evaluate()\n\n # append data from this (nest,module) onto d_save\n # placeholders:\n if cv_counter == 0:\n include_keys[ii] = stack.modules[ii].d_out[0].keys(\n ) - exclude_keys\n d_save[ii] = copy.deepcopy(stack.modules[ii].d_out)\n log.info(include_keys[ii])\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\n if not d['est'] and cv_counter > 0:\n for k in include_keys[ii]:\n if d[k] is None or d[k] == []:\n pass\n elif k == 'pupil' and d[k].ndim == 3 and d['resp'].shape[1] != d[k].shape[1]:\n d2[k] = np.append(d2[k], d[k], axis=2)\n elif d[k].ndim == 3:\n d2[k] = np.append(d2[k], d[k], axis=1)\n else:\n d2[k] = np.append(d2[k], d[k], axis=0)\n\n # save accumulated data stack back to main data stack\n\n # figure out mapping to get val data back into original order\n for ii in range(xval_idx, mse_idx):\n jj = -1\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\n if not d['est']:\n jj += 1 # count validation files only\n validx = np.concatenate(\n stack.modules[xval_idx].validx_sets[jj])\n mapidx = np.argsort(validx)\n for k in include_keys[ii]:\n if d2[k] is None or d[k] == []:\n d[k] = d2[k]\n elif k == 'pupil' and d[k].ndim == 3 and d2['resp'].shape[1] != d2[k].shape[1]:\n d[k] = d2[k][:, :, mapidx]\n elif d[k].ndim == 3:\n d[k] = d2[k][:, mapidx, :]\n elif d[k].ndim == 2:\n d[k] = d2[k][mapidx, :]\n else:\n d[k] = d2[k][mapidx]\n\n # continue standard evaluation of later stack elements\n for ii in range(mse_idx, len(self.modules)):\n log.info(\"eval {0} in valmode\".format(ii))\n self.modules[ii].evaluate()\n\n else:\n # standard evaluation when not using nested cross-validation\n for ii in range(start, len(self.modules)):\n self.modules[ii].evaluate()","def evaluate(model, df_result, label='test'):\n\n y_true = df_result['RUL']\n y_hat = df_result['y_hat']\n df_result['breakdown'].replace(0, False, inplace=True) # rsf only takes true or false\n df_result['breakdown'].replace(1, True, inplace=True) # rsf only takes true or false\n\n mse = mean_squared_error(y_true, y_hat)\n rmse = np.sqrt(mse)\n variance = r2_score(y_true, y_hat)\n\n # the concordance index (CI) is interested on the order of the predictions, not the predictions themselves\n # CI can only be measured between individual samples where a censoring or failure event occurred\n # https://medium.com/analytics-vidhya/concordance-index-72298c11eac7#:~:text=The%20concordance%20index%20or%20c,this%20definition%20mean%20in%20practice\n df_result_grouped = df_result.groupby('unit num').last()\n breakdown = df_result_grouped['breakdown']\n y_true = df_result_grouped['RUL']\n y_hat = df_result_grouped['y_hat']\n ci_sk = ci_scikit(breakdown, y_true, y_hat)[0]\n score = nasaScore(y_true, y_hat) # score should be based on the last instance\n # print(f'Number of concordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[1]}')\n # print(f'Number of discordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[2]}')\n # print(f'Number of pairs having tied estimated risks (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[3]}')\n # print(f'Number of comparable pairs sharing the same time (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[4]}')\n print('{} set RMSE:{:.2f}, Score:{:.2f}, CI(scikit):{:.4f}, R2:{:.2f}'.format(label, rmse, score, ci_sk, variance))\n result = [model, label, rmse, score, ci_sk, variance]\n return result","def sanity_checks(df: pd.DataFrame) -> None:\n df_temp = df.copy()\n # checks that the max date is less than tomorrow's date.\n assert datetime.datetime.strptime(df_temp['Date'].max(), '%Y-%m-%d') < (datetime.datetime.utcnow() + datetime.timedelta(days=1))\n # checks that there are no duplicate dates\n assert df_temp['Date'].duplicated().sum() == 0, 'One or more rows share the same date.'\n if 'Cumulative total' not in df_temp.columns:\n df_temp['Cumulative total'] = df_temp['Daily change in cumulative total'].cumsum()\n # checks that the cumulative number of tests on date t is always greater than the figure for t-1:\n assert (df_temp['Cumulative total'].iloc[1:] >= df_temp['Cumulative total'].shift(1).iloc[1:]).all(), \"On one or more dates, `Cumulative total` is greater on date t-1.\"\n # df.iloc[1:][df['Cumulative total'].iloc[1:] < df['Cumulative total'].shift(1).iloc[1:]]\n # cross-checks a sample of scraped figures against the expected result.\n assert len(sample_official_data) > 0\n for dt, d in sample_official_data:\n val = df_temp.loc[df_temp['Date'] == dt, SERIES_TYPE].squeeze().sum()\n assert val == d[SERIES_TYPE], f\"scraped value ({val:,d}) != official value ({d[SERIES_TYPE]:,d}) on {dt}\"\n return None","def place_evaluation_data(self):\n monthly_data = self.Scenario.get('monthly_data')\n time_series = self.Scenario.get('time_series')\n\n if time_series is not None or monthly_data is not None:\n for value_stream in self.value_streams.values():\n value_stream.update_price_signals(monthly_data, time_series)\n\n if 'customer_tariff' in self.Finance:\n self.tariff = self.Finance['customer_tariff']\n\n if 'User' in self.value_streams.keys():\n self.update_with_evaluation(self.value_streams['User'], self.valuestream_values['User'], self.verbose)\n\n for der_inst in self.ders:\n der_tag = der_inst.tag\n der_id = der_inst.id\n evaluation_inputs = self.ders_values.get(der_tag, {}).get(der_id)\n if evaluation_inputs is not None:\n der_inst.update_for_evaluation(evaluation_inputs)","def evaluate(self, valid_x, valid_y):\n results = self.model.evaluate(valid_x, valid_y, batch_size=self.BATCH_SIZE)\n print(results)\n return results[1:] + [\"NaN\"]","def fit(self):\n self.model = RegressionModel(model_expression=self.model_expression,\n fit_filters=self.filters, predict_filters=self.out_filters,\n ytransform=None, name=self.name)\n\n df = get_data(tables = self.tables,\n filters = self.filters,\n model_expression = self.model_expression)\n \n results = self.model.fit(df)\n \n self.name = self._generate_name()\n self.summary_table = str(results.summary())\n print(self.summary_table)\n \n # We don't strictly need to save the fitted parameters, because they are also\n # contained in the urbansim.models.RegressionModel() sub-object. But maintaining\n # a parallel data structure to other templates will make it easier to refactor the\n # code later on to not rely on RegressionModel any more. \n \n self.fitted_parameters = results.params.tolist()\n self.residuals = results.resid","def _eval_classifier(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\n try:\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\n except ValueError:\n auc_baseline = \"NA\"\n\n precision_sample = precision_score(y_label_sample, y_pred_sample)\n recall_sample = recall_score(y_label_sample, y_pred_sample)\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\n f1_sample = f1_score(y_label_sample, y_pred_sample)\n try:\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\n except ValueError:\n auc_sample = \"NA\"\n\n metrics_df = pd.DataFrame(\n {\n \"Accuracy\": [acc_baseline, acc_sample],\n \"Precision\": [precision_baseline, precision_sample],\n \"Recall\": [recall_baseline, recall_sample],\n \"F1\": [f1_baseline, f1_sample],\n \"AUC\": [auc_baseline, auc_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def test_create_dataframe(chosen_columns, chosen_url):\n print(\"reading in data\")\n chosen_df = readindata(chosen_columns, chosen_url)\n print(\"checking columns\")\n checkcolumnstest(chosen_columns, chosen_df)\n print(\"checking types\")\n checktypestest(chosen_df)\n print(\"checking for Nan\")\n checkfornan(chosen_df)\n print(\"checking 1 row\")\n checkrowstest(chosen_df)\n return True","def _evaluate(self,\n logits,\n predictions,\n data, evaluation_fn,\n max_eval_batches=None,\n calculate_scores=True,\n write_results=False):\n # counting the evaluation batches\n num_eval_batches = 0\n # logits and predictions from the model\n all_logits = []\n all_predictions = []\n # fetched data that led to the predictions\n # dictionary of {seq_1: [], seq_2: [], target: []}\n all_fetched_data = collections.defaultdict(list)\n try:\n while True:\n # sample predictions\n (fetched_logits,\n fetched_predictions,\n fetched_data) = self._fetch_data_batch(\n logits=logits, predictions=predictions, data=data)\n\n # Cache the data\n all_logits += fetched_logits\n all_predictions += fetched_predictions\n all_fetched_data[\"target\"] += fetched_data[\"target\"]\n\n # break the loop if max_eval_batches is set\n num_eval_batches += 1\n if (max_eval_batches and\n num_eval_batches >= max_eval_batches):\n break\n\n except tf.errors.OutOfRangeError:\n pass\n\n # Evaluate\n scores = None\n if calculate_scores:\n scores = evaluation_fn(\n all_predictions,\n all_fetched_data[\"seq_1\"], # Should be empty\n all_fetched_data[\"seq_2\"], # Should be empty\n all_fetched_data[\"target\"])\n\n if write_results:\n _write_results_to_csv(\n all_logits,\n all_predictions,\n all_fetched_data,\n output_dir=os.path.join(\n self._logdir, RESULTS_CSV_FNAME))\n\n return len(all_predictions), scores","def walkforward_validation(data, test_start_date, test_end_date=None, step_size=15, testsize=15, model='SARIMA'):\n test_start_date = pd.to_datetime(test_start_date)\n current_max_date = test_start_date\n\n modelling_results = pd.DataFrame(columns=['series_name', 'model_type', 'test_start', 'test_end', 'MAE', 'MAPE', 'RMSE'])\n\n if test_end_date is None:\n test_end_date = data.index.max()\n test_end_date = pd.to_datetime(test_end_date)\n else:\n test_end_date = pd.to_datetime(test_end_date)\n\n while current_max_date < test_end_date:\n data.index = pd.to_datetime(data.index)\n iter_data = data[data.index <= current_max_date + timedelta(days=testsize)]\n test, train = test_train_spl(iter_data, testsize=testsize)\n\n if (model.upper() == 'SARIMA') | (model.upper() == 'SARIMAX'):\n print('USING SARIMA MODEL')\n mae, rmse, mape, name, preds, conf_intervals = mod_sarima(train=train, test=test, **arima_model_params)\n elif model.upper() == 'PROPHET':\n print('USING PROPHET MODEL')\n mae, rmse, mape, name, preds, conf_intervals = mod_prophet(train=train, test=test, **prophet_model_params)\n else:\n print('model name not known')\n iter_results = pd.DataFrame({'series_name': name, 'model_type': model, 'test_start': [current_max_date],\n 'test_end': [current_max_date + timedelta(testsize)], 'MAE': [mae], 'MAPE': [mape], 'RMSE': [rmse]})\n modelling_results = modelling_results.append(iter_results, ignore_index=True)\n\n # this line is just for validation of the effect of regressors in the forecast\n preds.to_csv(mod_report_path + arima_model_params['name'] + 'forecast_' + str(current_max_date).replace(':', '')+ '.csv')\n\n current_max_date = current_max_date + timedelta(days=step_size)\n\n return modelling_results","def execute(self, params):\n\n if \"train_df\" in params.keys():\n self.train_df = params[\"train_df\"]\n if \"test_df\" in params.keys():\n self.test_df = params[\"test_df\"]\n if \"cat_cols\" in params.keys():\n self.cat_cols = params[\"cat_cols\"]\n if \"replace_cat_nulls\" in params.keys():\n self.replace_cat_nulls = params[\"replace_cat_nulls\"]\n if \"drop_cols\" in params.keys():\n self.drop_cols = params[\"drop_cols\"]\n if \"fill_missing\" in params.keys():\n self.fill_missing = params[\"fill_missing\"]\n if \"fill_values\" in params.keys():\n self.fill_values = params[\"fill_values\"]\n\n self.__validate_input()\n\n self.__categoricalnull()\n if self.drop_cols is not None:\n (\n self.train_df,\n self.test_df,\n ) = self.__drop_column_with_null_values()\n\n if self.fill_missing is not None:\n if \"mean\" in self.fill_missing.keys():\n self.train_df, self.test_df = self.__fill_missing_with_mean(\n self.fill_missing[\"mean\"]\n )\n if \"median\" in self.fill_missing.keys():\n self.train_df, self.test_df = self.__fill_missing_with_median(\n self.fill_missing[\"median\"]\n )\n\n if self.fill_values is not None:\n self.train_df, self.test_df = self.__fill_values_columns()\n\n (\n self.final_train,\n self.final_test,\n ) = self.__drop_all_rows_with_null_values()\n\n params[\"train_df\"] = self.final_train\n params[\"test_df\"] = self.final_test","def convert_to_data_frame(result, exp_name, nets, critic, loss, seed):\n label = \"{}, {}, {}\".format(nets, critic, loss)\n rows = list(\n zip(\n itertools.repeat(exp_name),\n itertools.repeat(nets),\n itertools.repeat(critic),\n itertools.repeat(loss),\n itertools.repeat(seed),\n result.iterations,\n [-loss for loss in result.testing_losses], # Loss -> bound.\n result.classification_accuracies,\n itertools.repeat(label)))\n df_eval = pd.DataFrame(\n rows,\n columns=(\"exp_name\", \"nets\", \"Critic\", \"Estimator\",\n \"run\", \"iteration\", \"bound_value\", \"accuracy\", \"label\"))\n\n df_eval[\"Estimator\"] = df_eval[\"Estimator\"].replace(\n to_replace={\n \"cpc\": \"$CPC$\",\n \"pcc\": \"$PCC$\",\n \"drfc\": \"$D-RFC$\",\n \"wpc\": \"$WPC$\"\n })\n df_eval[\"Critic\"] = df_eval[\"Critic\"].replace(\n to_replace={\n \"concat\": \"MLP\",\n \"separable\": \"Separable\",\n \"innerprod\": \"Inner product\",\n \"bilinear\": \"Bilinear\"\n })\n return df_eval","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def _get_consent_validation_dataframe(self, sql_template):\n if not self.db_conn:\n raise (EnvironmentError, 'No active DB connection object')\n\n df = pandas.DataFrame()\n for consent_int in CONSENTS_LIST:\n sql = sql_template\n # The tuple retrieved from the CONSENT_PARTICIPANT_SUMMARY_FIELDS dict has two elements like:\n # ('consent_for_study_enrollment', 'consent_for_study_enrollment_first_yes_authored')\n consent_status_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][0]\n consent_authored_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][1]\n sql = sql.format_map(SafeDict(consent_type=consent_int,\n status_field=consent_status_field,\n authored_field=consent_authored_field,\n missing_check_mark=ConsentOtherErrors.MISSING_CONSENT_CHECK_MARK,\n non_va_for_va=ConsentOtherErrors.NON_VETERAN_CONSENT_FOR_VETERAN,\n va_for_non_va=ConsentOtherErrors.VETERAN_CONSENT_FOR_NON_VETERAN\n ))\n consent_df = pandas.read_sql_query(sql, self.db_conn)\n # Replace any null values in the calculated error flag columns with (uint8 vs. pandas default float) zeroes\n for error_type in TRACKED_CONSENT_ERRORS:\n consent_df = consent_df.fillna({error_type: 0}).astype({error_type: 'uint8'})\n\n df = df.append(consent_df)\n\n # Temporary? Attempt to filter false positives for va_consent_for_non_va consent version errors out of the\n # generated dataframe\n df = self._remove_potential_false_positives_for_consent_version(df)\n\n return df","def run(self):\n\t\tself.print_header_information()\n\n\t\t#self.get_number_of_instances_from_user()\n\n\t\t#self.compile_dataframe(self.number_of_instances)\n\n\t\tprint \"\\n{}\".format(self.data)\n\n\t\t# Uncomment these lines for debugging\n\t\tself.compile_dataframe_default()\n\t\t# print \"\\n{}\".format(self.data)\n\n\t\tself.analysis_of_dataframe(self.data)","def get_datadfs(self, recal=True):\n\n # those files contain score >1\n trn_fname = os.path.join(self.save_dir, 'reg_trn_set_df.csv')\n val_fname = os.path.join(self.save_dir, 'reg_val_set_df.csv')\n tst_fname = os.path.join(self.save_dir, 'reg_tst_set_df.csv')\n\n if os.path.exists(trn_fname) and os.path.exists(val_fname) and os.path.exists(tst_fname) and not recal:\n logging.info('reading...\\n{}\\n{}\\n{}'.format(trn_fname, val_fname, tst_fname))\n trn_set_df = pd.read_csv(trn_fname, sep='\\t')\n val_set_df = pd.read_csv(val_fname, sep='\\t')\n tst_set_df = pd.read_csv(tst_fname, sep='\\t')\n else:\n # read phage and bact relation file\n data_meta_info_f = self.config['data_meta_info']\n if not os.path.exists(data_meta_info_f):\n logging.error('data meta information file not Found. {}'.format(data_meta_info_f))\n raise FileNotFoundError('data meta information file not Found')\n data_info = pd.read_csv(data_meta_info_f)\n logging.info('total samples: {}'.format(len(data_info)))\n\n # select specific columns\n sel_cols = 'hostID,phageID,b_Score,phage_bac_name,bac_len,phage_len'.split(',')\n data_info_df = data_info[sel_cols]\n\n # select rows with score > 1\n data_info_sel = data_info_df[data_info_df['b_Score'] > 1].copy()\n data_info_sel.reset_index(drop=True, inplace=True)\n\n b_scores = data_info_sel['b_Score'].values\n b_scores = b_scores.reshape(-1, 1)\n\n # MinMaxScaler()\n mm_scaler = MinMaxScaler()\n mm_scaler.fit(b_scores)\n mm_scaler_fname = os.path.join(self.save_dir, 'minmax_scaler.joblib')\n if os.path.exists(mm_scaler_fname):\n os.remove(mm_scaler_fname)\n dump(mm_scaler, mm_scaler_fname)\n data_info_sel['minmax_bscore'] = np.squeeze(mm_scaler.transform(b_scores))\n\n # StandardScaler()\n ss_scaler = StandardScaler()\n ss_scaler.fit(b_scores)\n ss_scaler_fname = os.path.join(self.save_dir, 'standard_scaler.joblib')\n if os.path.exists(ss_scaler_fname):\n os.remove(ss_scaler_fname)\n dump(ss_scaler, ss_scaler_fname)\n data_info_sel['norm_bscore'] = np.squeeze(ss_scaler.transform(b_scores))\n\n # MaxAbsScaler()\n ma_scaler = MaxAbsScaler()\n ma_scaler.fit(b_scores)\n ma_scaler_fname = os.path.join(self.save_dir, 'maxabs_scaler.joblib')\n if os.path.exists(ma_scaler_fname):\n os.remove(ma_scaler_fname)\n dump(ma_scaler, ma_scaler_fname)\n data_info_sel['maxabs_bscore'] = np.squeeze(ma_scaler.transform(b_scores))\n\n logging.info('number of samples with score > 1 : {}'.format(len(data_info_sel)))\n\n # creat train, validation and test dataset\n # split dataframe, 80% for train , 10% for validation and 10% for test\n trn_set_df, val_set_df, tst_set_df = np.split(data_info_sel.sample(frac=1, random_state=1),\n [int(.7*len(data_info_sel)), int(.85*len(data_info_sel))])\n\n trn_set_df.reset_index(drop=True, inplace=True)\n val_set_df.reset_index(drop=True, inplace=True)\n tst_set_df.reset_index(drop=True, inplace=True)\n\n if os.path.exists(trn_fname):\n os.remove(trn_fname)\n trn_set_df.to_csv(trn_fname, sep='\\t', index=False)\n if os.path.exists(val_fname):\n os.remove(val_fname)\n val_set_df.to_csv(val_fname, sep='\\t', index=False)\n if os.path.exists(tst_fname):\n os.remove(tst_fname)\n tst_set_df.to_csv(tst_fname, sep='\\t', index=False)\n\n logging.info('train sample: {}'.format(len(trn_set_df)))\n logging.info('valid sample: {}'.format(len(val_set_df)))\n logging.info('test sample: {}'.format(len(tst_set_df)))\n\n return trn_set_df, val_set_df, tst_set_df","def task_3():\n threshold = [0.86, 0.87, 0.88, 0.89]\n for t in threshold: \n # Create a list to store the number of iteration that DE converge \n # @ given threshold for p1(5, 40), p2(10, 20), p3(20, 10), p4(40, 5) \n iter_p1 = []\n iter_p2 = [] \n iter_p3 = [] \n iter_p4 = []\n \n # Create a list to store the cost at the end of the DE \n # p1(5, 40), p2(10, 20), p3(20, 10), p4(40, 5)\n cost_p1 = []\n cost_p2 = []\n cost_p3 = []\n cost_p4 = [] \n \n # Run the experiment and record the result for the given threshold\n experiment(t)\n \n # Loop over experiment and record the number of iteration of each set of param\n # for 30 times\n for i in range(30):\n record = experiment(t) # replace the argument with the testing threshold\n iter_p1.append(record[0][0])\n iter_p2.append(record[1][0])\n iter_p3.append(record[2][0])\n iter_p4.append(record[3][0])\n \n cost_p1.append(record[0][1])\n cost_p2.append(record[1][1])\n cost_p3.append(record[2][1])\n cost_p4.append(record[3][1])\n \n # Convert the result into a dictionary then transform it to a pandas DataFrame\n iteration_dict = {\"iteration(5,40)\":iter_p1, \"iteration(10,20)\":iter_p2, \n \"iteration(20,10)\": iter_p3, \"iteration(40,5)\": iter_p4}\n cost_dict = {\"cost(5,40)\": cost_p1, \"cost(10,20)\": cost_p2, \n \"cost(20,10)\": cost_p3, \"cost(40,5)\":cost_p4}\n df_iteration = pd.DataFrame.from_dict(iteration_dict) \n df_iteration.to_csv(\"iteration_\" + str(t) + \".csv\")\n \n df_cost = pd.DataFrame.from_dict(cost_dict)\n df_cost.to_csv(\"cost_\" + str(t) + \".csv\")","def evaluate(self, test_data):\n result = self.model.run(test_data)\n self._save_result(result)","def fit(self, df):\n try:\n df = df.astype(float)\n except Exception:\n raise ValueError(\"Data Cannot Be Converted to Numeric Float\")\n\n y = df.values\n if y.shape[1] == 1:\n y = y.ravel()\n X = date_part(df.index, method=self.datepart_method)\n from autots.models.sklearn import retrieve_regressor\n\n multioutput = True\n if y.ndim < 2:\n multioutput = False\n elif y.shape[1] < 2:\n multioutput = False\n self.model = retrieve_regressor(\n regression_model=self.regression_model,\n verbose=0,\n verbose_bool=False,\n random_seed=2020,\n multioutput=multioutput,\n )\n self.model = self.model.fit(X, y)\n self.shape = df.shape\n return self"],"string":"[\n \"def evaluate_df(self, df):\\n ## Check invariant; model inputs must be subset of df columns\\n var_diff = set(self.var).difference(set(df.columns))\\n if len(var_diff) != 0:\\n raise ValueError(\\n \\\"Model inputs not a subset of given columns;\\\\n\\\"\\n + \\\"missing var = {}\\\".format(var_diff)\\n )\\n\\n df_tmp = df.copy().drop(self.out, axis=1, errors=\\\"ignore\\\")\\n ## Evaluate each function\\n for func in self.functions:\\n ## Concatenate to make intermediate results available\\n df_tmp = concat((df_tmp, func.eval(df_tmp)), axis=1)\\n\\n return df_tmp[self.out]\",\n \"def compute_error(self):\\n \\n self.error = pd.DataFrame()\\n \\n for name in self.conf[\\\"w_sizes\\\"].keys():\\n \\n self.error[f\\\"mae {name}\\\"] = self.predict[[name, \\\"test\\\"]].apply(lambda x: mae(x), axis=1)\\n self.error[f\\\"mape {name}\\\"] = self.predict[[name, \\\"test\\\"]].apply(lambda x: MAPE(x[0], x[1]), axis=1)\\n \\n self.predict['error'] = self.error.filter(like='mae').apply(lambda r: tuple(r), axis=1).apply(np.array)\",\n \"def run(self):\\n\\n # In case there's no exogenous\\n if len(self.demand.columns) == 1:\\n forecast, model, error = self.run_model()\\n best = pd.DataFrame([[forecast, model, error, None]],\\n columns=['forecast', 'model', 'error_predictions','additional_features'])\\n\\n else:\\n # Define external variables to be iteratively included\\n # Possibilities: 'sales', 'marketing', 'macroeconomics', 'stock',...\\n exogenous = self.demand.drop(columns=\\\"y\\\")\\n features_list = list(exogenous.columns)\\n\\n # Build all possible combinations of external features. Order is not relevant\\n features_combinations = []\\n for i in range(1, len(features_list) + 1):\\n features_combinations += list(itertools.combinations(features_list, i))\\n\\n # Create a model per set of external features\\n results = list()\\n for f in features_combinations:\\n forecast, model, error = self.run_model(additional_features=f)\\n results.append((forecast, model, error, '_'.join(f)))\\n\\n results_df = pd.DataFrame(results)\\n results_df.columns = ['forecast', 'model', 'error_predictions','additional_features']\\n best = self.check_best(results_df)\\n\\n return best.iloc[0], best['error_predictions'].values[0] < self.error_target\",\n \"def _eval_regressor(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n rmse_baseline = self._rmse(y_label_baseline, y_pred_baseline)\\n mae_baseline = mean_absolute_error(y_label_baseline, y_pred_baseline)\\n r2_baseline = r2_score(y_label_baseline, y_pred_baseline)\\n\\n rmse_sample = self._rmse(y_label_sample, y_pred_sample)\\n mae_sample = mean_absolute_error(y_label_sample, y_pred_sample)\\n r2_sample = r2_score(y_label_sample, y_pred_sample)\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"RMSE\\\": [rmse_baseline, rmse_sample],\\n \\\"MAE\\\": [mae_baseline, mae_sample],\\n \\\"R2\\\": [r2_baseline, r2_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def evaluated_data(self) -> Dict:\\n if not self.eval_data:\\n raise Exception(\\\"Evaluation Failed\\\")\\n\\n statistics = [stat['statistics'] for stat in self.eval_data]\\n for count, stat in enumerate(statistics):\\n if stat:\\n eval_data = stat.split(\\\"=\\\")\\n char_error = re.findall(r\\\"\\\\d+\\\\.\\\\d+\\\", eval_data[-2])[0]\\n word_error = eval_data[-1]\\n\\n self.eval_data[count]['character_error'] = float(char_error)\\n self.eval_data[count]['word_error'] = float(word_error)\\n del self.eval_data[count]['statistics']\\n\\n return self.eval_data\",\n \"def evaluate(self, dataset):\\n\\t\\tpass\",\n \"def run_test(self):\\n self.output_analytics = self.run_inference()\\n self.output_df = pd.DataFrame(self.output_analytics)\",\n \"def calc(self) -> pd.DataFrame:\\n raise NotImplementedError\",\n \"def evaluate():\\n log.info('Loading dev data...')\\n if args.version_2:\\n dev_data = SQuAD('dev', version='2.0')\\n else:\\n dev_data = SQuAD('dev', version='1.1')\\n (_, _), (data_file_name, _) \\\\\\n = dev_data._data_file[dev_data._version][dev_data._segment]\\n dev_data_path = os.path.join(dev_data._root, data_file_name)\\n\\n if args.debug:\\n sampled_data = [dev_data[0], dev_data[1], dev_data[2]]\\n dev_data = mx.gluon.data.SimpleDataset(sampled_data)\\n log.info('Number of records in dev data: %d', len(dev_data))\\n\\n dev_data_features = preprocess_dataset(\\n tokenizer, dev_data, vocab=vocab, max_seq_length=args.max_seq_length,\\n doc_stride=args.doc_stride, num_workers=args.num_workers,\\n max_query_length=args.max_query_length, load_from_pickle=args.load_pickle,\\n feature_file=args.dev_dataset_file)\\n\\n dev_data_input = convert_full_features_to_input_features(dev_data_features)\\n log.info('The number of examples after preprocessing: %d', len(dev_data_input))\\n\\n dev_dataloader = mx.gluon.data.DataLoader(dev_data_input, batchify_fn=batchify_fn,\\n num_workers=4, batch_size=args.test_batch_size,\\n shuffle=False, last_batch='keep')\\n\\n log.info('start prediction')\\n\\n all_results = collections.defaultdict(list)\\n\\n epoch_tic = time.time()\\n total_num = 0\\n for (batch_id, data) in enumerate(dev_dataloader):\\n data_list = list(split_and_load(data, ctx))\\n for splited_data in data_list:\\n example_ids, inputs, token_types, valid_length, p_mask, _, _, _ = splited_data\\n total_num += len(inputs)\\n outputs = net_eval(inputs, token_types, valid_length, p_mask=p_mask)\\n example_ids = example_ids.asnumpy().tolist()\\n for c, example_ids in enumerate(example_ids):\\n result = RawResultExtended(start_top_log_probs=outputs[0][c].asnumpy().tolist(),\\n start_top_index=outputs[1][c].asnumpy().tolist(),\\n end_top_log_probs=outputs[2][c].asnumpy().tolist(),\\n end_top_index=outputs[3][c].asnumpy().tolist(),\\n cls_logits=outputs[4][c].asnumpy().tolist())\\n all_results[example_ids].append(result)\\n if batch_id % args.log_interval == 0:\\n log.info('Batch: %d/%d', batch_id + 1, len(dev_dataloader))\\n\\n epoch_toc = time.time()\\n log.info('Time cost=%2f s, Thoughput=%.2f samples/s', epoch_toc - epoch_tic,\\n total_num / (epoch_toc - epoch_tic))\\n\\n log.info('Get prediction results...')\\n\\n all_predictions = collections.OrderedDict()\\n all_nbest_json = collections.OrderedDict()\\n scores_diff_json = collections.OrderedDict()\\n for features in dev_data_features:\\n results = all_results[features[0].example_id]\\n example_qas_id = features[0].qas_id\\n score_diff, best_non_null_entry, nbest_json = predict_extended(\\n features=features, results=results, n_best_size=args.n_best_size,\\n max_answer_length=args.max_answer_length, start_n_top=args.start_top_n,\\n end_n_top=args.end_top_n)\\n scores_diff_json[example_qas_id] = score_diff\\n all_predictions[example_qas_id] = best_non_null_entry\\n all_nbest_json[example_qas_id] = nbest_json\\n\\n output_prediction_file = os.path.join(args.output_dir, 'predictions.json')\\n output_nbest_file = os.path.join(args.output_dir, 'nbest_predictions.json')\\n output_null_log_odds_file = os.path.join(args.output_dir, 'null_odds.json')\\n\\n with open(output_prediction_file, 'w') as writer:\\n writer.write(json.dumps(all_predictions, indent=4) + '\\\\n')\\n with open(output_nbest_file, 'w') as writer:\\n writer.write(json.dumps(all_nbest_json, indent=4) + '\\\\n')\\n with open(output_null_log_odds_file, 'w') as writer:\\n writer.write(json.dumps(scores_diff_json, indent=4) + '\\\\n')\\n\\n if os.path.exists(sys.path[0] + '/evaluate-v2.0.py'):\\n arguments = [\\n dev_data_path, output_prediction_file, '--na-prob-thresh',\\n str(args.null_score_diff_threshold)\\n ]\\n if args.version_2:\\n arguments += ['--na-prob-file', output_null_log_odds_file]\\n subprocess.call([sys.executable, sys.path[0] + '/evaluate-v2.0.py'] + arguments)\\n else:\\n log.info('Please download evaluate-v2.0.py to get evaluation results for SQuAD. '\\n 'Check index.rst for the detail.')\",\n \"def evaluate(directory: str,\\n y_hat: Union[pd.DataFrame, str],\\n validation: bool = False) -> pd.DataFrame:\\n if isinstance(y_hat, str):\\n y_hat = M5Evaluation.load_benchmark(directory, y_hat, validation)\\n\\n M5.download(directory)\\n path = f'{directory}/m5/datasets'\\n if validation:\\n weights = pd.read_csv(f'{path}/weights_validation.csv')\\n sales = pd.read_csv(f'{path}/sales_train_vaidation.csv')\\n y_test = pd.read_csv(f'{path}/sales_test_vaidation.csv')\\n else:\\n weights = pd.read_csv(f'{path}/weights_evaluation.csv')\\n sales = pd.read_csv(f'{path}/sales_train_evaluation.csv')\\n y_test = pd.read_csv(f'{path}/sales_test_evaluation.csv')\\n\\n # sales\\n sales = M5Evaluation.aggregate_levels(sales)\\n def scale(x):\\n x = x.values\\n x = x[np.argmax(x!=0):]\\n scale = ((x[1:] - x[:-1]) ** 2).mean()\\n return scale\\n scales = sales.agg(scale, 1).rename('scale').reset_index()\\n\\n # y_test\\n y_test = M5Evaluation.aggregate_levels(y_test)\\n\\n #y_hat\\n y_hat = M5Evaluation.aggregate_levels(y_hat)\\n\\n score = (y_test - y_hat) ** 2\\n score = score.mean(1)\\n score = score.rename('rmse').reset_index()\\n score = score.merge(weights, how='left',\\n on=['Level_id', 'Agg_Level_1', 'Agg_Level_2'])\\n score = score.merge(scales, how='left',\\n on=['Level_id', 'Agg_Level_1', 'Agg_Level_2'])\\n score['wrmsse'] = (score['rmse'] / score['scale']).pow(1 / 2) * score['weight']\\n score = score.groupby('Level_id')[['wrmsse']].sum()\\n score = score.loc[M5Evaluation.levels.keys()]\\n total = score.mean().rename('Total').to_frame().T\\n score = pd.concat([total, score])\\n\\n return score\",\n \"def validate(self):\\n self.set_model_mode('eval')\\n self.evaluator.reset()\\n losses = MetricMeter()\\n\\n print('Do evaluation on {} set'.format('valid set'))\\n data_loader = self.val_loader\\n assert data_loader is not None\\n for batch_idx, batch in enumerate(data_loader):\\n input, label = self.parse_batch_test(batch)\\n loss = self.forward_backward(batch, backprob=False)\\n losses.update(loss)\\n # total_loss += loss['loss']\\n output = self.model_inference(input)\\n self.evaluator.process(output, label)\\n\\n results = self.evaluator.evaluate()\\n total_loss = losses.meters['loss_x'].avg\\n\\n for k, v in results.items():\\n tag = '{}/{}'.format('validation', k)\\n self.write_scalar(tag, v, self.epoch)\\n # if full_results:\\n return [total_loss,losses.dict_results(),results]\\n # return total_loss\",\n \"def _fit(self, df):\\n return df\",\n \"def fit_evalute_fn(df, fn_string, symbols):\\n fn = process_fn(fn_string, symbols)\\n\\n rmse, y_pred, y_true, c = test_fn(df, fn)\\n return rmse, y_pred, y_true, c\",\n \"def eval(self, df):\\n ## Check invariant; model inputs must be subset of df columns\\n if not set(self.var).issubset(set(df.columns)):\\n raise ValueError(\\n \\\"Model function `{}` var not a subset of given columns\\\".format(\\n self.name\\n )\\n )\\n\\n ## Set up output\\n n_rows = df.shape[0]\\n results = zeros((n_rows, len(self.out)))\\n\\n for ind in range(n_rows):\\n results[ind] = self.func(*df.loc[ind, self.var])\\n\\n ## Package output as DataFrame\\n return DataFrame(data=results, columns=self.out)\",\n \"def test_y_multi_col_df_error(self):\\n\\n df = d.create_df_1()\\n\\n x = BaseTransformer(columns=\\\"a\\\")\\n\\n with pytest.raises(ValueError):\\n\\n x.fit(X=df, y=df)\",\n \"def Evaluate():\\n global reg\\n reg = ModelRegression()\\n \\n # Retrieve dataset files\\n data_fls, ref_fls = LoadTroikaDataset()\\n errs, confs = [], []\\n for data_fl, ref_fl in zip(data_fls, ref_fls):\\n # Run the pulse rate algorithm on each trial in the dataset\\n errors, confidence = RunPulseRateAlgorithm(data_fl, ref_fl)\\n errs.append(errors)\\n confs.append(confidence)\\n # Compute aggregate error metric\\n errs = np.hstack(errs)\\n confs = np.hstack(confs)\\n return AggregateErrorMetric(errs, confs)\",\n \"def run():\\n\\n import matplotlib.pyplot as plt\\n\\n anomalies_t = []\\n anomalies_v = []\\n anomalies_c = []\\n\\n all_t = []\\n all_v = []\\n\\n rows = []\\n for i, row in dataSet.iterrows():\\n\\n inputData = row.to_dict()\\n\\n detectorValues = handleRecord(inputData)\\n\\n if (detectorValues[0] > 0.65):\\n anomalies_t.append(inputData[\\\"timestamp\\\"])\\n anomalies_v.append(inputData[\\\"value\\\"])\\n anomalies_c.append(detectorValues[0])\\n\\n all_t.append(inputData[\\\"timestamp\\\"])\\n all_v.append(inputData[\\\"value\\\"])\\n\\n outputRow = list(row) + list(detectorValues)\\n\\n rows.append(outputRow)\\n\\n # Progress report\\n if (i % 1000) == 0:\\n print \\\".\\\",\\n sys.stdout.flush()\\n\\n fig, ax = plt.subplots()\\n\\n ax.plot(all_t, all_v)\\n ax.plot(anomalies_t, anomalies_v, 'ro')\\n\\n plt.show()\\n\\n ans = pandas.DataFrame(rows)\\n return ans\",\n \"def eval(self, df):\\n df_res = self.func(df)\\n return df_res[self.out]\",\n \"def eval(self, df):\\n return self.ev(self.model, df)\",\n \"def clean_qa_data(df) -> pd.DataFrame:\\n date_column = \\\"sample date\\\"\\n # The final table column names and corresponding types\\n column_names = [date_column, \\\"gene\\\", \\\"stdev/avg\\\", \\\"single 1\\\", \\\"single 2\\\", \\\"single 3\\\", \\\"single 4\\\", \\\"single 5\\\", \\\"single 6\\\", \\\"avg\\\", \\\"stdev\\\", \\\"unit\\\"]\\n column_types = [\\\"date\\\", \\\"text\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"number\\\", \\\"text\\\"]\\n # Drop any row where all columns in drop_ifna are None\\n drop_ifna = [\\\"single 1\\\", \\\"single 2\\\", \\\"single 3\\\", \\\"single 4\\\", \\\"single 5\\\", \\\"single 6\\\"]\\n\\n # The lab sheet has 6 tables, arranged in a 2x3 (v x h) grid, split them up and stack them into a single table\\n # Each new table begins with the a column named date_column, split into 3 tables\\n splits = [idx for idx in range(len(df.columns)) if df.columns[idx].lower().startswith(date_column)]\\n splits.append(len(df.columns))\\n tables = [df[df.columns[splits[i]:splits[i+1]]].copy() for i in range(len(splits)-1)]\\n\\n # Horizontally, the three tables are for \\\"gcPMMoV\\\", \\\"gcGs\\\", and\\\"gcL\\\".\\n for table, unit in zip(tables, [\\\"gcPMMoV\\\", \\\"gcGs\\\", \\\"gcL\\\"]):\\n table.columns = column_names\\n table[date_column] = pd.to_datetime(table[date_column], errors=\\\"coerce\\\")\\n table.dropna(subset=[date_column], inplace=True)\\n\\n table[drop_ifna] = table[drop_ifna].applymap(lambda x: float(x) if (isinstance(x, float) and not math.isnan(x)) else None)\\n # applymap (from above) will sometimes force a None object into a float(\\\"nan\\\"), so set them as None here\\n table[drop_ifna] = table[drop_ifna].where(pd.notnull(table[drop_ifna]), None)\\n\\n table.dropna(subset=[\\\"single 1\\\", \\\"single 2\\\", \\\"single 3\\\", \\\"single 4\\\", \\\"single 5\\\", \\\"single 6\\\"], how=\\\"all\\\", inplace=True)\\n table[\\\"unit\\\"] = unit\\n\\n # Merge tables\\n df = pd.concat(tables, axis=0)\\n\\n # Add the types column (ie. date, text, number)\\n df.loc[-1] = column_types\\n df.index = df.index + 1\\n df = df.sort_index()\\n df.index = list(range(len(df.index)))\\n\\n return df\",\n \"def evaluate(self):\\n # define start index test set\\n start_test_set = int(len(self.X) * 2 / 3)\\n\\n # Different methods for cummulativa vs day-ahead forecasting\\n if self.forecast_horizon == 1:\\n # In sample\\n lin_residuals_in_sample = self.y - (self.betas[0] + np.dot(self.X, self.betas[1]))\\n self.rmse_in_sample = np.mean(lin_residuals_in_sample ** 2) ** 0.5\\n self.var_in_sample = np.var(self.y)\\n\\n # Out of sample\\n # Calculate MSE of wls-ev prediction\\n self.mse_wlsev = np.mean((self.y[start_test_set:] - self.ols_predict()) ** 2)\\n # Calculate MSE of benchmark prediction\\n self.mse_benchmark = np.mean((self.y[start_test_set:] - self.benchmark_predict()) ** 2)\\n else:\\n # In Sample with betas estimated on full time series\\n lin_residuals_in_sample = rolling_sum(self.y, self.forecast_horizon) - (\\n self.betas[0] + np.dot(self.X[:-(self.forecast_horizon-1)], self.betas[1]))\\n self.rmse_in_sample = np.mean(lin_residuals_in_sample ** 2) ** 0.5\\n self.var_in_sample = np.var(rolling_sum(self.y, self.forecast_horizon))\\n\\n # Out of sample\\n # calculate realized cummulative returns over forecast horizon sequences\\n cum_rets_realized = rolling_sum(self.y[start_test_set:], self.forecast_horizon)\\n # Calculate MSE of wls-ev prediction, only where realized values are available\\n self.mse_wlsev = np.mean((cum_rets_realized - self.ols_predict()[:-(self.forecast_horizon-1)]) ** 2)\\n # Calculate MSE of benchmark prediction, only where realized values are available\\n self.mse_benchmark = np.mean(\\n (cum_rets_realized - self.benchmark_predict()[:-(self.forecast_horizon-1)]) ** 2)\\n\\n # Calculate out of sample r-squared\\n self.oos_r_squared = 1 - (self.mse_wlsev / self.mse_benchmark)\\n # Calculate in sample r-squared\\n self.in_sample_r_squared = 1.0 - (self.rmse_in_sample ** 2) / self.var_in_sample\",\n \"def _evaluate_model(\\n run_id: str, dataset_filename: str, dataset_sampling_column: str = None\\n):\\n fix_multiprocessing_with_keras_on_macos()\\n\\n run = _get_run(run_id)\\n hyperparameters = run.config\\n\\n # no need to run this on a gpu since it's 1 epoch\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = \\\"-1\\\"\\n\\n with ModelBestH5File(run) as model_h5_filepath:\\n model = _load_untrainable_model(hyperparameters, model_h5_filepath)\\n\\n model_name = run.config[\\\"model_name\\\"]\\n x, y = _get_prepared_dataset(\\n model_name, hyperparameters, dataset_filename, dataset_sampling_column\\n )\\n\\n wandb.init(\\n config={\\n \\\"run_id\\\": run_id,\\n \\\"dataset_filename\\\": dataset_filename,\\n \\\"dataset_sampling_column\\\": dataset_sampling_column,\\n },\\n tags=[\\\"model-evaluation\\\"],\\n )\\n\\n batch_size = hyperparameters[\\\"batch_size\\\"]\\n label_scale_factor_mmhg = hyperparameters[\\\"label_scale_factor_mmhg\\\"]\\n acceptable_error_mg_l = hyperparameters[\\\"acceptable_error_mg_l\\\"]\\n acceptable_fraction_outside_error = hyperparameters[\\n \\\"acceptable_fraction_outside_error\\\"\\n ]\\n\\n # we're using fit() instead of evaluate() to get the functionality of these callbacks\\n # training performance in the results should be ignored, as it can be affected by some\\n # training-only layers such as dropout\\n model.fit(\\n x,\\n y,\\n batch_size=batch_size,\\n epochs=1,\\n verbose=2,\\n validation_data=(x, y),\\n callbacks=[\\n ThresholdValMeanAbsoluteErrorOnCustomMetric(\\n acceptable_fraction_outside_error=acceptable_fraction_outside_error,\\n acceptable_error_mg_l=acceptable_error_mg_l,\\n ),\\n WandbCallback(verbose=1, monitor=\\\"val_adjusted_mean_absolute_error\\\"),\\n LogPredictionsAndWeights(\\n metric=\\\"val_adjusted_mean_absolute_error\\\",\\n dataset=([], [], x, y),\\n label_scale_factor_mmhg=label_scale_factor_mmhg,\\n ),\\n ],\\n )\\n\\n # returning model and dataset for use in jupyter notebooks\\n return model, (x, y)\",\n \"def set_data(self):\\n # take care of samples\\n patients = self.samples.iloc[:,1].tolist()\\n samples = self.samples.iloc[:,0].tolist()\\n self.samples = pd.DataFrame(patients,index = samples,columns = ['patient']) # indexed by sample\\n #\\n # take care of expression data\\n cols = self.expression.SYMBOL.tolist() # set new column names to transposed expression_data \\n \\n new_exp = self.expression.T.ix[1:,:] # transpose\\n new_exp.columns = cols\\n self.expression = new_exp # add columns\\n self.data = pd.merge(self.expression,self.samples,left_index = True,right_index=True) # merged data sets\\n #pd.merge(df1,df2,how = 'left',left_index=True,right_index=True) # do a left join\",\n \"def run_and_evaluate():\\n tsp_problems = read_all_problems()\\n # Empty list of metrics\\n results = []\\n for problem in tqdm.tqdm(tsp_problems):\\n # As random factors are involved repeat experiments a couple of times\\n best_routes_base = []\\n best_routes_af = []\\n best_routes_ms = []\\n base_times = []\\n af_times = []\\n ms_times = []\\n for i in range(10):\\n # Base solution\\n start_time = timeit.default_timer()\\n best_route_base = solve_tsp_basic(problem)\\n base_time = timeit.default_timer() - start_time\\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\\n base_times.append(base_time)\\n\\n # AF clustering solution\\n start_time = timeit.default_timer()\\n best_route_af = solve_tsp_affinity_propagation(problem)\\n af_time = timeit.default_timer() - start_time\\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\\n af_times.append(af_time)\\n\\n # MS solution\\n start_time = timeit.default_timer()\\n best_route_ms = solve_mean_shift(problem)\\n ms_time = timeit.default_timer() - start_time\\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\\n ms_times.append(ms_time)\\n\\n results.append(\\n {\\n \\\"problem name\\\": problem.name,\\n \\\"optimal solution\\\": find_route_optimal_route_length(problem),\\n \\\"baseline tour length\\\": mean(best_routes_base),\\n \\\"af clustering tour length\\\": mean(best_routes_af),\\n \\\"ms clustering tour length\\\": mean(best_routes_ms),\\n \\\"baseline algorithm time\\\": mean(base_times),\\n \\\"af clustering algorithm time\\\": mean(af_times),\\n \\\"ms clustering algorithm time\\\": mean(ms_times),\\n }\\n )\\n # Create dataframe and safe results\\n df = pd.DataFrame(results)\\n df.to_csv(\\\"results.csv\\\", index=False)\\n return df\",\n \"def eda_base():\\n ######################################\\n # Missing Values\\n ######################################\\n # cat_cols, num_cols, cat_but_car, num_but_cat = grab_col_names(df)\\n # Observations: 356255\\n # Variables: 122\\n # cat_cols: 15\\n # num_cols: 67\\n # cat_but_car: 1\\n # num_but_cat: 39\\n global train, test, df\\n train = pd.read_csv('datasets/home-credit-default-risk/application_train.csv')\\n test = pd.read_csv('datasets/home-credit-default-risk/application_test.csv')\\n df = train.append(test).reset_index(drop=True)\\n\\n df.isnull().sum()\\n df.isnull().sum().sum() # 10670198\\n df.shape\\n # df.dropna(inplace=True)\\n # msno.matrix(df.sample(250))\\n # plt.show()\\n\\n df = df[df['CODE_GENDER'] != 'XNA']\\n df['DAYS_EMPLOYED'].replace(365243, np.nan, inplace=True)\\n\\n df[df.columns[df.isnull().any()]]\\n\\n cat_cols, num_cols, cat_but_car, num_but_cat = grab_col_names(df)\\n\\n na_cols_cat = [col for col in cat_cols if df[col].isnull().sum() > 0]\\n df[na_cols_cat] = df[na_cols_cat].apply(lambda x: x.fillna(x.mode()), axis=0)\\n\\n na_cols_num = [col for col in num_cols if df[col].isnull().sum() > 0 and \\\"TARGET\\\" not in col]\\n df[na_cols_num] = df[na_cols_num].apply(lambda x: x.fillna(x.median()), axis=0)\\n\\n na_cols_cat_but_car = [col for col in cat_but_car if df[col].isnull().sum() > 0]\\n df[na_cols_cat_but_car] = df[na_cols_cat_but_car].apply(lambda x: x.fillna(x.mode()), axis=0)\\n\\n na_cols_num_but_cat = [col for col in num_but_cat if df[col].isnull().sum() > 0 and \\\"TARGET\\\" not in col]\\n df[na_cols_num_but_cat] = df[na_cols_num_but_cat].apply(lambda x: x.fillna(x.median()), axis=0)\\n\\n df['OCCUPATION_TYPE'] = df['OCCUPATION_TYPE'].fillna(df['OCCUPATION_TYPE'].mode()[0])\\n\\n ######################################\\n # Feature Engineering\\n ######################################\\n\\n #############################################\\n # Outliers\\n #############################################\\n\\n #############################################\\n # Label Encoding\\n #############################################\\n\\n #############################################\\n # Rare Encoding\\n #############################################\\n\\n #############################################\\n # One-Hot Encoding\\n #############################################\\n df = pd.get_dummies(df, dummy_na=True)\\n df.shape\\n #############################################\\n # Standart Scaler\\n #############################################\\n\\n ######################################\\n # Modeling\\n ######################################\\n global train_df, test_df\\n train_df = df[df['TARGET'].notnull()]\\n test_df = df[df['TARGET'].isnull()].drop(\\\"TARGET\\\", axis=1)\\n\\n global X, y, X_train, X_test, y_train, y_test\\n y = train_df[\\\"TARGET\\\"]\\n X = train_df.drop([\\\"SK_ID_CURR\\\", \\\"TARGET\\\"], axis=1)\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)\",\n \"def evaluate(cfg: DictConfig):\\n\\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\\n fixed_t0 = cfg.get('fixed_t0', False)\\n ext = '_fixedT0' if fixed_t0 else ''\\n\\n base_dir = cfg.device.root\\n datasource = cfg.datasource.name\\n\\n if experiments == 'ablations':\\n models = {\\n 'FluxRGNN': ['final',\\n 'final_without_encoder',\\n 'final_without_boundary'],\\n 'LocalLSTM': ['final']\\n }\\n elif experiments == 'final':\\n models = {\\n 'FluxRGNN': ['final'],\\n 'GAM': ['final'],\\n 'HA': ['final'],\\n 'GBT': ['final']\\n }\\n else:\\n m = cfg.model.name\\n year = cfg.datasource.test_year\\n\\n # find all experiments available for this model, datasource and test year\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\\n models = {\\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\\n }\\n\\n\\n # thresholds for binary classification metrics\\n if cfg.datasource.name == 'abm':\\n thresholds = [0.0019, 0.0207]\\n else:\\n thresholds = [0, 10, 20]\\n\\n rmse_per_hour = []\\n mae_per_hour = []\\n pcc_per_hour = []\\n bin_per_hour = []\\n\\n rmse_per_night = []\\n mae_per_night = []\\n\\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\\n os.makedirs(output_dir, exist_ok=True)\\n\\n counter = 0\\n\\n for m, dirs in models.items():\\n print(f'evaluate {m}')\\n\\n for d in dirs:\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\\n\\n # check if directory exists\\n if os.path.isdir(result_dir):\\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\\n\\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\\n f'{model_cfg[\\\"t_unit\\\"]}_{model_cfg[\\\"model\\\"][\\\"edge_type\\\"]}_ndummy={model_cfg[\\\"datasource\\\"][\\\"n_dummy_radars\\\"]}',\\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\\n\\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n\\n if fixed_t0:\\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n\\n # compute binary classification measures\\n for thr in thresholds:\\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\\n\\n counter += 1\\n\\n else:\\n print(f'Experiment \\\"{d}\\\" for model \\\"{m}\\\" and datasource \\\"{datasource}\\\" is not available. '\\n f'Use \\\"run_experiments.py model={m} datasource={datasource} +experiment={d}\\\" to run this experiment.')\\n\\n if counter > 0:\\n rmse_per_hour = pd.concat(rmse_per_hour)\\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\\n\\n mae_per_hour = pd.concat(mae_per_hour)\\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\\n\\n pcc_per_hour = pd.concat(pcc_per_hour)\\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\\n\\n bin_per_hour = pd.concat(bin_per_hour)\\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\\n\\n if fixed_t0:\\n rmse_per_night = pd.concat(rmse_per_night)\\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\\n\\n mae_per_night = pd.concat(mae_per_night)\\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))\",\n \"def calc_errors(y_panel_df, y_insample_df, seasonality, benchmark_model='Naive2'):\\n\\n assert benchmark_model in y_panel_df.columns\\n\\n y_panel = y_panel_df[['unique_id', 'ds', 'y']]\\n y_hat_panel_fun = lambda model_name: y_panel_df[['unique_id', 'ds', model_name]].rename(columns={model_name: 'y_hat'})\\n\\n model_names = set(y_panel_df.columns) - set(y_panel.columns)\\n\\n errors_smape = y_panel[['unique_id']].drop_duplicates().reset_index(drop=True)\\n errors_mase = errors_smape.copy()\\n\\n for model_name in model_names:\\n errors_smape[model_name] = None\\n errors_mase[model_name] = None\\n y_hat_panel = y_hat_panel_fun(model_name)\\n\\n errors_smape[model_name] = evaluate_panel(y_panel, y_hat_panel, smape)\\n errors_mase[model_name] = evaluate_panel(y_panel, y_hat_panel, mase, y_insample_df, seasonality)\\n\\n mean_smape_benchmark = errors_smape[benchmark_model].mean()\\n mean_mase_benchmark = errors_mase[benchmark_model].mean()\\n\\n errors_smape = errors_smape.drop(columns=benchmark_model).set_index('unique_id')\\n errors_mase = errors_mase.drop(columns=benchmark_model).set_index('unique_id')\\n\\n errors = errors_smape/mean_mase_benchmark + errors_mase/mean_smape_benchmark\\n errors = 0.5*errors\\n errors = errors\\n\\n return errors\",\n \"def report_creation(data_all_df, pred_start):\\n data_all_df[\\\"HD MM/GSD\\\"] = np.where(data_all_df.MM.str.contains(\\\"HD\\\"), \\\"HD MM\\\", \\\"GSD\\\")\\n \\n\\n select_cols = [\\\"IDV_LEAD_MNTS_Pred\\\", \\\"IDV_HELPER_MNTS_Pred\\\",\\\"IDV_HELPER_OVR_Pred\\\",\\n \\\"IDV_LD_UNCLAIMED_Pred\\\", \\\"IDV_HP_UNCLAIMED_Pred\\\", \\\"IDV_HPN_UNCLAIMED_Pred\\\",\\n \\\"IDV_LD_DRIVE_Pred\\\", \\\"IDV_HP_DRIVE_Pred\\\", \\\"IDV_HPN_DRIVE_Pred\\\"]\\n\\n for col in select_cols:\\n data_all_df[col.replace('MNTS','HRS')] = round(data_all_df[col]/60,1)\\n \\n \\n data_all_df[\\\"Lead Hrs/Appnt\\\"] = data_all_df[\\\"IDV_LEAD_HRS_Pred\\\"]/data_all_df[\\\"IDV_APPT_ID_Pred\\\"]\\n data_all_df[\\\"Helper Hrs/Appnt\\\"] = data_all_df[\\\"IDV_HELPER_HRS_Pred\\\"]/data_all_df[\\\"IDV_APPT_ID_Pred\\\"]\\n \\n res_cols = [\\\"MM\\\", \\\"HD MM/GSD\\\", \\\"FISC_WK_OF_MTH_ID\\\", \\\"RSS\\\",\\n \\\"Prediction_Trf\\\", \\\"Lead Hrs/Appnt\\\",\\n \\\"IDV_LEAD_HRS_Pred\\\", \\\"IDV_HELPER_HRS_Pred\\\", \\\"Helper Hrs/Appnt\\\", \\n \\\"IDV_HELPER_OVR_Pred\\\",\\n \\\"IDV_LD_UNCLAIMED_Pred\\\", \\\"IDV_HP_UNCLAIMED_Pred\\\", \\\"IDV_HPN_UNCLAIMED_Pred\\\",\\n \\\"IDV_LD_DRIVE_Pred\\\", \\\"IDV_HP_DRIVE_Pred\\\", \\\"IDV_HPN_DRIVE_Pred\\\"]\\n data_result = data_all_df[res_cols]\\n data_result = data_result[data_result.FISC_WK_OF_MTH_ID >= pred_start]\\n data_result.columns = [\\\"MM\\\", \\\"HD MM/GSD\\\", \\\"FISCAL_WK_ID\\\", \\\"RSS\\\",\\n \\\"Order Lines\\\", \\\"Lead Hrs/Appnt\\\",\\n \\\"Lead Hrs\\\", \\\"Helper Hrs\\\", \\\"Helper Hrs/Appnt\\\",\\n \\\"Helper Hrs Float\\\",\\n \\\"Unclaimed Lead\\\", \\\"Unclaimed Helper\\\", \\\"Unclaimed Helper Hrs Float\\\",\\n \\\"Lead Drive Time\\\", \\\"Helper Drive Time\\\", \\\"Helper Hrs Float Drive Time\\\"]\\n data_result['FISCAL_WK_ID'] = data_result['FISCAL_WK_ID'].astype(int)\\n return data_result\",\n \"def run_calculation(self) -> pd.DataFrame:\\n\\n initial_switcher, initial_geo_coords = self.get_placeholder_values(self.parsed_log)\\n\\n calculated_distances = self.process_log(log=self.parsed_log,\\n placeholder_switcher=initial_switcher,\\n placeholder_geo=initial_geo_coords)\\n\\n distance_report = self.generate_report(calculated_distances)\\n\\n self.monitor.info(distance_report)\\n\\n return distance_report\",\n \"def test_evaluate(self):\\n # Check build does not raise errors\\n dataset = KDDCupDataset()\\n dataset.create_fixed_samples(\\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\\n dataset.set_current_sample(0)\\n model = self.MODEL(dataset, **self.model_arguments)\\n model.fit(training_epochs=50)\\n metric = model.evaluate('test')\\n self.assertLessEqual(0, metric)\\n self.assertGreaterEqual(1, metric)\",\n \"def ml_df(df, parameters, t_size, model = DecisionTreeRegressor()):\\n ndf = df[parameters]\\n x = ndf.loc[:, ndf.columns != 'T_exp']\\n y = ndf['T_exp']\\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=t_size)\\n model = model\\n p = PolynomialFeatures(degree = 2)\\n X_poly = p.fit_transform(x_train)\\n X_poly_test = p.fit_transform(x_test)\\n model.fit(X_poly,y_train)\\n y_train_pred = model.predict(X_poly)\\n y_test_pred = model.predict(X_poly_test)\\n result = pd.DataFrame()\\n result['T_exp'] = y_test\\n result['T_prd'] = y_test_pred\\n result['ratio'] = result['T_exp']/result['T_prd']\\n return result\",\n \"def _prepare_evaluate(self):\\n labels = list()\\n labels += ['num_procs', 'num_periods', 'is_debug', 'seed_emax', 'seed_sim']\\n labels += ['num_draws_emax', 'num_agents_sim', 'num_types', 'edu_spec', 'version']\\n labels += ['num_draws_prob', 'seed_prob']\\n num_procs, num_periods, is_debug, seed_emax, seed_sim, num_draws_emax, num_agents_sim, \\\\\\n num_types, edu_spec, version, num_draws_prob, seed_prob = \\\\\\n dist_class_attributes(self.respy_base, *labels)\\n\\n periods_draws_emax = create_draws(num_periods, num_draws_emax, seed_emax, is_debug)\\n periods_draws_sims = create_draws(num_periods, num_agents_sim, seed_sim, is_debug)\\n\\n disturbances = (periods_draws_emax, periods_draws_sims)\\n\\n # We want to maintain a pure PYTHON version for testing purposes.\\n args = list()\\n args += [num_periods, num_types, edu_spec['start'], edu_spec['max'], edu_spec['max'] + 1]\\n state_space_info = respy_f2py.wrapper_create_state_space(*args)\\n if self.mpi_setup == MISSING_INT:\\n slavecomm = self.mpi_setup\\n else:\\n slavecomm = self.mpi_setup.py2f()\\n self.set_up_baseline(periods_draws_emax, None)\\n\\n initial_conditions = get_initial_conditions(self.respy_base)\\n\\n args = (smm_sample_f2py, state_space_info, initial_conditions, disturbances, slavecomm)\\n self.simulate_sample = partial(*args)\",\n \"def evaluate(self):\\n\\n\\t\\t## We should be evaluating on dev dataset as well, so commenting x_test\\n\\t\\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\\n\\t\\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\n\\t\\t##Saving atucal vs predicted predictions\\n\\t\\t##np.argmax returns the index where it see's 1 in the row\\n\\t\\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\\n\\t\\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\\n\\n\\t\\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\\n\\t\\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\\n\\t\\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\\n\\t\\toutputFile = self.resultDir + \\\"/outputPredict.csv\\\" \\n\\t\\tnp.savetxt(outputFile, output_predict, fmt=\\\"%5.0f\\\", delimiter=\\\",\\\")\\n\\n\\t\\t##Error Analysis of the prediction\\n\\t\\terrorAnalysis(outputFile)\\n\\n\\t\\treturn self.model_score\",\n \"def perform_analysis(self):\\n analysis_type = self._analysis_type_variable.get()\\n self.parent.set_analysis_type(analysis_type)\\n\\n # Validates the appropriateness of the data for regression\\n if analysis_type == 'Regression':\\n num_cols = []\\n for col in list(self._df.columns.values):\\n data_type = self._df.dtypes[col]\\n if data_type == np.int64 or data_type == np.float64:\\n num_cols.append(col)\\n\\n if len(num_cols) < 2:\\n messagebox.showerror('Error', 'Data is not appropriate for simple linear regression')\\n return\\n\\n self.parent.select_columns()\",\n \"def evaluate(self):\\n\\n rew_rl = []\\n for ckpt_path in self._config.eval_ckpt_paths:\\n self._load_ckpt(ckpt_path, self._config.ckpt_num)\\n\\n logger.info(\\n \\\"Run %d evaluations for %d environments\\\",\\n self._config.num_eval,\\n len(self._envs),\\n )\\n rollouts, info = self._evaluate(record_video=self._config.record_video)\\n\\n info_stat = info.get_stat()\\n\\n rew_rl.append(np.mean(info[\\\"rew_rl\\\"]))\\n\\n logger.info(\\\"All Eval Rew Values: %s\\\", rew_rl)\\n logger.info(\\\"Eval Rew RL Average: %f, Std: %f\\\", np.mean(rew_rl), np.std(rew_rl))\\n\\n os.makedirs(\\\"result\\\", exist_ok=True)\\n with h5py.File(\\\"result/{}.hdf5\\\".format(self._config.run_name), \\\"w\\\") as hf:\\n for k, v in info.items():\\n hf.create_dataset(k, data=info[k])\\n with open(\\\"result/{}.txt\\\".format(self._config.run_name), \\\"w\\\") as f:\\n for k, v in info_stat.items():\\n f.write(\\\"{}\\\\t{:.03f} $\\\\\\\\pm$ {:.03f}\\\\n\\\".format(k, v[0], v[1]))\",\n \"def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\\n r_temp = {}\\n for metric_name in self.metrics:\\n r_temp.update({f\\\"{metric_name}_Model\\\": name, f\\\"{metric_name}_Sum\\\": 0,\\n f\\\"{metric_name}_Min\\\": 1000000, f\\\"{metric_name}_Max\\\": 0})\\n\\n for i in range(self.repetitions):\\n is_nan = True\\n while (is_nan):\\n model = self.get_model(train_x.shape[1], n_targets)\\n model.fit(train_x, train_y, **self.fit_kwargs)\\n result = model.predict(test_x)\\n is_nan = np.any(np.isnan(result))\\n del model\\n\\n for metric_name in self.metrics:\\n metric = self.get_metrics(metric_name)\\n value = metric(result, test_y)\\n r_temp[f\\\"{metric_name}_Sum\\\"] += value\\n if r_temp[f\\\"{metric_name}_Min\\\"] > value:\\n r_temp[f\\\"{metric_name}_Min\\\"] = value\\n if r_temp[f\\\"{metric_name}_Max\\\"] < value:\\n r_temp[f\\\"{metric_name}_Max\\\"] = value\\n keras.backend.clear_session()\\n for metric_name in self.metrics:\\n r_temp[f\\\"{metric_name}_Mean\\\"] = r_temp[f\\\"{metric_name}_Sum\\\"] / self.repetitions\\n return r_temp\",\n \"def metrics(true, predictions):\\n metrics = pd.DataFrame(columns=['Metric Value'])\\n metrics.loc['MAE'] = mean_absolute_error(true, predictions)\\n metrics.loc['RMSE'] = rmse(true, predictions)\\n metrics.loc['R2'] = r2_score(true, predictions)\\n metrics.loc['MAPE'] = mape(true, predictions)\\n metrics.loc['sMAPE'] = smape(true, predictions)\\n \\n return metrics\",\n \"def run(self, orig_target_df):\\n\\n # For each fold\\n for fold_idx, (fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df) in enumerate(self._generate_validation_fold()):\\n train_test_date_split = fold_training_set_df[\\\"date\\\"].max()\\n eval_start_date = train_test_date_split - timedelta(days = self.test_nb_days)\\n date_to_predict = train_test_date_split + timedelta(days = 1)\\n print(\\\"Warning: date_to_predict offset should be computed dynamically. Currently fixed to 1.\\\")\\n\\n # For each prediction method\\n for process, process_name in zip(self.process_lst, self.process_names_lst):\\n print(\\\"Running validation for process:\\\", process_name, \\\"on fold:\\\", fold_idx, \\\"...\\\")\\n\\n # Train the model\\n with open(self.data_cache_path_str + \\\"data_bkp.pkl\\\", \\\"wb\\\") as f:\\n pickle.dump((fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df), f)\\n\\n y_train = fold_target_df[\\\"demand\\\"].reset_index(drop = True)\\n model = process(train_test_date_split, eval_start_date)\\n model.fit(fold_training_set_df, y_train)\\n\\n # Generate predictions for validation set\\n preds = model.predict(fold_testing_set_df, date_to_predict)\\n preds[\\\"demand\\\"] = (orig_target_df[\\\"shifted_demand\\\"] + preds[\\\"demand\\\"]).apply(np.expm1)\\n\\n # Score the predictions\\n preds2 = preds.copy()\\n preds2.columns = [\\\"id\\\", \\\"date\\\", \\\"preds\\\"]\\n preds_rmse_by_date_df = preds2.merge(fold_truth_df, how = \\\"left\\\", on = [\\\"id\\\", \\\"date\\\"])\\n preds_rmse_by_date_df = preds_rmse_by_date_df[[\\\"date\\\", \\\"preds\\\", \\\"demand\\\"]].groupby(\\\"date\\\").apply(lambda x: self._rmse(x[\\\"demand\\\"], x[\\\"preds\\\"])).reset_index()\\n preds_rmse_by_date_df.columns = [\\\"date\\\", \\\"preds_rmse\\\"]\\n\\n best_preds_piv = preds[[\\\"id\\\", \\\"date\\\", \\\"demand\\\"]].pivot(index = \\\"id\\\", columns = \\\"date\\\", values = \\\"demand\\\").reset_index()\\n truth_piv = fold_truth_df[[\\\"id\\\", \\\"date\\\", \\\"demand\\\"]].pivot(index = \\\"id\\\", columns = \\\"date\\\", values = \\\"demand\\\").reset_index()\\n truth_piv.set_index(\\\"id\\\", inplace = True)\\n best_preds_piv.set_index(\\\"id\\\", inplace = True)\\n best_preds_piv.columns = [\\\"F\\\" + str(i) for i in range(1, 29)]\\n truth_piv.columns = [\\\"F\\\" + str(i) for i in range(1, 29)]\\n validation_WRMSSE = round(model.evaluator.wrmsse(best_preds_piv, truth_piv, score_only = True), 6)\\n\\n # Save result for later use\\n self.scores[process_name].append((fold_idx, preds_rmse_by_date_df, validation_WRMSSE))\\n \\n if self.verbose == True: \\n print(process_name, \\\"had a score of\\\", validation_WRMSSE, \\\"on validation period\\\", fold_testing_set_df[\\\"date\\\"].min(), \\\"to\\\", fold_testing_set_df[\\\"date\\\"].max())\\n\\n metrics_lst = []\\n for process_name, content in self.scores.items():\\n for fold_idx, preds_rmse_by_date_df, validation_WRMSSE in content:\\n preds_rmse_by_date_df[\\\"process_name\\\"] = process_name\\n preds_rmse_by_date_df[\\\"fold_idx\\\"] = fold_idx\\n preds_rmse_by_date_df[\\\"WRMSSE\\\"] = validation_WRMSSE\\n metrics_lst.append(preds_rmse_by_date_df)\\n\\n metrics_df = pd.concat(metrics_lst, axis = 0)\\n metrics_df.set_index(\\\"date\\\", inplace = True)\\n\\n return metrics_df\",\n \"def mgcEval(self):\\n import numpy as np\\n def report_to_df(report):\\n\\n \\\"\\\"\\\"\\n function to convert classification report to dataframe (for visualisation plot)\\n \\\"\\\"\\\"\\n\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"avg / total\\\", \\\"avg/total\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n # update this due to sklearn classification report output change\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"micro avg\\\", \\\"micro_avg\\\").replace(\\\"macro avg\\\", \\\"macro_avg\\\").replace(\\\"weighted avg\\\", \\\"weighted_avg\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n report_df = pd.read_csv(StringIO(\\\"Classes\\\" + report), sep=' ', index_col=0) \\n return(report_df)\\n \\n #txt report to df\\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\\n df_report = report_to_df(class_rpttop1)\\n\\n df_report = df_report.iloc[:self.nb_classes, :].copy()\\n df_report.index = df_report.index.astype(int)\\n \\n\\n # classifier prediction metrics\\n def classMetrics(averagex):\\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\\n \\n return(\\n print(''), \\n print('-------------{0:}--------------------'.format(averagex)), \\n print('precision: {0:.4f}'.format(precision)),\\n print('recall: {0:.4f}'.format(recall)),\\n print('fscore: {0:.4f}'.format(fscore)),\\n print(''),\\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\\n \\n def predSamp():\\n\\n correct = np.nonzero(self.y_pred==self.y_true)[0]\\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\\n\\n # quick check of the number of correct prediction from validation set\\n print(\\\"\\\")\\n print(\\\"correct/total = {0: .4f}\\\".format(len(correct)/(len(correct)+len(incorrect))))\\n print(\\\"total correct sample = {0: .0f}\\\".format(len(correct)))\\n print('------------------------------------------------------------------')\\n \\n def classReport():\\n print('----------------------------- Classfication Report -------------------------------')\\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\\n \\n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\\n \\n self.classMetricsMac = classMetrics(\\\"macro\\\")\\n self.classMetricsMic = classMetrics(\\\"micro\\\")\\n self.predSample = predSamp()\\n self.class_rptTop1 = classReport()\\n \\n return self\",\n \"def run(self):\\n # Convert the dataset, index: Recovered, column: log10(Susceptible)\\n sr_df = self.sr_df.copy()\\n sr_df[self.S] = np.log10(sr_df[self.S].astype(np.float64))\\n df = sr_df.pivot_table(index=self.R, values=self.S, aggfunc=\\\"last\\\")\\n # Convert index to serial numbers\\n serial_df = pd.DataFrame(np.arange(1, df.index.max() + 1, 1))\\n serial_df.index += 1\\n df = pd.merge(\\n df, serial_df, left_index=True, right_index=True, how=\\\"outer\\\"\\n )\\n series = df.reset_index(drop=True).iloc[:, 0]\\n series = series.interpolate(limit_direction=\\\"both\\\")\\n # Sampling to reduce run-time of Ruptures\\n samples = np.linspace(\\n 0, series.index.max(), len(self.sr_df), dtype=np.int64\\n )\\n series = series[samples]\\n # Detection with Ruptures\\n algorithm = rpt.Pelt(model=\\\"rbf\\\", jump=2, min_size=self.min_size)\\n results = algorithm.fit_predict(series.values, pen=0.5)\\n # Convert index values to Susceptible values\\n reset_series = series.reset_index(drop=True)\\n reset_series.index += 1\\n susceptible_df = reset_series[results].reset_index()\\n # Convert Susceptible values to dates\\n df = pd.merge_asof(\\n susceptible_df.sort_values(self.S),\\n sr_df.reset_index().sort_values(self.S),\\n on=self.S, direction=\\\"nearest\\\"\\n )\\n found_list = df[self.DATE].sort_values()[:-1]\\n # Only use dates when the previous phase has more than {min_size + 1} days\\n delta_days = timedelta(days=self.min_size)\\n first_obj = self.to_date_obj(self.dates[0])\\n last_obj = self.to_date_obj(self.dates[-1])\\n effective_list = [first_obj]\\n for found in found_list:\\n if effective_list[-1] + delta_days < found:\\n effective_list.append(found)\\n # The last change date must be under the last date of records {- min_size} days\\n if effective_list[-1] >= last_obj - delta_days:\\n effective_list = effective_list[:-1]\\n # Set change points\\n self._change_dates = [\\n date.strftime(self.DATE_FORMAT) for date in effective_list[1:]\\n ]\\n return self\",\n \"def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\\n all_predictions_table: pd.DataFrame) -> Dict:\\n\\n viewed = viewed_table.to_numpy()\\n predictions = predictions_table.to_numpy()\\n all_predictions = all_predictions_table.to_numpy()\\n ratings = ratings_table.to_numpy()\\n test = test_table.to_numpy(copy=True)\\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\\n\\n result = dict()\\n\\n # Test set evaluation\\n test_predictions = np.multiply(all_predictions, test_set)\\n diff = np.subtract(test_predictions, test_demeaned)\\n rmse = np.sqrt(np.mean(np.square(diff)))\\n result.update({\\\"RMSE\\\": rmse})\\n mae = np.mean(np.absolute(diff))\\n result.update({\\\"MAE\\\": mae})\\n\\n # overall evaluation\\n movies_recommended = set()\\n i = 0\\n for index, row in predictions_table.iterrows():\\n if i > 10000: break\\n else: i += 1\\n\\n labels = row.nlargest(20).keys().tolist()\\n for movie in labels:\\n movies_recommended.update(movie)\\n\\n result.update({\\\"Coverage\\\": len(movies_recommended)})\\n\\n return result\",\n \"def regression_evaluation(self, test_set, predicted_values):\\r\\n\\r\\n MAE = self.mean_absolute_error(test_set, predicted_values)\\r\\n MSE = self.mean_square_error(test_set, predicted_values)\\r\\n print(f\\\"Mean Percent Error:\\\\t{MAE:.2f}\\\")\\r\\n print(f\\\"Mean Square Error:\\\\t{MSE:.2f}\\\")\",\n \"def test_df_contents(self):\\n df_out = annualize(dat, period_label=\\\"fqtr\\\", period_val=4)\\n\\n assert all(df_out['fqtr'] == 4), \\\"Error, the DataFrame has data from the wrong period.\\\"\",\n \"def evaluate(self, start=0):\\n\\n if self.valmode and self.meta['nests'] > 0:\\n # new nested eval, doesn't require special evaluation procedure\\n # by modules. instead, all the remapping and collecting of val\\n # data from each nest handled inside this evaluation function.\\n\\n # 2017-09-08- still something not quite right.\\n # 2017-10-06- working finally. this is new norm for cross-val\\n stack = self\\n\\n try:\\n xval_idx = ut.utils.find_modules(stack, 'est_val.crossval')[0]\\n except BaseException:\\n xval_idx = 1\\n\\n try:\\n mse_idx = ut.utils.find_modules(stack, 'metrics.mean_square_error')\\n mse_idx = int(mse_idx[0])\\n except BaseException:\\n mse_idx = len(self.modules)\\n\\n log.info(\\\"Evaluating nested validation data: xvidx={0} mseidx={1}\\\"\\n .format(xval_idx, mse_idx))\\n\\n # evaluate up to xval module (if necessary)\\n if start > xval_idx:\\n start = xval_idx\\n for ii in range(start, xval_idx):\\n log.info(\\\"eval {0} in valmode\\\".format(ii))\\n stack.modules[ii].evaluate()\\n\\n # go through each nest and evaluate stack, saving data stack to\\n # a placeholder (d_save). copy all keys from data stack except\\n # known metadata listed in exclude_keys. this allows for arbitrary\\n # new data elements to be created (stim2, etc)\\n exclude_keys = ['avgresp', 'poststim', 'fs', 'isolation', 'stimparam', 'filestate',\\n 'prestim', 'duration', 'est', 'stimFs', 'respFs',\\n 'resp_raw', 'pupil_raw']\\n include_keys = {}\\n d_save = {}\\n for cv_counter in range(0, stack.meta['nests']):\\n # for cv_counter in range(0,1):\\n stack.meta['cv_counter'] = cv_counter\\n\\n # load in parameters for appropriate nested fit\\n st = 0\\n for midx in stack.fitted_modules:\\n phi_old = stack.modules[midx].parms2phi()\\n s = phi_old.shape\\n # stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st+np.prod(s))])\\n stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st + np.prod(s))])\\n st += np.prod(s)\\n\\n # evaluate stack for this nest up to before error metric\\n # modules\\n for ii in range(xval_idx, mse_idx):\\n log.info(\\\"nest={0}, eval {1} in valmode\\\".format(cv_counter, ii))\\n stack.modules[ii].evaluate()\\n\\n # append data from this (nest,module) onto d_save\\n # placeholders:\\n if cv_counter == 0:\\n include_keys[ii] = stack.modules[ii].d_out[0].keys() - exclude_keys\\n d_save[ii] = copy.deepcopy(stack.modules[ii].d_out)\\n log.info(include_keys[ii])\\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\\n if not d['est'] and cv_counter > 0:\\n for k in include_keys[ii]:\\n if d[k] is None or d[k] == []:\\n pass\\n elif k == 'pupil' and d[k].ndim == 3 and d['resp'].shape[1] != d[k].shape[1]:\\n d2[k] = np.append(d2[k], d[k], axis=2)\\n elif d[k].ndim == 3:\\n d2[k] = np.append(d2[k], d[k], axis=1)\\n else:\\n d2[k] = np.append(d2[k], d[k], axis=0)\\n\\n # save accumulated data stack back to main data stack\\n\\n # figure out mapping to get val data back into original order\\n for ii in range(xval_idx, mse_idx):\\n jj = -1\\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\\n if not d['est']:\\n jj += 1 # count validation files only\\n validx = np.concatenate(\\n stack.modules[xval_idx].validx_sets[jj])\\n mapidx = np.argsort(validx)\\n for k in include_keys[ii]:\\n if d2[k] is None or d[k] == []:\\n d[k] = d2[k]\\n elif k == 'pupil' and d[k].ndim == 3 and d2['resp'].shape[1] != d2[k].shape[1]:\\n d[k] = d2[k][:, :, mapidx]\\n elif d[k].ndim == 3:\\n d[k] = d2[k][:, mapidx, :]\\n elif d[k].ndim == 2:\\n d[k] = d2[k][mapidx, :]\\n else:\\n d[k] = d2[k][mapidx]\\n\\n # continue standard evaluation of later stack elements\\n for ii in range(mse_idx, len(self.modules)):\\n log.info(\\\"eval {0} in valmode\\\".format(ii))\\n self.modules[ii].evaluate()\\n\\n else:\\n # standard evaluation when not using nested cross-validation\\n for ii in range(start, len(self.modules)):\\n self.modules[ii].evaluate()\",\n \"def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\\n\\n model = algorithm(train)\\n\\n test_labels = test['Labels']\\n\\n predictions = predict_data(test, model)\\n\\n error = mean_square_error(predictions, test_labels)\\n\\n acc = accuracy(predictions, test_labels)\\n\\n return acc, error\",\n \"def _test_all(\\n data: pd.Series,\\n data_name: Optional[str] = None,\\n alpha: float = 0.05,\\n data_kwargs: Optional[Dict] = None,\\n) -> pd.DataFrame:\\n result_summary_stats = _summary_stats(\\n data=data, data_name=data_name, data_kwargs=data_kwargs\\n )\\n result_wn = _is_white_noise(\\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\\n )\\n result_adf = _is_stationary_adf(\\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\\n )\\n result_kpss = _is_stationary_kpss(\\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\\n )\\n result_normality = _is_gaussian(\\n data, data_name=data_name, alpha=alpha, verbose=True, data_kwargs=data_kwargs\\n )\\n\\n all_dfs = [\\n result_summary_stats,\\n result_wn[1],\\n result_adf[1],\\n result_kpss[1],\\n result_normality[1],\\n ]\\n final = pd.concat(all_dfs)\\n return final\",\n \"def model_performance_summary(df, data_all_df, cov_buck, fisc_calender, mod_start, pred_start, summ_start, summ_end):\\n var = \\\"pv_yr\\\" \\n agg_col = \\\"LINE_ORDERS\\\"\\n select_cols = [ \\\"LINE_ORDERS_ACT\\\", \\\"Prediction_Trf\\\", \\\"LEAD_MNTS_ACT\\\", \\\"LD_UNCLAIMED_ACT\\\", \\\"LD_DRIVE_ACT\\\", \\n \\\"IDV_LEAD_MNTS_Pred\\\", \\\"IDV_LD_UNCLAIMED_Pred\\\", \\\"IDV_LD_DRIVE_Pred\\\",\\n \\\"IDV_LEAD_MNTS_ACT\\\", \\\"IDV_LD_UNCLAIMED_ACT\\\", \\\"IDV_LD_DRIVE_ACT\\\",\\n \\\"HELPER_MNTS_ACT\\\", \\\"HP_UNCLAIMED_ACT\\\", \\\"HP_DRIVE_ACT\\\",\\n \\\"IDV_HELPER_MNTS_Pred\\\", \\\"IDV_HP_UNCLAIMED_Pred\\\", \\\"IDV_HP_DRIVE_Pred\\\",\\n \\\"IDV_HELPER_MNTS_ACT\\\", \\\"IDV_HP_UNCLAIMED_ACT\\\", \\\"IDV_HP_DRIVE_ACT\\\",\\n \\\"HELPER_OVR_ACT\\\", \\\"HPN_UNCLAIMED_ACT\\\", \\\"HPN_DRIVE_ACT\\\",\\n \\\"IDV_HELPER_OVR_Pred\\\", \\\"IDV_HPN_UNCLAIMED_Pred\\\", \\\"IDV_HPN_DRIVE_Pred\\\",\\n \\\"IDV_HELPER_OVR_ACT\\\", \\\"IDV_HPN_UNCLAIMED_ACT\\\", \\\"IDV_HPN_DRIVE_ACT\\\"\\n ]\\n\\n for i in select_cols:\\n if str(i) not in data_all_df.columns:\\n data_all_df[str(i)] = np.nan\\n\\n cov_grp_mm = dp.cov_check(\\\"RSS_MM\\\", df, cov_buck, agg_col, fisc_calender, summ_start, summ_end)\\n cov_mm = dp.cov_check(\\\"MM\\\", df, cov_buck, agg_col, fisc_calender, summ_start, summ_end)\\n \\n sample = data_all_df[data_all_df.Variable_Type == var].copy()\\n sample = pd.merge(sample, cov_grp_mm[[\\\"RSS_MM\\\", \\\"CAT\\\"]])\\n sample.CAT = sample.CAT.astype(int)\\n sample[\\\"MAPE\\\"] = abs(sample[\\\"LINE_ORDERS_ACT\\\"]-sample[\\\"Prediction_Trf\\\"])/sample[\\\"LINE_ORDERS_ACT\\\"]\\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\\n labels = [1, 2, 3, 4, 5, 6, 7]\\n sample[\\\"MAPE_BIN\\\"] = pd.cut(sample['MAPE'], bins=bins, labels=labels)\\n wk_list = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID >= pred_start].FISC_WK_OF_MTH_ID.unique()\\n ly_start = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID == wk_list[4]].LY_FISC_WK_OF_MTH_ID.values\\n ly_end = fisc_calender[fisc_calender.FISC_WK_OF_MTH_ID == wk_list[16]].LY_FISC_WK_OF_MTH_ID.values\\n train = sample[((sample.FISC_WK_OF_MTH_ID >= mod_start) & (sample.FISC_WK_OF_MTH_ID < pred_start))]\\n test_in_train = sample[((sample.FISC_WK_OF_MTH_ID >= ly_start[0]) & (sample.FISC_WK_OF_MTH_ID <= ly_end[0]))]\\n # The 4 th index of the list has the prediction start date after excluding the 4 week hold out period\\n # for analysis purpose we are considereing only 13 weeks of test period\\n test = sample[((sample.FISC_WK_OF_MTH_ID >= wk_list[4]) & (sample.FISC_WK_OF_MTH_ID <= wk_list[16]))]\\n fy20 = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\\n \\n ####################################################################################\\n \\n df_grp_summary = fy20.groupby([\\\"RSS\\\"]).sum()[\\\"LINE_ORDERS_ACT\\\"].reset_index()\\n df_grp_summary[\\\"LINE_ORDERS_PERC\\\"] = df_grp_summary[\\\"LINE_ORDERS_ACT\\\"]/df_grp_summary[\\\"LINE_ORDERS_ACT\\\"].sum()\\n ####################################################################################\\n \\n df_sample_list = []\\n df_sample_list = cu.mape_stability(train, \\\"Train CAT\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n df_sample_list = cu.mape_stability(test_in_train, \\\"Test_in_train CAT\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n df_sample_list = cu.mape_stability(test, \\\"Test CAT\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n df_sample_list = cu.mape_stability(fy20, \\\"FY20 CAT\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n stability = pd.concat(df_sample_list)\\n stability.reset_index(inplace = True)\\n ####################################################################################\\n \\n df_sample_res = cu.mape_stability_2d(fy20, \\\"FISC_MTH_NBR\\\", \\\"CAT\\\")\\n grp_sum = fy20.groupby(\\\"FISC_MTH_NBR\\\").sum()[\\\"LINE_ORDERS_ACT\\\"].reset_index()\\n monthly_stability_check = df_sample_res.merge(grp_sum)\\n ####################################################################################\\n \\n mape_cov = cu.mape_stability_2d(fy20, \\\"CAT\\\", \\\"MAPE_BIN\\\")\\n ####################################################################################\\n \\n mape_grp = cu.mape_stability_2d(fy20, \\\"RSS\\\", \\\"MAPE_BIN\\\")\\n mape_grp[\\\"TYPE\\\"] = \\\"MAPE Buckets\\\"\\n ####################################################################################\\n \\n mape_cov_grp = cu.mape_stability_2d(fy20, \\\"RSS\\\", \\\"CAT\\\")\\n mape_cov_grp[\\\"TYPE\\\"] = \\\"Covariance Category\\\"\\n ####################################################################################\\n \\n fy20 = cu.sh_mape(fy20)\\n \\n sh_summary = []\\n for grp in fy20[\\\"RSS\\\"].unique():\\n sample_df = fy20[fy20[\\\"RSS\\\"] == grp]\\n\\n sh_summary = cu.mape_stability(sample_df, grp, \\\"MAPE_LD_BIN\\\", \\\"MAPE_LD\\\", \\\"TOTAL_LEAD_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, grp, \\\"MAPE_HP_BIN\\\", \\\"MAPE_HP\\\", \\\"TOTAL_HELPER_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, grp, \\\"MAPE_HPN_BIN\\\", \\\"MAPE_HPN\\\", \\\"TOTAL_HELPERN_ACT\\\", sh_summary)\\n sh_summary_grp = pd.concat(sh_summary)\\n sh_summary_grp.reset_index(inplace = True)\\n\\n ####################################################################################\\n\\n sh_summary = []\\n var_list = [\\\"pv_yr\\\", \\\"pv_roll_5wk\\\"]\\n for var in var_list:\\n sample_df = data_all_df[data_all_df.Variable_Type == var].groupby([\\\"FISC_WK_OF_MTH_ID\\\", \\\"FISC_YR_NBR\\\", \\\"MM\\\"]).sum()[select_cols].reset_index()\\n sample_df = pd.merge(sample_df, cov_mm[[\\\"MM\\\", \\\"CAT\\\"]])\\n sample_df = sample_df[sample_df.CAT>0]\\n sample_df = sample_df[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\\n sample_df = cu.sh_mape(sample_df)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_LDA_BIN\\\", \\\"MAPE_LD_ACT\\\", \\\"TOTAL_LEAD_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HPA_BIN\\\", \\\"MAPE_HP_ACT\\\", \\\"TOTAL_HELPER_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HPNA_BIN\\\", \\\"MAPE_HPN_ACT\\\", \\\"TOTAL_HELPERN_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_LD_BIN\\\", \\\"MAPE_LD\\\", \\\"TOTAL_LEAD_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HP_BIN\\\", \\\"MAPE_HP\\\", \\\"TOTAL_HELPER_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HPN_BIN\\\", \\\"MAPE_HPN\\\", \\\"TOTAL_HELPERN_ACT\\\", sh_summary)\\n sh_mm_summary_df = pd.concat(sh_summary)\\n sh_mm_summary_df.reset_index(inplace = True)\\n\\n ####################################################################################\\n\\n sh_summary = []\\n for var in data_all_df.Variable_Type.unique():\\n sample_df = data_all_df[data_all_df.Variable_Type == var].groupby([\\\"FISC_WK_OF_MTH_ID\\\", \\\"FISC_YR_NBR\\\", \\\"MM\\\"]).sum()[select_cols].reset_index()\\n sample_df[select_cols] = sample_df[select_cols].replace({0:np.nan})\\n sample_df = pd.merge(sample_df, cov_mm[[\\\"MM\\\", \\\"CAT\\\"]])\\n sample_df = sample_df[sample_df.CAT>0]\\n sample_df = sample_df[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\\n sample_df = cu.sh_mape(sample_df)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_LDAP_BIN\\\", \\\"MAPE_LD_ACT_PRED\\\", \\\"TOTAL_LEAD_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HPAP_BIN\\\", \\\"MAPE_HP_ACT_PRED\\\", \\\"TOTAL_HELPER_ACT\\\", sh_summary)\\n sh_summary = cu.mape_stability(sample_df, var, \\\"MAPE_HPNAP_BIN\\\", \\\"MAPE_HPN_ACT_PRED\\\", \\\"TOTAL_HELPERN_ACT\\\", sh_summary)\\n sh_prop_summary = pd.concat(sh_summary)\\n sh_prop_summary.reset_index(inplace = True)\\n \\n best_mthd = sh_prop_summary.groupby(['IDENTIFIER']).mean()['WEIGHTED MAPE'].reset_index().sort_values(by = [\\\"WEIGHTED MAPE\\\"], ascending = True)\\n var_list = best_mthd[\\\"IDENTIFIER\\\"][:2].to_list()\\n ####################################################################################\\n\\n sample_df = fy20.copy()\\n sample_df = sample_df[sample_df.MM.str.contains(\\\"HD\\\")]\\n sample_df = sample_df.groupby([\\\"FISC_WK_OF_MTH_ID\\\", \\\"MM\\\"]).sum()[[\\\"LINE_ORDERS_ACT\\\", \\\"Prediction_Trf\\\"]].reset_index()\\n df_grp_all = sample_df.copy()\\n df_grp_all[[\\\"LINE_ORDERS_ACT\\\"]] = df_grp_all[[\\n \\\"LINE_ORDERS_ACT\\\"]].replace({0:np.nan})\\n df_grp_all[\\\"MAPE_TA\\\"] = abs(df_grp_all[\\\"LINE_ORDERS_ACT\\\"]-df_grp_all[\\\"Prediction_Trf\\\"])/df_grp_all[\\\"LINE_ORDERS_ACT\\\"]\\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\\n labels = [1, 2, 3, 4, 5, 6, 7]\\n df_grp_all[\\\"MAPE_TA_BIN\\\"] = pd.cut(df_grp_all['MAPE_TA'], bins=bins, labels=labels)\\n\\n var = \\\"pv_yr\\\" \\n sample = data_all_df[data_all_df.Variable_Type == var].copy()\\n \\n sample = sample.merge(cov_grp_mm[[\\\"RSS_MM\\\", \\\"CAT\\\"]])\\n sample = sample[sample.CAT > 0]\\n sample = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\\n \\n \\n sample = data_all_df[data_all_df.Variable_Type == var].copy()\\n sample = pd.merge(sample, cov_mm[[\\\"MM\\\", \\\"CAT\\\"]])\\n sample = sample[sample.CAT > 0]\\n sample = sample[(sample.FISC_WK_OF_MTH_ID >= summ_start) & (sample.FISC_WK_OF_MTH_ID <= summ_end)]\\n fy20_mm = sample.groupby([\\\"FISC_WK_OF_MTH_ID\\\", \\\"MM\\\", \\\"CAT\\\"]).sum()[[\\\"LINE_ORDERS_ACT\\\", \\\"Prediction_Trf\\\"]].reset_index()\\n fy20_mm[[\\\"LINE_ORDERS_ACT\\\" ]] = fy20_mm[[\\\"LINE_ORDERS_ACT\\\"]].replace({0:np.nan})\\n fy20_mm[\\\"MAPE\\\"] = abs(fy20_mm[\\\"LINE_ORDERS_ACT\\\"]-fy20_mm[\\\"Prediction_Trf\\\"])/fy20_mm[\\\"LINE_ORDERS_ACT\\\"]\\n bins= [-1, 0.1, 0.15, 0.20, 0.30, 0.50, 1.00, np.inf]\\n labels = [1, 2, 3, 4, 5, 6, 7]\\n fy20_mm[\\\"MAPE_BIN\\\"] = pd.cut(fy20_mm['MAPE'], bins=bins, labels=labels)\\n \\n df_sample_list = []\\n df_sample_list = cu.mape_stability(fy20, \\\"FY20 RSS_MM\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n df_sample_list = cu.mape_stability(fy20_mm, \\\"FY20 MM\\\", \\\"CAT\\\", \\\"MAPE\\\", \\\"LINE_ORDERS_ACT\\\", df_sample_list)\\n df_overall_summay = pd.concat(df_sample_list)\\n df_overall_summay.reset_index(inplace = True)\\n return df_grp_summary, stability, monthly_stability_check, mape_cov, mape_cov_grp, mape_grp, sh_mm_summary_df, sh_summary_grp, sh_prop_summary, df_overall_summay, var_list\",\n \"def test_input_pandas(multiple_linear_regression_data):\\n X, y = multiple_linear_regression_data\\n x = pd.DataFrame(X)\\n y = pd.DataFrame(y)\\n out = multiple_linear_regression(x, y)\\n assert out[\\\"SE\\\"] == approx(0.03206, abs=1e-5)\",\n \"def evaluate1patient(df, patient):\\n test_1pat = df[df['Patient_number']==patient]\\n x_test, y_test, target_unique = prepTestSet(test_1pat)\\n remaining_pateients = df[df['Patient_number']!=patient]\\n x_train, y_train = prepTrain(remaining_pateients)\\n label = remaining_pateients.Output_label.values\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(label), label)\\n class_weights = class_weights/min(class_weights)\\n class_weights = [round(class_weight) for class_weight in class_weights]\\n model = build_model_cnn(x_train, n=32, d=0.25, k=5)\\n history=fitModel(model, x_train, y_train, class_weights)\\n return_array, cm = modelEvaluator(x_test, y_test, model, target_unique)\\n return history, return_array, cm\",\n \"def apply_evaluation(x, label_true, params, names, database_name):\\n rows = []\\n\\n for i in range(0, len(names)):\\n act_name = names[i]\\n act_data = x[i]\\n\\n algorithm = KMeans(k=params['k'], seed=params['seed'], max_it=params['max_it'], tol=params['tol'])\\n labels = algorithm.fit_predict(act_data)\\n\\n unsupervised = evaluate_unsupervised_internal(act_data, labels)\\n supervised = evaluate_supervised_external(label_true, labels)\\n\\n row = {**dict(Names=act_name), **supervised, **unsupervised}\\n rows.append(row)\\n df_results = pd.DataFrame(rows)\\n set_output(df_results, 'pca_analysis_'+database_name)\",\n \"def prep_data_fn(self, st_train_dt, end_train_dt, st_val_dt, end_val_dt, st_test_dt, end_test_dt):\\n df = self.get_prep_data()\\n train = df[(df['ft_data_dt'] >= st_train_dt) & (df['ft_data_dt'] <= end_train_dt)]\\n val = df[(df['ft_data_dt'] >= st_val_dt) & (df['ft_data_dt'] <= end_val_dt)].sample(frac=0.4, random_state=2021)\\n test = df[(df['ft_data_dt'] >= st_test_dt) & (df['ft_data_dt'] <= end_test_dt)]\\n print(f'----train----')\\n print(train[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\\n print(f'----validation----')\\n print(val[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\\n print(f'----test----')\\n print(test[['ft_data_dt', 'target', 'idd']].groupby(['ft_data_dt', 'target']).agg(['count']))\\n self.set_train(train)\\n self.set_validation(val)\\n self.set_test(test)\\n train_X = train[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\\n train_y = train['target']\\n val_X = val[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\\n val_y = val['target']\\n test_X = test[[c for c in train.columns if c not in ['idd', 'ft_data_dt', 'target']]]\\n test_y = test['target']\\n self.set_train_X(train_X)\\n self.set_train_y(train_y)\\n self.set_val_X(val_X)\\n self.set_val_y(val_y)\\n self.set_test_X(test_X)\\n self.set_test_y(test_y)\",\n \"def train(self): \\n start_time = time()\\n\\n # reset previous results\\n self.best_result = pd.DataFrame()\\n self.result = pd.DataFrame()\\n\\n # Generate dictionaries of all posible parameter permutations\\n keys, values = zip(*self.params.items())\\n self.permutations_dict = [dict(zip(keys, v)) for v in itertools.product(*values)] \\n\\n # Run through all models in parallel threads\\n with Pool(self.thread_cnt) as p:\\n result = p.map(self.analyze_model, self.permutations_dict)\\n\\n\\n # wrap up results\\n if self.classes_names: # acts as trigger for computation of cms\\n for i, dic in enumerate(result):\\n dic[\\\"id\\\"] = i\\n self.cms = [(dic[\\\"id\\\"] ,dic.pop(\\\"cm\\\")) for dic in result]\\n\\n self.result = pd.DataFrame(result)\\n self.best_result = self.result.iloc[self.result[\\\"score\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"f1_score\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"recall\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"precision\\\"].argmax()] # store row with the best score\\n end_time = time()\\n print(\\\"Finished evaluation\\\")\\n print(\\\"Best parameteters found with:\\\", self.best_parameter_set())\\n print(\\\"score=\\\", self.best_score())\\n #print(\\\"f1_score=\\\", self.best_f1_score())\\n #print(\\\"recall_score=\\\", self.best_recall_score())\\n #print(\\\"precision_score=\\\", self.best_precision_score())\\n print(\\\"Total evaluation time = {:.2f}s\\\".format(end_time-start_time))\\n\\n return self.best_parameter_set(), self.best_score()\",\n \"def test_X_non_df_error(self):\\n\\n x = BaseTransformer(columns=\\\"a\\\")\\n\\n with pytest.raises(ValueError):\\n\\n x.fit(\\\"a\\\")\",\n \"def create_dataframe(euctr_cond):\\n def f(x):\\n d = {}\\n d['number_of_countries'] = x.eudract_number_with_country.nunique()\\n d['min_end_date'] = x.date_of_the_global_end_of_the_trial.min()\\n d['max_end_date'] = x.date_of_the_global_end_of_the_trial.max()\\n d['comp_date'] = np.where(pd.notnull(x.date_of_the_global_end_of_the_trial),1,0).sum()\\n d['has_results'] = x.trial_results.sum()\\n d['includes_pip'] = x.trial_is_part_of_a_paediatric_investigation_plan.sum()\\n d['single_blind'] = x.trial_single_blind.sum()\\n d['not_single_blind'] = x.not_single_blind.sum()\\n d['rare_disease'] = x.trial_condition_being_studied_is_a_rare_disease.sum()\\n d['not_rare_disease'] = x.not_rare_disease.sum()\\n d['rare_disease_blank'] = x.rare_disease_blank.sum()\\n d['completed'] = np.where(x.end_of_trial_status == 'Completed', 1, 0).sum()\\n d['ongoing'] = np.where((x.end_of_trial_status == 'Ongoing') | (x.end_of_trial_status == 'Restarted'), 1, 0).sum()\\n d['terminated'] = np.where(x.end_of_trial_status == 'Prematurely Ended', 1, 0).sum()\\n d['suspended'] = np.where((x.end_of_trial_status == 'Temporarily Halted') | (x.end_of_trial_status == 'Suspended by CA'), 1, 0).sum()\\n d['other_status'] = np.where((x.end_of_trial_status == 'Not Authorised') | (x.end_of_trial_status == 'Prohibited by CA'), 1, 0).sum()\\n d['no_status'] = np.where(pd.isnull(x.end_of_trial_status),1,0).sum()\\n d['phase_1'] = x.trial_human_pharmacology_phase_i.sum()\\n d['phase_2'] = x.trial_therapeutic_exploratory_phase_ii.sum()\\n d['phase_3'] = x.trial_therapeutic_confirmatory_phase_iii.sum()\\n d['phase_4'] = x.trial_therapeutic_use_phase_iv.sum()\\n d['bioequivalence'] = x.trial_bioequivalence_study.sum()\\n d['not_bioequivalence'] = x.not_bioequivalence_study.sum()\\n d['healthy_volunteers'] = x.subject_healthy_volunteers.sum()\\n d['not_healthy_volunteers'] = x.not_healthy_volunteers.sum()\\n d['full_title'] = x.full_title.astype('str').min()\\n d['abbreviated_title'] = x.abbreviated_title.astype('str').max()\\n d['non_eu'] = x.non_eu.sum()\\n return pd.Series(d)\\n\\n return euctr_cond.groupby('eudract_number').apply(f).reset_index()\",\n \"def run_tests():\\n with open(FILENAME) as file:\\n # Loads testing parameters from the yaml file.\\n tests = yaml.safe_load(file)\\n\\n # create a dataframe to keep the results\\n test_dict = tests['Tests']\\n results = pd.DataFrame(test_dict)\\n results['Last Average Score'] = \\\"\\\"\\n results['No of Q-Learning episodes'] = \\\"\\\"\\n\\n # run experiments:\\n for i, test in enumerate(test_dict):\\n grid = Rooms(test[\\\"env_size\\\"], testing=True)\\n learning = QLearning(grid, test[\\\"gamma\\\"], test[\\\"alpha\\\"], test[\\\"agent_start_pos\\\"])\\n e_greedy = Policy(\\\"e-greedy\\\", test[\\\"epsilon\\\"], test[\\\"decay\\\"])\\n greedy = Policy(policy_type=\\\"greedy\\\")\\n experiment = Experiments(grid, learning, greedy, test[\\\"iters\\\"],\\n test[\\\"agent_start_pos\\\"], test[\\\"test_no\\\"])\\n\\n for session in range(test[\\\"iters\\\"]):\\n learning.run_multiple_episodes(test[\\\"batch_episodes\\\"], e_greedy)\\n mean_reward = experiment.run_experiments(test[\\\"exp_per_batch\\\"])\\n\\n results.loc[i,'Last Average Score'] = mean_reward\\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\\\"batch_episodes\\\"]\\n\\n # save results to csv file\\n filename = 'results/' + 'test_table.csv'\\n results.to_csv(filename)\\n\\n # plot & save graphs\\n experiment.generate_results(test[\\\"test_no\\\"], test)\\n\\n return results\",\n \"def force_fix():\\n df = force_test_data()\\n return df\",\n \"def evaluate(self, epoch, exploration_paths):\\n logger.log(\\\"Collecting samples for evaluation\\\")\\n paths = self._sample_eval_paths(epoch)\\n statistics = OrderedDict()\\n\\n statistics.update(self._statistics_from_paths(paths, \\\"Test\\\"))\\n statistics.update(self._get_other_statistics())\\n statistics.update(self._statistics_from_paths(exploration_paths,\\n \\\"Exploration\\\"))\\n\\n statistics['AverageReturn'] = get_average_returns(paths)\\n statistics['Epoch'] = epoch\\n\\n for key, value in statistics.items():\\n logger.record_tabular(key, value)\\n\\n self.log_diagnostics(paths)\",\n \"def run(self):\\n\\n # TODO try/catch to ensure proper shutdown even if error encountered\\n\\n params = self._get_params_for_run()\\n result_rows = []\\n\\n # Check for valid configuration\\n if self._test_docs is None and self._k_folds == 0:\\n self._logger.error(\\\"Explicit test set or number of cross-validation folds must be specified.\\\")\\n metrics = Metrics()\\n result_row = {**params, **metrics.get_scores_as_dict()}\\n result_rows.append(result_row)\\n return result_rows\\n\\n # Continue while there are configured parameter settings to evaluate\\n while params is not None:\\n\\n # Get collection of training and test sets for current run\\n data_sets = self._get_training_and_test_sets()\\n for set_index, (training_docs, test_docs) in enumerate(data_sets):\\n\\n # Retrieve an encoder module trained with the specified configuration\\n self._encoder = self._get_encoder(params)\\n\\n set_index += 1 # Only used for user output, so start index at 1\\n\\n num_sets = len(data_sets)\\n if num_sets > 1:\\n self._logger.info(\\\"Training and evaluating fold {} of {}.\\\".format(set_index, num_sets))\\n\\n start = time.time()\\n self._train_and_evaluate(params, self._encoder, training_docs, test_docs)\\n runtime = time.time() - start\\n self._logger.info(\\n \\\"Trained and evaluated fold {} of sequence model in {} seconds.\\\".format(set_index, runtime))\\n\\n # Combine run parameters with evaluation results and store\\n result_row = {**params, **self._evaluator.get_score_as_dict()}\\n result_rows.append(result_row)\\n\\n # Check if model should be saved\\n if self._is_model_saving_enabled():\\n\\n operator = self._evaluator.get_operator()\\n current_score = self._evaluator.get_score()\\n\\n best_model = self._get_best_model()\\n if best_model is not None:\\n (best_metric, _) = best_model\\n if not operator(best_metric, current_score):\\n self._set_best_model(current_score, (params, self._encoder, self._sequence_learner))\\n else:\\n # New model is the best one if no previous existed\\n self._set_best_model(current_score, (params, self._encoder, self._sequence_learner))\\n\\n # Invoke optimizer callback to report on results of this run\\n if self._optimizer is not None:\\n self._optimizer.process_run_result(params=params,\\n score=self._evaluator.get_score_as_dict(),\\n encoder=self._encoder,\\n sequence_learner=self._sequence_learner)\\n\\n # Check if there are additional runs to execute\\n if self._optimizer is not None:\\n params = self._optimizer.get_next_params()\\n else:\\n params = None\\n\\n # Store best model, if configured\\n if self._is_model_saving_enabled():\\n path, name = self._get_model_save_path_and_name()\\n try:\\n self.save(path, name)\\n except Exception:\\n self._logger.error(\\\"Failed to save model, clearing Keras session and trying again.\\\")\\n self._sequence_learner.clear_session()\\n self.save(path, name)\\n\\n # Clear Keras/Tensorflow models # TODO why a second time?\\n if self._sequence_learner is not None:\\n self._sequence_learner.clear_session()\\n\\n return pd.DataFrame(result_rows)\",\n \"def optimizer() -> pd.DataFrame:\\n global iteration, coefs_all\\n\\n X_train, X_test, y_train, y_test = train_test()\\n\\n # Number of observations in train & test set\\n n_train = len(X_train)\\n n_test = len(X_test)\\n n_coefs = X_train.shape[1]\\n\\n # Initialize coefficients\\n coefs_init = np.random.normal(\\n loc=conf.coef_mu, \\n scale=conf.coef_sigma, \\n size=n_coefs\\n )\\n coefs_all = coefs_init.copy()\\n\\n # Coefficients shall be bounded\\n bounds = [conf.coef_bounds] * n_coefs\\n iteration = 0\\n\\n # Run optimization\\n result = minimize( \\n fun=lambda x: loss_func(x, X_train, y_train, n_train),\\n callback=lambda x: callback_func(x, X_train, y_train, n_train),\\n x0=coefs_init,\\n bounds=bounds\\n )\\n # Collect optimal coefficients\\n coefs = pd.Series(data=result.x, index=X_train.columns, name=\\\"coefs\\\")\\n coefs_df = pd.DataFrame(data=coefs_all, columns=X_train.columns).T\\n coefs_df.index.name = \\\"area\\\"\\n\\n rmse_train = result.fun\\n rmse_test = loss_func(\\n coefs=coefs, \\n X=X_test, \\n y=y_test, \\n n=n_test, \\n )\\n print(\\\"\\\\n\\\")\\n print (f\\\"Train RMSE: {rmse_train:.4f}\\\")\\n print (f\\\"Test RMSE: {rmse_test:.4f}\\\")\\n\\n return coefs_df\",\n \"def test_error_metrics(self, whp_pandas):\\n test_class = Slug_Forecasting(whp_pandas.copy())\\n test_class.stationarity_check()\\n test_class.split_data()\\n test_class.ARIMA_model(1, 0, 1, show=False)\\n\\n # Test error metrics parameter entry\\n assert test_class.error_metrics(error=\\\"other\\\", verbose=False) == None, \\\"Nothing is returned\\\"\\n\\n # Test values returned for fitting regression\\n assert len(test_class.error_metrics(error=\\\"fit\\\", verbose=False)) == 4, \\\\\\n \\\"Three variables must be returned in this example\\\"\\n mape, mse, rmse, r2 = test_class.error_metrics(error=\\\"fit\\\", verbose=False)\\n\\n # test stats:\\n assert r2 < 1.0, \\\"Coefficient of Determination r2 should be less than 1\\\"\\n assert np.isclose(math.sqrt(mse), rmse, atol=0.01), \\\\\\n \\\"Square rooted mean squared error should equal root mean squared error\\\"\\n\\n test_class.ARIMA_pred(pred_time=60, show=False) # Forecast values\\n\\n # Test values returned for forecasting regression\\n assert len(test_class.error_metrics(error=\\\"pred\\\", verbose=False)) == 4, \\\\\\n \\\"Three variables must be returned in this example\\\"\\n mape, mse, rmse, r2 = test_class.error_metrics(error=\\\"pred\\\", verbose=False)\\n\\n # test stats:\\n assert r2 < 1.0, \\\"Coefficient of Determination r2 should be less than 1\\\"\\n assert np.isclose(math.sqrt(mse), rmse, atol=0.01), \\\\\\n \\\"Square rooted mean squared error should equal root mean squared error\\\"\",\n \"def gen_df_err_extend(cur_data, cur_mod, random_assignment=False, rand_seed=0):\\n if random_assignment:\\n np.random.seed(rand_seed)\\n clust_list = (cur_mod.z).copy()\\n np.random.permutation(clust_list) \\n \\n df_err_extend = pd.DataFrame(columns=['full_id', 'id', 'proj', 'idx', 'clust', 'err'])\\n\\n for i in range(0,len(cur_data['SI'])):\\n cur_x = cur_data['XA'][i]\\n cur_x = cur_x[~np.isnan(cur_x)]\\n cur_y = cur_data['YA'][i]\\n cur_y = cur_y[~np.isnan(cur_y)]\\n full_cur_id = cur_data['SI'][i]\\n cur_id = cur_data['SI'][i].split('_')[0]\\n cur_proj = cur_data['SI'][i].split('_')[1]\\n\\n if random_assignment:\\n clust_assign = clust_list[i]\\n else:\\n rank_clust, _ = utils.rank_cluster_prediction(cur_mod, cur_x, cur_y)\\n clust_assign = rank_clust[0]\\n \\n y_pred_mean = calc_y_pred_model(cur_mod, cur_x, clust_assign)\\n err = calc_error(cur_y, y_pred_mean)\\n df_err_extend = df_err_extend.append({'full_id':full_cur_id, 'id':cur_id, 'proj':cur_proj, 'idx':i, 'clust':clust_assign, 'err': err}, ignore_index=True)\\n \\n return df_err_extend\",\n \"def evaluate(self, ind, filename=\\\"\\\"):\\n start = dt.now()\\n # rule_set = self._generator.create_rule_set(ind)\\n rule_set, indicators = self._generator.create_rule_set(ind)\\n data_selected = self._data[indicators]\\n\\n # Calculate the signals according to the fuzzy rule set\\n decision = fuzzy.DecisionMaker(rule_set, data_selected)\\n\\n # signals = pd.DataFrame([0.5, -0.4, 0.2, 0.4, 0.1, -0.2, -0.3, 0.2, 0.3, 0.1], index=self._data.index,columns=['Signal'])\\n\\n signals = []\\n # signals = decision.defuzzify(self._data) #signal is a dataframe\\n for row_index, data_row in zip(range(len(data_selected)), data_selected.iterrows()):\\n dictionary = dict(data_row[1])\\n signal = decision.defuzzify(dictionary)\\n signals.append(signal)\\n\\n self._data['Signal'] = signals\\n print(\\\"::::: [evaluator] Calculate signals \\\", dt.now() - start, \\\":::::\\\")\\n\\n start = dt.now()\\n # Calculate the fitness value according to the trading signals\\n Hold = 0\\n Money = 10000000\\n Fortune = []\\n for i, row in self._data.iterrows():\\n Hold, Money, fortune = self.trade(row, Hold, Money)\\n Fortune.append(fortune)\\n self._data['Fortune'] = Fortune\\n # self._data['Operation'] = 0\\n # self._data.Operation[self._data.Signal > 0] = 1\\n # self._data.Operation[self._data.Signal < 0] = -1\\n fit_val = self._data.iloc[-1]['Fortune']\\n\\n print(\\\"::::: [evaluator] Calculate fitness value\\\", dt.now() - start, \\\":::::\\\")\\n return fit_val\",\n \"def train_and_eval():\\n # train_file_name = 'adult.data'\\n # test_file_name = 'adult.test'\\n train_file_name = 'poker-hand-testing.data'\\n test_file_name = 'poker-hand-training-true.data'\\n #test_file_name = maybe_download()\\n df_train = pd.read_csv(\\n tf.gfile.Open(\\\"/opt/tensor/race_result_clean.csv\\\"),\\n names=COLUMNS,\\n skipinitialspace=True,\\n skiprows=1)\\n df_test = pd.read_csv(\\n tf.gfile.Open(\\\"/opt/tensor/race_result_clean.csv\\\"),\\n names=COLUMNS,\\n skipinitialspace=True,\\n skiprows=1)\\n\\n #df_train[LABEL_COLUMN] = (df_train[\\\"CLASS_Poker_Hand\\\"].apply(lambda x: x>5)).astype(int)\\n #df_test[LABEL_COLUMN] = (df_test[\\\"CLASS_Poker_Hand\\\"].apply(lambda x: x>5)).astype(int)\\n\\n model_dir = tempfile.mkdtemp() if not FLAGS.model_dir else FLAGS.model_dir\\n print(\\\"model directory = %s\\\" % model_dir)\\n m = build_estimator(model_dir)\\n print(m)\\n m.fit(input_fn=lambda: input_fn(df_train), steps=FLAGS.train_steps)\\n results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1)\\n for key in sorted(results):\\n print(\\\"%s: %s\\\" % (key, results[key]))\",\n \"def run(self, action: str = 'evaluate') -> Union[\\n pd.DataFrame, List[Dict[str, Dict[str, Union[Union[float, str], Any]]]]]:\\n model = VAR(endog=self.train)\\n model_fit = model.fit()\\n if action == 'predict':\\n # Use full dataset to get prediction\\n model_full = VAR(endog=self.df)\\n model_fit_full = model_full.fit()\\n return pd.DataFrame(model_fit.forecast(model_fit_full.y, steps=2), index=['2008', '2009'],\\n columns=[self.df.columns])\\n else:\\n tmp = []\\n for col in self.df.columns:\\n tmp.append({col: {'rmse_val': sqrt(\\n mean_squared_error(self.valid[col], self._prediction(model_fit, self.valid)[[col]])),\\n 'mae_val': mean_absolute_error(self.valid[col],\\n self._prediction(model_fit, self.valid)[[col]]),\\n 'mape_val': f'{self.mean_absolute_percentage_error(self.valid[col], self._prediction(model_fit, self.valid)[[col]])} %'}})\\n\\n return tmp\",\n \"def stepwise_regression(train_per_list, cut_off_list, C_list,\\n factors,non_factors, data_path, executable_path):\\n sql_table = 'aggregated_ctr' #Data table\\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\\n # remove cross terms\\n\\n factors+=['campaign_id','ad_account_id','pub_account_id', \\n 'campaign_id*site', 'ad*pub_account_id']\\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\\n 'user':'readonly','passwd':'z0q909TVZj'}\\n con_dict_dse={'host':'db.lqm.io','db':'dse','user':'dse','passwd':'dSe@lQm'}\\n rtb_flag=[0,1]\\n \\n test_per_list= map(lambda x: ( add_hour(x[1], 1), add_hour(x[1], 3)), train_per_list)\\n \\n # test period is next 3 hours after end of training period\\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\\n MySQL_save_data_loop(con_dict_dse, sql_table,\\n train_per_list, sql_features, rtb_flag, data_path)\\n MySQL_save_data_loop(con_dict_dse, sql_table,\\n test_per_list, sql_features, rtb_flag, data_path)\\n \\n model_type=0\\n has_intercept = True # bias term in LR\\n tol = 0.00000001\\n\\n # NB these filenames are HARDCODED in write_sparse routines\\n weights_file = 'train_ais.txt'\\n train_file = 'train_svm.txt'\\n test_file = 'test_svm.txt'\\n probability_file = 'preds_SummModel_py.txt'\\n\\n \\n res_df_list=[]\\n trial_factors=[]\\n remaining_factors=factors[:]\\n while len(remaining_factors):\\n results = [] \\n # we assume we cannot load all the data in memory\\n # so we have to reload for every step of stepwise selection\\n for train_per, test_per in zip(train_per_list, test_per_list):\\n \\n train_df=load_data(data_path,train_per)\\n test_df=load_data(data_path,test_per)\\n \\n sc, click_no_click_df, weights, targets \\\\\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\\n \\n for cut_off in cut_off_list:\\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\\n sparse_test_all = sc.transform(test_df)\\n for fac in remaining_factors:\\n trial_factors.append(fac)\\n trial_factors.sort(key=lambda x: sc.factors.index(x))\\n # libsvm expects the indices in ascending order\\n print (trial_factors) \\n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\\n\\n for C in C_list:\\n model_file = \\\\\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\\n start=date_name(train_per[0]),\\n stop=date_name(train_per[1]),\\n cut_off=cut_off, C=C)\\n fit(executable_path, data_path, train_file,\\n model_file, weights_file, model_type, reg_param=C, tol=tol,\\n has_intercept=has_intercept)\\n \\n pCTR = libLinear_functions.predict(\\n executable_path, data_path, test_file,\\n model_file, probability_file)\\n if type(pCTR) is pd.Series:\\n amounts = pd.DataFrame({\\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\\n 'clicks':test_df['clicks']})\\n mean_log_loss, weighted_log_loss =\\\\\\n libLinear_functions.log_loss_weighted(pCTR, amounts)\\n results.append([train_per[:], tuple(trial_factors),fac, cut_off, C, mean_log_loss])\\n # what to do if ERROR?\\n trial_factors.remove(fac)\\n res_df=pd.DataFrame(results,columns=['train_per','factors','add_factor','cut_off','C','mean_log_loss'])\\n res_avg=res_df.groupby(['factors','add_factor','cut_off','C']).agg([np.mean,np.std])\\n best_params=res_avg['mean_log_loss','mean'].argmin()\\n best_fac=best_params[1]\\n remaining_factors.remove(best_fac)\\n trial_factors.append(best_fac)\\n res_df_list.append(res_df)\\n results_df=pd.concat(res_df_list)\\n return results_df\",\n \"def evaluate(self):\\n # Method variables definition\\n X_train, X_test, y_train, y_test = dm.reshape_y_set_split_data(self.datasetManager)\\n featureScaleDependentVariables = self.datasetManager.params.featureScaleDependentVariables\\n\\n # Feature Scaling\\n X_scaler, X_train = dm.do_feature_scaling(X_train)\\n if featureScaleDependentVariables:\\n y_scaler, y_train = dm.do_feature_scaling(y_train)\\n else:\\n y_scaler = None\\n y_train = self.datasetManager.y_train\\n \\n self.X_scaler = X_scaler\\n self.y_scaler = y_scaler\\n\\n # Training the SVR model on the training set\\n regressor = SVR(kernel = 'rbf')\\n regressor.fit(X_train, y_train.ravel())\\n self.regressor = regressor\\n\\n # Predicting the Test set results\\n self.y_pred = y_scaler.inverse_transform(regressor.predict(X_scaler.transform(X_test))) if featureScaleDependentVariables else regressor.predict(X_test)\\n \\n # Returning the process result : the regression type and the predicted dependent variables set\\n return [\\\"Support Vector Regression\\\", self.get_r2_score(y_test, self.y_pred)]\",\n \"def concat_all_evaluation_results(list_of_folders):\\n\\n\\n train_eval_df_list = []\\n val_eval_df_list = []\\n train_val_eval_df_list = []\\n\\n\\n for item in list_of_folders:\\n path_to_eval_folder = os.path.join(EMBEDDING_DEST, item)\\n files = os.listdir(path_to_eval_folder)\\n\\n for f in files:\\n\\n # for each evaluation result csv file, see whether it is from training set, or validation set, or training+validation\\n if f.endswith(\\\"image_level_evaluation_result_top_tri.csv\\\"):\\n\\n if \\\"random\\\" in f:\\n if \\\"random_training_validation\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n train_val_eval_df_list.append(df)\\n\\n elif \\\"random_training\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n train_eval_df_list.append(df)\\n\\n\\n elif \\\"random_validation\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n val_eval_df_list.append(df)\\n\\n\\n else:\\n if \\\"triplet\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n train_val_eval_df_list.append(df)\\n\\n elif \\\"training\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n train_eval_df_list.append(df)\\n\\n elif \\\"validation\\\" in f:\\n df = pd.read_csv(os.path.join(path_to_eval_folder, f))\\n val_eval_df_list.append(df)\\n\\n\\n # add 'training_' or 'validation_' to the column names of evaluation results coming from training and validation sets.\\n # This is to be able to distinguish them in the final general csv file.\\n\\n columns = list(train_val_eval_df_list[0])\\n train_columns = [\\\"training_\\\"+item for item in columns[1:]]\\n train_columns = [columns[0]] + train_columns\\n train_columns_dict ={}\\n \\n val_columns = [\\\"validation_\\\"+item for item in columns[1:]]\\n val_columns = [columns[0]] + val_columns\\n val_columns_dict ={}\\n\\n #train_and_val_columns = [\\\"train_and_validation_\\\"+item for item in columns[1:]]\\n #train_and_val_columns = [columns[0]] + train_and_val_columns\\n #train_and_val_columns_dict ={}\\n\\n\\n for i in range(len(columns)):\\n train_columns_dict[columns[i]] = train_columns[i]\\n val_columns_dict[columns[i]] = val_columns[i]\\n #train_and_val_columns_dict[columns[i]] = train_and_val_columns[i]\\n\\n\\n concatenated_training_df = pd.concat(train_eval_df_list, sort=False)\\n concatenated_training_df = concatenated_training_df.rename(columns=train_columns_dict)\\n\\n concatenated_validation_df = pd.concat(val_eval_df_list, sort=False)\\n concatenated_validation_df = concatenated_validation_df.rename(columns=val_columns_dict)\\n \\n concatenated_train_and_validation_df = pd.concat(train_val_eval_df_list, sort=False)\\n #concatenated_train_and_validation_df = concatenated_train_and_validation_df.rename(columns=train_and_val_columns_dict)\\n\\n\\n concatenated_training_df.to_csv(os.path.join(EMBEDDING_DEST,\\\"compare_with_no_sz\\\", \\\"training_all_evaluation_result_top_tri.csv\\\"),index=None)\\n concatenated_validation_df.to_csv(os.path.join(EMBEDDING_DEST, \\\"compare_with_no_sz\\\", \\\"validation_all_evaluation_result_top_tri.csv\\\"),index=None)\\n concatenated_train_and_validation_df.to_csv(os.path.join(EMBEDDING_DEST,\\\"compare_with_no_sz\\\",\\\"training_and_validation_all_evaluation_result_top_tri.csv\\\"), index=None)\\n\\n # ---------\\n # If you have columns on arguments, keep them in training but drop them in validation and train_and_val to prevent duplicates\\n list_of_cols_in_validation_df = list(concatenated_validation_df)\\n list_of_cols_in_train_val_df = list(concatenated_train_and_validation_df)\\n args_cols = get_json_argument_list()\\n\\n args_cols_val = [\\\"validation_\\\"+item for item in args_cols]\\n \\n if len(list_of_cols_in_train_val_df) == len(list_of_cols_in_validation_df) and len(list_of_cols_in_train_val_df) > 7:\\n concatenated_validation_df = concatenated_validation_df.drop(args_cols_val, axis=1, errors='ignore')\\n concatenated_train_and_validation_df = concatenated_train_and_validation_df.drop(args_cols, axis=1, errors='ignore')\\n\\n\\n # ---------\\n\\n all_three_df_list = [concatenated_training_df, concatenated_validation_df, concatenated_train_and_validation_df]\\n concatenated_all_df = pd.concat(all_three_df_list, axis=1)\\n concatenated_all_df.to_csv(os.path.join(EMBEDDING_DEST,\\\"compare_with_no_sz\\\", \\\"all_evaluation_result_top_tri.csv\\\"), index=None)\",\n \"def supplement_data(df, test, store, dept):\\n\\n df_s = pd.DataFrame({'Store': store,\\n 'Dept': dept,\\n 'Date': all_date,\\n 'Weekly_Sales': 0,\\n 'check': str(store) + '_' + str(dept)})\\n return df_s\",\n \"def evaluate_regression(x, t, w, basis, degree):\\n \\t# TO DO:: Compute t_est and err \\n #w_tranpose=w.T\\n\\n\\n # My logic goes as follows:\\n # Definition of test error is when you run the trained\\n # model against a dataset that it hasn't been exposed to\\n # this dataset is known as the testset \\n\\n # As such the basic algorithm goes as follows:\\n # We do not need to recompute the weights but we need to recompute\\n # phi for our test data\\n\\n # As such, we are interested in how well our trained weights\\n # estimate against the test data so we matrix multiply our\\n # weights against the phi from our test data\\n # thus t_est = w_train.T*phi(x) since we want to know how well our\\n # trained model estimates against the training data\\n # but in implementation we do phi(x)*w_train\\n # to match array dimensions \\n\\n\\n #Compute design matrix from test data \\n phi=design_matrix(x,basis,degree)\\n phi_cross=np.linalg.pinv(phi)\\n\\n # Compute testing weights // just in case we require this variable\\n #if(t is not None):\\n #w_test=phi_cross.dot(t)\\n #w_test=phi_cross.dot(t)\\n\\n # We want to be able to index into our target vector\\n\\n #t_est=phi.dot(w_test)\\n #if (t is not None):\\n # testing_estimate=phi.dot(w_test)\\n #testing_estimate=phi.dot(w_test)\\n\\n # Estimate of our targets according to test data against learned \\n # coefficients\\n t_est=phi.dot(w)\\n #print(\\\"t_est\\\",t_est)\\n #t_est = None\\n\\n # We calculate the RMS error as follows\\n # Take equation 3.12 of PRML and modify as follows\\n # My logic:\\n # The equation given in PRML gives the SSE (sum of squares error)\\n # By definition the MSE (mean squared error) takes the SSE and divides \\n # it by population size, we also preserve the 1/2 constant \\n # throughout our calcuations \\n # Afterwards we take our MSE and square root it.\\n\\n # Compute difference between target and estimate\\n\\n if(t is not None):\\n \\n diff=t-t_est\\n # Square all observations\\n diff_squared=np.power(diff,2)\\n # Sum up all the observations in our vector\\n sig_squared=diff_squared.sum()\\n half_sig_squared=0.5*(sig_squared)\\n # Calculate population size\\n population_size=t.shape[0]\\n rmse=np.sqrt(half_sig_squared/population_size)\\n err=rmse\\n else:\\n err=None\\n\\n #diff=t-t_est\\n\\n\\n # Square all observations \\n #diff_squared=np.power(diff,2)\\n\\n # Sum up all the observations in our vector\\n #sig_squared=diff_squared.sum()\\n\\n #half_sig_squared=0.5*(sig_squared)\\n\\n # Calculate population size\\n #population_size=t.shape[0]\\n\\n #rmse=np.sqrt(half_sig_squared/population_size)\\n #err = rmse\\n #print(\\\"err inside function\\\",err)\\n #err=rmse\\n return (t_est, err)\",\n \"def dependent_error_exp(data, weak_signal_data, num_weak_signal):\\n\\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\\n\\n training_data = data['training_data'][0].T\\n training_labels = data['training_data'][1]\\n val_data, val_labels = data['validation_data']\\n val_data = val_data.T\\n test_data = data['test_data'][0].T\\n test_labels = data['test_data'][1]\\n\\n num_features, num_data_points = training_data.shape\\n\\n weak_signal_ub = w_model['error_bounds']\\n weak_signal_probabilities = w_model['probabilities']\\n weak_test_accuracy = w_model['test_accuracy']\\n\\n weights = np.zeros(num_features)\\n\\n print(\\\"Running tests...\\\")\\n\\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\\n\\n # calculate test probabilities\\n test_probabilities = probability(test_data, optimized_weights)\\n # calculate test accuracy\\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\\n\\n print(\\\"\\\")\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n print(\\\"Experiment %d\\\"%num_weak_signal)\\n print(\\\"We trained %d learnable classifiers with %d weak signals\\\" %(1, num_weak_signal))\\n print(\\\"The accuracy of the model on the test data is\\\", test_accuracy)\\n print(\\\"The accuracy of weak signal(s) on the test data is\\\", weak_test_accuracy)\\n print(\\\"\\\")\\n\\n # calculate ge criteria\\n print(\\\"Running tests on ge criteria...\\\")\\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\\n print(\\\"The accuracy of ge criteria on test data is\\\", ge_test_accuracy)\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n\\n # calculate baseline\\n print(\\\"Running tests on the baselines...\\\")\\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\\n print(\\\"The accuracy of the baseline models on test data is\\\", b_test_accuracy)\\n print(\\\"\\\")\\n\\n output = {}\\n output['ALL'] = test_accuracy\\n output['WS'] = w_model['test_accuracy'][-1]\\n output['GE'] = ge_test_accuracy\\n output['AVG'] = b_test_accuracy[-1]\\n\\n return output\",\n \"def evaluate(self, test_data, test_labels):\\n raise NotImplementedError\",\n \"def general_analysis(df):\\n pass\",\n \"def update_error_plot_values(self):\\n check_is_dir(\\\"mp_plotdata\\\")\\n check_is_dir(\\\"mp_plotdata/\\\"+self.name)\\n\\n data_train = self.get_data.evaluate_on_train_data(n_samples=50)\\n data_validation = self.get_data.evaluate_on_validation_data(n_samples=50)\\n\\n for data, _set in zip([data_train, data_validation], [\\\"train\\\", \\\"validation\\\"]):\\n object_real_samples = data[\\\"object_real_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n object_imag_samples = data[\\\"object_imag_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n diffraction_samples = data[\\\"diffraction_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n\\n filename = \\\"mp_plotdata/\\\"+self.name+\\\"/\\\"+_set+\\\"_log.dat\\\"\\n if not os.path.exists(filename):\\n with open(filename, \\\"w\\\") as file:\\n file.write(\\\"# time[s] epoch real_loss imag_loss reconstruction_loss\\\\n\\\")\\n\\n # real loss\\n real_loss = self.sess.run(self.nn_nodes[\\\"real_loss\\\"],\\n feed_dict={self.x:diffraction_samples,\\n self.real_actual:object_real_samples})\\n\\n # imaginary loss\\n imag_loss = self.sess.run(self.nn_nodes[\\\"imag_loss\\\"],\\n feed_dict={self.x:diffraction_samples,\\n self.imag_actual:object_imag_samples})\\n\\n # reconstruction\\n reconstruction_loss = self.sess.run(self.nn_nodes[\\\"reconstruction_loss\\\"],\\n feed_dict={self.x:diffraction_samples})\\n\\n datastring = \\\"\\\"\\n datastring+= str(time.time())\\n datastring+= \\\" \\\"\\n datastring+= str(self.epoch)\\n datastring+= \\\" \\\"\\n datastring+= str(real_loss)\\n datastring+= \\\" \\\"\\n datastring+= str(imag_loss)\\n datastring+= \\\" \\\"\\n datastring+= str(reconstruction_loss)\\n datastring+= \\\"\\\\n\\\"\\n\\n with open(filename, \\\"a\\\") as file:\\n file.write(datastring)\\n\\n\\n for key in self.experimental_traces.keys():\\n trace = self.experimental_traces[key]\\n\\n # reconstruction\\n reconstruction_loss = self.sess.run(self.nn_nodes[\\\"reconstruction_loss\\\"],\\n feed_dict={self.x:trace})\\n\\n logger_name = key+\\\"_reconstructed\\\"\\n filename = \\\"mp_plotdata/\\\"+self.name+\\\"/\\\"+logger_name+\\\".dat\\\"\\n if not os.path.exists(filename):\\n with open(filename, \\\"w\\\") as file:\\n file.write(\\\"# time[s] epoch reconstruction_loss\\\\n\\\")\\n\\n datastring = \\\"\\\"\\n datastring+= str(time.time())\\n datastring+= \\\" \\\"\\n datastring+= str(self.epoch)\\n datastring+= \\\" \\\"\\n datastring+= str(reconstruction_loss)\\n datastring+= \\\"\\\\n\\\"\\n with open(filename, \\\"a\\\") as file:\\n file.write(datastring)\",\n \"def fit(self, df):\\n self.df_std = df.std(axis=0, skipna=True)\\n self.df_mean = df.mean(axis=0, skipna=True)\\n return self\",\n \"def create_evaluation_df(predictions, test_inputs, H, scaler):\\n eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, H+1)])\\n eval_df['timestamp'] = test_inputs.dataframe.index\\n eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')\\n eval_df['actual'] = np.transpose(test_inputs['target']).ravel()\\n eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])\\n return eval_df\",\n \"def filldf(df, response, sorted_selection, params_selection, constant=True, verbose=True):\\n selections_iter = iter(sorted_selection)\\n params_iter = iter(params_selection)\\n idxmissing = df[response][df[response].isnull() == True].index # slect where their is missing data\\n\\n print(\\\"Filling .... \\\")\\n\\n while len(idxmissing) > 0:\\n print(\\\"Their is [\\\" + str(len(idxmissing)) + \\\"] events missing\\\")\\n\\n try: # Try if their is still other stations to fill with\\n selection = next(selections_iter)\\n param = next(params_iter)\\n except StopIteration:\\n print(\\\"NO MORE SELECTED STATIONS\\\")\\n break\\n\\n try:\\n Y = df.loc[:, response]\\n X1 = df.loc[:, selection[0]]\\n X2 = df.loc[:, selection[1]]\\n select = pd.concat([X1, X2], keys=['X1', 'X2'], axis=1, join='inner').dropna()\\n if constant:\\n newdata = param[0] + param[1] * select['X1'] + param[2] * select['X2'] # reconstruct the data\\n else:\\n newdata = param[0] * select['X1'] + param[1] * select['X2'] # reconstruct the data\\n\\n df.loc[idxmissing, response] = newdata.loc[idxmissing]\\n idxmissing = df[response][df[response].isnull() == True].index # slect where their is missing data\\n except KeyError:\\n if verbose:\\n print('Selected stations ' + str(selection) + 'did not fill any events')\\n else:\\n pass\\n\\n except ValueError:\\n if verbose:\\n print('The variable ' + var + \\\"Does not exist or no data to do the multilinear regression \\\")\\n else:\\n pass\\n\\n return df.loc[:, response]\",\n \"def run(self):\\n dataset_train = np.hstack(self.hstacK_generator(self.train))\\n dataset_valid = np.hstack(self.hstacK_generator(self.valid_arb))\\n\\n X_train, y_train = self.split_sequences(dataset_train, self.n_steps_in, self.n_steps_out)\\n X_valid, y_valid = self.split_sequences(dataset_valid, self.n_steps_in, self.n_steps_out)\\n\\n model = self.make_model(X_train.shape[2])\\n model.fit(X_train, y_train, epochs=200, verbose=0,\\n callbacks=[tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)],\\n validation_data=(X_valid, y_valid))\\n\\n pred_valid = model.predict(X_valid, verbose=0)\\n pred_train = model.predict(X_train, verbose=0)\\n\\n tmp = []\\n for j, col in enumerate(self.df.columns):\\n tmp.append({col: {'rmse_train': sqrt(mean_squared_error([y_train[i][0][j] for i in range(0, len(y_train))],\\n [pred_train[i][0][j] for i in\\n range(0, len(pred_train))])),\\n 'rmse_val': sqrt(mean_squared_error([y_valid[i][0][j] for i in range(0, len(y_valid))],\\n [pred_valid[i][0][j] for i in\\n range(0, len(pred_valid))])),\\n 'mae_train': mean_absolute_error([y_train[i][0][j] for i in range(0, len(y_train))],\\n [pred_train[i][0][j] for i in\\n range(0, len(pred_train))]),\\n 'mae_val': mean_absolute_error([y_valid[i][0][j] for i in range(0, len(y_valid))],\\n [pred_valid[i][0][j] for i in range(0, len(pred_valid))]),\\n 'mape_train': f'{self.mean_absolute_percentage_error([y_train[i][0][j] for i in range(0, len(y_train))], [pred_train[i][0][j] for i in range(0, len(pred_train))])} %',\\n 'mape_val': f'{self.mean_absolute_percentage_error([y_valid[i][0][j] for i in range(0, len(y_valid))], [pred_train[i][0][j] for i in range(0, len(pred_valid))])} %'}})\\n\\n return tmp\",\n \"def runStats(df):\\n\\tpass\",\n \"def error_data(url):\\n \\n idr = id_from_url(url)\\n xml = get_poll_lxml(idr)\\n \\n colors = plot_colors(xml)\\n if len(colors) == 0:\\n return pd.DataFrame()\\n \\n df = rcp_poll_data(xml)\\n result = race_result(url)\\n \\n #remove non-letter characters from columns\\n df = df.rename(columns={c: _strip(c) for c in df.columns})\\n for k, v in list(result.items()):\\n result[_strip(k)] = v \\n \\n candidates = [c for c in df.columns if c is not 'date']\\n \\n #turn into a timeseries...\\n df.index = df.date\\n \\n #...so that we can resample at regular, daily intervals\\n df = df.resample('D',convention='start').asfreq()\\n df = df.dropna()\\n \\n #compute forecast length in days\\n #(assuming that last forecast happens on the day of the election, for simplicity)\\n forecast_length = (df.date.max() - df.date).values\\n forecast_length = forecast_length / np.timedelta64(1, 'D') # convert to number of days\\n \\n #compute forecast error\\n errors = {}\\n normalized = {}\\n poll_lead = {}\\n\\n \\n for c in candidates:\\n #turn raw percentage into percentage of poll votes\\n \\n corr = (df[c].astype('float64') / df[candidates].astype('float64').sum(axis=1))*100.\\n \\n err = corr - result[_strip(c)]\\n \\n \\n normalized[c] = corr\\n errors[c] = err\\n \\n n = forecast_length.size\\n \\n result = {}\\n result['percentage'] = np.hstack(normalized[c] for c in candidates)\\n result['error'] = np.hstack(errors[c] for c in candidates)\\n result['candidate'] = np.hstack(np.repeat(c, n) for c in candidates)\\n result['party'] = np.hstack(np.repeat(party_from_color(colors[_strip(c)]), n) for c in candidates)\\n result['forecast_length'] = np.hstack(forecast_length for _ in candidates)\\n \\n result = pd.DataFrame(result)\\n \\n return result\",\n \"def test_non_pd_type_error(self):\\n\\n df = d.create_df_1()\\n\\n x = BaseTransformer(columns=\\\"a\\\")\\n\\n with pytest.raises(ValueError):\\n\\n x.fit(X=df, y=[1, 2, 3, 4, 5, 6])\",\n \"def makedata():\\n # train\\n print('Clean Train Dataset and separate questions')\\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\\n t = df.shape[0] * 2\\n print t\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\\n # test\\n\\n print('Clean Test Dataset and separate questions')\\n df = pd.read_csv(TEST_DATASET).fillna(' ')\\n t1 = df.shape[0] * 2\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\\n\\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\\n print len(overallquestions), t1 + t\",\n \"def evaluate_old(self, start=0):\\n\\n if self.valmode and self.nests > 0:\\n # evaluate using the old nesting scheme devised by Noah\\n # this section is deprecated and should be deleted\\n\\n log.info('Evaluating nested validation data')\\n mse_idx = ut.utils.find_modules(self, 'metrics.mean_square_error')\\n mse_idx = int(mse_idx[0])\\n try:\\n xval_idx = ut.utils.find_modules(self, 'est_val.crossval')[0]\\n except BaseException:\\n xval_idx = 1\\n\\n if start > xval_idx:\\n start = xval_idx\\n for ii in range(start, xval_idx + 1):\\n self.modules[ii].evaluate()\\n\\n start = xval_idx + 1\\n for ii in range(start, mse_idx):\\n for cv_counter in range(0, self.nests):\\n log.info(\\\"Eval %d in valmode, nest=%d\\\", cv_counter, ii)\\n st = 0\\n for m in self.fitted_modules:\\n phi_old = self.modules[m].parms2phi()\\n s = phi_old.shape\\n self.modules[m].phi2parms(\\n self.parm_fits[cv_counter][st:(st + np.prod(s))])\\n st += np.prod(s)\\n self.modules[ii].evaluate(nest=cv_counter)\\n ut.utils.concatenate_helper(\\n self, start=xval_idx + 1, end=mse_idx + 1)\\n\\n for ii in range(mse_idx, len(self.modules)):\\n self.modules[ii].evaluate()\\n\\n elif self.valmode and self.meta['nests'] > 0:\\n # new nested eval, doesn't require special evaluation procedure\\n # by modules. instead, all the remapping and collecting of val\\n # data from each nest handled inside this evaluation function.\\n\\n # 2017-09-08- still something not quite right.\\n # 2017-10-06- working finally. this is new norm for cross-val\\n stack = self\\n\\n try:\\n xval_idx = ut.utils.find_modules(stack, 'est_val.crossval')[0]\\n except BaseException:\\n xval_idx = 1\\n\\n try:\\n mse_idx = ut.utils.find_modules(\\n stack, 'metrics.mean_square_error')\\n mse_idx = int(mse_idx[0])\\n except BaseException:\\n mse_idx = len(self.modules)\\n\\n log.info(\\\"Evaluating nested validation data: xvidx={0} mseidx={1}\\\"\\n .format(xval_idx, mse_idx))\\n\\n # evaluate up to xval module (if necessary)\\n if start > xval_idx:\\n start = xval_idx\\n for ii in range(start, xval_idx):\\n log.info(\\\"eval {0} in valmode\\\".format(ii))\\n stack.modules[ii].evaluate()\\n\\n # go through each nest and evaluate stack, saving data stack to\\n # a placeholder (d_save). copy all keys from data stack except\\n # known metadata listed in exclude_keys. this allows for arbitrary\\n # new data elements to be created (stim2, etc)\\n exclude_keys = ['avgresp', 'poststim', 'fs', 'isolation', 'stimparam', 'filestate',\\n 'prestim', 'duration', 'est', 'stimFs', 'respFs',\\n 'resp_raw', 'pupil_raw']\\n include_keys = {}\\n d_save = {}\\n for cv_counter in range(0, stack.meta['nests']):\\n # for cv_counter in range(0,1):\\n stack.meta['cv_counter'] = cv_counter\\n\\n # load in parameters for appropriate nested fit\\n st = 0\\n for midx in stack.fitted_modules:\\n phi_old = stack.modules[midx].parms2phi()\\n s = phi_old.shape\\n # stack.modules[midx].phi2parms(stack.parm_fits[cv_counter][st:(st+np.prod(s))])\\n stack.modules[midx].phi2parms(\\n stack.parm_fits[cv_counter][st:(st + np.prod(s))])\\n st += np.prod(s)\\n\\n # evaluate stack for this nest up to before error metric\\n # modules\\n for ii in range(xval_idx, mse_idx):\\n log.info(\\\"nest={0}, eval {1} in valmode\\\"\\n .format(cv_counter, ii))\\n stack.modules[ii].evaluate()\\n\\n # append data from this (nest,module) onto d_save\\n # placeholders:\\n if cv_counter == 0:\\n include_keys[ii] = stack.modules[ii].d_out[0].keys(\\n ) - exclude_keys\\n d_save[ii] = copy.deepcopy(stack.modules[ii].d_out)\\n log.info(include_keys[ii])\\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\\n if not d['est'] and cv_counter > 0:\\n for k in include_keys[ii]:\\n if d[k] is None or d[k] == []:\\n pass\\n elif k == 'pupil' and d[k].ndim == 3 and d['resp'].shape[1] != d[k].shape[1]:\\n d2[k] = np.append(d2[k], d[k], axis=2)\\n elif d[k].ndim == 3:\\n d2[k] = np.append(d2[k], d[k], axis=1)\\n else:\\n d2[k] = np.append(d2[k], d[k], axis=0)\\n\\n # save accumulated data stack back to main data stack\\n\\n # figure out mapping to get val data back into original order\\n for ii in range(xval_idx, mse_idx):\\n jj = -1\\n for d, d2 in zip(stack.modules[ii].d_out, d_save[ii]):\\n if not d['est']:\\n jj += 1 # count validation files only\\n validx = np.concatenate(\\n stack.modules[xval_idx].validx_sets[jj])\\n mapidx = np.argsort(validx)\\n for k in include_keys[ii]:\\n if d2[k] is None or d[k] == []:\\n d[k] = d2[k]\\n elif k == 'pupil' and d[k].ndim == 3 and d2['resp'].shape[1] != d2[k].shape[1]:\\n d[k] = d2[k][:, :, mapidx]\\n elif d[k].ndim == 3:\\n d[k] = d2[k][:, mapidx, :]\\n elif d[k].ndim == 2:\\n d[k] = d2[k][mapidx, :]\\n else:\\n d[k] = d2[k][mapidx]\\n\\n # continue standard evaluation of later stack elements\\n for ii in range(mse_idx, len(self.modules)):\\n log.info(\\\"eval {0} in valmode\\\".format(ii))\\n self.modules[ii].evaluate()\\n\\n else:\\n # standard evaluation when not using nested cross-validation\\n for ii in range(start, len(self.modules)):\\n self.modules[ii].evaluate()\",\n \"def evaluate(model, df_result, label='test'):\\n\\n y_true = df_result['RUL']\\n y_hat = df_result['y_hat']\\n df_result['breakdown'].replace(0, False, inplace=True) # rsf only takes true or false\\n df_result['breakdown'].replace(1, True, inplace=True) # rsf only takes true or false\\n\\n mse = mean_squared_error(y_true, y_hat)\\n rmse = np.sqrt(mse)\\n variance = r2_score(y_true, y_hat)\\n\\n # the concordance index (CI) is interested on the order of the predictions, not the predictions themselves\\n # CI can only be measured between individual samples where a censoring or failure event occurred\\n # https://medium.com/analytics-vidhya/concordance-index-72298c11eac7#:~:text=The%20concordance%20index%20or%20c,this%20definition%20mean%20in%20practice\\n df_result_grouped = df_result.groupby('unit num').last()\\n breakdown = df_result_grouped['breakdown']\\n y_true = df_result_grouped['RUL']\\n y_hat = df_result_grouped['y_hat']\\n ci_sk = ci_scikit(breakdown, y_true, y_hat)[0]\\n score = nasaScore(y_true, y_hat) # score should be based on the last instance\\n # print(f'Number of concordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[1]}')\\n # print(f'Number of discordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[2]}')\\n # print(f'Number of pairs having tied estimated risks (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[3]}')\\n # print(f'Number of comparable pairs sharing the same time (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[4]}')\\n print('{} set RMSE:{:.2f}, Score:{:.2f}, CI(scikit):{:.4f}, R2:{:.2f}'.format(label, rmse, score, ci_sk, variance))\\n result = [model, label, rmse, score, ci_sk, variance]\\n return result\",\n \"def sanity_checks(df: pd.DataFrame) -> None:\\n df_temp = df.copy()\\n # checks that the max date is less than tomorrow's date.\\n assert datetime.datetime.strptime(df_temp['Date'].max(), '%Y-%m-%d') < (datetime.datetime.utcnow() + datetime.timedelta(days=1))\\n # checks that there are no duplicate dates\\n assert df_temp['Date'].duplicated().sum() == 0, 'One or more rows share the same date.'\\n if 'Cumulative total' not in df_temp.columns:\\n df_temp['Cumulative total'] = df_temp['Daily change in cumulative total'].cumsum()\\n # checks that the cumulative number of tests on date t is always greater than the figure for t-1:\\n assert (df_temp['Cumulative total'].iloc[1:] >= df_temp['Cumulative total'].shift(1).iloc[1:]).all(), \\\"On one or more dates, `Cumulative total` is greater on date t-1.\\\"\\n # df.iloc[1:][df['Cumulative total'].iloc[1:] < df['Cumulative total'].shift(1).iloc[1:]]\\n # cross-checks a sample of scraped figures against the expected result.\\n assert len(sample_official_data) > 0\\n for dt, d in sample_official_data:\\n val = df_temp.loc[df_temp['Date'] == dt, SERIES_TYPE].squeeze().sum()\\n assert val == d[SERIES_TYPE], f\\\"scraped value ({val:,d}) != official value ({d[SERIES_TYPE]:,d}) on {dt}\\\"\\n return None\",\n \"def place_evaluation_data(self):\\n monthly_data = self.Scenario.get('monthly_data')\\n time_series = self.Scenario.get('time_series')\\n\\n if time_series is not None or monthly_data is not None:\\n for value_stream in self.value_streams.values():\\n value_stream.update_price_signals(monthly_data, time_series)\\n\\n if 'customer_tariff' in self.Finance:\\n self.tariff = self.Finance['customer_tariff']\\n\\n if 'User' in self.value_streams.keys():\\n self.update_with_evaluation(self.value_streams['User'], self.valuestream_values['User'], self.verbose)\\n\\n for der_inst in self.ders:\\n der_tag = der_inst.tag\\n der_id = der_inst.id\\n evaluation_inputs = self.ders_values.get(der_tag, {}).get(der_id)\\n if evaluation_inputs is not None:\\n der_inst.update_for_evaluation(evaluation_inputs)\",\n \"def evaluate(self, valid_x, valid_y):\\n results = self.model.evaluate(valid_x, valid_y, batch_size=self.BATCH_SIZE)\\n print(results)\\n return results[1:] + [\\\"NaN\\\"]\",\n \"def fit(self):\\n self.model = RegressionModel(model_expression=self.model_expression,\\n fit_filters=self.filters, predict_filters=self.out_filters,\\n ytransform=None, name=self.name)\\n\\n df = get_data(tables = self.tables,\\n filters = self.filters,\\n model_expression = self.model_expression)\\n \\n results = self.model.fit(df)\\n \\n self.name = self._generate_name()\\n self.summary_table = str(results.summary())\\n print(self.summary_table)\\n \\n # We don't strictly need to save the fitted parameters, because they are also\\n # contained in the urbansim.models.RegressionModel() sub-object. But maintaining\\n # a parallel data structure to other templates will make it easier to refactor the\\n # code later on to not rely on RegressionModel any more. \\n \\n self.fitted_parameters = results.params.tolist()\\n self.residuals = results.resid\",\n \"def _eval_classifier(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\\n try:\\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\\n except ValueError:\\n auc_baseline = \\\"NA\\\"\\n\\n precision_sample = precision_score(y_label_sample, y_pred_sample)\\n recall_sample = recall_score(y_label_sample, y_pred_sample)\\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\\n f1_sample = f1_score(y_label_sample, y_pred_sample)\\n try:\\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\\n except ValueError:\\n auc_sample = \\\"NA\\\"\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"Accuracy\\\": [acc_baseline, acc_sample],\\n \\\"Precision\\\": [precision_baseline, precision_sample],\\n \\\"Recall\\\": [recall_baseline, recall_sample],\\n \\\"F1\\\": [f1_baseline, f1_sample],\\n \\\"AUC\\\": [auc_baseline, auc_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def test_create_dataframe(chosen_columns, chosen_url):\\n print(\\\"reading in data\\\")\\n chosen_df = readindata(chosen_columns, chosen_url)\\n print(\\\"checking columns\\\")\\n checkcolumnstest(chosen_columns, chosen_df)\\n print(\\\"checking types\\\")\\n checktypestest(chosen_df)\\n print(\\\"checking for Nan\\\")\\n checkfornan(chosen_df)\\n print(\\\"checking 1 row\\\")\\n checkrowstest(chosen_df)\\n return True\",\n \"def _evaluate(self,\\n logits,\\n predictions,\\n data, evaluation_fn,\\n max_eval_batches=None,\\n calculate_scores=True,\\n write_results=False):\\n # counting the evaluation batches\\n num_eval_batches = 0\\n # logits and predictions from the model\\n all_logits = []\\n all_predictions = []\\n # fetched data that led to the predictions\\n # dictionary of {seq_1: [], seq_2: [], target: []}\\n all_fetched_data = collections.defaultdict(list)\\n try:\\n while True:\\n # sample predictions\\n (fetched_logits,\\n fetched_predictions,\\n fetched_data) = self._fetch_data_batch(\\n logits=logits, predictions=predictions, data=data)\\n\\n # Cache the data\\n all_logits += fetched_logits\\n all_predictions += fetched_predictions\\n all_fetched_data[\\\"target\\\"] += fetched_data[\\\"target\\\"]\\n\\n # break the loop if max_eval_batches is set\\n num_eval_batches += 1\\n if (max_eval_batches and\\n num_eval_batches >= max_eval_batches):\\n break\\n\\n except tf.errors.OutOfRangeError:\\n pass\\n\\n # Evaluate\\n scores = None\\n if calculate_scores:\\n scores = evaluation_fn(\\n all_predictions,\\n all_fetched_data[\\\"seq_1\\\"], # Should be empty\\n all_fetched_data[\\\"seq_2\\\"], # Should be empty\\n all_fetched_data[\\\"target\\\"])\\n\\n if write_results:\\n _write_results_to_csv(\\n all_logits,\\n all_predictions,\\n all_fetched_data,\\n output_dir=os.path.join(\\n self._logdir, RESULTS_CSV_FNAME))\\n\\n return len(all_predictions), scores\",\n \"def walkforward_validation(data, test_start_date, test_end_date=None, step_size=15, testsize=15, model='SARIMA'):\\n test_start_date = pd.to_datetime(test_start_date)\\n current_max_date = test_start_date\\n\\n modelling_results = pd.DataFrame(columns=['series_name', 'model_type', 'test_start', 'test_end', 'MAE', 'MAPE', 'RMSE'])\\n\\n if test_end_date is None:\\n test_end_date = data.index.max()\\n test_end_date = pd.to_datetime(test_end_date)\\n else:\\n test_end_date = pd.to_datetime(test_end_date)\\n\\n while current_max_date < test_end_date:\\n data.index = pd.to_datetime(data.index)\\n iter_data = data[data.index <= current_max_date + timedelta(days=testsize)]\\n test, train = test_train_spl(iter_data, testsize=testsize)\\n\\n if (model.upper() == 'SARIMA') | (model.upper() == 'SARIMAX'):\\n print('USING SARIMA MODEL')\\n mae, rmse, mape, name, preds, conf_intervals = mod_sarima(train=train, test=test, **arima_model_params)\\n elif model.upper() == 'PROPHET':\\n print('USING PROPHET MODEL')\\n mae, rmse, mape, name, preds, conf_intervals = mod_prophet(train=train, test=test, **prophet_model_params)\\n else:\\n print('model name not known')\\n iter_results = pd.DataFrame({'series_name': name, 'model_type': model, 'test_start': [current_max_date],\\n 'test_end': [current_max_date + timedelta(testsize)], 'MAE': [mae], 'MAPE': [mape], 'RMSE': [rmse]})\\n modelling_results = modelling_results.append(iter_results, ignore_index=True)\\n\\n # this line is just for validation of the effect of regressors in the forecast\\n preds.to_csv(mod_report_path + arima_model_params['name'] + 'forecast_' + str(current_max_date).replace(':', '')+ '.csv')\\n\\n current_max_date = current_max_date + timedelta(days=step_size)\\n\\n return modelling_results\",\n \"def execute(self, params):\\n\\n if \\\"train_df\\\" in params.keys():\\n self.train_df = params[\\\"train_df\\\"]\\n if \\\"test_df\\\" in params.keys():\\n self.test_df = params[\\\"test_df\\\"]\\n if \\\"cat_cols\\\" in params.keys():\\n self.cat_cols = params[\\\"cat_cols\\\"]\\n if \\\"replace_cat_nulls\\\" in params.keys():\\n self.replace_cat_nulls = params[\\\"replace_cat_nulls\\\"]\\n if \\\"drop_cols\\\" in params.keys():\\n self.drop_cols = params[\\\"drop_cols\\\"]\\n if \\\"fill_missing\\\" in params.keys():\\n self.fill_missing = params[\\\"fill_missing\\\"]\\n if \\\"fill_values\\\" in params.keys():\\n self.fill_values = params[\\\"fill_values\\\"]\\n\\n self.__validate_input()\\n\\n self.__categoricalnull()\\n if self.drop_cols is not None:\\n (\\n self.train_df,\\n self.test_df,\\n ) = self.__drop_column_with_null_values()\\n\\n if self.fill_missing is not None:\\n if \\\"mean\\\" in self.fill_missing.keys():\\n self.train_df, self.test_df = self.__fill_missing_with_mean(\\n self.fill_missing[\\\"mean\\\"]\\n )\\n if \\\"median\\\" in self.fill_missing.keys():\\n self.train_df, self.test_df = self.__fill_missing_with_median(\\n self.fill_missing[\\\"median\\\"]\\n )\\n\\n if self.fill_values is not None:\\n self.train_df, self.test_df = self.__fill_values_columns()\\n\\n (\\n self.final_train,\\n self.final_test,\\n ) = self.__drop_all_rows_with_null_values()\\n\\n params[\\\"train_df\\\"] = self.final_train\\n params[\\\"test_df\\\"] = self.final_test\",\n \"def convert_to_data_frame(result, exp_name, nets, critic, loss, seed):\\n label = \\\"{}, {}, {}\\\".format(nets, critic, loss)\\n rows = list(\\n zip(\\n itertools.repeat(exp_name),\\n itertools.repeat(nets),\\n itertools.repeat(critic),\\n itertools.repeat(loss),\\n itertools.repeat(seed),\\n result.iterations,\\n [-loss for loss in result.testing_losses], # Loss -> bound.\\n result.classification_accuracies,\\n itertools.repeat(label)))\\n df_eval = pd.DataFrame(\\n rows,\\n columns=(\\\"exp_name\\\", \\\"nets\\\", \\\"Critic\\\", \\\"Estimator\\\",\\n \\\"run\\\", \\\"iteration\\\", \\\"bound_value\\\", \\\"accuracy\\\", \\\"label\\\"))\\n\\n df_eval[\\\"Estimator\\\"] = df_eval[\\\"Estimator\\\"].replace(\\n to_replace={\\n \\\"cpc\\\": \\\"$CPC$\\\",\\n \\\"pcc\\\": \\\"$PCC$\\\",\\n \\\"drfc\\\": \\\"$D-RFC$\\\",\\n \\\"wpc\\\": \\\"$WPC$\\\"\\n })\\n df_eval[\\\"Critic\\\"] = df_eval[\\\"Critic\\\"].replace(\\n to_replace={\\n \\\"concat\\\": \\\"MLP\\\",\\n \\\"separable\\\": \\\"Separable\\\",\\n \\\"innerprod\\\": \\\"Inner product\\\",\\n \\\"bilinear\\\": \\\"Bilinear\\\"\\n })\\n return df_eval\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def _get_consent_validation_dataframe(self, sql_template):\\n if not self.db_conn:\\n raise (EnvironmentError, 'No active DB connection object')\\n\\n df = pandas.DataFrame()\\n for consent_int in CONSENTS_LIST:\\n sql = sql_template\\n # The tuple retrieved from the CONSENT_PARTICIPANT_SUMMARY_FIELDS dict has two elements like:\\n # ('consent_for_study_enrollment', 'consent_for_study_enrollment_first_yes_authored')\\n consent_status_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][0]\\n consent_authored_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][1]\\n sql = sql.format_map(SafeDict(consent_type=consent_int,\\n status_field=consent_status_field,\\n authored_field=consent_authored_field,\\n missing_check_mark=ConsentOtherErrors.MISSING_CONSENT_CHECK_MARK,\\n non_va_for_va=ConsentOtherErrors.NON_VETERAN_CONSENT_FOR_VETERAN,\\n va_for_non_va=ConsentOtherErrors.VETERAN_CONSENT_FOR_NON_VETERAN\\n ))\\n consent_df = pandas.read_sql_query(sql, self.db_conn)\\n # Replace any null values in the calculated error flag columns with (uint8 vs. pandas default float) zeroes\\n for error_type in TRACKED_CONSENT_ERRORS:\\n consent_df = consent_df.fillna({error_type: 0}).astype({error_type: 'uint8'})\\n\\n df = df.append(consent_df)\\n\\n # Temporary? Attempt to filter false positives for va_consent_for_non_va consent version errors out of the\\n # generated dataframe\\n df = self._remove_potential_false_positives_for_consent_version(df)\\n\\n return df\",\n \"def run(self):\\n\\t\\tself.print_header_information()\\n\\n\\t\\t#self.get_number_of_instances_from_user()\\n\\n\\t\\t#self.compile_dataframe(self.number_of_instances)\\n\\n\\t\\tprint \\\"\\\\n{}\\\".format(self.data)\\n\\n\\t\\t# Uncomment these lines for debugging\\n\\t\\tself.compile_dataframe_default()\\n\\t\\t# print \\\"\\\\n{}\\\".format(self.data)\\n\\n\\t\\tself.analysis_of_dataframe(self.data)\",\n \"def get_datadfs(self, recal=True):\\n\\n # those files contain score >1\\n trn_fname = os.path.join(self.save_dir, 'reg_trn_set_df.csv')\\n val_fname = os.path.join(self.save_dir, 'reg_val_set_df.csv')\\n tst_fname = os.path.join(self.save_dir, 'reg_tst_set_df.csv')\\n\\n if os.path.exists(trn_fname) and os.path.exists(val_fname) and os.path.exists(tst_fname) and not recal:\\n logging.info('reading...\\\\n{}\\\\n{}\\\\n{}'.format(trn_fname, val_fname, tst_fname))\\n trn_set_df = pd.read_csv(trn_fname, sep='\\\\t')\\n val_set_df = pd.read_csv(val_fname, sep='\\\\t')\\n tst_set_df = pd.read_csv(tst_fname, sep='\\\\t')\\n else:\\n # read phage and bact relation file\\n data_meta_info_f = self.config['data_meta_info']\\n if not os.path.exists(data_meta_info_f):\\n logging.error('data meta information file not Found. {}'.format(data_meta_info_f))\\n raise FileNotFoundError('data meta information file not Found')\\n data_info = pd.read_csv(data_meta_info_f)\\n logging.info('total samples: {}'.format(len(data_info)))\\n\\n # select specific columns\\n sel_cols = 'hostID,phageID,b_Score,phage_bac_name,bac_len,phage_len'.split(',')\\n data_info_df = data_info[sel_cols]\\n\\n # select rows with score > 1\\n data_info_sel = data_info_df[data_info_df['b_Score'] > 1].copy()\\n data_info_sel.reset_index(drop=True, inplace=True)\\n\\n b_scores = data_info_sel['b_Score'].values\\n b_scores = b_scores.reshape(-1, 1)\\n\\n # MinMaxScaler()\\n mm_scaler = MinMaxScaler()\\n mm_scaler.fit(b_scores)\\n mm_scaler_fname = os.path.join(self.save_dir, 'minmax_scaler.joblib')\\n if os.path.exists(mm_scaler_fname):\\n os.remove(mm_scaler_fname)\\n dump(mm_scaler, mm_scaler_fname)\\n data_info_sel['minmax_bscore'] = np.squeeze(mm_scaler.transform(b_scores))\\n\\n # StandardScaler()\\n ss_scaler = StandardScaler()\\n ss_scaler.fit(b_scores)\\n ss_scaler_fname = os.path.join(self.save_dir, 'standard_scaler.joblib')\\n if os.path.exists(ss_scaler_fname):\\n os.remove(ss_scaler_fname)\\n dump(ss_scaler, ss_scaler_fname)\\n data_info_sel['norm_bscore'] = np.squeeze(ss_scaler.transform(b_scores))\\n\\n # MaxAbsScaler()\\n ma_scaler = MaxAbsScaler()\\n ma_scaler.fit(b_scores)\\n ma_scaler_fname = os.path.join(self.save_dir, 'maxabs_scaler.joblib')\\n if os.path.exists(ma_scaler_fname):\\n os.remove(ma_scaler_fname)\\n dump(ma_scaler, ma_scaler_fname)\\n data_info_sel['maxabs_bscore'] = np.squeeze(ma_scaler.transform(b_scores))\\n\\n logging.info('number of samples with score > 1 : {}'.format(len(data_info_sel)))\\n\\n # creat train, validation and test dataset\\n # split dataframe, 80% for train , 10% for validation and 10% for test\\n trn_set_df, val_set_df, tst_set_df = np.split(data_info_sel.sample(frac=1, random_state=1),\\n [int(.7*len(data_info_sel)), int(.85*len(data_info_sel))])\\n\\n trn_set_df.reset_index(drop=True, inplace=True)\\n val_set_df.reset_index(drop=True, inplace=True)\\n tst_set_df.reset_index(drop=True, inplace=True)\\n\\n if os.path.exists(trn_fname):\\n os.remove(trn_fname)\\n trn_set_df.to_csv(trn_fname, sep='\\\\t', index=False)\\n if os.path.exists(val_fname):\\n os.remove(val_fname)\\n val_set_df.to_csv(val_fname, sep='\\\\t', index=False)\\n if os.path.exists(tst_fname):\\n os.remove(tst_fname)\\n tst_set_df.to_csv(tst_fname, sep='\\\\t', index=False)\\n\\n logging.info('train sample: {}'.format(len(trn_set_df)))\\n logging.info('valid sample: {}'.format(len(val_set_df)))\\n logging.info('test sample: {}'.format(len(tst_set_df)))\\n\\n return trn_set_df, val_set_df, tst_set_df\",\n \"def task_3():\\n threshold = [0.86, 0.87, 0.88, 0.89]\\n for t in threshold: \\n # Create a list to store the number of iteration that DE converge \\n # @ given threshold for p1(5, 40), p2(10, 20), p3(20, 10), p4(40, 5) \\n iter_p1 = []\\n iter_p2 = [] \\n iter_p3 = [] \\n iter_p4 = []\\n \\n # Create a list to store the cost at the end of the DE \\n # p1(5, 40), p2(10, 20), p3(20, 10), p4(40, 5)\\n cost_p1 = []\\n cost_p2 = []\\n cost_p3 = []\\n cost_p4 = [] \\n \\n # Run the experiment and record the result for the given threshold\\n experiment(t)\\n \\n # Loop over experiment and record the number of iteration of each set of param\\n # for 30 times\\n for i in range(30):\\n record = experiment(t) # replace the argument with the testing threshold\\n iter_p1.append(record[0][0])\\n iter_p2.append(record[1][0])\\n iter_p3.append(record[2][0])\\n iter_p4.append(record[3][0])\\n \\n cost_p1.append(record[0][1])\\n cost_p2.append(record[1][1])\\n cost_p3.append(record[2][1])\\n cost_p4.append(record[3][1])\\n \\n # Convert the result into a dictionary then transform it to a pandas DataFrame\\n iteration_dict = {\\\"iteration(5,40)\\\":iter_p1, \\\"iteration(10,20)\\\":iter_p2, \\n \\\"iteration(20,10)\\\": iter_p3, \\\"iteration(40,5)\\\": iter_p4}\\n cost_dict = {\\\"cost(5,40)\\\": cost_p1, \\\"cost(10,20)\\\": cost_p2, \\n \\\"cost(20,10)\\\": cost_p3, \\\"cost(40,5)\\\":cost_p4}\\n df_iteration = pd.DataFrame.from_dict(iteration_dict) \\n df_iteration.to_csv(\\\"iteration_\\\" + str(t) + \\\".csv\\\")\\n \\n df_cost = pd.DataFrame.from_dict(cost_dict)\\n df_cost.to_csv(\\\"cost_\\\" + str(t) + \\\".csv\\\")\",\n \"def evaluate(self, test_data):\\n result = self.model.run(test_data)\\n self._save_result(result)\",\n \"def fit(self, df):\\n try:\\n df = df.astype(float)\\n except Exception:\\n raise ValueError(\\\"Data Cannot Be Converted to Numeric Float\\\")\\n\\n y = df.values\\n if y.shape[1] == 1:\\n y = y.ravel()\\n X = date_part(df.index, method=self.datepart_method)\\n from autots.models.sklearn import retrieve_regressor\\n\\n multioutput = True\\n if y.ndim < 2:\\n multioutput = False\\n elif y.shape[1] < 2:\\n multioutput = False\\n self.model = retrieve_regressor(\\n regression_model=self.regression_model,\\n verbose=0,\\n verbose_bool=False,\\n random_seed=2020,\\n multioutput=multioutput,\\n )\\n self.model = self.model.fit(X, y)\\n self.shape = df.shape\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65705955","0.61609674","0.61391914","0.61067426","0.60614115","0.60162455","0.60003746","0.59906065","0.59698033","0.5951393","0.5951041","0.5949095","0.5932602","0.5929731","0.59138703","0.58937687","0.5890896","0.5842125","0.58418965","0.582007","0.58184004","0.5817621","0.5801765","0.57826555","0.5768382","0.5768192","0.5758077","0.574172","0.5729105","0.57228696","0.57219535","0.5721753","0.57172036","0.5715232","0.5711591","0.57071364","0.5705399","0.5701634","0.56984025","0.5696877","0.569561","0.56955975","0.5695082","0.569233","0.5690107","0.5665346","0.56608427","0.5658824","0.5651286","0.56473583","0.56437266","0.5643516","0.5639533","0.56388575","0.5634892","0.5628498","0.5624037","0.5614359","0.56129605","0.56123894","0.5608401","0.5606474","0.56016916","0.5594937","0.5593603","0.55859995","0.5582146","0.55715495","0.5567649","0.556214","0.5548116","0.5542223","0.55415237","0.55407417","0.55352217","0.55347484","0.5530799","0.552984","0.552715","0.5519563","0.5516009","0.55070955","0.5494062","0.54859716","0.54834753","0.5482236","0.5479207","0.5470553","0.54629236","0.545367","0.5452507","0.545106","0.5436062","0.54298997","0.5428468","0.5427401","0.54260224","0.54213965","0.5421205","0.54172474"],"string":"[\n \"0.65705955\",\n \"0.61609674\",\n \"0.61391914\",\n \"0.61067426\",\n \"0.60614115\",\n \"0.60162455\",\n \"0.60003746\",\n \"0.59906065\",\n \"0.59698033\",\n \"0.5951393\",\n \"0.5951041\",\n \"0.5949095\",\n \"0.5932602\",\n \"0.5929731\",\n \"0.59138703\",\n \"0.58937687\",\n \"0.5890896\",\n \"0.5842125\",\n \"0.58418965\",\n \"0.582007\",\n \"0.58184004\",\n \"0.5817621\",\n \"0.5801765\",\n \"0.57826555\",\n \"0.5768382\",\n \"0.5768192\",\n \"0.5758077\",\n \"0.574172\",\n \"0.5729105\",\n \"0.57228696\",\n \"0.57219535\",\n \"0.5721753\",\n \"0.57172036\",\n \"0.5715232\",\n \"0.5711591\",\n \"0.57071364\",\n \"0.5705399\",\n \"0.5701634\",\n \"0.56984025\",\n \"0.5696877\",\n \"0.569561\",\n \"0.56955975\",\n \"0.5695082\",\n \"0.569233\",\n \"0.5690107\",\n \"0.5665346\",\n \"0.56608427\",\n \"0.5658824\",\n \"0.5651286\",\n \"0.56473583\",\n \"0.56437266\",\n \"0.5643516\",\n \"0.5639533\",\n \"0.56388575\",\n \"0.5634892\",\n \"0.5628498\",\n \"0.5624037\",\n \"0.5614359\",\n \"0.56129605\",\n \"0.56123894\",\n \"0.5608401\",\n \"0.5606474\",\n \"0.56016916\",\n \"0.5594937\",\n \"0.5593603\",\n \"0.55859995\",\n \"0.5582146\",\n \"0.55715495\",\n \"0.5567649\",\n \"0.556214\",\n \"0.5548116\",\n \"0.5542223\",\n \"0.55415237\",\n \"0.55407417\",\n \"0.55352217\",\n \"0.55347484\",\n \"0.5530799\",\n \"0.552984\",\n \"0.552715\",\n \"0.5519563\",\n \"0.5516009\",\n \"0.55070955\",\n \"0.5494062\",\n \"0.54859716\",\n \"0.54834753\",\n \"0.5482236\",\n \"0.5479207\",\n \"0.5470553\",\n \"0.54629236\",\n \"0.545367\",\n \"0.5452507\",\n \"0.545106\",\n \"0.5436062\",\n \"0.54298997\",\n \"0.5428468\",\n \"0.5427401\",\n \"0.54260224\",\n \"0.54213965\",\n \"0.5421205\",\n \"0.54172474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7769943"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81392,"cells":{"query":{"kind":"string","value":"Returns roman equivalent to an arabic"},"document":{"kind":"string","value":"def to_roman(an_arabic):\n result = \"\"\n\n for level, symbol in [(1000,\"M\"),\n (900,\"CM\"),\n (500,\"D\"),\n (400,\"CD\"),\n (100,\"C\"),\n (90,\"XC\"),\n (50,\"L\"),\n (40,\"XL\"),\n (10,\"X\"),\n (9,\"IX\"),\n (5,\"V\"),\n (4,\"IV\"),\n (1,\"I\")]:\n\n while an_arabic >= level:\n result += symbol\n an_arabic -= level\n \n return result"},"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 arabic_to_roman_replace(test_word):\n arabic_word = test_word\n\n \"\"\"\n testWord = \"دَرْس\"\n print(testWord, sep=\" \")\n \"\"\"\n\n # converting into roman characters\n print()\n roman_characters = \"\"\n for letter in arabic_word:\n #print(letter)\n if letter in dictionary:\n roman_characters += Dictionary.get_lebanese_to_roman_char(letter) #.roman_text #Dictionary.get_lebanese_to_roman_char(letter)\n elif letter in dictionary_vowels:\n roman_characters += dictionary_vowels[letter]\n # print(\"test\")\n elif letter == \" \":\n roman_characters += \" \"\n return roman_characters\n ####print(str(roman_characters), str(test_word))\n\n # مِلْء\n #####plans for improving the program#####","def toRoman(n):\n pass","def fromRoman(s):\n pass","def romanify(num):\n result = \"\"\n return result","def romanize(digit, glyphs):\n if 1 <= digit <= 3:\n return digit*glyphs[0]\n elif digit == 4:\n return glyphs[0] + glyphs[1]\n elif digit >= 5 and digit <= 8:\n return glyphs[1] + ((digit - 5) * glyphs[0])\n elif digit == 9:\n return glyphs[0]+glyphs[2]\n else:\n return ''","def toRoman(n):\n result = \"\"\n for numeral, integer in romanNumeralMap:\n while n >= integer:\n result += numeral\n n -= integer\n return result","def num2roman(num):\n roman = ''\n while num > 0:\n for i, r in ROMAN_MAP:\n while num >= i:\n roman += r\n num -= i\n return roman","def _RomanToLatin(self, roman_numerals):\n roman = roman_numerals.strip().upper()\n return {'I': '1', 'II': '2', 'III': '3', 'IV': '4', 'V': '5'}[roman]","def romanify(num):\n result = \"\"\n onesDict = {1:\"I\", 2: \"II\", 3: \"III\", 4: \"IV\", 5: \"V\", 6: \"VI\", 7: \"VII\", 8: \"VIII\", 9: \"IX\", 0:\"\"}\n ones = num%10\n num-=num%10\n result = onesDict[ones] + result\n tensDict = {10:\"X\", 20: \"XX\", 30: \"XXX\", 40:\"XL\", 50:\"L\", 60:\"LX\", 70: \"LXX\", 80: \"LXXX\", 90: \"XC\", 0:\"\"}\n tens = num%100\n num-=num%100\n result = tensDict[tens] + result\n hunsDict = {100:\"C\", 200: \"CC\", 300: \"CCC\", 400:\"CD\", 500:\"D\", 600:\"DC\", 700: \"DCC\", 800: \"DCCC\", 900: \"CM\", 0:\"\"}\n huns = num%1000\n num-=num%1000\n result = hunsDict[huns] + result\n thous = num/1000\n result = \"M\"*thous + result\n \n return result","def int_to_roman(i):\n result = []\n for integer, numeral in NUMERAL_MAP:\n count = i // integer\n result.append(numeral * count)\n i -= integer * count\n return ''.join(result)","def to_roman(n: Union[Integral, np.integer]) -> str:\n if not isinstance(n, (Integral, np.integer)):\n raise TypeError(f\"{n} cannot be converted to a Roman numeral.\")\n if not (0 < n < 5000):\n raise OutOfRangeError(\"Number is out of range (need 0 < n < 5000)\")\n\n result = \"\"\n for numeral, integer in _romanNumeralMap:\n while n >= integer:\n result += numeral\n n -= integer\n return result","def to_roman(numeral):\n mapping = {\n 'M': 1000,\n 'CM': 900,\n 'D': 500,\n 'CD': 400,\n 'C': 100,\n 'XC': 90,\n 'L': 50,\n 'XL': 40,\n 'X': 10,\n 'IX': 9,\n 'V': 5,\n 'IV': 4,\n 'I': 1\n }\n romans = {v:k for k,v in mapping.items()}\n result = ''\n\n for divisor, symbol in romans.items():\n count = numeral // divisor\n remainder = numeral % divisor\n numeral = remainder\n result += symbol * count\n\n return result","def intToRoman(self, num: int) -> str:\n\n # Last remainder\n remainder = num\n\n # Initial string\n roman = \"\"\n\n # Loops through all remainder values\n for v in self.values:\n division = remainder // v\n remainder = remainder % v\n\n # Adds to the string only if division is not empty.\n if division != 0:\n roman += self.symbols[v] * division\n\n return roman","def to_roman(n):\n if not isinstance(n, int):\n try:\n n = int(n)\n except ValueError:\n raise NotIntegerError(\"non-integers cannot be converted\")\n\n if not (0 < n < 4000):\n raise OutOfRangeError(\"number out of range (must be 1..3999)\")\n\n result = \"\"\n for numeral, integer in ROMAN_NUMBER_MAP:\n while n >= integer:\n result += numeral\n n -= integer\n return result","def formatRomanNumeral(rn, key):\n # Something of \"I\" and \"I\" of something\n if rn == \"I/I\":\n rn = \"I\"\n return rn","def toRoman(n):\n if not isinstance(n, int):\n raise NorIntegerError(\"decimals can not be converted\")\n if not (0 < n < 5000):\n raise OutOfRangeError(\"number out of range (must be 1..4999)\")\n \n result = \"\"\n for numeral, integer in romanNumeralMap:\n while n >= integer:\n result += numeral\n n -= integer\n return result","def romanize(string: str, locale: t.Union[Locale, str]) -> str:\n locale = validate_locale(locale)\n\n if locale not in (Locale.RU, Locale.UK, Locale.KK):\n raise ValueError(f\"Romanization is not available for: {locale}\")\n\n table = _get_translation_table(locale)\n\n return string.translate(table)","def uCSIsArabic(code):\n ret = libxml2mod.xmlUCSIsArabic(code)\n return ret","def roman_converter(number):\n num_dict = {'I': '1', 'II': '2', 'III': '3', 'IIII': '4', 'V': '5', 'VI': '6', 'VII': '7', 'VIII': '8', 'VIIII': '9', 'X': '10'}\n if number in num_dict:\n return num_dict[number]\n return number","def _int_to_roman(self, i):\n numeral_map = zip((1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),\n ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'))\n result = []\n for integer, numeral in numeral_map:\n count = int(i / integer)\n result.append(numeral * count)\n i -= integer * count\n return ''.join(result)","def roman_to_arabic_previous(roman):\n result = [0]\n previous_number = 4000\n p_previous_number = 4001\n # we store 2 previous numbers in order to check is\n # this number still correct\n for i, char in enumerate(roman):\n if char in MAP_ROMAN:\n number = MAP_ROMAN[char]\n # Chars in Roman numbers should decrease if not 3 same chars in line\n if p_previous_number <= number and previous_number != number:\n raise ValueError('Wrong Roman Number (...1)')\n if number > previous_number:\n # minus previous number if current > previous\n # IV: 5 - 1, IX: 10 - 1, XC: 100 - 10\n if number % previous_number < 5:\n sign = -1\n else:\n raise ValueError('Wrong Roman number (...2)')\n else:\n sign = 1\n\n print_debug(i, roman, char, number, previous_number, sign)\n\n result[-1] *= sign\n result.append(number)\n p_previous_number = previous_number\n previous_number = number\n else:\n raise ValueError('Unknown char \"%s\" in input roman number' % char)\n counts = defaultdict(int)\n\n # test for same multiple Roman numbers\n for number in result:\n num = abs(number)\n counts[num] += 1\n if counts[num] > 3:\n raise ValueError('Wrong Roman number (...3)')\n\n return sum(result)","def toRoman(dec):\t\t\n if dec <=0:\n\t raise ValueError, \"It must be a positive\"\n # to avoid MMMM\n\telif dec>=4000: \n\t raise ValueError, \"It must be lower than MMMM(4000)\"\n \n\treturn decToRoman(dec,\"\",decimalDens,romanDens)","def int_to_roman(input_rom): # Konverter v rimske številke. Nisem avtor te funkcije.\n ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)\n nums = ('M', 'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I')\n result = []\n for i in range(len(ints)):\n count = int(input_rom / ints[i])\n result.append(nums[i] * count)\n input_rom -= ints[i] * count\n return ''.join(result)","def roman_numerals(text):\n return re.findall(r\"\\b([IVXLCDM]+)\\b\", text)","def int2roman(i, lower=False):\n warn('The function int2roman is deprecated from JAMS. Use module pyjams.',\n category=DeprecationWarning)\n assert i >= 1, 'integer must be > 0.'\n result = []\n for integer, numeral in numeral_map:\n count = int(i // integer)\n result.append(numeral * count)\n i -= integer * count\n if lower: result = [ i.lower() for i in result ]\n return ''.join(result)","def decToRoman(numStr):\n try:\n n = int(numStr)\n if n >= 4000:\n return 'Error!'\n romans = [\n (1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'),\n (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'),\n (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'),\n (1, 'I')\n ]\n result = ''\n for value, letters in romans:\n while n >= value:\n result += letters\n n -= value\n return result\n except:\n result = 'Error!'\n return result","def int_to_roman(number):\n result = []\n\n for integer, numeral in NUMERAL_MAP:\n count = number // integer\n result.append(numeral * count)\n number -= integer * count\n\n return ''.join(result)","def roman_numerals_decoder(roman):\n roman_numerals = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n result = 0\n for i, c in enumerate(roman):\n if (i + 1) == len(roman) or roman_numerals[c] >= roman_numerals[roman[i + 1]]:\n result += roman_numerals[c]\n else:\n result -= roman_numerals[c]\n return result","def normalize_arabic(text):\n text = re.sub(\"[ثبت]\", \"ٮ\", text)\n text = re.sub(\"[جخ]\", \"ح\", text)\n text = re.sub(\"ق\", \"ٯ\", text)\n text = re.sub(\"ف\", \"ڡ\", text)\n text = re.sub(\"ض\", \"ص\", text)\n text = re.sub(\"[إأٱآا]\", \"ا\", text)\n text = re.sub(\"[ئي]\", \"ى\", text)\n text = re.sub(\"ؤ\", \"و\", text)\n # text = re.sub(r\"(\\s)ن\", r\"\\1ں\", text)\n text = re.sub(r\"ن(\\s)\", r\"ں\\1\", text)\n # text = re.sub(r\"لله\", r\"لﻠه\", text)\n text = re.sub(r\"ن\", \"ٮ\", text)\n text = re.sub(\"ش\", \"س\", text)\n text = re.sub(\"ظ\", \"ط\", text)\n text = re.sub(\"ذ\", \"د\", text)\n text = re.sub(\"غ\", \"ع\", text)\n text = re.sub(\"ز\", \"ر\", text)\n text = re.sub(\"ة\", \"ه\", text)\n text = re.sub(\"ء\", \"\", text)\n return text","def int2roman(num):\n try:\n num_int = int(num)\n except ValueError:\n raise InputError(num, \"Input value must be in integer representation.\")\n except TypeError:\n raise InputError(num, \"Input must be a number, string, or a bytes-like object.\")\n if float(num) != float(num_int):\n raise InputError(num, \"Input cannot be a non-integer decimal value.\")\n else:\n num = int(num)\n if not 0 < num < 5000:\n raise InputError(num, \"Input must be an integer in [1,4999] range.\")\n\n res = \"\"\n for r, i in __extended_map:\n while num >= i:\n res += r\n num -= i\n return res","def normalize_arabic_alphabet(self, text):\n text = re.sub(\"[إأآا]\", \"ا\", text)\n text = re.sub(\"ى\", \"ي\", text)\n text = re.sub(\"ؤ\", \"ء\", text)\n text = re.sub(\"ئ\", \"ء\", text)\n text = re.sub(\"ة\", \"ه\", text)\n text = re.sub(\"گ\", \"ك\", text)\n return text","def _roman2word(strNumber):\n strNumber = strNumber\n cardinalNumber = fromRoman(strNumber)\n return NumberFormula._cardinal2word(cardinalNumber)","def num_to_roman(num):\n value = [1000, 500, 100, 50, 10, 5, 1]\n romans = ['M', 'D', 'C', 'L', 'X', 'V', 'I']\n roman_num = ''\n i = 0\n while num > 0:\n for _ in range(len(value)):\n roman_num += romans[i]\n num -= value[i]\n i += 1\n return roman_num","def fromRoman(s):\n if not s:\n raise InvalidRomanNumeralError, 'Input can not be blank'\n if not romanNumeralPattern.search(s):\n raise InvalidRomanNumeralError, 'Invalid Roman numeral: %s' % s\n\n result = 0\n index = 0\n for numeral, integer in romanNumeralMap:\n while s[index:index+len(numeral)] == numeral:\n result += integer\n index += len(numeral)\n return result","def label(mi_, ma_):\n\treturn \"caractères Unicode des points de code {} à {}\".format(mi_, ma_)","def from_roman(s: str) -> Integral:\n if not isinstance(s, str):\n raise TypeError(\"The argument to from_roman must be a string.\")\n if not _romanNumeralPattern.search(s):\n raise InvalidRomanNumeralError(f\"Invalid Roman numeral: {s}\")\n\n result = 0\n index = 0\n for numeral, integer in _romanNumeralMap:\n while s[index : index + len(numeral)] == numeral:\n result += integer\n index += len(numeral)\n return result","def test_i18n04(self):\n output = self.engine.render_to_string('i18n04', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'å')","def test_i18n04(self):\n output = self.engine.render_to_string('i18n04', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'å')","def to_rna(self):\n thymidine = 'T'\n uracil = 'U'\n return self.dna.replace(thymidine, uracil)","def __repr__(self):\t\n\t\treturn arabicRepr.repr(self.__dict__);","def convert_to_roman_numeral(positive_int):\n # Have to use if and elif statements to avoid index out of range error\n if len(str(positive_int)) == 5:\n return thousands_conversion(positive_int)\n elif len(str(positive_int)) == 4:\n return thousands_conversion(positive_int) + hundreds_conversion(positive_int) \\\n + tens_conversion(positive_int) + ones_conversion(positive_int)\n elif len(str(positive_int)) == 3:\n return hundreds_conversion(positive_int) + tens_conversion(positive_int) + ones_conversion(positive_int)\n elif len(str(positive_int)) == 2:\n return tens_conversion(positive_int) + ones_conversion(positive_int)\n elif len(str(positive_int)) == 1:\n return ones_conversion(positive_int)\n elif positive_int == 0:\n return '0'","def convert_text(text):\n global indic_char_map\n\n text_length = len(text)\n roman_tokens = []\n phonetic_tokens = []\n\n if indic_char_map is None:\n indic_char_map = load_mapping_tables()\n\n for i in range(text_length):\n current_char = text[i]\n\n if current_char == ' ':\n roman_tokens.append(' ')\n phonetic_tokens.append(' ')\n continue\n try:\n current_char_map = indic_char_map[current_char]\n except KeyError:\n # Unknown indic character. Default to printing it out as\n # it is. Assume it can't be pronounced.\n roman_tokens.append(current_char)\n continue\n\n current_char_type = current_char_map['char_type']\n current_char_roman_form = current_char_map['roman_form']\n current_char_phonetic_form = current_char_map['phonetic_form']\n\n if current_char_type in ('i', 'x'):\n # Ignore\n continue\n\n elif current_char_type == 'p':\n # Punctuation\n roman_tokens.append(current_char_roman_form)\n\n elif current_char_type in ('fv', 'v', 'n', 'd'):\n # Simple mapping\n roman_tokens.append(current_char_roman_form)\n phonetic_tokens.append(current_char_phonetic_form)\n\n elif current_char_type == 'ag':\n # Vowel lengthener\n\n # If previous character was a vowel (but not full vowel),\n # repeat it in phonetic form, not in romanized\n # form. Otherwise ignore this char\n\n if i > 0:\n prev_char = text[i - 1]\n try:\n prev_char_map = indic_char_map[prev_char]\n except KeyError:\n # Ignore error\n continue\n prev_char_type = prev_char_map['char_type']\n prev_char_phonetic_form = prev_char_map['phonetic_form']\n if prev_char_type == 'v':\n phonetic_tokens.append(prev_char_phonetic_form)\n\n elif current_char_type == 'gn':\n # Context dependent nasal\n if i == text_length - 1:\n # current char is last char\n roman_tokens.append('m')\n phonetic_tokens.append('m')\n else:\n next_char = text[i + 1]\n try:\n next_char_map = indic_char_map[next_char]\n except KeyError:\n roman_tokens.append('m')\n phonetic_tokens.append('m')\n continue\n next_char_roman_form = next_char_map['roman_form']\n next_char_roman_beginning = next_char_roman_form[0]\n if next_char_roman_beginning in \"kg\":\n roman_tokens.append('n')\n phonetic_tokens.append('ng')\n elif next_char_roman_beginning in \"cjtdn\":\n roman_tokens.append('n')\n phonetic_tokens.append('n')\n else:\n roman_tokens.append('m')\n phonetic_tokens.append('m')\n\n elif current_char_type == 'c':\n try:\n next_char = text[i + 1]\n except IndexError:\n # We are already at last character\n roman_tokens.append(current_char_roman_form)\n phonetic_tokens.append(current_char_phonetic_form)\n\n end_v, end_p = determine_inherent_ending_vowel(\n current_char_type,\n current_char)\n\n if end_v:\n roman_tokens.extend(end_v)\n if end_p:\n phonetic_tokens.extend(end_p)\n\n continue\n\n try:\n next_char_map = indic_char_map[next_char]\n except KeyError:\n roman_tokens.append(current_char_roman_form)\n phonetic_tokens.append(current_char_phonetic_form)\n\n end_v, end_p = determine_inherent_ending_vowel(\n current_char_type,\n current_char)\n\n if end_v:\n roman_tokens.extend(end_v)\n if end_p:\n phonetic_tokens.extend(end_p)\n continue\n\n next_char_type = next_char_map['char_type']\n if next_char_type in ('v', 'x', 'p', 'i') or next_char in \" .,\":\n roman_tokens.append(current_char_roman_form)\n phonetic_tokens.append(current_char_phonetic_form)\n else:\n # No vowel coming up next, so add one\n roman_tokens.extend([current_char_roman_form, 'a'])\n phonetic_tokens.extend([current_char_phonetic_form, 'ah0'])\n else:\n print(\"Unknown char type: %s\" % current_char_type, file=sys.stderr)\n sys.exit(1)\n\n roman_text = ''.join(roman_tokens)\n phonetic_text = ' '.join(phonetic_tokens)\n\n return {'roman_form': roman_text,\n 'phonetic_form': phonetic_text}","def testToRomanKnownValues(self):\n for integer, numeral in self.knownValues:\n result = roman.toRoman(integer)\n self.assertEqual(numeral, result)","def roman_to_int(self, s):\r\n if not s:\r\n return 0\r\n\r\n # Create hash table for Roman numerals\r\n d = self.make_reference()\r\n\r\n p = \"\"\r\n x = 0\r\n for c in s.upper():\r\n # Evaluate M (1000)\r\n if c == \"M\":\r\n if p == \"C\":\r\n p = \"CM\"\r\n else:\r\n p = \"M\"\r\n # Evaluate D (500)\r\n elif c == \"D\":\r\n if p == \"C\":\r\n p = \"CD\"\r\n else:\r\n p = \"D\"\r\n # Evaluate C (100)\r\n elif c == \"C\":\r\n if p == \"X\":\r\n p = \"XC\"\r\n else:\r\n p = \"C\"\r\n # Evaluate L (50)\r\n elif c == \"L\":\r\n if p == \"X\":\r\n p = \"XL\"\r\n else:\r\n p = \"L\"\r\n # Evaluate X (10)\r\n elif c == \"X\":\r\n if p == \"I\":\r\n p = \"IX\"\r\n else:\r\n p = \"X\"\r\n # Evaluate V (5)\r\n elif c == \"V\":\r\n if p == \"I\":\r\n p = \"IV\"\r\n else:\r\n p = \"V\"\r\n # Evaluate I (1)\r\n else:\r\n p = \"I\"\r\n \r\n x += d[p]\r\n\r\n return x","def enlabel(mi_, ma_):\n\treturn \"Unicode characters from {} to {} codepoints\".format(mi_, ma_)","def test_map_to_arabic_value(self):\n data_provider = [\n {\"roman_value\": 'I', \"expected_converted_value\": '1'},\n {\"roman_value\": 'V', \"expected_converted_value\": '5'},\n {\"roman_value\": 'X', \"expected_converted_value\": '10'},\n {\"roman_value\": 'L', \"expected_converted_value\": '50'},\n {\"roman_value\": 'C', \"expected_converted_value\": '100'},\n {\"roman_value\": 'D', \"expected_converted_value\": '500'},\n {\"roman_value\": 'M', \"expected_converted_value\": '1000'},\n ]\n for test_number in range(data_provider.__len__()):\n with self.subTest(i=test_number):\n # Set up\n mapper = RomanToArabicValueMapper()\n\n # Exercise\n mapped_value = mapper.get_mapped_numeral(data_provider[test_number]['roman_value'])\n\n # Verify\n self.assertEqual(mapped_value, data_provider[test_number][\"expected_converted_value\"])","def test_legacyi18n04(self):\n output = self.engine.render_to_string('legacyi18n04', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'å')","def test_legacyi18n04(self):\n output = self.engine.render_to_string('legacyi18n04', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'å')","def dec_to_roman(dec):\n if dec <= 0:\n raise ValueError(\"Input value must be positive\")\n # to avoid MMMM\n elif dec >= 4000:\n raise ValueError(\"Input value must be lower than MMMM(4000)\")\n\n return _dec_to_roman(dec, \"\", decimalDens, romanDens)","def unicode2ascii(_unicrap):\n xlate = {0xc0:'A', 0xc1:'A', 0xc2:'A', 0xc3:'A', 0xc4:'A', 0xc5:'A',\n 0xc6:'Ae', 0xc7:'C',\n 0xc8:'E', 0xc9:'E', 0xca:'E', 0xcb:'E',\n 0xcc:'I', 0xcd:'I', 0xce:'I', 0xcf:'I',\n 0xd0:'Th', 0xd1:'N',\n 0xd2:'O', 0xd3:'O', 0xd4:'O', 0xd5:'O', 0xd6:'O', 0xd8:'O',\n 0xd9:'U', 0xda:'U', 0xdb:'U', 0xdc:'U',\n 0xdd:'Y', 0xde:'th', 0xdf:'ss',\n 0xe0:'a', 0xe1:'a', 0xe2:'a', 0xe3:'a', 0xe4:'a', 0xe5:'a',\n 0xe6:'ae', 0xe7:'c',\n 0xe8:'e', 0xe9:'e', 0xea:'e', 0xeb:'e',\n 0xec:'i', 0xed:'i', 0xee:'i', 0xef:'i',\n 0xf0:'th', 0xf1:'n',\n 0xf2:'o', 0xf3:'o', 0xf4:'o', 0xf5:'o', 0xf6:'o', 0xf8:'o',\n 0xf9:'u', 0xfa:'u', 0xfb:'u', 0xfc:'u',\n 0xfd:'y', 0xfe:'th', 0xff:'y',\n 0xa1:'!', 0xa2:'{cent}', 0xa3:'{pound}', 0xa4:'{currency}',\n 0xa5:'{yen}', 0xa6:'|', 0xa7:'{section}', 0xa8:'{umlaut}',\n 0xa9:'{C}', 0xaa:'{^a}', 0xab:'<<', 0xac:'{not}',\n 0xad:'-', 0xae:'{R}', 0xaf:'_', 0xb0:'{degrees}',\n 0xb1:'{+/-}', 0xb2:'{^2}', 0xb3:'{^3}', 0xb4:\"'\",\n 0xb5:'{micro}', 0xb6:'{paragraph}', 0xb7:'*', 0xb8:'{cedilla}',\n 0xb9:'{^1}', 0xba:'{^o}', 0xbb:'>>',\n 0xbc:'{1/4}', 0xbd:'{1/2}', 0xbe:'{3/4}', 0xbf:'?',\n 0xd7:'*', 0xf7:'/'\n }\n\n s = \"\"\n for i in _unicrap:\n ordi = ord(i)\n if ordi in xlate:\n s += xlate[ordi]\n elif ordi >= 0x80:\n pass\n else:\n s += str(i)\n return s","def uCSIsArabicPresentationFormsA(code):\n ret = libxml2mod.xmlUCSIsArabicPresentationFormsA(code)\n return ret","def roman_number(value):\n try:\n value = to_roman(value)\n except RomanError as e:\n raise TemplateSyntaxError(\"roman_number error: %s\" % str(e))\n return value","def test_to_roman_known_values(self):\n for integer, numeral in self.known_values:\n result = roman1.to_roman(integer)\n self.assertEqual(numeral, result)","def mp_mb_checker(self, seq):\n# print('input ' + seq)\n seq = re.sub(r'([ёуеыаоэяию])м(п|б)',r'\\1н\\2',seq)\n# print('output ' + seq)\n return seq","def normalize_alef_maksura_ar(s):\n\n return s.replace(u'\\u0649', u'\\u064a')","def to_rna(seq):\n seq=seq.replace('A','U')\n seq=seq.replace('T','A')\n seq=seq.replace('C',\"P\")\n seq=seq.replace('G','C')\n seq=seq.replace('P','G')\n return seq","def roman2int(n):\n warn('The function roman2int is deprecated from JAMS. Use module pyjams.',\n category=DeprecationWarning)\n n = str(n).upper()\n i = result = 0\n for integer, numeral in numeral_map:\n while n[i:i + len(numeral)] == numeral:\n result += integer\n i += len(numeral)\n return result","def convert_number(number):\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '","def test_ukrainian_symbols(self):\n string = \"Минає ніч від’їзду\"\n expected = \"Minaye nich vid’yizdu\"\n self.assertEqual(transliterate(string), expected)","def testFromRomanKnownValues(self):\n for integer, numeral in self.knownValues:\n result = roman.fromRoman(numeral)\n self.assertEqual(integer, result)","def solution(roman):\n r = roman.upper()\n nums = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n total = 0\n for i, c in enumerate(r):\n if i < len(r) - 1:\n if nums[r[i]] < nums[r[i+1]]:\n total -= nums[c]\n else:\n total += nums[c]\n else:\n total += nums[c]\n return total","def to_symbol(text):\n text = text.upper()\n if text in (\"BGM\", \"BANGUMI\"):\n return \"bgm\"\n elif text in (\"MAL\", \"MYANIMELIST\"):\n return \"mal\"\n else:\n return None","def roman2int(input):\n numerals = {\n 'I': 1,\n 'V': 5,\n 'X': 10,\n 'L': 50,\n 'C': 100,\n 'D': 500,\n 'M': 1000\n }\n input = input.strip()\n dlugosc = len(input)\n out = 0\n for i in range(dlugosc):\n if i+1 < dlugosc and numerals[input[i]] < numerals[input[i+1]]:\n out -= numerals[input[i]]\n else:\n out += numerals[input[i]]\n return out","def test_i18n03(self):\n output = self.engine.render_to_string('i18n03', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'Å')","def test_i18n03(self):\n output = self.engine.render_to_string('i18n03', {'anton': b'\\xc3\\x85'})\n self.assertEqual(output, 'Å')","def ta2en(text):\n return IITB_translator(\"ta\", \"en\", text)","def test_i18n04(self):\n output = self.engine.render_to_string(\"i18n04\", {\"anton\": \"Å\"})\n self.assertEqual(output, \"å\")","def translate(nuc):\n\tfrom Bio import Seq\n\ttry:\n\t\ttmp_aa = Seq.translate(nuc.replace('-','N')) #returns string when argument is a string, Bio.Seq otherwise\n\texcept:\n\t\tprint(\"translation failed\",nuc)\n\t\ttmp_aa = 'X'*len(nuc)//3\n\taa_seq = \"\"\n\tfor i,aa in enumerate(tmp_aa):\n\t\tif nuc[i*3:(i+1)*3]=='---':\n\t\t\taa_seq+='-'\n\t\telse:\n\t\t\taa_seq+=aa\n\treturn aa_seq","def test_legacyi18n04(self):\n output = self.engine.render_to_string(\"legacyi18n04\", {\"anton\": \"Å\"})\n self.assertEqual(output, \"å\")","def convert(roman_num: str) -> int:\n result = 0\n roman_num = roman_num.upper()\n rome_dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n\n for i, _ in enumerate(roman_num):\n if i + 1 < len(roman_num) and rome_dict[roman_num[i]] < rome_dict[roman_num[i + 1]]:\n result -= rome_dict[roman_num[i]]\n else:\n result += rome_dict[roman_num[i]]\n\n return result","def minimal_roman(integer):\n\n\tint_dict = {1 : 'I',\n\t\t\t\t5 : 'V',\n\t\t\t\t10 : 'X',\n\t\t\t\t50 : 'L',\n\t\t\t\t100 : 'C',\n\t\t\t\t500 : 'D',\n\t\t\t\t1000 : 'M'}\n\n\tnum_count = {k : 0 for k in int_dict.keys() }\n\n\tfor div in list(num_count.keys())[::-1]:\n\t\tif div <= integer:\n\t\t\t\n\t\t\tcount = integer // div\n\t\t\t\n\t\t\tnum_count[div] = count\n\n\t\t\tinteger = integer % div\n\n\tnum_string = ''\n\n\tfor num, count in num_count.items():\n\n\t\t#should only see a 4 for base 10\n\t\tif count == 4 and num < 1000:\n\t\t\t\n\t\t\tif num_count[(num * 5)] == 1:\n\t\t\t\taddition = f'{int_dict[num]}{int_dict[(num * 10)]}'\n\t\t\t\tnum_count[(num * 5)] = 0\n\n\t\t\telse:\n\t\t\t\taddition = f'{int_dict[num]}{int_dict[(num * 5)]}'\n\n\t\t\tnum_string = addition + num_string\n\n\t\telse:\n\t\t\taddition = [int_dict[num] for n in range(0, count)]\n\t\t\tnum_string = ''.join(addition) + num_string\n\n\treturn num_string","def question_new_translate():","def residue_ramachandran_type(residue) :\n if residue_amino(residue)==\"GLY\" :\n return rama_GLYCINE\n elif residue_amino(residue)==\"PRO\" :\n return rama_PROLINE\n elif residue_amino(next_residue(residue))==\"PRO\" :\n #exlcudes those that are Pro or Gly\n return rama_PRE_PRO\n else :\n return rama_GENERAL","def uCSIsArmenian(code):\n ret = libxml2mod.xmlUCSIsArmenian(code)\n return ret","def roman_to_int(roman_string):\n\n NUMERALS_SET = set(list(zip(*NUMERAL_MAP))[1])\n roman_string = roman_string.upper()\n if len(set(list(roman_string.upper())) - NUMERALS_SET) != 0:\n raise ValueError('{0} does not seem to be a roman numeral'.format(\n roman_string))\n i = result = 0\n for integer, numeral in NUMERAL_MAP:\n while roman_string[i:i + len(numeral)] == numeral:\n result += integer\n i += len(numeral)\n if result < 1:\n raise ValueError('Can not interpret Roman Numeral {0}'.format(roman_string))\n return result","def getAmbigProchiralLabel(resonance):\n\n letter = ''\n if hasattr(resonance, 'onebond'):\n del resonance.onebond\n\n resonanceSet = resonance.resonanceSet\n \n if resonanceSet:\n if resonance.isotopeCode == '1H':\n data = []\n for resonance2 in resonanceSet.sortedResonances():\n if resonance2.shifts:\n data.append( ('%f%d' % (resonance2.findFirstShift().value,resonance2.serial),resonance2) )\n else:\n data.append( (resonance2.serial,resonance2) )\n \n data.sort()\n resonances = [x[1] for x in data]\n i = resonances.index(resonance)\n letter = chr(ord('a')+i)\n\n else:\n resonance2 = getOnebondResonance(resonance, isotopeCode='1H') \n \n if resonance2 and resonance2.resonanceSet and (len(resonance2.resonanceSet.atomSets) > 1):\n letter = getAmbigProchiralLabel(resonance2)\n resonance2.onebond = resonance\n \n elif (len(resonanceSet.resonances) > 1) and (len(resonanceSet.atomSets) > 1):\n for resonance2 in resonanceSet.resonances:\n if resonance2 is not resonance:\n resonance3 = getOnebondResonance(resonance2)\n if resonance3 and resonance3.resonanceSet and (len(resonance3.resonanceSet.atomSets) > 1):\n letter = 'b'\n break\n \n if not letter:\n data = []\n for resonance2 in resonanceSet.resonances:\n if resonance2.shifts:\n data.append( (resonance2.findFirstShift().value,resonance2) )\n else:\n data.append( (resonance2.serial,resonance2) )\n \n data.sort()\n resonances = [x[1] for x in data]\n i = resonances.index(resonance)\n letter = chr(ord('a')+i) \n\n #keyword = 'ambigProchiralLabel'\n #app = 'Analysis'\n #appData = resonance.findFirstApplicationData(application=app, keyword=keyword)\n #\n #if appData and (appData.value != letter):\n # appData.delete()\n # appData = None\n # \n #if not appData:\n # AppDataString(resonance,application=app,keyword=keyword, value=letter)\n \n return letter","def translate(rna):\n RNA_CODON_TABLE = {\"UUU\": \"F\", \"UUC\": \"F\", \"UUA\": \"L\", \"UUG\": \"L\",\n \"UCU\": \"S\", \"UCC\": \"S\", \"UCA\": \"S\", \"UCG\": \"S\",\n \"UAU\": \"Y\", \"UAC\": \"Y\", \"UAA\": \"*\", \"UAG\": \"*\",\n \"UGU\": \"C\", \"UGC\": \"C\", \"UGA\": \"*\", \"UGG\": \"W\",\n \"CUU\": \"L\", \"CUC\": \"L\", \"CUA\": \"L\", \"CUG\": \"L\",\n \"CCU\": \"P\", \"CCC\": \"P\", \"CCA\": \"P\", \"CCG\": \"P\",\n \"CAU\": \"H\", \"CAC\": \"H\", \"CAA\": \"Q\", \"CAG\": \"Q\",\n \"CGU\": \"R\", \"CGC\": \"R\", \"CGA\": \"R\", \"CGG\": \"R\",\n \"AUU\": \"I\", \"AUC\": \"I\", \"AUA\": \"I\", \"AUG\": \"M\",\n \"ACU\": \"T\", \"ACC\": \"T\", \"ACA\": \"T\", \"ACG\": \"T\",\n \"AAU\": \"N\", \"AAC\": \"N\", \"AAA\": \"K\", \"AAG\": \"K\",\n \"AGU\": \"S\", \"AGC\": \"S\", \"AGA\": \"R\", \"AGG\": \"R\",\n \"GUU\": \"V\", \"GUC\": \"V\", \"GUA\": \"V\", \"GUG\": \"V\",\n \"GCU\": \"A\", \"GCC\": \"A\", \"GCA\": \"A\", \"GCG\": \"A\",\n \"GAU\": \"D\", \"GAC\": \"D\", \"GAA\": \"E\", \"GAG\": \"E\",\n \"GGU\": \"G\", \"GGC\": \"G\", \"GGA\": \"G\", \"GGG\": \"G\"}\n str = ''\n list = [rna[i:i+3] for i in range(0,len(rna),3)]\n for x in list:\n #checks if x is in key of RNA_CODON_TABLE\n if x in RNA_CODON_TABLE:\n #appends only if the value for the given key is not *\n if RNA_CODON_TABLE[x] != '*':\n str = str + RNA_CODON_TABLE[x]\n #if only one char is extra(meaning apart form the 3 pair characters available in dictionary)\n #checks if the char is in following\n elif len(x) == 1 and x in ['A','G','C','U']:\n str = str + x\n #if the char is of length 2 i.e, 2 words extra\n elif len(x) == 2 and x[0] in ['A','G','C','U'] and x[1] in ['A','G','C','U']:\n #Then appending the char to the actually converted string\n str = str + x[0]\n str = str + x[1]\n #if the char is not in the above characters then it is a unrecognised character.\n else:\n print(\"Unrecognised character:\",x)\n return str","def multiplicationRoman(x, y):\n a = fromRoman(x)\n b = fromRoman(y)\n \n c = a * b \n d = toRoman(c)\n return d","def res_1Letter(RES):\n RES_LetterCode = ['HOH', 'ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE','LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL']\n R_LetterCode = ['O', 'A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V']\t\n return R_LetterCode[RES_LetterCode.index(RES)]","def uCSIsArabicPresentationFormsB(code):\n ret = libxml2mod.xmlUCSIsArabicPresentationFormsB(code)\n return ret","def translate(inp: str) -> str:\n\t# list for encdoe cirylic symbols in latinc.\n\tsymbols = (u\"абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯöÖåÅ\",\n\t\t\tu\"abvgdeejzijklmnoprstufhzcss_y_euaABVGDEEJZIJKLMNOPRSTUFHZCSS_Y_EUAoOaA\")\n\t# generate dict like {\"a\":\"a\",\"б\":\"\",...}\n\ttr = {ord(a):ord(b) for a, b in zip(*symbols)}\n\t# switch all symbols\n\toutput = inp.translate(tr)\n\treturn output","def provisional(self, positive=False, kanji=False):\n if positive:\n verb = self.kanji if kanji else self.kana\n for before, after in Verb.ENDING_U_TO_E.items():\n if verb.endswith(before):\n base = re.sub(before + '$', after, verb)\n return base + 'ば'\n else:\n verb = self.present_indicative(polite=False, positive=False, kanji=kanji)\n return re.sub('い$', 'ければ', verb)","def _dec_to_roman(num, s, decs, romans):\n if decs:\n if (num < decs[0]):\n # deal with the rest denomination\n return _dec_to_roman(num, s, decs[1:], romans[1:])\n else:\n # deduce this denomation till num<desc[0]\n return _dec_to_roman(num - decs[0], s + romans[0], decs, romans)\n else:\n # we run out of denomination, we are done\n return s","def Get_Hebrew_Stop_Words():\r\n # Explain Of The Function #\r\n\r\n return ['אני', 'את', 'אתה', 'אנחנו', 'אתן', 'אתם', 'הם', 'הן', 'היא', 'הוא', 'שלי', 'שלו', 'שלך', 'שלה', 'שלנו',\r\n 'שלכם', 'שלכן', 'שלהם', 'עד', 'אשר', 'במידה', 'שוב', 'יותר',\r\n 'שלהן', 'לי', 'לו', 'לה', 'לנו', 'לכם', 'לכן', 'להם', 'להן', 'אותה', 'אותו', 'זה', 'זאת', 'אלה', 'אלו',\r\n 'תחת', 'מתחת', 'מעל', 'בין', 'מכיוון', 'יכולה', 'יכולים', 'יכולות',\r\n 'עם', 'עד', 'נגר', 'על', 'אל', 'מול', 'של', 'אצל', 'כמו', 'אחר', 'אותו', 'בלי', 'לפני', 'אחרי',\r\n 'מאחורי', 'עלי', 'עליו', 'עליה', 'הסיבה שבגללה', 'למה', 'אלו', 'אף', 'על', 'מעל',\r\n 'עליך', 'עלינו', 'עליכם', 'לעיכן', 'עליהם', 'עליהן', 'כל', 'כולם', 'כולן', 'כך', 'ככה', 'כזה', 'זה',\r\n 'זאת', 'אותי', 'אותה', 'אותם', 'איתן', 'איתנו', 'עצמן', 'עצמנו', 'מהיכן', 'מן', 'לעבר', 'מכאן',\r\n 'אותך', 'אותו', 'אותן', 'אותנו', 'ואת', 'את', 'אתכם', 'אתכן', 'איתי', 'איתו', 'איתך', 'איתה', 'איתם',\r\n 'איתכם', 'איתכן', 'יהיה', 'תהיה', 'היתי', 'היתה', 'היה', 'להיות', 'עצמי', 'עצמו', 'עצמה', 'עצמם',\r\n 'עצמהם', 'עצמהן', 'מי', 'מה', 'איפה', 'היכן', 'במקום שבו', 'אם', 'לאן', 'למקום שבו', 'מקום בו', 'איזה',\r\n 'איך', 'כיצד', 'באיזו מידה', 'מתי', 'בשעה ש', 'כאשר', 'כש', 'למרות', 'לפני', 'אחרי', 'מאיזו סיבה',\r\n 'מדוע', 'לאיזו תכלית', 'כי', 'יש', 'אין', 'אך', 'מנין', 'מאין', 'מאיפה', 'יכל', 'יכלה', 'יכלו', 'יכול',\r\n 'יוכלו', 'יוכל', 'מסוגל', 'לא', 'רק', 'אולי', 'אין', 'לאו', 'אי', 'כלל', 'נגד', 'אם', 'עם', 'אל', 'אלה',\r\n 'מתחת', 'מצד', 'בשביל', 'לבין', 'באמצע', 'בתוך', 'דרך', 'מבעד', 'באמצעות', 'למעלה', 'למטה', 'מחוץ',\r\n 'כאן', 'הנה', 'הרי', 'פה', 'שם', 'אך', 'ברם', 'שוב', 'אבל', 'מבלי', 'בלי', 'מלבד', 'רק', 'בגלל',\r\n 'ואילו', 'למרות', 'אס', 'כמו', 'כפי', 'אז', 'אחרי', 'כן', 'לכן', 'לפיכך', 'מאד', 'עז', 'מעט', 'מעטים',\r\n 'מדי', 'גם', 'כן', 'נו', 'אחר', 'אחרת', 'אחרים', 'אחרות', 'אשר', 'או']\r\n pass","def to_ascii(self):\n code = self.build()\n for i, line in enumerate(code):\n code[i] = line.replace('1', '|').replace('0', '_')\n return '\\n'.join(code)","def romanAddition(x, y):\n \n # Replace the x and y parameters with longer roman numerals\n suby1 = y.replace(\"CM\", \"DCCCC\")\n suby2 = suby1.replace(\"CD\", \"CCCC\")\n suby3 = suby2.replace(\"XC\", \"LXXXX\")\n suby4 = suby3.replace(\"XL\", \"XXXX\")\n suby5 = suby4.replace(\"IX\", \"VIIII\")\n suby6 = suby5.replace(\"IV\", \"IIII\")\n \n subx1 = x.replace(\"CM\", \"DCCCC\")\n subx2 = subx1.replace(\"CD\", \"CCCC\")\n subx3 = subx2.replace(\"XC\", \"LXXXX\")\n subx4 = subx3.replace(\"XL\", \"XXXX\")\n subx5 = subx4.replace(\"IX\", \"VIIII\")\n subx6 = subx5.replace(\"IV\", \"IIII\")\n\n # Making result into a string\n # Combining the parameters into one string\n result = \"\"\n add = subx6 + suby6\n result += add\n\n # Sorting with a condition\n valueOrder = \"MDCLXVI\"\n sortingList = sorted(result, key=valueOrder.index)\n \n\n \n str1 = ''.join(sortingList)\n \n # Replace the long roman numeral with an original roman numeral\n tmp1 = str1.replace(\"IIIII\", \"V\")\n tmp2 = tmp1.replace(\"VV\", \"X\")\n tmp3 = tmp2.replace(\"XXXXX\", \"L\")\n tmp4 = tmp3.replace(\"LL\", \"C\")\n tmp5 = tmp4.replace(\"CCCCC\", \"D\")\n tmp6 = tmp5.replace(\"DD\", \"M\")\n \n tmp7 = tmp6.replace(\"VIIII\", \"IX\")\n tmp8 = tmp7.replace(\"IIII\", \"IV\")\n tmp9 = tmp8.replace(\"XXXX\", \"XL\")\n tmp10 = tmp9.replace(\"LXXXX\", \"XC\")\n tmp11 = tmp10.replace(\"CCCC\", \"CD\")\n tmp12 = tmp11.replace(\"DCCCC\", \"CM\")\n \n return tmp12","def normalize_RTL(src: str):\n if not src.isascii():\n return src + ' (' + src[::-1] + ')'\n return src","def transcribe(seq):\n rna = ''\n for letter in seq:\n if letter == 'A':\n rna = rna + 'U'\n elif letter == 'T':\n rna = rna + 'A'\n elif letter == 'G':\n rna = rna + 'C'\n else:\n rna = rna + 'G'\n return rna","def text_direction(self) -> str:\n return ''.join(word[0] for word in self.character_order.split('-'))","def roman2int(s):\n if not s or not isinstance(s, str):\n raise InputError(s, \"Input value must be a non-empty string.\")\n elif __roman_numeral_regex.search(s) is None:\n raise InputError(s, \"Input is not a valid Roman numeral representation of numbers in the 1-4999 range.\")\n\n return sum([__bmap[i] if __bmap[i] >= __bmap[j] else -__bmap[i] for i, j in zip(s, s[1:])]) + __bmap[s[-1]]","def residue_amino(residue) :\n if residue :\n return residue.name[0:3].upper()\n else :\n return None","def normalize_teh_marbuta_ar(s):\n\n return s.replace(u'\\u0629', u'\\u0647')","def en2ta(text):\n return IITB_translator(\"en\", \"ta\", text)","def test_i18n03(self):\n output = self.engine.render_to_string(\"i18n03\", {\"anton\": \"Å\"})\n self.assertEqual(output, \"Å\")","def EnglishToPig(str):\r\n\r\n # TODO: Your code here\r\n\r\n\r\n # Change the return to return the converted string\r\n return(\"\")","def PigToEnglish(str):\r\n\r\n # TODO: Your code here\r\n\r\n\r\n # Change the return to return the converted string\r\n return(\"\")","def simpleTranslateToBrl(text):\n\n\t# initialize output\n\tout = \"\"\n\n\tlog.debug(\"translating %d characters into Braille\" % len(text))\n\tlog.debug(\"using map: %s\" % str(simpleBrailleMap))\n\n\t# iterate through entire string and setup a Braille character string\n\tfor c in text.lower():\n\t\ttry:\n\t\t\tch = simpleBrailleMap[c]\n\t\t\tout += chr(ch) # append found character\n\t\texcept KeyError:\n\t\t\t# An unknown character was found. Log and replace with a full cell.\n\t\t\tlog.debug(\"the character '%s' was not found.\" % c)\n\t\t\tout += \"\\xff\" # full cell\n\treturn out","def normalize_alef_ar(s):\n\n return _ALEF_NORMALIZE_AR_RE.sub(u'\\u0627', s)","def lcd_string_kana(self, message, line):\n codes = u'線線線線線線線線線線線線線線線線 '\\\n u' !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFG'\\\n u'HIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{'\\\n u'|}→← '\\\n u' 。「」、・ヲァィゥェォャュョッーア'\\\n u'イウエオカキクケコサシスセソタチツテトナニヌネノハヒ'\\\n u'フヘホマミムメモヤユヨラリルレロワン゛゜αäβεμσρq√陰ι'\\\n u'×￠￡nöpqθ∞ΩüΣπxν千万円÷ 塗'\n dic ={u'ガ':u'カ゛',u'ギ':u'キ゛',u'グ':u'ク゛',\\\n u'ゲ':u'ケ゛',u'ゴ':u'コ゛',u'ザ':u'サ゛',\\\n u'ジ':u'シ゛',u'ズ':u'ス゛',u'ゼ':u'セ゛',\\\n u'ゾ':u'ソ゛',u'ダ':u'タ゛',u'ヂ':u'チ゛',\\\n u'ヅ':u'ツ゛',u'デ':u'テ゛',u'ド':u'ト゛',\\\n u'バ':u'ハ゛',u'ビ':u'ヒ゛',u'ブ':u'フ゛',\\\n u'ベ':u'ヘ゛',u'ボ':u'ホ゛',u'パ':u'ハ゜',\\\n u'ピ':u'ヒ゜',u'プ':u'フ゜',u'ペ':u'ヘ゜',\\\n u'ポ':u'ホ゜',u'℃':u'゜C'}\n\n self.lcd_byte(line, LCD_CMD)\n message2 = ''\n for i in range(len(message)):\n if (message[i] in dic.keys()):\n message2 += dic[message[i]]\n else:\n message2 += message[i]\n\n for i in range(len(message2)):\n if message2[i] == ' ':\n self.lcd_byte(ord(message2[i]), LCD_CHR)\n elif (codes.find(message2[i]) >= 0):\n self.lcd_byte(codes.find(message2[i]) + 1, LCD_CHR)\n elif (codes_han.find(message2[i]) >= 0):\n self.lcd_byte(codes.find(message2[i]) + 1, LCD_CHR)\n elif (message2[i] != u' '):\n self.lcd_byte('?', LCD_CHR)","def convert_numerals(input_str):\n # credit to: http://code.activestate.com/recipes/81611-roman-numerals/\n copy = input_str[:]\n copy = copy.split(\" \")\n\n nums = ['m', 'd', 'c', 'l', 'x', 'v', 'i']\n ints = [1000, 500, 100, 50, 10, 5, 1]\n places = []\n\n for i in range(len(copy)):\n is_valid = True\n\n if \".\" in copy[i]:\n copy[i] = copy[i].replace(\".\", \"\")\n else:\n # . must be appended to end of string to signify it is a roman\n # numeral\n is_valid = False\n\n if \"xix\" in copy[i] or \"xviii\" in copy[i]:\n is_valid = True\n\n for c in copy[i].lower():\n if c not in nums:\n # return original\n is_valid = False\n\n if is_valid is False:\n continue\n\n for char_index in range(len(copy[i])):\n c = copy[i][char_index].lower()\n value = ints[nums.index(c)]\n # If the next place holds a larger number, this value is negative.\n try:\n nextvalue = ints[nums.index(copy[i][char_index + 1].lower())]\n if nextvalue > value:\n value *= -1\n except IndexError:\n # there is no next place.\n pass\n places.append(value)\n\n out = 0\n\n for n in places:\n out += n\n\n copy[i] = str(out)\n\n return \" \".join(copy)"],"string":"[\n \"def arabic_to_roman_replace(test_word):\\n arabic_word = test_word\\n\\n \\\"\\\"\\\"\\n testWord = \\\"دَرْس\\\"\\n print(testWord, sep=\\\" \\\")\\n \\\"\\\"\\\"\\n\\n # converting into roman characters\\n print()\\n roman_characters = \\\"\\\"\\n for letter in arabic_word:\\n #print(letter)\\n if letter in dictionary:\\n roman_characters += Dictionary.get_lebanese_to_roman_char(letter) #.roman_text #Dictionary.get_lebanese_to_roman_char(letter)\\n elif letter in dictionary_vowels:\\n roman_characters += dictionary_vowels[letter]\\n # print(\\\"test\\\")\\n elif letter == \\\" \\\":\\n roman_characters += \\\" \\\"\\n return roman_characters\\n ####print(str(roman_characters), str(test_word))\\n\\n # مِلْء\\n #####plans for improving the program#####\",\n \"def toRoman(n):\\n pass\",\n \"def fromRoman(s):\\n pass\",\n \"def romanify(num):\\n result = \\\"\\\"\\n return result\",\n \"def romanize(digit, glyphs):\\n if 1 <= digit <= 3:\\n return digit*glyphs[0]\\n elif digit == 4:\\n return glyphs[0] + glyphs[1]\\n elif digit >= 5 and digit <= 8:\\n return glyphs[1] + ((digit - 5) * glyphs[0])\\n elif digit == 9:\\n return glyphs[0]+glyphs[2]\\n else:\\n return ''\",\n \"def toRoman(n):\\n result = \\\"\\\"\\n for numeral, integer in romanNumeralMap:\\n while n >= integer:\\n result += numeral\\n n -= integer\\n return result\",\n \"def num2roman(num):\\n roman = ''\\n while num > 0:\\n for i, r in ROMAN_MAP:\\n while num >= i:\\n roman += r\\n num -= i\\n return roman\",\n \"def _RomanToLatin(self, roman_numerals):\\n roman = roman_numerals.strip().upper()\\n return {'I': '1', 'II': '2', 'III': '3', 'IV': '4', 'V': '5'}[roman]\",\n \"def romanify(num):\\n result = \\\"\\\"\\n onesDict = {1:\\\"I\\\", 2: \\\"II\\\", 3: \\\"III\\\", 4: \\\"IV\\\", 5: \\\"V\\\", 6: \\\"VI\\\", 7: \\\"VII\\\", 8: \\\"VIII\\\", 9: \\\"IX\\\", 0:\\\"\\\"}\\n ones = num%10\\n num-=num%10\\n result = onesDict[ones] + result\\n tensDict = {10:\\\"X\\\", 20: \\\"XX\\\", 30: \\\"XXX\\\", 40:\\\"XL\\\", 50:\\\"L\\\", 60:\\\"LX\\\", 70: \\\"LXX\\\", 80: \\\"LXXX\\\", 90: \\\"XC\\\", 0:\\\"\\\"}\\n tens = num%100\\n num-=num%100\\n result = tensDict[tens] + result\\n hunsDict = {100:\\\"C\\\", 200: \\\"CC\\\", 300: \\\"CCC\\\", 400:\\\"CD\\\", 500:\\\"D\\\", 600:\\\"DC\\\", 700: \\\"DCC\\\", 800: \\\"DCCC\\\", 900: \\\"CM\\\", 0:\\\"\\\"}\\n huns = num%1000\\n num-=num%1000\\n result = hunsDict[huns] + result\\n thous = num/1000\\n result = \\\"M\\\"*thous + result\\n \\n return result\",\n \"def int_to_roman(i):\\n result = []\\n for integer, numeral in NUMERAL_MAP:\\n count = i // integer\\n result.append(numeral * count)\\n i -= integer * count\\n return ''.join(result)\",\n \"def to_roman(n: Union[Integral, np.integer]) -> str:\\n if not isinstance(n, (Integral, np.integer)):\\n raise TypeError(f\\\"{n} cannot be converted to a Roman numeral.\\\")\\n if not (0 < n < 5000):\\n raise OutOfRangeError(\\\"Number is out of range (need 0 < n < 5000)\\\")\\n\\n result = \\\"\\\"\\n for numeral, integer in _romanNumeralMap:\\n while n >= integer:\\n result += numeral\\n n -= integer\\n return result\",\n \"def to_roman(numeral):\\n mapping = {\\n 'M': 1000,\\n 'CM': 900,\\n 'D': 500,\\n 'CD': 400,\\n 'C': 100,\\n 'XC': 90,\\n 'L': 50,\\n 'XL': 40,\\n 'X': 10,\\n 'IX': 9,\\n 'V': 5,\\n 'IV': 4,\\n 'I': 1\\n }\\n romans = {v:k for k,v in mapping.items()}\\n result = ''\\n\\n for divisor, symbol in romans.items():\\n count = numeral // divisor\\n remainder = numeral % divisor\\n numeral = remainder\\n result += symbol * count\\n\\n return result\",\n \"def intToRoman(self, num: int) -> str:\\n\\n # Last remainder\\n remainder = num\\n\\n # Initial string\\n roman = \\\"\\\"\\n\\n # Loops through all remainder values\\n for v in self.values:\\n division = remainder // v\\n remainder = remainder % v\\n\\n # Adds to the string only if division is not empty.\\n if division != 0:\\n roman += self.symbols[v] * division\\n\\n return roman\",\n \"def to_roman(n):\\n if not isinstance(n, int):\\n try:\\n n = int(n)\\n except ValueError:\\n raise NotIntegerError(\\\"non-integers cannot be converted\\\")\\n\\n if not (0 < n < 4000):\\n raise OutOfRangeError(\\\"number out of range (must be 1..3999)\\\")\\n\\n result = \\\"\\\"\\n for numeral, integer in ROMAN_NUMBER_MAP:\\n while n >= integer:\\n result += numeral\\n n -= integer\\n return result\",\n \"def formatRomanNumeral(rn, key):\\n # Something of \\\"I\\\" and \\\"I\\\" of something\\n if rn == \\\"I/I\\\":\\n rn = \\\"I\\\"\\n return rn\",\n \"def toRoman(n):\\n if not isinstance(n, int):\\n raise NorIntegerError(\\\"decimals can not be converted\\\")\\n if not (0 < n < 5000):\\n raise OutOfRangeError(\\\"number out of range (must be 1..4999)\\\")\\n \\n result = \\\"\\\"\\n for numeral, integer in romanNumeralMap:\\n while n >= integer:\\n result += numeral\\n n -= integer\\n return result\",\n \"def romanize(string: str, locale: t.Union[Locale, str]) -> str:\\n locale = validate_locale(locale)\\n\\n if locale not in (Locale.RU, Locale.UK, Locale.KK):\\n raise ValueError(f\\\"Romanization is not available for: {locale}\\\")\\n\\n table = _get_translation_table(locale)\\n\\n return string.translate(table)\",\n \"def uCSIsArabic(code):\\n ret = libxml2mod.xmlUCSIsArabic(code)\\n return ret\",\n \"def roman_converter(number):\\n num_dict = {'I': '1', 'II': '2', 'III': '3', 'IIII': '4', 'V': '5', 'VI': '6', 'VII': '7', 'VIII': '8', 'VIIII': '9', 'X': '10'}\\n if number in num_dict:\\n return num_dict[number]\\n return number\",\n \"def _int_to_roman(self, i):\\n numeral_map = zip((1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),\\n ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'))\\n result = []\\n for integer, numeral in numeral_map:\\n count = int(i / integer)\\n result.append(numeral * count)\\n i -= integer * count\\n return ''.join(result)\",\n \"def roman_to_arabic_previous(roman):\\n result = [0]\\n previous_number = 4000\\n p_previous_number = 4001\\n # we store 2 previous numbers in order to check is\\n # this number still correct\\n for i, char in enumerate(roman):\\n if char in MAP_ROMAN:\\n number = MAP_ROMAN[char]\\n # Chars in Roman numbers should decrease if not 3 same chars in line\\n if p_previous_number <= number and previous_number != number:\\n raise ValueError('Wrong Roman Number (...1)')\\n if number > previous_number:\\n # minus previous number if current > previous\\n # IV: 5 - 1, IX: 10 - 1, XC: 100 - 10\\n if number % previous_number < 5:\\n sign = -1\\n else:\\n raise ValueError('Wrong Roman number (...2)')\\n else:\\n sign = 1\\n\\n print_debug(i, roman, char, number, previous_number, sign)\\n\\n result[-1] *= sign\\n result.append(number)\\n p_previous_number = previous_number\\n previous_number = number\\n else:\\n raise ValueError('Unknown char \\\"%s\\\" in input roman number' % char)\\n counts = defaultdict(int)\\n\\n # test for same multiple Roman numbers\\n for number in result:\\n num = abs(number)\\n counts[num] += 1\\n if counts[num] > 3:\\n raise ValueError('Wrong Roman number (...3)')\\n\\n return sum(result)\",\n \"def toRoman(dec):\\t\\t\\n if dec <=0:\\n\\t raise ValueError, \\\"It must be a positive\\\"\\n # to avoid MMMM\\n\\telif dec>=4000: \\n\\t raise ValueError, \\\"It must be lower than MMMM(4000)\\\"\\n \\n\\treturn decToRoman(dec,\\\"\\\",decimalDens,romanDens)\",\n \"def int_to_roman(input_rom): # Konverter v rimske številke. Nisem avtor te funkcije.\\n ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)\\n nums = ('M', 'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I')\\n result = []\\n for i in range(len(ints)):\\n count = int(input_rom / ints[i])\\n result.append(nums[i] * count)\\n input_rom -= ints[i] * count\\n return ''.join(result)\",\n \"def roman_numerals(text):\\n return re.findall(r\\\"\\\\b([IVXLCDM]+)\\\\b\\\", text)\",\n \"def int2roman(i, lower=False):\\n warn('The function int2roman is deprecated from JAMS. Use module pyjams.',\\n category=DeprecationWarning)\\n assert i >= 1, 'integer must be > 0.'\\n result = []\\n for integer, numeral in numeral_map:\\n count = int(i // integer)\\n result.append(numeral * count)\\n i -= integer * count\\n if lower: result = [ i.lower() for i in result ]\\n return ''.join(result)\",\n \"def decToRoman(numStr):\\n try:\\n n = int(numStr)\\n if n >= 4000:\\n return 'Error!'\\n romans = [\\n (1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'),\\n (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'),\\n (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'),\\n (1, 'I')\\n ]\\n result = ''\\n for value, letters in romans:\\n while n >= value:\\n result += letters\\n n -= value\\n return result\\n except:\\n result = 'Error!'\\n return result\",\n \"def int_to_roman(number):\\n result = []\\n\\n for integer, numeral in NUMERAL_MAP:\\n count = number // integer\\n result.append(numeral * count)\\n number -= integer * count\\n\\n return ''.join(result)\",\n \"def roman_numerals_decoder(roman):\\n roman_numerals = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\\n result = 0\\n for i, c in enumerate(roman):\\n if (i + 1) == len(roman) or roman_numerals[c] >= roman_numerals[roman[i + 1]]:\\n result += roman_numerals[c]\\n else:\\n result -= roman_numerals[c]\\n return result\",\n \"def normalize_arabic(text):\\n text = re.sub(\\\"[ثبت]\\\", \\\"ٮ\\\", text)\\n text = re.sub(\\\"[جخ]\\\", \\\"ح\\\", text)\\n text = re.sub(\\\"ق\\\", \\\"ٯ\\\", text)\\n text = re.sub(\\\"ف\\\", \\\"ڡ\\\", text)\\n text = re.sub(\\\"ض\\\", \\\"ص\\\", text)\\n text = re.sub(\\\"[إأٱآا]\\\", \\\"ا\\\", text)\\n text = re.sub(\\\"[ئي]\\\", \\\"ى\\\", text)\\n text = re.sub(\\\"ؤ\\\", \\\"و\\\", text)\\n # text = re.sub(r\\\"(\\\\s)ن\\\", r\\\"\\\\1ں\\\", text)\\n text = re.sub(r\\\"ن(\\\\s)\\\", r\\\"ں\\\\1\\\", text)\\n # text = re.sub(r\\\"لله\\\", r\\\"لﻠه\\\", text)\\n text = re.sub(r\\\"ن\\\", \\\"ٮ\\\", text)\\n text = re.sub(\\\"ش\\\", \\\"س\\\", text)\\n text = re.sub(\\\"ظ\\\", \\\"ط\\\", text)\\n text = re.sub(\\\"ذ\\\", \\\"د\\\", text)\\n text = re.sub(\\\"غ\\\", \\\"ع\\\", text)\\n text = re.sub(\\\"ز\\\", \\\"ر\\\", text)\\n text = re.sub(\\\"ة\\\", \\\"ه\\\", text)\\n text = re.sub(\\\"ء\\\", \\\"\\\", text)\\n return text\",\n \"def int2roman(num):\\n try:\\n num_int = int(num)\\n except ValueError:\\n raise InputError(num, \\\"Input value must be in integer representation.\\\")\\n except TypeError:\\n raise InputError(num, \\\"Input must be a number, string, or a bytes-like object.\\\")\\n if float(num) != float(num_int):\\n raise InputError(num, \\\"Input cannot be a non-integer decimal value.\\\")\\n else:\\n num = int(num)\\n if not 0 < num < 5000:\\n raise InputError(num, \\\"Input must be an integer in [1,4999] range.\\\")\\n\\n res = \\\"\\\"\\n for r, i in __extended_map:\\n while num >= i:\\n res += r\\n num -= i\\n return res\",\n \"def normalize_arabic_alphabet(self, text):\\n text = re.sub(\\\"[إأآا]\\\", \\\"ا\\\", text)\\n text = re.sub(\\\"ى\\\", \\\"ي\\\", text)\\n text = re.sub(\\\"ؤ\\\", \\\"ء\\\", text)\\n text = re.sub(\\\"ئ\\\", \\\"ء\\\", text)\\n text = re.sub(\\\"ة\\\", \\\"ه\\\", text)\\n text = re.sub(\\\"گ\\\", \\\"ك\\\", text)\\n return text\",\n \"def _roman2word(strNumber):\\n strNumber = strNumber\\n cardinalNumber = fromRoman(strNumber)\\n return NumberFormula._cardinal2word(cardinalNumber)\",\n \"def num_to_roman(num):\\n value = [1000, 500, 100, 50, 10, 5, 1]\\n romans = ['M', 'D', 'C', 'L', 'X', 'V', 'I']\\n roman_num = ''\\n i = 0\\n while num > 0:\\n for _ in range(len(value)):\\n roman_num += romans[i]\\n num -= value[i]\\n i += 1\\n return roman_num\",\n \"def fromRoman(s):\\n if not s:\\n raise InvalidRomanNumeralError, 'Input can not be blank'\\n if not romanNumeralPattern.search(s):\\n raise InvalidRomanNumeralError, 'Invalid Roman numeral: %s' % s\\n\\n result = 0\\n index = 0\\n for numeral, integer in romanNumeralMap:\\n while s[index:index+len(numeral)] == numeral:\\n result += integer\\n index += len(numeral)\\n return result\",\n \"def label(mi_, ma_):\\n\\treturn \\\"caractères Unicode des points de code {} à {}\\\".format(mi_, ma_)\",\n \"def from_roman(s: str) -> Integral:\\n if not isinstance(s, str):\\n raise TypeError(\\\"The argument to from_roman must be a string.\\\")\\n if not _romanNumeralPattern.search(s):\\n raise InvalidRomanNumeralError(f\\\"Invalid Roman numeral: {s}\\\")\\n\\n result = 0\\n index = 0\\n for numeral, integer in _romanNumeralMap:\\n while s[index : index + len(numeral)] == numeral:\\n result += integer\\n index += len(numeral)\\n return result\",\n \"def test_i18n04(self):\\n output = self.engine.render_to_string('i18n04', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'å')\",\n \"def test_i18n04(self):\\n output = self.engine.render_to_string('i18n04', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'å')\",\n \"def to_rna(self):\\n thymidine = 'T'\\n uracil = 'U'\\n return self.dna.replace(thymidine, uracil)\",\n \"def __repr__(self):\\t\\n\\t\\treturn arabicRepr.repr(self.__dict__);\",\n \"def convert_to_roman_numeral(positive_int):\\n # Have to use if and elif statements to avoid index out of range error\\n if len(str(positive_int)) == 5:\\n return thousands_conversion(positive_int)\\n elif len(str(positive_int)) == 4:\\n return thousands_conversion(positive_int) + hundreds_conversion(positive_int) \\\\\\n + tens_conversion(positive_int) + ones_conversion(positive_int)\\n elif len(str(positive_int)) == 3:\\n return hundreds_conversion(positive_int) + tens_conversion(positive_int) + ones_conversion(positive_int)\\n elif len(str(positive_int)) == 2:\\n return tens_conversion(positive_int) + ones_conversion(positive_int)\\n elif len(str(positive_int)) == 1:\\n return ones_conversion(positive_int)\\n elif positive_int == 0:\\n return '0'\",\n \"def convert_text(text):\\n global indic_char_map\\n\\n text_length = len(text)\\n roman_tokens = []\\n phonetic_tokens = []\\n\\n if indic_char_map is None:\\n indic_char_map = load_mapping_tables()\\n\\n for i in range(text_length):\\n current_char = text[i]\\n\\n if current_char == ' ':\\n roman_tokens.append(' ')\\n phonetic_tokens.append(' ')\\n continue\\n try:\\n current_char_map = indic_char_map[current_char]\\n except KeyError:\\n # Unknown indic character. Default to printing it out as\\n # it is. Assume it can't be pronounced.\\n roman_tokens.append(current_char)\\n continue\\n\\n current_char_type = current_char_map['char_type']\\n current_char_roman_form = current_char_map['roman_form']\\n current_char_phonetic_form = current_char_map['phonetic_form']\\n\\n if current_char_type in ('i', 'x'):\\n # Ignore\\n continue\\n\\n elif current_char_type == 'p':\\n # Punctuation\\n roman_tokens.append(current_char_roman_form)\\n\\n elif current_char_type in ('fv', 'v', 'n', 'd'):\\n # Simple mapping\\n roman_tokens.append(current_char_roman_form)\\n phonetic_tokens.append(current_char_phonetic_form)\\n\\n elif current_char_type == 'ag':\\n # Vowel lengthener\\n\\n # If previous character was a vowel (but not full vowel),\\n # repeat it in phonetic form, not in romanized\\n # form. Otherwise ignore this char\\n\\n if i > 0:\\n prev_char = text[i - 1]\\n try:\\n prev_char_map = indic_char_map[prev_char]\\n except KeyError:\\n # Ignore error\\n continue\\n prev_char_type = prev_char_map['char_type']\\n prev_char_phonetic_form = prev_char_map['phonetic_form']\\n if prev_char_type == 'v':\\n phonetic_tokens.append(prev_char_phonetic_form)\\n\\n elif current_char_type == 'gn':\\n # Context dependent nasal\\n if i == text_length - 1:\\n # current char is last char\\n roman_tokens.append('m')\\n phonetic_tokens.append('m')\\n else:\\n next_char = text[i + 1]\\n try:\\n next_char_map = indic_char_map[next_char]\\n except KeyError:\\n roman_tokens.append('m')\\n phonetic_tokens.append('m')\\n continue\\n next_char_roman_form = next_char_map['roman_form']\\n next_char_roman_beginning = next_char_roman_form[0]\\n if next_char_roman_beginning in \\\"kg\\\":\\n roman_tokens.append('n')\\n phonetic_tokens.append('ng')\\n elif next_char_roman_beginning in \\\"cjtdn\\\":\\n roman_tokens.append('n')\\n phonetic_tokens.append('n')\\n else:\\n roman_tokens.append('m')\\n phonetic_tokens.append('m')\\n\\n elif current_char_type == 'c':\\n try:\\n next_char = text[i + 1]\\n except IndexError:\\n # We are already at last character\\n roman_tokens.append(current_char_roman_form)\\n phonetic_tokens.append(current_char_phonetic_form)\\n\\n end_v, end_p = determine_inherent_ending_vowel(\\n current_char_type,\\n current_char)\\n\\n if end_v:\\n roman_tokens.extend(end_v)\\n if end_p:\\n phonetic_tokens.extend(end_p)\\n\\n continue\\n\\n try:\\n next_char_map = indic_char_map[next_char]\\n except KeyError:\\n roman_tokens.append(current_char_roman_form)\\n phonetic_tokens.append(current_char_phonetic_form)\\n\\n end_v, end_p = determine_inherent_ending_vowel(\\n current_char_type,\\n current_char)\\n\\n if end_v:\\n roman_tokens.extend(end_v)\\n if end_p:\\n phonetic_tokens.extend(end_p)\\n continue\\n\\n next_char_type = next_char_map['char_type']\\n if next_char_type in ('v', 'x', 'p', 'i') or next_char in \\\" .,\\\":\\n roman_tokens.append(current_char_roman_form)\\n phonetic_tokens.append(current_char_phonetic_form)\\n else:\\n # No vowel coming up next, so add one\\n roman_tokens.extend([current_char_roman_form, 'a'])\\n phonetic_tokens.extend([current_char_phonetic_form, 'ah0'])\\n else:\\n print(\\\"Unknown char type: %s\\\" % current_char_type, file=sys.stderr)\\n sys.exit(1)\\n\\n roman_text = ''.join(roman_tokens)\\n phonetic_text = ' '.join(phonetic_tokens)\\n\\n return {'roman_form': roman_text,\\n 'phonetic_form': phonetic_text}\",\n \"def testToRomanKnownValues(self):\\n for integer, numeral in self.knownValues:\\n result = roman.toRoman(integer)\\n self.assertEqual(numeral, result)\",\n \"def roman_to_int(self, s):\\r\\n if not s:\\r\\n return 0\\r\\n\\r\\n # Create hash table for Roman numerals\\r\\n d = self.make_reference()\\r\\n\\r\\n p = \\\"\\\"\\r\\n x = 0\\r\\n for c in s.upper():\\r\\n # Evaluate M (1000)\\r\\n if c == \\\"M\\\":\\r\\n if p == \\\"C\\\":\\r\\n p = \\\"CM\\\"\\r\\n else:\\r\\n p = \\\"M\\\"\\r\\n # Evaluate D (500)\\r\\n elif c == \\\"D\\\":\\r\\n if p == \\\"C\\\":\\r\\n p = \\\"CD\\\"\\r\\n else:\\r\\n p = \\\"D\\\"\\r\\n # Evaluate C (100)\\r\\n elif c == \\\"C\\\":\\r\\n if p == \\\"X\\\":\\r\\n p = \\\"XC\\\"\\r\\n else:\\r\\n p = \\\"C\\\"\\r\\n # Evaluate L (50)\\r\\n elif c == \\\"L\\\":\\r\\n if p == \\\"X\\\":\\r\\n p = \\\"XL\\\"\\r\\n else:\\r\\n p = \\\"L\\\"\\r\\n # Evaluate X (10)\\r\\n elif c == \\\"X\\\":\\r\\n if p == \\\"I\\\":\\r\\n p = \\\"IX\\\"\\r\\n else:\\r\\n p = \\\"X\\\"\\r\\n # Evaluate V (5)\\r\\n elif c == \\\"V\\\":\\r\\n if p == \\\"I\\\":\\r\\n p = \\\"IV\\\"\\r\\n else:\\r\\n p = \\\"V\\\"\\r\\n # Evaluate I (1)\\r\\n else:\\r\\n p = \\\"I\\\"\\r\\n \\r\\n x += d[p]\\r\\n\\r\\n return x\",\n \"def enlabel(mi_, ma_):\\n\\treturn \\\"Unicode characters from {} to {} codepoints\\\".format(mi_, ma_)\",\n \"def test_map_to_arabic_value(self):\\n data_provider = [\\n {\\\"roman_value\\\": 'I', \\\"expected_converted_value\\\": '1'},\\n {\\\"roman_value\\\": 'V', \\\"expected_converted_value\\\": '5'},\\n {\\\"roman_value\\\": 'X', \\\"expected_converted_value\\\": '10'},\\n {\\\"roman_value\\\": 'L', \\\"expected_converted_value\\\": '50'},\\n {\\\"roman_value\\\": 'C', \\\"expected_converted_value\\\": '100'},\\n {\\\"roman_value\\\": 'D', \\\"expected_converted_value\\\": '500'},\\n {\\\"roman_value\\\": 'M', \\\"expected_converted_value\\\": '1000'},\\n ]\\n for test_number in range(data_provider.__len__()):\\n with self.subTest(i=test_number):\\n # Set up\\n mapper = RomanToArabicValueMapper()\\n\\n # Exercise\\n mapped_value = mapper.get_mapped_numeral(data_provider[test_number]['roman_value'])\\n\\n # Verify\\n self.assertEqual(mapped_value, data_provider[test_number][\\\"expected_converted_value\\\"])\",\n \"def test_legacyi18n04(self):\\n output = self.engine.render_to_string('legacyi18n04', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'å')\",\n \"def test_legacyi18n04(self):\\n output = self.engine.render_to_string('legacyi18n04', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'å')\",\n \"def dec_to_roman(dec):\\n if dec <= 0:\\n raise ValueError(\\\"Input value must be positive\\\")\\n # to avoid MMMM\\n elif dec >= 4000:\\n raise ValueError(\\\"Input value must be lower than MMMM(4000)\\\")\\n\\n return _dec_to_roman(dec, \\\"\\\", decimalDens, romanDens)\",\n \"def unicode2ascii(_unicrap):\\n xlate = {0xc0:'A', 0xc1:'A', 0xc2:'A', 0xc3:'A', 0xc4:'A', 0xc5:'A',\\n 0xc6:'Ae', 0xc7:'C',\\n 0xc8:'E', 0xc9:'E', 0xca:'E', 0xcb:'E',\\n 0xcc:'I', 0xcd:'I', 0xce:'I', 0xcf:'I',\\n 0xd0:'Th', 0xd1:'N',\\n 0xd2:'O', 0xd3:'O', 0xd4:'O', 0xd5:'O', 0xd6:'O', 0xd8:'O',\\n 0xd9:'U', 0xda:'U', 0xdb:'U', 0xdc:'U',\\n 0xdd:'Y', 0xde:'th', 0xdf:'ss',\\n 0xe0:'a', 0xe1:'a', 0xe2:'a', 0xe3:'a', 0xe4:'a', 0xe5:'a',\\n 0xe6:'ae', 0xe7:'c',\\n 0xe8:'e', 0xe9:'e', 0xea:'e', 0xeb:'e',\\n 0xec:'i', 0xed:'i', 0xee:'i', 0xef:'i',\\n 0xf0:'th', 0xf1:'n',\\n 0xf2:'o', 0xf3:'o', 0xf4:'o', 0xf5:'o', 0xf6:'o', 0xf8:'o',\\n 0xf9:'u', 0xfa:'u', 0xfb:'u', 0xfc:'u',\\n 0xfd:'y', 0xfe:'th', 0xff:'y',\\n 0xa1:'!', 0xa2:'{cent}', 0xa3:'{pound}', 0xa4:'{currency}',\\n 0xa5:'{yen}', 0xa6:'|', 0xa7:'{section}', 0xa8:'{umlaut}',\\n 0xa9:'{C}', 0xaa:'{^a}', 0xab:'<<', 0xac:'{not}',\\n 0xad:'-', 0xae:'{R}', 0xaf:'_', 0xb0:'{degrees}',\\n 0xb1:'{+/-}', 0xb2:'{^2}', 0xb3:'{^3}', 0xb4:\\\"'\\\",\\n 0xb5:'{micro}', 0xb6:'{paragraph}', 0xb7:'*', 0xb8:'{cedilla}',\\n 0xb9:'{^1}', 0xba:'{^o}', 0xbb:'>>',\\n 0xbc:'{1/4}', 0xbd:'{1/2}', 0xbe:'{3/4}', 0xbf:'?',\\n 0xd7:'*', 0xf7:'/'\\n }\\n\\n s = \\\"\\\"\\n for i in _unicrap:\\n ordi = ord(i)\\n if ordi in xlate:\\n s += xlate[ordi]\\n elif ordi >= 0x80:\\n pass\\n else:\\n s += str(i)\\n return s\",\n \"def uCSIsArabicPresentationFormsA(code):\\n ret = libxml2mod.xmlUCSIsArabicPresentationFormsA(code)\\n return ret\",\n \"def roman_number(value):\\n try:\\n value = to_roman(value)\\n except RomanError as e:\\n raise TemplateSyntaxError(\\\"roman_number error: %s\\\" % str(e))\\n return value\",\n \"def test_to_roman_known_values(self):\\n for integer, numeral in self.known_values:\\n result = roman1.to_roman(integer)\\n self.assertEqual(numeral, result)\",\n \"def mp_mb_checker(self, seq):\\n# print('input ' + seq)\\n seq = re.sub(r'([ёуеыаоэяию])м(п|б)',r'\\\\1н\\\\2',seq)\\n# print('output ' + seq)\\n return seq\",\n \"def normalize_alef_maksura_ar(s):\\n\\n return s.replace(u'\\\\u0649', u'\\\\u064a')\",\n \"def to_rna(seq):\\n seq=seq.replace('A','U')\\n seq=seq.replace('T','A')\\n seq=seq.replace('C',\\\"P\\\")\\n seq=seq.replace('G','C')\\n seq=seq.replace('P','G')\\n return seq\",\n \"def roman2int(n):\\n warn('The function roman2int is deprecated from JAMS. Use module pyjams.',\\n category=DeprecationWarning)\\n n = str(n).upper()\\n i = result = 0\\n for integer, numeral in numeral_map:\\n while n[i:i + len(numeral)] == numeral:\\n result += integer\\n i += len(numeral)\\n return result\",\n \"def convert_number(number):\\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '\",\n \"def test_ukrainian_symbols(self):\\n string = \\\"Минає ніч від’їзду\\\"\\n expected = \\\"Minaye nich vid’yizdu\\\"\\n self.assertEqual(transliterate(string), expected)\",\n \"def testFromRomanKnownValues(self):\\n for integer, numeral in self.knownValues:\\n result = roman.fromRoman(numeral)\\n self.assertEqual(integer, result)\",\n \"def solution(roman):\\n r = roman.upper()\\n nums = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\\n total = 0\\n for i, c in enumerate(r):\\n if i < len(r) - 1:\\n if nums[r[i]] < nums[r[i+1]]:\\n total -= nums[c]\\n else:\\n total += nums[c]\\n else:\\n total += nums[c]\\n return total\",\n \"def to_symbol(text):\\n text = text.upper()\\n if text in (\\\"BGM\\\", \\\"BANGUMI\\\"):\\n return \\\"bgm\\\"\\n elif text in (\\\"MAL\\\", \\\"MYANIMELIST\\\"):\\n return \\\"mal\\\"\\n else:\\n return None\",\n \"def roman2int(input):\\n numerals = {\\n 'I': 1,\\n 'V': 5,\\n 'X': 10,\\n 'L': 50,\\n 'C': 100,\\n 'D': 500,\\n 'M': 1000\\n }\\n input = input.strip()\\n dlugosc = len(input)\\n out = 0\\n for i in range(dlugosc):\\n if i+1 < dlugosc and numerals[input[i]] < numerals[input[i+1]]:\\n out -= numerals[input[i]]\\n else:\\n out += numerals[input[i]]\\n return out\",\n \"def test_i18n03(self):\\n output = self.engine.render_to_string('i18n03', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'Å')\",\n \"def test_i18n03(self):\\n output = self.engine.render_to_string('i18n03', {'anton': b'\\\\xc3\\\\x85'})\\n self.assertEqual(output, 'Å')\",\n \"def ta2en(text):\\n return IITB_translator(\\\"ta\\\", \\\"en\\\", text)\",\n \"def test_i18n04(self):\\n output = self.engine.render_to_string(\\\"i18n04\\\", {\\\"anton\\\": \\\"Å\\\"})\\n self.assertEqual(output, \\\"å\\\")\",\n \"def translate(nuc):\\n\\tfrom Bio import Seq\\n\\ttry:\\n\\t\\ttmp_aa = Seq.translate(nuc.replace('-','N')) #returns string when argument is a string, Bio.Seq otherwise\\n\\texcept:\\n\\t\\tprint(\\\"translation failed\\\",nuc)\\n\\t\\ttmp_aa = 'X'*len(nuc)//3\\n\\taa_seq = \\\"\\\"\\n\\tfor i,aa in enumerate(tmp_aa):\\n\\t\\tif nuc[i*3:(i+1)*3]=='---':\\n\\t\\t\\taa_seq+='-'\\n\\t\\telse:\\n\\t\\t\\taa_seq+=aa\\n\\treturn aa_seq\",\n \"def test_legacyi18n04(self):\\n output = self.engine.render_to_string(\\\"legacyi18n04\\\", {\\\"anton\\\": \\\"Å\\\"})\\n self.assertEqual(output, \\\"å\\\")\",\n \"def convert(roman_num: str) -> int:\\n result = 0\\n roman_num = roman_num.upper()\\n rome_dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\\n\\n for i, _ in enumerate(roman_num):\\n if i + 1 < len(roman_num) and rome_dict[roman_num[i]] < rome_dict[roman_num[i + 1]]:\\n result -= rome_dict[roman_num[i]]\\n else:\\n result += rome_dict[roman_num[i]]\\n\\n return result\",\n \"def minimal_roman(integer):\\n\\n\\tint_dict = {1 : 'I',\\n\\t\\t\\t\\t5 : 'V',\\n\\t\\t\\t\\t10 : 'X',\\n\\t\\t\\t\\t50 : 'L',\\n\\t\\t\\t\\t100 : 'C',\\n\\t\\t\\t\\t500 : 'D',\\n\\t\\t\\t\\t1000 : 'M'}\\n\\n\\tnum_count = {k : 0 for k in int_dict.keys() }\\n\\n\\tfor div in list(num_count.keys())[::-1]:\\n\\t\\tif div <= integer:\\n\\t\\t\\t\\n\\t\\t\\tcount = integer // div\\n\\t\\t\\t\\n\\t\\t\\tnum_count[div] = count\\n\\n\\t\\t\\tinteger = integer % div\\n\\n\\tnum_string = ''\\n\\n\\tfor num, count in num_count.items():\\n\\n\\t\\t#should only see a 4 for base 10\\n\\t\\tif count == 4 and num < 1000:\\n\\t\\t\\t\\n\\t\\t\\tif num_count[(num * 5)] == 1:\\n\\t\\t\\t\\taddition = f'{int_dict[num]}{int_dict[(num * 10)]}'\\n\\t\\t\\t\\tnum_count[(num * 5)] = 0\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\taddition = f'{int_dict[num]}{int_dict[(num * 5)]}'\\n\\n\\t\\t\\tnum_string = addition + num_string\\n\\n\\t\\telse:\\n\\t\\t\\taddition = [int_dict[num] for n in range(0, count)]\\n\\t\\t\\tnum_string = ''.join(addition) + num_string\\n\\n\\treturn num_string\",\n \"def question_new_translate():\",\n \"def residue_ramachandran_type(residue) :\\n if residue_amino(residue)==\\\"GLY\\\" :\\n return rama_GLYCINE\\n elif residue_amino(residue)==\\\"PRO\\\" :\\n return rama_PROLINE\\n elif residue_amino(next_residue(residue))==\\\"PRO\\\" :\\n #exlcudes those that are Pro or Gly\\n return rama_PRE_PRO\\n else :\\n return rama_GENERAL\",\n \"def uCSIsArmenian(code):\\n ret = libxml2mod.xmlUCSIsArmenian(code)\\n return ret\",\n \"def roman_to_int(roman_string):\\n\\n NUMERALS_SET = set(list(zip(*NUMERAL_MAP))[1])\\n roman_string = roman_string.upper()\\n if len(set(list(roman_string.upper())) - NUMERALS_SET) != 0:\\n raise ValueError('{0} does not seem to be a roman numeral'.format(\\n roman_string))\\n i = result = 0\\n for integer, numeral in NUMERAL_MAP:\\n while roman_string[i:i + len(numeral)] == numeral:\\n result += integer\\n i += len(numeral)\\n if result < 1:\\n raise ValueError('Can not interpret Roman Numeral {0}'.format(roman_string))\\n return result\",\n \"def getAmbigProchiralLabel(resonance):\\n\\n letter = ''\\n if hasattr(resonance, 'onebond'):\\n del resonance.onebond\\n\\n resonanceSet = resonance.resonanceSet\\n \\n if resonanceSet:\\n if resonance.isotopeCode == '1H':\\n data = []\\n for resonance2 in resonanceSet.sortedResonances():\\n if resonance2.shifts:\\n data.append( ('%f%d' % (resonance2.findFirstShift().value,resonance2.serial),resonance2) )\\n else:\\n data.append( (resonance2.serial,resonance2) )\\n \\n data.sort()\\n resonances = [x[1] for x in data]\\n i = resonances.index(resonance)\\n letter = chr(ord('a')+i)\\n\\n else:\\n resonance2 = getOnebondResonance(resonance, isotopeCode='1H') \\n \\n if resonance2 and resonance2.resonanceSet and (len(resonance2.resonanceSet.atomSets) > 1):\\n letter = getAmbigProchiralLabel(resonance2)\\n resonance2.onebond = resonance\\n \\n elif (len(resonanceSet.resonances) > 1) and (len(resonanceSet.atomSets) > 1):\\n for resonance2 in resonanceSet.resonances:\\n if resonance2 is not resonance:\\n resonance3 = getOnebondResonance(resonance2)\\n if resonance3 and resonance3.resonanceSet and (len(resonance3.resonanceSet.atomSets) > 1):\\n letter = 'b'\\n break\\n \\n if not letter:\\n data = []\\n for resonance2 in resonanceSet.resonances:\\n if resonance2.shifts:\\n data.append( (resonance2.findFirstShift().value,resonance2) )\\n else:\\n data.append( (resonance2.serial,resonance2) )\\n \\n data.sort()\\n resonances = [x[1] for x in data]\\n i = resonances.index(resonance)\\n letter = chr(ord('a')+i) \\n\\n #keyword = 'ambigProchiralLabel'\\n #app = 'Analysis'\\n #appData = resonance.findFirstApplicationData(application=app, keyword=keyword)\\n #\\n #if appData and (appData.value != letter):\\n # appData.delete()\\n # appData = None\\n # \\n #if not appData:\\n # AppDataString(resonance,application=app,keyword=keyword, value=letter)\\n \\n return letter\",\n \"def translate(rna):\\n RNA_CODON_TABLE = {\\\"UUU\\\": \\\"F\\\", \\\"UUC\\\": \\\"F\\\", \\\"UUA\\\": \\\"L\\\", \\\"UUG\\\": \\\"L\\\",\\n \\\"UCU\\\": \\\"S\\\", \\\"UCC\\\": \\\"S\\\", \\\"UCA\\\": \\\"S\\\", \\\"UCG\\\": \\\"S\\\",\\n \\\"UAU\\\": \\\"Y\\\", \\\"UAC\\\": \\\"Y\\\", \\\"UAA\\\": \\\"*\\\", \\\"UAG\\\": \\\"*\\\",\\n \\\"UGU\\\": \\\"C\\\", \\\"UGC\\\": \\\"C\\\", \\\"UGA\\\": \\\"*\\\", \\\"UGG\\\": \\\"W\\\",\\n \\\"CUU\\\": \\\"L\\\", \\\"CUC\\\": \\\"L\\\", \\\"CUA\\\": \\\"L\\\", \\\"CUG\\\": \\\"L\\\",\\n \\\"CCU\\\": \\\"P\\\", \\\"CCC\\\": \\\"P\\\", \\\"CCA\\\": \\\"P\\\", \\\"CCG\\\": \\\"P\\\",\\n \\\"CAU\\\": \\\"H\\\", \\\"CAC\\\": \\\"H\\\", \\\"CAA\\\": \\\"Q\\\", \\\"CAG\\\": \\\"Q\\\",\\n \\\"CGU\\\": \\\"R\\\", \\\"CGC\\\": \\\"R\\\", \\\"CGA\\\": \\\"R\\\", \\\"CGG\\\": \\\"R\\\",\\n \\\"AUU\\\": \\\"I\\\", \\\"AUC\\\": \\\"I\\\", \\\"AUA\\\": \\\"I\\\", \\\"AUG\\\": \\\"M\\\",\\n \\\"ACU\\\": \\\"T\\\", \\\"ACC\\\": \\\"T\\\", \\\"ACA\\\": \\\"T\\\", \\\"ACG\\\": \\\"T\\\",\\n \\\"AAU\\\": \\\"N\\\", \\\"AAC\\\": \\\"N\\\", \\\"AAA\\\": \\\"K\\\", \\\"AAG\\\": \\\"K\\\",\\n \\\"AGU\\\": \\\"S\\\", \\\"AGC\\\": \\\"S\\\", \\\"AGA\\\": \\\"R\\\", \\\"AGG\\\": \\\"R\\\",\\n \\\"GUU\\\": \\\"V\\\", \\\"GUC\\\": \\\"V\\\", \\\"GUA\\\": \\\"V\\\", \\\"GUG\\\": \\\"V\\\",\\n \\\"GCU\\\": \\\"A\\\", \\\"GCC\\\": \\\"A\\\", \\\"GCA\\\": \\\"A\\\", \\\"GCG\\\": \\\"A\\\",\\n \\\"GAU\\\": \\\"D\\\", \\\"GAC\\\": \\\"D\\\", \\\"GAA\\\": \\\"E\\\", \\\"GAG\\\": \\\"E\\\",\\n \\\"GGU\\\": \\\"G\\\", \\\"GGC\\\": \\\"G\\\", \\\"GGA\\\": \\\"G\\\", \\\"GGG\\\": \\\"G\\\"}\\n str = ''\\n list = [rna[i:i+3] for i in range(0,len(rna),3)]\\n for x in list:\\n #checks if x is in key of RNA_CODON_TABLE\\n if x in RNA_CODON_TABLE:\\n #appends only if the value for the given key is not *\\n if RNA_CODON_TABLE[x] != '*':\\n str = str + RNA_CODON_TABLE[x]\\n #if only one char is extra(meaning apart form the 3 pair characters available in dictionary)\\n #checks if the char is in following\\n elif len(x) == 1 and x in ['A','G','C','U']:\\n str = str + x\\n #if the char is of length 2 i.e, 2 words extra\\n elif len(x) == 2 and x[0] in ['A','G','C','U'] and x[1] in ['A','G','C','U']:\\n #Then appending the char to the actually converted string\\n str = str + x[0]\\n str = str + x[1]\\n #if the char is not in the above characters then it is a unrecognised character.\\n else:\\n print(\\\"Unrecognised character:\\\",x)\\n return str\",\n \"def multiplicationRoman(x, y):\\n a = fromRoman(x)\\n b = fromRoman(y)\\n \\n c = a * b \\n d = toRoman(c)\\n return d\",\n \"def res_1Letter(RES):\\n RES_LetterCode = ['HOH', 'ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE','LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL']\\n R_LetterCode = ['O', 'A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V']\\t\\n return R_LetterCode[RES_LetterCode.index(RES)]\",\n \"def uCSIsArabicPresentationFormsB(code):\\n ret = libxml2mod.xmlUCSIsArabicPresentationFormsB(code)\\n return ret\",\n \"def translate(inp: str) -> str:\\n\\t# list for encdoe cirylic symbols in latinc.\\n\\tsymbols = (u\\\"абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯöÖåÅ\\\",\\n\\t\\t\\tu\\\"abvgdeejzijklmnoprstufhzcss_y_euaABVGDEEJZIJKLMNOPRSTUFHZCSS_Y_EUAoOaA\\\")\\n\\t# generate dict like {\\\"a\\\":\\\"a\\\",\\\"б\\\":\\\"\\\",...}\\n\\ttr = {ord(a):ord(b) for a, b in zip(*symbols)}\\n\\t# switch all symbols\\n\\toutput = inp.translate(tr)\\n\\treturn output\",\n \"def provisional(self, positive=False, kanji=False):\\n if positive:\\n verb = self.kanji if kanji else self.kana\\n for before, after in Verb.ENDING_U_TO_E.items():\\n if verb.endswith(before):\\n base = re.sub(before + '$', after, verb)\\n return base + 'ば'\\n else:\\n verb = self.present_indicative(polite=False, positive=False, kanji=kanji)\\n return re.sub('い$', 'ければ', verb)\",\n \"def _dec_to_roman(num, s, decs, romans):\\n if decs:\\n if (num < decs[0]):\\n # deal with the rest denomination\\n return _dec_to_roman(num, s, decs[1:], romans[1:])\\n else:\\n # deduce this denomation till num<desc[0]\\n return _dec_to_roman(num - decs[0], s + romans[0], decs, romans)\\n else:\\n # we run out of denomination, we are done\\n return s\",\n \"def Get_Hebrew_Stop_Words():\\r\\n # Explain Of The Function #\\r\\n\\r\\n return ['אני', 'את', 'אתה', 'אנחנו', 'אתן', 'אתם', 'הם', 'הן', 'היא', 'הוא', 'שלי', 'שלו', 'שלך', 'שלה', 'שלנו',\\r\\n 'שלכם', 'שלכן', 'שלהם', 'עד', 'אשר', 'במידה', 'שוב', 'יותר',\\r\\n 'שלהן', 'לי', 'לו', 'לה', 'לנו', 'לכם', 'לכן', 'להם', 'להן', 'אותה', 'אותו', 'זה', 'זאת', 'אלה', 'אלו',\\r\\n 'תחת', 'מתחת', 'מעל', 'בין', 'מכיוון', 'יכולה', 'יכולים', 'יכולות',\\r\\n 'עם', 'עד', 'נגר', 'על', 'אל', 'מול', 'של', 'אצל', 'כמו', 'אחר', 'אותו', 'בלי', 'לפני', 'אחרי',\\r\\n 'מאחורי', 'עלי', 'עליו', 'עליה', 'הסיבה שבגללה', 'למה', 'אלו', 'אף', 'על', 'מעל',\\r\\n 'עליך', 'עלינו', 'עליכם', 'לעיכן', 'עליהם', 'עליהן', 'כל', 'כולם', 'כולן', 'כך', 'ככה', 'כזה', 'זה',\\r\\n 'זאת', 'אותי', 'אותה', 'אותם', 'איתן', 'איתנו', 'עצמן', 'עצמנו', 'מהיכן', 'מן', 'לעבר', 'מכאן',\\r\\n 'אותך', 'אותו', 'אותן', 'אותנו', 'ואת', 'את', 'אתכם', 'אתכן', 'איתי', 'איתו', 'איתך', 'איתה', 'איתם',\\r\\n 'איתכם', 'איתכן', 'יהיה', 'תהיה', 'היתי', 'היתה', 'היה', 'להיות', 'עצמי', 'עצמו', 'עצמה', 'עצמם',\\r\\n 'עצמהם', 'עצמהן', 'מי', 'מה', 'איפה', 'היכן', 'במקום שבו', 'אם', 'לאן', 'למקום שבו', 'מקום בו', 'איזה',\\r\\n 'איך', 'כיצד', 'באיזו מידה', 'מתי', 'בשעה ש', 'כאשר', 'כש', 'למרות', 'לפני', 'אחרי', 'מאיזו סיבה',\\r\\n 'מדוע', 'לאיזו תכלית', 'כי', 'יש', 'אין', 'אך', 'מנין', 'מאין', 'מאיפה', 'יכל', 'יכלה', 'יכלו', 'יכול',\\r\\n 'יוכלו', 'יוכל', 'מסוגל', 'לא', 'רק', 'אולי', 'אין', 'לאו', 'אי', 'כלל', 'נגד', 'אם', 'עם', 'אל', 'אלה',\\r\\n 'מתחת', 'מצד', 'בשביל', 'לבין', 'באמצע', 'בתוך', 'דרך', 'מבעד', 'באמצעות', 'למעלה', 'למטה', 'מחוץ',\\r\\n 'כאן', 'הנה', 'הרי', 'פה', 'שם', 'אך', 'ברם', 'שוב', 'אבל', 'מבלי', 'בלי', 'מלבד', 'רק', 'בגלל',\\r\\n 'ואילו', 'למרות', 'אס', 'כמו', 'כפי', 'אז', 'אחרי', 'כן', 'לכן', 'לפיכך', 'מאד', 'עז', 'מעט', 'מעטים',\\r\\n 'מדי', 'גם', 'כן', 'נו', 'אחר', 'אחרת', 'אחרים', 'אחרות', 'אשר', 'או']\\r\\n pass\",\n \"def to_ascii(self):\\n code = self.build()\\n for i, line in enumerate(code):\\n code[i] = line.replace('1', '|').replace('0', '_')\\n return '\\\\n'.join(code)\",\n \"def romanAddition(x, y):\\n \\n # Replace the x and y parameters with longer roman numerals\\n suby1 = y.replace(\\\"CM\\\", \\\"DCCCC\\\")\\n suby2 = suby1.replace(\\\"CD\\\", \\\"CCCC\\\")\\n suby3 = suby2.replace(\\\"XC\\\", \\\"LXXXX\\\")\\n suby4 = suby3.replace(\\\"XL\\\", \\\"XXXX\\\")\\n suby5 = suby4.replace(\\\"IX\\\", \\\"VIIII\\\")\\n suby6 = suby5.replace(\\\"IV\\\", \\\"IIII\\\")\\n \\n subx1 = x.replace(\\\"CM\\\", \\\"DCCCC\\\")\\n subx2 = subx1.replace(\\\"CD\\\", \\\"CCCC\\\")\\n subx3 = subx2.replace(\\\"XC\\\", \\\"LXXXX\\\")\\n subx4 = subx3.replace(\\\"XL\\\", \\\"XXXX\\\")\\n subx5 = subx4.replace(\\\"IX\\\", \\\"VIIII\\\")\\n subx6 = subx5.replace(\\\"IV\\\", \\\"IIII\\\")\\n\\n # Making result into a string\\n # Combining the parameters into one string\\n result = \\\"\\\"\\n add = subx6 + suby6\\n result += add\\n\\n # Sorting with a condition\\n valueOrder = \\\"MDCLXVI\\\"\\n sortingList = sorted(result, key=valueOrder.index)\\n \\n\\n \\n str1 = ''.join(sortingList)\\n \\n # Replace the long roman numeral with an original roman numeral\\n tmp1 = str1.replace(\\\"IIIII\\\", \\\"V\\\")\\n tmp2 = tmp1.replace(\\\"VV\\\", \\\"X\\\")\\n tmp3 = tmp2.replace(\\\"XXXXX\\\", \\\"L\\\")\\n tmp4 = tmp3.replace(\\\"LL\\\", \\\"C\\\")\\n tmp5 = tmp4.replace(\\\"CCCCC\\\", \\\"D\\\")\\n tmp6 = tmp5.replace(\\\"DD\\\", \\\"M\\\")\\n \\n tmp7 = tmp6.replace(\\\"VIIII\\\", \\\"IX\\\")\\n tmp8 = tmp7.replace(\\\"IIII\\\", \\\"IV\\\")\\n tmp9 = tmp8.replace(\\\"XXXX\\\", \\\"XL\\\")\\n tmp10 = tmp9.replace(\\\"LXXXX\\\", \\\"XC\\\")\\n tmp11 = tmp10.replace(\\\"CCCC\\\", \\\"CD\\\")\\n tmp12 = tmp11.replace(\\\"DCCCC\\\", \\\"CM\\\")\\n \\n return tmp12\",\n \"def normalize_RTL(src: str):\\n if not src.isascii():\\n return src + ' (' + src[::-1] + ')'\\n return src\",\n \"def transcribe(seq):\\n rna = ''\\n for letter in seq:\\n if letter == 'A':\\n rna = rna + 'U'\\n elif letter == 'T':\\n rna = rna + 'A'\\n elif letter == 'G':\\n rna = rna + 'C'\\n else:\\n rna = rna + 'G'\\n return rna\",\n \"def text_direction(self) -> str:\\n return ''.join(word[0] for word in self.character_order.split('-'))\",\n \"def roman2int(s):\\n if not s or not isinstance(s, str):\\n raise InputError(s, \\\"Input value must be a non-empty string.\\\")\\n elif __roman_numeral_regex.search(s) is None:\\n raise InputError(s, \\\"Input is not a valid Roman numeral representation of numbers in the 1-4999 range.\\\")\\n\\n return sum([__bmap[i] if __bmap[i] >= __bmap[j] else -__bmap[i] for i, j in zip(s, s[1:])]) + __bmap[s[-1]]\",\n \"def residue_amino(residue) :\\n if residue :\\n return residue.name[0:3].upper()\\n else :\\n return None\",\n \"def normalize_teh_marbuta_ar(s):\\n\\n return s.replace(u'\\\\u0629', u'\\\\u0647')\",\n \"def en2ta(text):\\n return IITB_translator(\\\"en\\\", \\\"ta\\\", text)\",\n \"def test_i18n03(self):\\n output = self.engine.render_to_string(\\\"i18n03\\\", {\\\"anton\\\": \\\"Å\\\"})\\n self.assertEqual(output, \\\"Å\\\")\",\n \"def EnglishToPig(str):\\r\\n\\r\\n # TODO: Your code here\\r\\n\\r\\n\\r\\n # Change the return to return the converted string\\r\\n return(\\\"\\\")\",\n \"def PigToEnglish(str):\\r\\n\\r\\n # TODO: Your code here\\r\\n\\r\\n\\r\\n # Change the return to return the converted string\\r\\n return(\\\"\\\")\",\n \"def simpleTranslateToBrl(text):\\n\\n\\t# initialize output\\n\\tout = \\\"\\\"\\n\\n\\tlog.debug(\\\"translating %d characters into Braille\\\" % len(text))\\n\\tlog.debug(\\\"using map: %s\\\" % str(simpleBrailleMap))\\n\\n\\t# iterate through entire string and setup a Braille character string\\n\\tfor c in text.lower():\\n\\t\\ttry:\\n\\t\\t\\tch = simpleBrailleMap[c]\\n\\t\\t\\tout += chr(ch) # append found character\\n\\t\\texcept KeyError:\\n\\t\\t\\t# An unknown character was found. Log and replace with a full cell.\\n\\t\\t\\tlog.debug(\\\"the character '%s' was not found.\\\" % c)\\n\\t\\t\\tout += \\\"\\\\xff\\\" # full cell\\n\\treturn out\",\n \"def normalize_alef_ar(s):\\n\\n return _ALEF_NORMALIZE_AR_RE.sub(u'\\\\u0627', s)\",\n \"def lcd_string_kana(self, message, line):\\n codes = u'線線線線線線線線線線線線線線線線 '\\\\\\n u' !\\\"#$%&()*+,-./0123456789:;<=>?@ABCDEFG'\\\\\\n u'HIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{'\\\\\\n u'|}→← '\\\\\\n u' 。「」、・ヲァィゥェォャュョッーア'\\\\\\n u'イウエオカキクケコサシスセソタチツテトナニヌネノハヒ'\\\\\\n u'フヘホマミムメモヤユヨラリルレロワン゛゜αäβεμσρq√陰ι'\\\\\\n u'×￠￡nöpqθ∞ΩüΣπxν千万円÷ 塗'\\n dic ={u'ガ':u'カ゛',u'ギ':u'キ゛',u'グ':u'ク゛',\\\\\\n u'ゲ':u'ケ゛',u'ゴ':u'コ゛',u'ザ':u'サ゛',\\\\\\n u'ジ':u'シ゛',u'ズ':u'ス゛',u'ゼ':u'セ゛',\\\\\\n u'ゾ':u'ソ゛',u'ダ':u'タ゛',u'ヂ':u'チ゛',\\\\\\n u'ヅ':u'ツ゛',u'デ':u'テ゛',u'ド':u'ト゛',\\\\\\n u'バ':u'ハ゛',u'ビ':u'ヒ゛',u'ブ':u'フ゛',\\\\\\n u'ベ':u'ヘ゛',u'ボ':u'ホ゛',u'パ':u'ハ゜',\\\\\\n u'ピ':u'ヒ゜',u'プ':u'フ゜',u'ペ':u'ヘ゜',\\\\\\n u'ポ':u'ホ゜',u'℃':u'゜C'}\\n\\n self.lcd_byte(line, LCD_CMD)\\n message2 = ''\\n for i in range(len(message)):\\n if (message[i] in dic.keys()):\\n message2 += dic[message[i]]\\n else:\\n message2 += message[i]\\n\\n for i in range(len(message2)):\\n if message2[i] == ' ':\\n self.lcd_byte(ord(message2[i]), LCD_CHR)\\n elif (codes.find(message2[i]) >= 0):\\n self.lcd_byte(codes.find(message2[i]) + 1, LCD_CHR)\\n elif (codes_han.find(message2[i]) >= 0):\\n self.lcd_byte(codes.find(message2[i]) + 1, LCD_CHR)\\n elif (message2[i] != u' '):\\n self.lcd_byte('?', LCD_CHR)\",\n \"def convert_numerals(input_str):\\n # credit to: http://code.activestate.com/recipes/81611-roman-numerals/\\n copy = input_str[:]\\n copy = copy.split(\\\" \\\")\\n\\n nums = ['m', 'd', 'c', 'l', 'x', 'v', 'i']\\n ints = [1000, 500, 100, 50, 10, 5, 1]\\n places = []\\n\\n for i in range(len(copy)):\\n is_valid = True\\n\\n if \\\".\\\" in copy[i]:\\n copy[i] = copy[i].replace(\\\".\\\", \\\"\\\")\\n else:\\n # . must be appended to end of string to signify it is a roman\\n # numeral\\n is_valid = False\\n\\n if \\\"xix\\\" in copy[i] or \\\"xviii\\\" in copy[i]:\\n is_valid = True\\n\\n for c in copy[i].lower():\\n if c not in nums:\\n # return original\\n is_valid = False\\n\\n if is_valid is False:\\n continue\\n\\n for char_index in range(len(copy[i])):\\n c = copy[i][char_index].lower()\\n value = ints[nums.index(c)]\\n # If the next place holds a larger number, this value is negative.\\n try:\\n nextvalue = ints[nums.index(copy[i][char_index + 1].lower())]\\n if nextvalue > value:\\n value *= -1\\n except IndexError:\\n # there is no next place.\\n pass\\n places.append(value)\\n\\n out = 0\\n\\n for n in places:\\n out += n\\n\\n copy[i] = str(out)\\n\\n return \\\" \\\".join(copy)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.779442","0.74281687","0.7296251","0.7257054","0.67278147","0.67266434","0.6697449","0.6658061","0.66198784","0.65114695","0.6464905","0.64380807","0.639312","0.63480544","0.6299207","0.62872094","0.62515366","0.62329185","0.6206833","0.62048817","0.6163165","0.6124668","0.608321","0.6037591","0.599299","0.5966522","0.59608704","0.59371185","0.5906349","0.58590645","0.5844807","0.5771589","0.5757825","0.57370704","0.56426275","0.5619176","0.5611629","0.5611629","0.5610594","0.55839705","0.55713123","0.5566427","0.55624986","0.55531526","0.5545188","0.55424947","0.55358887","0.55358887","0.5528095","0.5502172","0.54855347","0.54754996","0.5471345","0.5467174","0.5443433","0.5440029","0.54217076","0.5421655","0.53853637","0.53789794","0.53323126","0.53293","0.5327297","0.5318242","0.5318242","0.53109276","0.52888274","0.52877253","0.52598953","0.52201146","0.5208956","0.51925313","0.51896095","0.51765245","0.51597774","0.5138279","0.5137843","0.5136883","0.51167053","0.51114756","0.5090865","0.5085271","0.5067737","0.5067698","0.50630826","0.50532436","0.5037899","0.5030319","0.5025945","0.50184506","0.5015403","0.50137","0.5013478","0.5007941","0.5004754","0.5004591","0.49985728","0.4996119","0.4992906","0.4989107"],"string":"[\n \"0.779442\",\n \"0.74281687\",\n \"0.7296251\",\n \"0.7257054\",\n \"0.67278147\",\n \"0.67266434\",\n \"0.6697449\",\n \"0.6658061\",\n \"0.66198784\",\n \"0.65114695\",\n \"0.6464905\",\n \"0.64380807\",\n \"0.639312\",\n \"0.63480544\",\n \"0.6299207\",\n \"0.62872094\",\n \"0.62515366\",\n \"0.62329185\",\n \"0.6206833\",\n \"0.62048817\",\n \"0.6163165\",\n \"0.6124668\",\n \"0.608321\",\n \"0.6037591\",\n \"0.599299\",\n \"0.5966522\",\n \"0.59608704\",\n \"0.59371185\",\n \"0.5906349\",\n \"0.58590645\",\n \"0.5844807\",\n \"0.5771589\",\n \"0.5757825\",\n \"0.57370704\",\n \"0.56426275\",\n \"0.5619176\",\n \"0.5611629\",\n \"0.5611629\",\n \"0.5610594\",\n \"0.55839705\",\n \"0.55713123\",\n \"0.5566427\",\n \"0.55624986\",\n \"0.55531526\",\n \"0.5545188\",\n \"0.55424947\",\n \"0.55358887\",\n \"0.55358887\",\n \"0.5528095\",\n \"0.5502172\",\n \"0.54855347\",\n \"0.54754996\",\n \"0.5471345\",\n \"0.5467174\",\n \"0.5443433\",\n \"0.5440029\",\n \"0.54217076\",\n \"0.5421655\",\n \"0.53853637\",\n \"0.53789794\",\n \"0.53323126\",\n \"0.53293\",\n \"0.5327297\",\n \"0.5318242\",\n \"0.5318242\",\n \"0.53109276\",\n \"0.52888274\",\n \"0.52877253\",\n \"0.52598953\",\n \"0.52201146\",\n \"0.5208956\",\n \"0.51925313\",\n \"0.51896095\",\n \"0.51765245\",\n \"0.51597774\",\n \"0.5138279\",\n \"0.5137843\",\n \"0.5136883\",\n \"0.51167053\",\n \"0.51114756\",\n \"0.5090865\",\n \"0.5085271\",\n \"0.5067737\",\n \"0.5067698\",\n \"0.50630826\",\n \"0.50532436\",\n \"0.5037899\",\n \"0.5030319\",\n \"0.5025945\",\n \"0.50184506\",\n \"0.5015403\",\n \"0.50137\",\n \"0.5013478\",\n \"0.5007941\",\n \"0.5004754\",\n \"0.5004591\",\n \"0.49985728\",\n \"0.4996119\",\n \"0.4992906\",\n \"0.4989107\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8043565"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81393,"cells":{"query":{"kind":"string","value":"Creates some B words for every pair, with the following constraints"},"document":{"kind":"string","value":"def create_B_words(path_to_pairs,\n path_to_librispeech_text,\n path_to_phonemes,\n path_save,\n freq_sim,\n len_sim,\n edit_sim):\n for i in range(len(path_to_pairs)):\n \n pairs = []\n dic_cl_eq = {} # Classe d'equivalence pour le sens des mots\n \n with open(path_to_pairs[i]) as f:\n for line in f:\n line = line.replace('\\n', '').split(' ')\n pairs.append(line)\n if line[0] in dic_cl_eq:\n dic_cl_eq[line[0]].add(line[1])\n else:\n dic_cl_eq[line[0]] = {line[1]}\n if line[1] in dic_cl_eq:\n dic_cl_eq[line[1]].add(line[0])\n else:\n dic_cl_eq[line[1]] = {line[0]}\n \n dic_cl_eq_prev = {}\n while dic_cl_eq_prev != dic_cl_eq:\n dic_cl_eq_prev = copy.deepcopy(dic_cl_eq)\n for word in dic_cl_eq:\n for syn in dic_cl_eq[word]:\n dic_cl_eq[word] = set.union(dic_cl_eq[word], dic_cl_eq[syn])\n \n with open(path_to_librispeech_text) as f:\n text_librispeech = f.read()\n text_librispeech_split = text_librispeech.replace('\\n', ' ').split(' ')\n freq_libri = {}\n for word in text_librispeech_split:\n if word in dic_cl_eq:\n if word in freq_libri:\n freq_libri[word] += 1\n else:\n freq_libri[word] = 1\n \n phonemes = []\n with open(path_to_phonemes[i]) as f:\n for line in f:\n line = line.replace('\\n', '').split(' ')\n phonemes.append(line)\n \n dic_word_phonemes = {}\n for j in range(len(pairs)):\n dic_word_phonemes[pairs[j][0]] = phonemes[j][0]\n dic_word_phonemes[pairs[j][1]] = phonemes[j][1]\n \n file = open(path_save[i], 'w+')\n file.truncate(0)\n \n for j in range(len(pairs)):\n A, X = pairs[j]\n B_0 = []\n for word in dic_cl_eq:\n if word not in dic_cl_eq[A]:\n if np.abs(np.log(freq_libri[word])/np.log(freq_sim) \\\n - np.log(freq_libri[A])/np.log(freq_sim)) <= 1:\n if (len(word) > (1-len_sim)*len(A)) and \\\n (len(word) < (1+len_sim)*len(A)):\n p_A = dic_word_phonemes[A]\n p_X = dic_word_phonemes[X]\n p_word = dic_word_phonemes[word]\n if np.abs(dist(p_A, p_X) - dist(p_X, p_word)) < edit_sim:\n B_0.append(word)\n line_0 = ' '.join([A, X] + B_0)\n \n X, A = pairs[j]\n B_1 = []\n for word in dic_cl_eq:\n if word not in dic_cl_eq[A]:\n if np.abs(np.log(freq_libri[word])/np.log(freq_sim) \\\n - np.log(freq_libri[A])/np.log(freq_sim)) <= 1:\n if (len(word) > np.around((1-len_sim)*len(A), decimals=2)) and \\\n (len(word) < np.around((1+len_sim)*len(A), decimals=2)):\n p_A = dic_word_phonemes[A]\n p_X = dic_word_phonemes[X]\n p_word = dic_word_phonemes[word]\n if np.abs(dist(p_A, p_X) - dist(p_X, p_word)) < edit_sim:\n B_1.append(word)\n line_1 = ' '.join([A, X] + B_1)\n \n if max(len(B_0), len(B_1)) == 0:\n print(X, A)\n \n line = line_0 if len(line_0) > len(line_1) else line_1\n if j < len(pairs) - 1:\n line += '\\n'\n file.write(line)\n \n file.close()"},"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 generate_pairs_of_words(word_list):\n def pair_words(word_list, i, j, connector):\n return word_list[i] + connector + word_list[j]\n pairs = []\n n = len(word_list)\n for i in range(n-1):\n for j in range(i+1, n):\n pairs.append(pair_words(word_list, i, j, ' '))\n pairs.append(pair_words(word_list, j, i, ' '))\n pairs.append(pair_words(word_list, i, j, '-'))\n pairs.append(pair_words(word_list, j, i, '-'))\n pairs.append(pair_words(word_list, i, j, '_'))\n pairs.append(pair_words(word_list, j, i, '_'))\n pairs.append(pair_words(word_list, i, j, ''))\n pairs.append(pair_words(word_list, j, i, ''))\n outputs = list(set(pairs)) # remove duplicates\n return outputs","def generate_word(model, whitelist, topk, radix=\"\"):\n if whitelist.empty():\n yield \"\", 0\n else:\n for prefix, prefix_proba in iterate_continutations(model, radix, whitelist, topk):\n if prefix is None:\n continue\n for suffix, suffix_proba in generate_word(\n model,\n whitelist.sub(LetterBag(prefix)),\n topk,\n radix + prefix):\n if suffix is None:\n continue\n yield prefix + suffix, prefix_proba + suffix_proba\n yield None, 0","def create_word(char_list):","def make_chains(text, text2):\n\n list_of_words = text.split() + text2.split()\n # Build dictionary where key = tuple and value = following word\n word_next_dict = {}\n pos = 0\n #Create word pairs of every combination from within source texts\n for word in list_of_words[0:-2]:\n pair = (list_of_words[pos], list_of_words[pos+1])\n if pair not in word_next_dict:\n word_next_dict[pair] = [list_of_words[pos+2]]\n pos += 1\n else:\n word_next_dict[pair].append(list_of_words[pos+2])\n pos += 1\n return word_next_dict","def generateWord2(self, parameters=None):\n\n\t\t##Initial set-up\n\t\t#A syllable consists of an optional onset, a nucleus, and an optional coda\n\t\t#Sources:\n\t\t# http://en.wikipedia.org/wiki/English_phonology#Phonotactics\n\t\t# http://en.wiktionary.org/wiki/Appendix:English_pronunciation\n\t\tonsets = [\"ch\", \"pl\", \"bl\", \"cl\", \"gl\", \"pr\", \"br\", \"tr\", \"dr\", \"cr\", \"gr\", \"tw\", \"dw\", \"qu\", \"pu\",\n\t\t\t\t \"fl\", \"sl\", \"fr\", \"thr\", \"shr\", \"wh\", \"sw\",\n\t\t\t\t \"sp\", \"st\", \"sk\", \"sm\", \"sn\", \"sph\", \"spl\", \"spr\", \"str\", \"scr\", \"squ\", \"sm\"] #Plus the normal consonants\n\t\tnuclei = [\"ai\", \"ay\", \"ea\", \"ee\", \"y\", \"oa\", \"au\", \"oi\", \"oo\", \"ou\"] #Plus the normal vowels\n\t\tcodas = [\"ch\", \"lp\", \"lb\", \"lt\", \"ld\", \"lch\", \"lg\", \"lk\", \"rp\", \"rb\", \"rt\", \"rd\", \"rch\", \"rk\", \"lf\", \"lth\",\n\t\t\t\t \"lsh\", \"rf\", \"rth\", \"rs\", \"rsh\", \"lm\", \"ln\", \"rm\", \"rn\", \"rl\", \"mp\", \"nt\", \"nd\", \"nch\", \"nk\", \"mph\",\n\t\t\t\t \"mth\", \"nth\", \"ngth\", \"ft\", \"sp\", \"st\", \"sk\", \"fth\", \"pt\", \"ct\", \"kt\", \"pth\", \"ghth\", \"tz\", \"dth\",\n\t\t\t\t \"ks\", \"lpt\", \"lfth\", \"ltz\", \"lst\", \"lct\", \"lx\",\"rmth\", \"rpt\", \"rtz\", \"rst\", \"rct\",\"mpt\", \"dth\",\n\t\t\t\t \"nct\", \"nx\", \"xth\", \"xt\"] #Plus normal consonants\n\n\t\tsimpleLetterChance = 65 #percent, whether a single letter is chosen instead of an onset/nucleus/coda\n\t\tbasicLetterChance = 75 #percent, whether a simple consonant/vowel is chosen over a more rare one\n\n\t\t#Prevent unnecessary and ugly code repetition\n\n\t\t#Start the word\n\t\trepeats = 1\n\t\tif parameters and len(parameters) > 0:\n\t\t\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\n\n\t\twords = []\n\t\tfor i in xrange(0, repeats):\n\t\t\tsyllableCount = 2\n\t\t\tif random.randint(1, 100) <= 50:\n\t\t\t\tsyllableCount -= 1\n\t\t\tif random.randint(1, 100) <= 35:\n\t\t\t\tsyllableCount += 1\n\n\t\t\tword = u\"\"\n\t\t\tfor j in range(0, syllableCount):\n\t\t\t\t#In most cases, add an onset\n\t\t\t\tif random.randint(1, 100) <= 75:\n\t\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"consonant\", basicLetterChance)\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(onsets)\n\n\t\t\t\t#Nucleus!\n\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"vowel\", basicLetterChance)\n\t\t\t\telse:\n\t\t\t\t\tword += random.choice(nuclei)\n\n\t\t\t\t#Add a coda in most cases (Always add it if this is the last syllable of the word and it'd be too short otherwise)\n\t\t\t\tif (j == syllableCount - 1 and len(word) < 3) or random.randint(1, 100) <= 75:\n\t\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"consonant\", basicLetterChance)\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(codas)\n\n\t\t\tword = word[0].upper() + word[1:]\n\t\t\twords.append(word)\n\n\t\treturn u\", \".join(words)","def rule_nnp_vbz_rb_vb(words):\n original_len = len(words)\n words = mutate_tag_seq(\n words,\n ['NNP','VBZ','RB','VB'],\n ['NNP','VB','RB']\n )\n if words is not None:\n if len(words) < original_len:\n i = index_tag_seq(words, ['NNP', 'VB', 'RB'])\n words[i+1].text += 's'\n words[i+1].tag = 'VBZ'\n return words","def proc_sw_both_not_empty(forward_pairs, uni_word, morphs, backward_pairs):\n sandwich_pairs = []\n morphs_str = ' + '.join([str(morph) for morph in morphs])\n word_morphs_str = '%s %s' % (uni_word.encode('UTF-8'), morphs_str)\n if word_morphs_str in _CORRECT_ALIGNS:\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs))\n elif word_morphs_str in ['해야 하/VV + 아야/EC + 하/VX', '해야 하/XSV + 아야/EC + 하/VX', '야 아야/EC + 하/VX',\n '야 어야/EC + 하/VX', '봐야 보/VX + 아야/EC + 하/VX', '해야 하/VX + 아야/EC + 하/VX'] \\\n and backward_pairs and str(backward_pairs[0].morphs[0]) == '겠/EP':\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\n backward_pairs[0].morphs.insert(0, morphs[-1])\n del morphs[:]\n elif word_morphs_str in ['졌 어/EC + 지/VX + 었/EP', '져 어/EC + 지/VX + 어/EC', '봐야 아/EC + 보/VX + 아야/EC',\n '왔 아/EC + 오/VX + 았/EP', '왔 어/EC + 오/VX + 았/EP', '봤 아/EC + 보/VX + 았/EP',\n '봐 아/EC + 보/VX + 아/EF', '왔 아/EC + 오/VV + 았/EP', '냈 아/EC + 내/VX + 었/EP',\n '내 아/EC + 내/VX + 어/EC'] \\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag == 'VV':\n forward_pairs[-1].morphs.append(morphs[0])\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:]))\n del morphs[:]\n elif word_morphs_str == '봐야 아/EC + 보/VX + 아야/EC + 하/VX' \\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag == 'VV' \\\n and backward_pairs and str(backward_pairs[0].morphs[0]) == '겠/EP':\n forward_pairs[-1].morphs.append(morphs[0])\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:-1]))\n backward_pairs[0].morphs.insert(0, morphs[-1])\n del morphs[:]\n elif uni_word in [u'해졌', u'해봤', u'해했', u'해봐', u'해줬', u'해줘', u'해와', u'해져'] and len(morphs) == 4:\n sandwich_pairs.append(WordStrMorphsPair(uni_word[0], morphs[:2]))\n sandwich_pairs.append(WordStrMorphsPair(uni_word[1], morphs[2:]))\n del morphs[:]\n elif word_morphs_str == '잖 이/VCP + 지/EC + 않/VX' \\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag.startswith('N'):\n forward_pairs[-1].morphs.append(morphs[0])\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:]))\n del morphs[:]\n elif word_morphs_str in ['해서 하/VV + 아서/EC + 이/VCP', '해서 하/XSV + 아서/EC + 이/VCP',\n '해서 하/VX + 아서/EC + 이/VCP', '서] 아서/EC+이/VCP'] \\\n and backward_pairs and backward_pairs[0].morphs[0].tag.startswith('E'):\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\n backward_pairs[0].morphs.insert(0, morphs[-1])\n del morphs[:]\n elif word_morphs_str in ['서 아서/EC + 이/VCP'] \\\n and backward_pairs and backward_pairs[0].morphs[0].tag.startswith('E'):\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\n backward_pairs[0].morphs.insert(0, morphs[-1])\n del morphs[:]\n else:\n sim = calc_similarity(uni_word, unicode(''.join([morph.lex for morph in morphs]), 'UTF-8'))\n if sim >= _SIMILARITY_MIN:\n # string similarity is greater than threshold\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs))\n else:\n raise AlignError()\n return sandwich_pairs","def create_model():\n # Get list of all syllables: [\"<s>\", \"AH\", \"</s>\", \"<s>\", \"T\", ...]\n syllabifier = Syllabifier()\n all_syllables = syllabifier.all_syllables()\n\n # Count conditional probabilties of phoneme tuples\n tcf = TrigramCollocationFinder.from_words(all_syllables)\n bcf = BigramCollocationFinder.from_words(all_syllables)\n tri_dict = dict(sorted(tcf.ngram_fd.items(), key=lambda t: (-t[1], t[0])))\n bi_dict = dict(sorted(bcf.ngram_fd.items(), key=lambda t: (-t[1], t[0])))\n\n # Create dictionary to count cond prob all phoneme tuples\n accepted_phonemes = [i[0] for i in cmudict.phones()]\n accepted_phonemes.append('<s>')\n accepted_phonemes.append('</s>')\n phoneme_tups = [p for p in itertools.product(accepted_phonemes, repeat=3)]\n cond_probs_dict = dict([(char, 0) for char in phoneme_tups])\n\n for t in tri_dict:\n p1, p2, p3 = t[0], t[1], t[2]\n tri_count = tri_dict[t]\n bi_count = bi_dict[(p1, p2)]\n if bi_count > 1:\n cond_prob = tri_count * 1.0 / bi_count\n else:\n cond_prob = 0.0\n cond_probs_dict[(p1, p2, p3)] = cond_prob\n\n pickle.dump(cond_probs_dict, open(COND_PROBS_PATH, \"wb\"))\n return","def equalize(pair, bias_axis, word_to_vec_map):\n\n ### START CODE HERE ###\n # Step 1: Select word vector representation of \"word\". Use word_to_vec_map. (≈ 2 lines)\n w1, w2 = pair\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\n\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\n mu = (e_w1 + e_w2) / 2\n\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n mu_orth = mu - mu_B\n\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\n\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\n e1 = corrected_e_w1B + mu_orth\n e2 = corrected_e_w2B + mu_orth\n\n ### END CODE HERE ###\n\n return e1, e2","def w_mark2_gen(w_amount, w_length, dict_2_let):\r\n nword_list_m2 = []\r\n for i in range(w_amount):\r\n rand_2_let = rand_let_gen(dict_2_let)\r\n nword = \"\".join(rand_2_let)\r\n i = 0\r\n while len(nword) != w_length:\r\n prefix = nword[i:i+2:1]\r\n if dict_2_let.get(prefix) != None:\r\n nword += (dict_2_let[prefix][0])\r\n i += 1\r\n else:\r\n i = 0\r\n rand_2_let = rand_let_gen(dict_2_let)\r\n nword_list_m2.append(nword)\r\n return nword_list_m2","def find_pairs(words): \n pass","def train():\n\tA = collections.defaultdict(dict)\n\tB = collections.defaultdict(dict)\n\tpos_list = []\n\tword_list = []\n\tstr_buf = []\n\n\n\t# read each line and count A and B\n\tfor line in sys.stdin:\n\t\tline = line.split()\n\t\t# print(line)\n\t\tif len(line) == 3:\n\t\t\tstr_buf.append((str(line[0]), str(line[1])))\n\t\t\tword_list.append(str(line[0]))\n\t\t\tpos_list.append(str(line[1]))\n\n\t\telse:\n\t\t\t# if come to the end of a sentence\n\t\t\tif len(str_buf) != 0:\n\t\t\t\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\n\t\t\t\tword_list += ['<s>', '</s>']\n\t\t\t\tpos_list += ['BOS', 'EOS']\n\n\t\t\t\tfor i, s in enumerate(str_buf):\n\t\t\t\t\tif s[0] in B[s[1]]:\n\t\t\t\t\t\tB[s[1]][s[0]] += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tB[s[1]][s[0]] = 1\n\n\t\t\t\t\tif s[0] != '</s>':\n\t\t\t\t\t\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\n\t\t\t\t\t\tif str_buf[i+1][1] in A[s[1]]:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] = 1\n\n\t\t\t\tstr_buf = []\n\n\t# get unique POS list and word list\n\tpos_list_uniq = list(set(pos_list))\n\tword_list_uniq = list(set(word_list))\n\n\n\t# assume <UNK>, smoothing, normalize\n\tB_sm = collections.defaultdict(dict)\n\tA_sm = A.copy()\n\n\t# assume words apeear less than 2 times as <UNK>\n\tword_count = collections.Counter(word_list)\n\tfor pos in B:\n\t\tfor word in B[pos]:\n\t\t\tif word_count[word] > 1:\n\t\t\t\tB_sm[pos][word] = B[pos][word]\n\n\t\t\telse: # add <UNK> to B_sm\n\t\t\t\tword_list_uniq.remove(word)\n\t\t\t\tif '<UNK>' in B_sm[pos]:\n\t\t\t\t\tB_sm[pos]['<UNK>'] += 1\n\t\t\t\telse:\n\t\t\t\t\tB_sm[pos]['<UNK>'] = 1\n\n\tword_list_uniq += ['<UNK>']\n\n\t# add 1 smoothing\n\tfor pos in pos_list_uniq:\n\t\tfor word in word_list_uniq:\n\t\t\tif word in B_sm[pos]:\n\t\t\t\tB_sm[pos][word] += 1\n\t\t\telse:\n\t\t\t\tB_sm[pos][word] = 1\n\n\tfor prev in pos_list_uniq:\n\t\tfor next in pos_list_uniq:\n\t\t\tif next in A_sm[prev]:\n\t\t\t\tA_sm[prev][next] += 1\n\t\t\telse:\n\t\t\t\tA_sm[prev][next] = 1\n\n\t# delete instances like A[VB][BOS], A[EOS][VB],\n\t# B[VB]['</s>'], B[EOS]['Jack']\n\n\tfor pos in B_sm:\n\t\tfor word in B_sm[pos]:\n\t\t\tif (pos == 'BOS' and word != '<s>') or \\\n\t\t\t(pos == 'EOS' and word != '</s>') or \\\n\t\t\t(word == '<s>' and pos != 'BOS') or \\\n\t\t\t(word == '</s>' and pos != 'EOS'):\n\t\t\t\tB_sm[pos][word] = 0\n\n\tfor prev in A_sm:\n\t\tfor next in A_sm[prev]:\n\t\t\tif prev == 'EOS' or next == 'BOS':\n\t\t\t\tA_sm[prev][next] = 0\n\n\t# normalize\n\tfor pos in B_sm:\n\t\ts = sum(B_sm[pos].values())\n\t\tfor word in B_sm[pos]:\n\t\t\tif B_sm[pos][word] != 0:\n\t\t\t\tB_sm[pos][word] /= s\n\n\tfor prev in A_sm:\n\t\ts = sum(A_sm[prev].values())\n\t\tfor next in A_sm[prev]:\n\t\t\tif A_sm[prev][next] != 0:\n\t\t\t\tA_sm[prev][next] /= s\n\n\treturn A_sm, B_sm, word_list_uniq","def bpe(self, word: List[str]) -> List[str]:\n pairs = self.get_pairs(word)\n\n if len(pairs) == 0:\n return word\n\n while True:\n min_rank = self.bpe_ranks.get('\\n'.join(pairs[0]), float('inf'))\n bigram = pairs[0]\n for pair in pairs[1:]:\n current_rank = self.bpe_ranks.get('\\n'.join(pair), float('inf'))\n if current_rank < min_rank:\n min_rank = current_rank\n bigram = pair\n if '\\n'.join(bigram) not in self.bpe_ranks:\n break\n first, second = bigram\n new_word: List[str] = []\n i = 0\n while i < len(word):\n found = False\n for j in range(i, len(word)):\n if word[j] == first:\n new_word.extend(word[i:j])\n i = j\n found = True\n break\n if not found:\n new_word.extend(word[i:])\n break\n\n if word[i] == first and i < len(word) - 1 and word[i + 1] == second:\n new_word.append(first + second)\n i += 2\n else:\n new_word.append(word[i])\n i += 1\n word = new_word.copy()\n if len(word) == 1:\n break\n else:\n pairs = self.get_pairs(word)\n return word","def create_bow(sentences, vocab=None, msg_prefix=\"\\n\"):\n print(\"{} Bow construction\".format(msg_prefix))\n tokens_per_sentence = preprocess_and_split_to_tokens(sentences)\n if vocab is None:\n print(\"{} Vocab construction\".format(msg_prefix))\n flattened_list = [y for x in tokens_per_sentence for y in x]\n flattened_set_list = list(set(flattened_list))\n vocab = {k:v for v,k in enumerate(flattened_set_list)}\n bow_array = []\n for sentence_word_list in tokens_per_sentence:\n bow_array_one = [0] * len(vocab)\n for word in sentence_word_list:\n if vocab.get(word) is not None:\n bow_array_one[vocab[word]] += 1\n bow_array.append(bow_array_one)\n return (vocab, bow_array)","def make_chains(markov_chains, clean_words):\n\n for i in range(len(clean_words)-2):\n\n tuple_words = (clean_words[i], clean_words[i+1])\n value = clean_words[i+2]\n\n if tuple_words not in markov_chains:\n markov_chains[tuple_words] = [value]\n else:\n markov_chains[tuple_words].append(value)\n\n return markov_chains","def viterbi(sent, dqml, eqml, S, V_CASE=-1):\n\n if type(sent) is list:\n sent_words = sent\n else:\n sent_words = word_tokenize(sent)\n n = len(sent_words)\n\n # define and initialize PI table\n pi = defaultdict(Counter)\n pi[0]['*'] = 1\n bp = {}\n\n for k in range(1, n+1):\n bp[k] = {}\n for v in S:\n eml = compute_eml(V_CASE, eqml, k, sent_words, v)\n if k-1 is 0: # w e S_0 -> w = '*'\n qmlr = compute_qml(dqml, v, '*')\n pival = pi[0]['*'] * qmlr * eml\n pi[k][v] = pival\n bp[k][v] = '*'\n else: # for w e S_k, S_k = S\n max_S = None\n max_w = -1\n for w in S:\n qmlr = compute_qml(dqml, v, w)\n currmax = pi[k-1][w] * qmlr * eml\n if currmax > 0 and currmax > max_w:\n max_w = currmax\n max_S = w\n # if word is unknown use tag 'NN'\n if max_S is None:\n max_w = 0.0\n max_S = UNKNOWN_TAG\n pi[k][v] = max_w\n bp[k][v] = max_S\n\n # calculate y_n\n max_y = -1\n yn = None\n for v in S:\n nextmax = pi[n][v] * compute_propability('STOP', v, dqml)\n if nextmax > max_y:\n max_y = nextmax\n yn = v\n\n # calculate y_n-1....y1\n yk1 = yn\n tagSequence = list()\n tagSequence.append(yn)\n for k in range(n-1,0,-1):\n yk = bp[k+1][yk1]\n tagSequence.append(yk)\n yk1 = yk\n\n tagSequence.reverse()\n return tagSequence","def make_bag(txt, stopw):\n bow = re.split('\\s',txt.lower())\n new_bow=[]\n for word in bow:\n if word not in stopw and len(word)>0 and not re.search('\\d',word):\n new_bow.append(word)\n return(new_bow)","def sentencesToBow(documents):\n bowSentences = []\n dictionary = Dictionary(documents)\n\n numDocs = len(documents);\n avgDocLength = sum(map(len, documents))/numDocs\n for document in documents:\n bowSentence = []\n docLength = len(document)\n bowDoc = dictionary.doc2bow(document)\n for bowTerm in bowDoc:\n\n docTermFreq = bowTerm[1]\n termDocFreq = dictionary.dfs[bowTerm[0]]\n\n termWeight = docTermWeight(docTermFreq, termDocFreq, docLength, avgDocLength, numDocs, k=5, b=0.1)\n newBowTerm = (bowTerm[0], termWeight)\n bowSentence.append(newBowTerm)\n\n bowSentences.append(bowSentence)\n\n return bowSentences, dictionary","def generate_words(combo,scrabble_words_dict):\n word_set = set()\n for w in itertools.permutations(combo):\n word = ''.join(w)\n if word in scrabble_words_dict:\n word_set.add(word)\n return word_set","def createTableBOW(self,DBcursor):\n sql=\"create table if not exists BOW (bow_id INTEGER PRIMARY KEY, word TEXT, word_count INTEGER);\"\n DBcursor.execute(sql)","def make_bprod(self):\n rhs1 = random.choice(self.nonterminals)\n rhs2 = random.choice(self.nonterminals)\n lhs = random.choice(self.nonterminals)\n return (lhs, (rhs1, rhs2))","def _gen_words(sentence, labels):\r\n word = \"\"\r\n words = []\r\n for token, label in zip(sentence, labels):\r\n word += token\r\n if label in [1, 3]:\r\n words.append(word)\r\n word = \"\"\r\n return words","def createTableBOW(self,DBcursor):\n sql=\"create table if not exists BOW (bow_id INTEGER PRIMARY KEY, word TEXT, total_count INTEGER, netloc_count INTEGER, path_count INTEGER, params_count INTEGER, query_count INTEGER, fragment_count INTEGER);\"\n DBcursor.execute(sql)","def feature_extraction_letters_pairs(name, B=676):\n v = np.zeros(B)\n i = 0\n \n ken = np.zeros((26,26))\n while (i<(len(name)-1)):\n zep = ord(name[i])-97\n zap = ord(name[i+1])-97\n ken[zep][zap] = ken[zep][zap] + 1\n i = i+1\n v = ken.flatten()\n return v","def viterbi_bigrams(transition_probabilities, label_matches, prev_tag, word, tag_possibilities):\r\n\tmax_prob = 0\r\n\tbest_tag = \"\"\r\n\ttag_counts = get_tag_counts(label_matches)\r\n\tfor tag in tag_possibilities:\r\n\t\temissions_probability = get_emissions_probability(label_matches, tag, word, tag_counts)\r\n\t\ttag_bigram = (prev_tag,tag)\r\n\t\ttransition_probability = transition_probabilities.get(tag_bigram, 0.000027)\r\n\t\tprob = emissions_probability * transition_probability\r\n\t\tif prob > max_prob:\r\n\t\t\tmax_prob = prob\r\n\t\t\tbest_tag = tag\r\n\tif best_tag == \"\":\r\n\t\tbest_tag = \"o\"\r\n\treturn best_tag","def getBiwords(self, words):\n bigrams_val = nltk.bigrams(words)\n biwords = []\n for word in bigrams_val:\n biwords.append(word)\n return biwords","def crossword_words(crossword: list) -> list:\n pass","def generate_words(self,N):\n for i in xrange(N):\n prefix = \" \" * self.chainlen\n name = \"\"\n suffix = \"\"\n while True:\n suffix = self.get_suffix(prefix)\n if suffix == \"\\n\" or len(name) > 9:\n break\n else:\n name = name + suffix\n prefix = prefix[1:] + suffix\n yield name.capitalize()","def make_text(chains):\n\n upper_keys = []\n \n for key in chains:\n if key[0][0].isupper():\n upper_keys.append(key)\n\n key = choice(upper_keys)\n # key = choice(chains.keys())\n words = []\n words.append(key[0])\n words.append(key[1])\n word = choice(chains[key])\n words.append(word)\n new_key = (key[1], word)\n \n while new_key in chains and len(words) < 140:\n word = choice(chains[new_key])\n words.append(word)\n new_key = (new_key[1], word)\n if not word[-1].isalpha():\n break\n \n\n\n return \" \".join(words)","def co_gram(sa, sb):\n gram = [(wa, wb) for wa in sa for wb in sb]\n return gram","def generate_word(self, length=7, upper=True):\n \n word = self._weighted_choice(self.beginning_freqs)\n\n if word[0] in self.vowels:\n offset = 0\n else:\n offset = 1\n \n for i in range(offset, length+offset):\t\t\t\n if i%2 ==0:\n word += self._weighted_choice(self.consonant_freqs)\n else:\n word += self._weighted_choice(self.vowel_freqs)\n \n if upper:\n word = word[:1].upper() + word[1:]\n \n if word.lower() in self.blacklist:\n # recurse and find another word\n return self.generate_word(length, upper)\n \n return word","def _choose_babble_phrases(self) -> tuple:\n noun_choices = ('singular nouns', 'plural nouns')\n noun_choice = self.random_element(noun_choices)\n\n adjective_choices = (\n 'adjectives starting with consonant',\n 'adjectives starting with vowel')\n\n if noun_choice == 'singular nouns':\n article_choice = self.random_element(self.article_choices)\n else:\n article_choice = 'the'\n\n if article_choice == 'an':\n adjective_choice = 'adjectives starting with vowel'\n elif article_choice == 'a':\n adjective_choice = 'adjectives starting with consonant'\n else:\n adjective_choice = self.random_element(adjective_choices)\n\n return (\n self.technobabble['verbs'],\n article_choice,\n self.technobabble[adjective_choice],\n self.technobabble[noun_choice])","def make_chains(text_string):\n\n chains = {}\n #create an empty dictionary\n words = text_string.split()\n #make text into string and then splitting it\n \n for i in range(len(words)-2):\n #for every word in string except for last two words\n bi_gram = (words[i], words[i + 1])\n #created key variable into tuple using two adjacent words\n if bi_gram in chains:\n # if the key is in the dictionary add the next word into list of values/words\n chains[bi_gram].append(words[i+2])\n else:\n # if word is not already in dictionary, create the list where word is placed\n chains[bi_gram] = [words[i+2]]\n #defining variable for last key/tuple \n last_bi_gram = (words[-2],words[-1])\n #if it is the last bi_gram in dictionary, add None as a value in list of words else add none/ nothing\n if last_bi_gram in chains:\n chains[last_bi_gram].append(None)\n else:\n chains[last_bi_gram] = [None]\n\n return chains","def learn_bpe(strings: List[str], pair_percent_threshold: float, char_percent_threshold:float, with_position:bool) -> dict:\n\n vocab = get_vocab(strings)\n percent = 1.0\n # 待改进，这里如果 pair_percent_threshold <=0，则会死循环\n while percent >= pair_percent_threshold:\n pair2freq = pair_freq_stats(vocab, with_position)\n best = max(pair2freq, key=pair2freq.get)\n percent = pair2freq.get(best) / len(strings)\n if percent >= pair_percent_threshold:\n vocab = merge_vocab(best, vocab, with_position)\n\n bpe_tokens = get_tokens(vocab, pair_percent_threshold, len(strings), char_percent_threshold, with_position)\n if with_position:\n bpe_tokens = sorted(bpe_tokens, key=lambda x: len(x[0]), reverse=True)\n else:\n bpe_tokens = sorted(bpe_tokens, key=len, reverse=True)\n bpe_token_dict = {'with_position':with_position,\n 'tokens': bpe_tokens}\n return bpe_token_dict","def make_inferences(self,KB):\n applied_rules={}\n KB=list(KB)\n for knowledge in KB:\n applied_rules[knowledge]=[knowledge]\n for antedecent,consequent in self.implication_rules.items(): #split in antedecent and consequent\n if type(knowledge)==str:\n if knowledge == antedecent: #if knowledge is the antedecent of the rule\n for v in consequent:\n applied_rules[antedecent]=consequent\n KB.append(v)\n \n \n elif knowledge in antedecent:\n atoms=antedecent.split(\",\")\n \n if (set(atoms) & set(KB) == set(atoms)):\n applied_rules[antedecent]=consequent\n KB.extend(consequent)\n return applied_rules,set(KB)","def proc_sandwich(word, forward_pairs, uni_word, morphs, backward_pairs):\n sandwich_pairs = []\n if uni_word and morphs:\n sandwich_pairs = proc_sw_both_not_empty(forward_pairs, uni_word, morphs, backward_pairs)\n elif uni_word:\n sandwich_pairs = proc_sw_only_word(word, uni_word, backward_pairs)\n elif morphs:\n sandwich_pairs = proc_sw_only_morphs(forward_pairs, morphs, backward_pairs)\n return sandwich_pairs","def surface_segment_data_preparation(word_dictionary: {str, str}):\n X = []\n Y = []\n words = []\n for word in word_dictionary:\n word_list = []\n word_label_list = []\n for i in range(len(word)):\n gram_dict = {}\n gram_arr = []\n\n ### Unigram\n # gram_dict[word[i]] = 1\n gram_dict[\"uni_\" + word[i]] = 1\n gram_arr.append(word[i])\n\n ### BIGRAM\n try:\n tmp = word[i - 1: i + 1]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 2:\n gram_dict[\"bi_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n try:\n tmp = word[i: i + 2]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 2:\n gram_dict[\"bi_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n ### TRIGRAM\n try:\n tmp = word[i - 1: i + 2]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 3:\n gram_dict[\"tri_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n ## FourGram\n try:\n tmp = word[i - 1: i + 3]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 4:\n gram_dict[\"four_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n try:\n tmp = word[i - 2: i + 2]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 4:\n gram_dict[\"four_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n ## FiveGram\n try:\n tmp = word[i - 2: i + 3]\n if tmp:\n # gram_dict[tmp] = 1\n if len(tmp) == 5:\n gram_dict[\"five_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n ## SixGram\n try:\n tmp = word[i - 3: i + 3]\n if tmp:\n if len(tmp) == 6:\n # gram_dict[tmp] = 1\n gram_dict[\"six_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n try:\n tmp = word[i - 2: i + 4]\n if tmp:\n if len(tmp) == 6:\n # gram_dict[tmp] = 1\n gram_dict[\"six_\" + tmp] = 1\n gram_arr.append(tmp)\n except IndexError:\n continue\n\n if word[i] in 'aeiou':\n gram_dict[\"vowel\"] = 1\n else:\n gram_dict[\"const\"] = 1\n\n if word[i].isupper():\n gram_dict[\"upper\"] = 1\n else:\n gram_dict[\"lower\"] = 1\n\n word_list.append(gram_dict)\n word_label_list.append(word_dictionary[word][i])\n\n X.append(word_list)\n Y.append(word_label_list)\n words.append([char for char in word])\n return X, Y, words","def make_text(chains):\n\n #current key is equal to a random key in the dictionary\n current_key = choice(chains.keys())\n #text is a string equal to the first index of the tuple and the second index of the tuple\n text = current_key[0] + \" \" + current_key[1]\n #create a loop that will repeat until the function reaches the last bi-gram\n while True:\n #created a variable for a random value of the current key\n chosen_word = choice(chains[current_key])\n #equivalent to: if chosen_word is None\n if not chosen_word:\n break\n # if it's not the last key add the chosen_word to the text to string\n text = text + \" \" + chosen_word\n # select new key\n current_key = (current_key[1], chosen_word)\n \n return text","def make_text(chains):\n words = []\n not_end_of_list = True\n # your code goes here\n \n # starts with a capital lettered word from source text\n capitalized_ngrams = []\n for key in chains.keys():\n # check if the first tuple in key[0][0]\n if key[0][0].isupper():\n capitalized_ngrams.append(key)\n \n \n\n selected_keys = list(capitalized_ngrams)\n count = 0\n while not_end_of_list:\n choice_n = choice(selected_keys)\n\n if count == 0:\n words.extend(choice_n)\n \n if chains[choice_n] and count <= 150:\n # as long as there is an option, picks a random element from dict list\n choose_next = choice(chains[choice_n])\n # adds new word to list\n words.append(choose_next)\n # creates a list of keys whose last item in tuple is item from list\n selected_keys = [x for x in chains.keys() if x == tuple([*choice_n[1:], choose_next])]\n # it is possible continues\n if selected_keys:\n pass\n else:\n not_end_of_list = False\n\n count += 1\n \n else:\n not_end_of_list = False\n\n return \" \".join(words)","def make_text(chains, n_gram):\n words = []\n\n link_key = choice(chains.keys())\n\n\n while True:\n if link_key[0] != link_key[0].capitalize():\n link_key = choice(chains.keys())\n else:\n break\n #have random key from our dict\n\n words = list(link_key)\n\n while link_key in chains.keys():\n next_word = choice(chains[link_key])\n\n words.append(next_word)\n\n next_key = list(link_key[1:]) + [next_word]\n\n link_key = tuple(next_key)\n\n return \" \".join(words)","def get_searched_pair_words(self):\n words = [word for word in self.searched_words if \" \" in word]\n return [Word(word).singularize() for word in words]","def generate_words(num_words, word_len, grid, reject_func=is_overlapping):\n height, width = len(grid), len(grid[0])\n restrictions = position_restrictions(word_len, height, width)\n word_hashes = set()\n words_positions = []\n words = []\n while len(word_hashes) < num_words:\n cardinal = random.choice(list(restrictions.keys()))\n (min_h, max_h), (min_w, max_w) = restrictions[cardinal]\n x0, y0 = random.randint(min_h, max_h), random.randint(min_w, max_w)\n x, y = DIRECTIONS[cardinal]\n positions = [(x0 + x * i, y0 + y * i) for i in range(word_len)]\n if (word_hash := (cardinal, (x0, y0))) not in word_hashes \\\n and not reject_func(p_set := set(positions), words_positions):\n words.append(\"\".join(str(grid[x][y]) for x, y in positions))\n word_hashes.add(word_hash)\n words_positions.append(p_set)\n return words","def create_word(self):\r\n\r\n template = self.word_constructions.get()\r\n word = \"\"\r\n for c in template:\r\n if c == \"v\":\r\n letter = self.get_letter(100)\r\n else:\r\n letter = self.get_letter(0)\r\n word += letter\r\n\r\n while not any(letter in self.vowels for letter in word):\r\n length = len(word)\r\n if length == 1:\r\n index = 0\r\n elif length == 2:\r\n index = random.randrange(0, 2)\r\n else:\r\n a = len(word) / 2\r\n index = a + random.randrange(-a / 2, a / 2)\r\n word = word[:index] + self.get_letter(100) + word[index + 1:]\r\n\r\n if random.random() > self.capital_chance:\r\n word = word.capitalize()\r\n self.words.append(word)\r\n self.word_count += 1\r\n return word","def find_words(text):\n print \"finding combinations\"\n length = len(text)\n n = length - 1\n num_combos = 2 ** (length - 1)\n\n bins = []\n for i in range(num_combos):\n num = bin(i).rsplit('b', 1)[1]\n num_str = num.zfill(n)\n bins.append(num_str)\n\n total_combos = []\n for binary_num in bins:\n combo = []\n for i in range(n):\n if binary_num[i] == '1':\n combo.append(text[i])\n combo.append(',')\n else:\n combo.append(text[i])\n\n combo.append(text[-1])\n combo = ''.join(combo)\n combo = combo.split(',')\n total_combos.append(combo)\n\n return total_combos","def dictionary(word_list):\n word_list.append(\"\")\n for i in range(len(word_list)-2):\n prob_dict.setdefault(word_list[i], []).append(word_list[i+1])","def make_text(chains):\n\n text = []\n nchars = 0\n\n # Starting ngram (as tuple), first word in tuple must be uppercase\n start = choice(get_uppercase(chains))\n\n # Add starting ngram to text list\n text.extend(start)\n\n # Add length of words in first bigram and two spaces to nchars\n nchars += len(start[0]) + len(start[1]) + 2\n\n while nchars < 119:\n # Choose next word randomly from list\n new_word = choice(chains[start])\n\n # add length of new word to nchars\n # add one for space between words\n nchars += len(new_word) + 1\n\n if nchars > 120:\n break\n else:\n # Add new word to text list\n text.append(new_word)\n\n # Generate tuple for next ngram\n new_key = start[1:] + (new_word,)\n\n # Break out of loop if bigram doesn't exist\n if new_key in chains:\n start = new_key\n else:\n break\n\n text.append(\"#hackbrightgracejan17\")\n\n # Find last sentence punctuation in text\n text_string = ' '.join(text)\n\n # period = text_string.rfind('.')\n # exclamation = text_string.rfind('!')\n # question = text_string.rfind('?')\n\n # largest = max(period, exclamation, question)\n\n # # Remove everything after the last punctuation, if there is anything\n # if len(text_string) == largest+1:\n # return text_string\n # else:\n # return text_string[:largest+1]\n\n return text_string","def smooth_tag_model(cls, heldout_data):\n\n # bi_transition_counts = defaultdict(int)\n n = 0 # count word-tags\n e = .0001 # stopping condition\n L = [.25, .25, .25, .25] # initialize lambdas uniformly\n i = 1 # iteration\n while True:\n # E Step (Step 1)\n # Iterate through all occurring trigrams\n # in the heldout.txt data (H), i.e. minimizing\n # log likelihood\n counts = [0, 0, 0, 0]\n ratio = [0, 0, 0, 0]\n nextL = 4 * [0] # next lambda\n\n for sent in heldout_data:\n\n # Handle beginning of sentence\n t = '<s>'\n u = '<s>'\n # bi_transition_counts[t, u] += 1\n\n # if first == '<s>' and second == '<s>': # add bigram for nulls\n\n for word, tag in sent:\n v = tag\n # tri_transitions[t, u, v] += 1\n # bi_transitions[u, v] += 1\n # # if first == '<s>' and second == '<s>': # add bigram for nulls\n # # tagger._bi_transitions[('<s>', '<s>')] += 1\n # uni_transitions[v] += 1\n # cls._emissions[word, tag] += 1\n # tags.add(v)\n # words.add(word)\n # uni_words[word] += 1\n\n\n # Calculate expected counts of lambdas\n ratio = cls.calc_tag_ratio(t, u, v, L)\n\n # M-step (Step 2)\n # Calculate expected counts of lambdas, i.e. weight, taking\n # into account the number of occurrences of each trigram (cnt)\n for j in range(len(L)):\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\n\n t = u\n u = v\n # n += 1\n\n # Handle end of sentence\n # tri_transitions[t, u, '</s>'] += 1\n v = '</s>'\n ratio = cls.calc_tag_ratio(t, u, v, L)\n for j in range(len(L)):\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\n\n # cls._bi_transitions[first, second] += 1\n # cls._tri_transitions[second, '</s>', '</s>'] += 1\n\n\n # Update values for parameters given current distribution\n for k in range(len(L)):\n total = np.sum(counts)\n nextL[k] = counts[k] / total # next lambda\n\n # Check if lambda values have converged\n converged = True\n for l in range(len(L)):\n if np.abs(nextL[l] - L[l]) > e: # tolerance = e\n converged = False\n L = nextL\n\n # Return values if lambdas have converged\n if converged:\n break\n\n i += 1 # increment iteration counter\n\n\n return L # copy lambdas passed by reference","def tag_word(self, words):\n self.j += 1\n self.i = self.j - 1\n self.matrix[self.i][self.j] = {}\n\n possible_tags = self.grammar.productions(rhs=words[self.j - 1])\n\n if not possible_tags:\n possible_tags = self.grammar.productions(rhs=\"UNK\")\n\n for rule in sorted(possible_tags, key=lambda x: x.prob()):\n lhs = rule.lhs().symbol()\n self.matrix[self.i][self.j][lhs] = (log(rule.prob()), Tree(lhs, [words[self.j - 1]]))","def generate_solutions(possible_words, labels):\r\n return []","def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\n\tglobal alpha, beta, gamma\n\n\t#Standard Bayesian\n\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\n\t# muNew = u1 + u2\n\t# return muNew, sigNew \n\n\t##In accordance with the nature papers:\n\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\n\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\n\tinv1 = 1 / float((math.pow(sig1, 2)))\n\tinv2 = 1 / float((math.pow(sig2, 2)))\n\tsumInverses = inv1 + inv2\n\n\t##inverse standard deviations squared\n\t# w1 = inv1 / float(sumInverses)\n\t# w2 = inv2 / float(sumInverses)\n\n\t## equal weighting\n\t# w1 = .5\n\t# w2 = .5\n\n\t## weightings based off of confidence\n\t# summation = confidence1 + confidence2\n\t# w1 = confidence1 / float(summation)\n\t# w2 = confidence2 / float(summation)\n\n\t##weightings with exponentials\n\t# w1 = w1**.001\n\t# w2 = w2**.001\n\t# newSummation = w1 + w2\n\t# w1 = w1 / float(newSummation)\n\t# w2 = w2 / float(newSummation)\n\n\t##weightings with polynomial factors\n\tw1 = (beta * confidence1 + alpha)**gamma \n\tw2 = (beta * confidence2 + alpha)**gamma \n\tnewSummation = w1 + w2\n\tw1 = w1 / float(newSummation)\n\tw2 = w2 / float(newSummation)\n\n\tmuNew = w1 * mu1 + w2 * mu2\n\treturn muNew, sigNew","def generate_words_with_scores(rack,placed_tile,scrabble_words_dict):\n res_set = set()\n word_score_dict = {}\n comb_set = generate_combinations(rack,placed_tile)\n for combo in comb_set:\n words_set = generate_words(combo, scrabble_words_dict)\n for word in words_set:\n res_set.add(word)\n for word in res_set:\n score = calculate_score(rack,word)\n word_score_dict[word] = score\n return word_score_dict","def make_chains(text_string, n_gram):\n\n chains = {}\n words = text_string.split()\n for i in range(len(words)-n_gram):\n temp_list = []\n for z in range(n_gram):\n temp_list = temp_list + [words[i + z]]\n\n temp_tup = tuple(temp_list)\n\n # if temp_tup in chains:\n # chains[temp_tup] = chains[temp_tup] + [words[i + 2]]\n # else:\n # chains[temp_tup] = [words[i + 2]]\n chains.setdefault(temp_tup, [])\n chains[temp_tup].append(words[i + n_gram])\n #chains[temp_tup] = chains.get(temp_tup, []) + [words[i + 2]]\n print chains\n return chains","def poly_desc(W, b):\n result = 'y = '\n for i, w in enumerate(W):\n result += '{:+.2f} x^{} '.format(w, len(W) - i)\n result += '{:+.2f}'.format(b[0])\n return result","def make_text(chains):\n\n words = []\n\n # Set random tuple to variable key\n key = choice(chains.keys())\n\n\n # First time through key in chains, unpack X - a tuple - to get \n # key[0], key[1] = key\n # print key0]\n # print key[2]\n # Append key[0], key[1] to words\n\n words.append(key[0])\n words.append(key[1])\n\n # While tuple is a key in chains, keep looping \n while key in chains:\n\n # Randomly choose a value from chains\n word = choice(chains[key])\n\n # Append word to words\n words.append(word)\n\n key = (key[1], word)\n\n # return \" \".join(words)\n\n # define variable of returned \" \".join(words) as markov-tweet\n markov_tweet = \" \".join(words)\n\n return markov_tweet","def Viterbi(words:Sequence[str], train_bag:Sequence[Tuple[str, str]]=train_tagged_words)-> Sequence[Tuple[str, str]]:\n state = []\n tags_set = list(set([pair[1] for pair in train_bag]))\n\n for key, word in enumerate(words):\n # initialise list of probability column for a given observation\n p = []\n for tag in tags_set:\n if key == 0:\n transition_p = tags_df.loc['.', tag]\n else:\n transition_p = tags_df.loc[state[-1], tag]\n\n # compute emission and state probabilities\n emission_p_parts = word_given_tag(word, tag)\n emission_p = emission_p_parts[0]/emission_p_parts[1]\n state_probability = emission_p * transition_p\n p.append(state_probability)\n\n p_max = max(p)\n # getting state for which probability is maximum\n state_max = tags_set[p.index(p_max)]\n state.append(state_max)\n return list(zip(words, state))","def viterbi_segment(text, P):\n # best[i] = best probability for text[0:i]\n # words[i] = best word ending at position i\n n = len(text)\n words = [''] + list(text)\n best = [1.0] + [0.0] * n\n\n # Fill in the vectors best, words via dynamic programming\n for i in range(n + 1):\n for j in range(0, i):\n w = text[j:i]\n if P[w] * best[i - len(w)] >= best[i]:\n best[i] = P[w] * best[i - len(w)]\n words[i] = w\n\n # Now recover the sequence of best words\n sequence = [];\n i = len(words) - 1\n while i > 0:\n sequence[0:0] = [words[i]]\n i = i - len(words[i])\n\n # Return sequence of best words and overall probability\n return sequence, best[-1]","def make_chains(word_list):\n\n chains = {}\n for index in range(0, len(word_list) - 2):\n # only making small chains because I like maximum absurdity\n key = tuple(word_list[index:index + 2])\n if key not in chains:\n chains[key] = [word_list[index + 2]]\n else:\n chains[key].append(word_list[index + 2])\n return chains","def pairwise_tokenize(sentence,w2v,remove_stopwords=True):\n\n ignore_words = stopwords.words('english')\n\n #Remove non-alphanumeric\n pattern = re.compile('[\\W_]+') \n sentence = pattern.sub(\" \",sentence) \n sentence = sentence.strip()\n words = sentence.split(\" \")\n\n compound_word_idx = []\n a_idx = 0\n for a,b in pairwise(words):\n combined = a +\"_\" + b\n try:\n w2v[combined]\n compound_word_idx.append(a_idx) #append the index of the 1st compound word\n a_idx += 1\n except KeyError:\n a_idx += 1\n\n for idx in compound_word_idx:\n words[idx] = words[idx] + \"_\" + words[idx + 1] #compound_word_idx stores index of 1st word, so combine with the next word\n\n #This cannot be combined into another loop to maintain where indices point\n for idx in reversed(compound_word_idx):\n words.pop(idx+1)\n\n if remove_stopwords == True:\n filtered = []\n for word in words:\n word = word.decode(\"utf-8\")\n if word not in ignore_words:\n filtered.append(word)\n\n words = filtered\n\n return words","def make_text(chains):\n\n # your code goes here\n n_gram = tuple(choice(chains['START']))\n words = [word for word in n_gram]\n\n while n_gram in chains:\n\n next_word = choice(chains[n_gram])\n if next_word == 'EOF':\n break\n words.append(next_word)\n\n n_gram = list(n_gram)[1:]\n n_gram.append(next_word)\n n_gram = tuple(n_gram)\n \n return \" \".join(words)","def make_chains(text_string):\n\n chains = {}\n\n words = text_string.split()\n\n # loop over range of length of words - 2\n for i in range(len(words) - 2):\n key = (words[i], words[i + 1]) # create a tuple that is the word and the word following\n if key not in chains: # if the tuple does not exist in the dict chains:\n chains[key] = [words[i + 2]] # add the tuple as the key and the word following the bigram as the value\n elif key in chains: # else if tuple is in dict:\n (chains[key]).append(words[i + 2]) # append the word following the bigram to the list that chains[key] is equal to\n\n return chains","def make_chains(text_string, n):\n \n chains = {}\n \n text_string_list = text_string.split()\n\n\n # Make a tuple of two adjecnt words\n for i in range(len(text_string_list)-n):\n chain_key = []\n for num in range(n):\n chain_key= text_string_list[i:i+n]\n key_tuple = tuple(chain_key)\n #print(key_tuple)\n value = text_string_list[i+n]\n #print(value)\n if key_tuple in chains:\n chains[key_tuple].append(value)\n else:\n chains[key_tuple] = [value]\n\n print(chains)","def generate_text_owc(model: Dict[str, Set[str]], n: int) -> str:\n # ACCUMULATOR: a list of the randomly-generated words so far\n words_so_far = []\n # We've provided this template as a starting point; you may modify it as necessary.\n words_so_far.append(generate_new_word(model))\n for x in range(0, n-1):\n key = words_so_far[x]\n new_word = generate_next_word(model,key)\n if new_word == \".\":\n words_so_far[x] = words_so_far[x]+'.'\n new_word= generate_new_word(model)\n elif new_word == {}:\n new_word = generate_new_word(model)\n words_so_far.append(new_word)\n\n return str.join(' ', words_so_far)","def make_text(chains):\n\n # what word should we start on? \"Would you\"?\n # dicitonaries are unordered, so what does \"first key\" mean?\n # from which list you should pull out the random word?\n\n # key 1st word (a)\n # key 2nd word (b)\n # random word from value ([list]) (c)\n # value of b, c tuple\n\n key_selection = choice(chains.keys())\n\n words = [key_selection[0], key_selection[1]]\n\n while key_selection in chains:\n new_word = choice(chains[key_selection])\n\n words.append(new_word)\n\n key_selection = (key_selection[1], new_word,)\n\n\n\n # print first_word,second_word,third_word\n\n # random.choice(chains)\n\n # your code goes here\n\n return \" \".join(words)","def make_text(chains, uppercase=True, break_on_first_punctuation=False, \n character_limit=True):\n\n random_key = choice(chains.keys())\n if uppercase:\n while True:\n if random_key[0][0].isalpha() and random_key[0][0].isupper():\n break\n else:\n random_key = choice(chains.keys())\n\n\n words = list(random_key)\n #words.extend(list(random_key))\n\n while True:\n random_value = choice(chains[random_key])\n if random_value is None:\n break \n words.append(random_value)\n if break_on_first_punctuation:\n if words[-1][-1] in [\"?\", \".\", \":\", \"!\"]:\n break \n next_key = random_key[1:] + (random_value,)\n random_key = next_key\n\n return_value = \" \".join(words)\n \n if character_limit:\n tweet_custom = return_value[:140]\n\n for i in range(len(tweet_custom)-1, 0, -1):\n if tweet_custom[i] in [\"?\", \".\", \"!\"]:\n return tweet_custom[:i+1]\n\n\n return return_value","def npa_constraints(\n assemblage: dict[tuple[int, int], cvxpy.Variable], k: int | str = 1, referee_dim: int = 1\n) -> list[cvxpy.constraints.constraint.Constraint]:\n a_out, a_in, b_out, b_in = _get_nonlocal_game_params(assemblage, referee_dim)\n\n words = _gen_words(k, a_out, a_in, b_out, b_in)\n dim = len(words)\n\n r_var = cvxpy.Variable((referee_dim * dim, referee_dim * dim), PSD=True, name=\"R\")\n # Normalization.\n norm = sum(r_var[i * dim, i * dim] for i in range(referee_dim))\n constraints = [norm == 1]\n\n seen = {}\n for i in range(dim):\n for j in range(i, dim):\n w_i, w_j = words[i], words[j]\n w_i = tuple(reversed(w_i))\n word = _reduce(w_i + w_j)\n\n sub_mat = r_var[i::dim, j::dim]\n # if i = 0 we would consider (ε, ε) as an empty word.\n if i != 0 and _is_zero(word):\n constraints.append(sub_mat == 0)\n\n elif _is_meas(word):\n s_a, s_b = word\n constraints.append(\n sub_mat\n == assemblage[s_a.question, s_b.question][\n s_a.answer * referee_dim : (s_a.answer + 1) * referee_dim,\n s_b.answer * referee_dim : (s_b.answer + 1) * referee_dim,\n ]\n )\n\n elif _is_meas_on_one_player(word):\n symbol = word[0]\n if symbol.player == \"Alice\":\n sum_all_bob_meas = sum(\n assemblage[symbol.question, 0][\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n constraints.append(sub_mat == sum_all_bob_meas)\n\n if symbol.player == \"Bob\":\n sum_all_alice_meas = sum(\n assemblage[0, symbol.question][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n constraints.append(sub_mat == sum_all_alice_meas)\n\n elif word in seen:\n old_i, old_j = seen[word]\n old_sub_mat = r_var[old_i::dim, old_j::dim]\n constraints.append(sub_mat == old_sub_mat)\n\n else:\n seen[word] = (i, j)\n\n # now we impose constraints to the assemblage operator\n for x_alice_in in range(a_in):\n for y_bob_in in range(b_in):\n sum_all_meas_and_trace = 0\n for a_ans in range(a_out):\n for b_ans in range(b_out):\n sum_all_meas_and_trace += sum(\n assemblage[x_alice_in, y_bob_in][\n i + a_ans * referee_dim, i + b_ans * referee_dim\n ]\n for i in range(referee_dim)\n )\n\n # r x r sub - block is PSD since it's an unnormalized quantum state.\n constraints.append(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n >> 0\n )\n\n constraints.append(sum_all_meas_and_trace == 1)\n\n # Bob marginal consistency\n for y_bob_in in range(b_in):\n for b_ans in range(b_out):\n sum_first_question = sum(\n assemblage[0, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n for x_alice_in in range(1, a_in):\n sum_cur_question = sum(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n constraints.append(sum_first_question == sum_cur_question)\n\n # Alice marginal consistency\n for x_alice_in in range(a_in):\n for a_ans in range(a_out):\n sum_first_question = sum(\n assemblage[x_alice_in, 0][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n for y_bob_in in range(1, b_in):\n sum_cur_question = sum(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n constraints.append(sum_first_question == sum_cur_question)\n\n return constraints","def __init__(self, n, sents, corpus='', beta=None, addone=True):\n self.n = n\n self.beta = beta\n self.corpus = corpus\n self.beta_flag = True\n self.addone = addone\n self.smoothingtechnique = 'Back Off (Katz) with Discounting Smoothing'\n self.counts = counts = defaultdict(int)\n self.A_set = defaultdict(set)\n voc = ['</s>']\n for s in sents:\n voc += s\n self.voc = set(voc)\n if beta is None:\n self.beta_flag = False\n\n # if no beta given, we compute it\n if not self.beta_flag:\n total_sents = len(sents)\n aux = int(total_sents * 90 / 100)\n # 90 per cent por training\n train_sents = sents[:aux]\n # 10 per cent for perplexity (held out data)\n held_out_sents = sents[-total_sents+aux:]\n\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\n for sent in train_sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # for efficiency, we save the A set as a dict of sets\n if j:\n self.A_set[ngram[:-1]].add(ngram[-1])\n for i in range(1, n):\n counts[('<s>',)*i] += len(train_sents)\n counts[('</s>',)] = len(train_sents)\n\n self.tocounts = counts\n # search for the beta that gives lower perplexity\n beta_candidates = [i*0.1 for i in range(1, 10)]\n # xs is a list with (beta, perplexity)\n xs = []\n self.sents = train_sents\n for aux_beta in beta_candidates:\n self.beta = aux_beta\n aux_perx = self.perplexity(held_out_sents)\n xs.append((aux_beta, aux_perx))\n xs.sort(key=lambda x: x[1])\n self.beta = xs[0][0]\n with open('old-stuff/backoff_'+str(n)+'_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('Beta: {}\\n'.format(self.beta))\n f.write('AddOne: {}\\n'.format(self.addone))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n else:\n sents = list(map((lambda x: x + ['</s>']), sents))\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\n\n for sent in sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # for efficiency, we save the A set as a dict of sets\n if j:\n self.A_set[ngram[:-1]].add(ngram[-1])\n for i in range(1, n):\n counts[('<s>',)*i] += len(sents)\n counts[('</s>',)] = len(sents)","def naive_bayes_train_bis(sms_file):\n dic, list1, list2 = tokenize_and_split_bis(sms_file)\n nbr_words = len(list1) + len(list2)\n spam_ratio = len(list1) / nbr_words\n document = list1 + list2\n\n nbr_spam = 0\n for line in list1:\n for word in line:\n nbr_spam += 1\n \n nbr_ham = 0\n for line in list2:\n for word in line:\n nbr_ham += 1\n \n nbr_words = nbr_ham + nbr_spam\n sms_ratio_list = compute_frequencies(nbr_words, document)\n spam_ratio_list = compute_frequencies(nbr_words, list1)\n spamicity = [0. for i in range(nbr_words)]\n # print(sms_ratio_list)\n # print(spam_ratio_list)\n spamicity_no = [0. for i in range(nbr_words)]\n spamicity_inv = [0. for i in range(nbr_words)]\n\n product_word_dic = 1\n for i in range(nbr_words):\n if sms_ratio_list[i] != 0:\n spamicity[i] = ((spam_ratio_list[i]) / sms_ratio_list[i])\n spamicity_no[i] = 1 - ((spam_ratio_list[i]) / sms_ratio_list[i])\n spamicity_inv[i] = ((1 - (spam_ratio_list[i])) / (1 - sms_ratio_list[i]))\n # print(spamicity_inv[i])\n # if spamicity_inv[i] != 0 :\n product_word_dic *= spamicity_inv[i]\n \n return spam_ratio, dic, spamicity, spamicity_no, spamicity_inv, product_word_dic","def _generateBigrams(self,text):\n self.bigrams=self._generateNgrams(text,2)","def crosswordPuzzle(crossword, words):\n words = words.split(';')\n n_rows = len(crossword)\n lines = []\n columns = []\n row = 0\n twisted = twistgrid(crossword)\n while row < n_rows:\n lines.append(list(re.finditer(r'(-){2,}', crossword[row])))\n columns.append(list(re.finditer(r'(-){2,}', twisted[row])))\n row += 1\n row_words = []\n col_words = []\n blank_lengths = []\n for irow, matches in enumerate(lines):\n row_words.extend([((irow, x.span()[0]),\n (irow, x.span()[1] - 1)) for x in matches])\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\n\n for icol, matches in enumerate(columns):\n col_words.extend([((x.span()[0], icol),\n (x.span()[1] - 1, icol)) for x in matches])\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\n\n intersections = {'row_words': [], 'col_words': []}\n n_intersections = 0\n\n for i, rword in enumerate(row_words):\n for j, cword in enumerate(col_words):\n if rword[0][0] >= cword[0][0] and rword[0][0] <= cword[1][0] and\\\n cword[0][1] >= rword[0][1] and cword[0][1] <= rword[1][1]:\n intersections['row_words'].append((i,\n cword[0][1] - rword[0][1]))\n intersections['col_words'].append((j,\n rword[0][0] - cword[0][0]))\n n_intersections += 1\n\n guesses = list(permutations(words))\n right_length = []\n for i, guess in enumerate(guesses):\n if all((len(guess[k]) == blank_lengths[k] for k in range(len(guess)))):\n right_length.append(guess)\n\n for k, guess in enumerate(right_length):\n row_intersections = []\n col_intersections = []\n i = 0\n while col_intersections == row_intersections and i < n_intersections:\n word = guess[intersections['row_words'][i][0]]\n letter_ind = intersections['row_words'][i][1]\n row_intersections.append(word[letter_ind])\n\n # now find letters of columns that are intersections\n word = guess[intersections['col_words'][i][0] + len(row_words)]\n # need offset because the first words in guess fall into rows\n letter_ind = intersections['col_words'][i][1]\n col_intersections.append(word[letter_ind])\n i += 1\n if col_intersections == row_intersections:\n print(f'Intersections match for guess {guess}')\n break # don't keep changing guess even after you found fit\n print(f'Found correct guess on search {k+1} out of {len(guesses)} choices')\n\n out = [list(row) for row in crossword]\n for i, word in enumerate(row_words):\n out[word[0][0]][word[0][1]:word[1][1] + 1] = list(guess[i])\n\n out = [''.join(row) for row in out]\n out = twistgrid(out)\n\n out = [list(row) for row in out]\n for i, word in enumerate(col_words):\n out[word[0][1]][word[0][0]:word[1][0] + 1] = list(guess[i + len(row_words)])\n out = [''.join(row) for row in out]\n out = twistgrid(out)\n out = [''.join(row) for row in out]\n print('\\n'.join(out))\n\n return out","def proc_sw_only_word(word, uni_word, backward_pairs):\n sandwich_pairs = []\n if uni_word == u'.' and word.raw.endswith('.'):\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('./SF'),]))\n elif uni_word == u'~' and (not backward_pairs or len(backward_pairs) == 1):\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('~/SO'),]))\n elif uni_word == u',' and not backward_pairs:\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('~/SP'),]))\n elif uni_word == u'<pause/>':\n pass\n else:\n raise AlignError()\n return sandwich_pairs","def word_combination(wlist:list) -> list :\r\n\r\n if wlist and len(wlist)>1:\r\n return chain(*map(lambda x: combinations(wlist, x), range(1, len(wlist)+1)))\r\n else :\r\n return wlist","def word2features(self,sent, i):\n word = sent[i][0]\n #postag = sent[i][1]\n\n features = {\n 'bias': 1.0,\n 'word.lower()': word.lower(),\n 'word.isupper()': word.isupper(),\n 'word.istitle()': word.istitle(),\n 'word.isdigit()': word.isdigit(),\n 'word.shape()':self.shape(word),\n 'word.isalnum()':word.isalnum(),\n 'word.isalpha()':word.isalpha(),\n # 'postag': postag,\n # 'postag[:2]': postag[:2],\n }\n if i > 0:\n word1 = sent[i - 1][0]\n #postag1 = sent[i - 1][1]\n features.update({\n '-1:word.lower()': word1.lower(),\n '-1:word.istitle()': word1.istitle(),\n '-1:word.isupper()': word1.isupper(),\n '-1:word.isdigit()': word1.isdigit(),\n '-1:word.isalnum()':word1.isalnum(),\n '-1:word.isalpha()':word1.isalpha(),\n # '-1:postag': postag1,\n # '-1:postag[:2]': postag1[:2],\n })\n else:\n features['BOS'] = True\n\n if i > 1:\n word2 = sent[i - 2][0]\n #postag2 = sent[i - 2][1]\n features.update({\n '-2:word.lower()': word2.lower(),\n '-2:word.istitle()': word2.istitle(),\n '-2:word.isupper()': word2.isupper(),\n '-2:word.isdigit()': word2.isdigit(),\n '-2:word.isalnum()': word2.isalnum(),\n '-2:word.isalpha()': word2.isalpha(),\n # '-2:postag': postag2,\n # '-2:postag[:2]': postag2[:2],\n })\n else:\n features['BOS1'] = True\n if i > 2:\n word3 = sent[i - 3][0]\n #postag3 = sent[i - 3][1]\n features.update({\n '-3:word.lower()': word3.lower(),\n '-3:word.istitle()': word3.istitle(),\n '-3:word.isupper()': word3.isupper(),\n '-3:word.isdigit()': word3.isdigit(),\n '-3:word.isalnum()': word3.isalnum(),\n '-3:word.isalpha()': word3.isalpha(),\n # '-3:postag': postag3,\n # '-3:postag[:2]': postag3[:2],\n })\n else:\n features['BOS2'] = True\n\n if i > 3:\n word4 = sent[i - 4][0]\n #postag4 = sent[i - 4][1]\n features.update({\n '-4:word.lower()': word4.lower(),\n '-4:word.istitle()': word4.istitle(),\n '-4:word.isupper()': word4.isupper(),\n '-4:word.isdigit()': word4.isdigit(),\n '-4:word.isalnum()': word4.isalnum(),\n '-4:word.isalpha()': word4.isalpha(),\n # '-4:postag': postag4,\n # '-4:postag[:2]': postag4[:2],\n })\n else:\n features['BOS2'] = True\n\n if i < len(sent) - 1:\n word1 = sent[i + 1][0]\n features.update({\n '+1:word.lower()': word1.lower(),\n '+1:word.istitle()': word1.istitle(),\n '+1:word.isupper()': word1.isupper(),\n '+1:word.isdigit()': word1.isdigit(),\n '+1:word.isalnum()': word1.isalnum(),\n '+1:word.isalpha()': word1.isalpha(),\n # '+1:postag': postag1,\n # '+1:postag[:2]': postag1[:2],\n })\n else:\n features['EOS'] = True\n if i < len(sent) - 2:\n word12 = sent[i + 2][0]\n #postag12 = sent[i + 2][1]\n features.update({\n '+2:word.lower()': word12.lower(),\n '+2:word.istitle()': word12.istitle(),\n '+2:word.isupper()': word12.isupper(),\n '+2:word.isdigit()': word12.isdigit(),\n '+2:word.isalnum()': word12.isalnum(),\n '+2:word.isalpha()': word12.isalpha(),\n # '+2:postag': postag12,\n # '+2:postag[:2]': postag12[:2],\n })\n else:\n features['EOS2'] = True\n if i < len(sent) - 3:\n word13 = sent[i + 3][0]\n #postag13 = sent[i + 3][1]\n features.update({\n '+3:word.lower()': word13.lower(),\n '+3:word.istitle()': word13.istitle(),\n '+3:word.isupper()': word13.isupper(),\n '+3:word.isdigit()': word13.isdigit(),\n '+3:word.isalnum()': word13.isalnum(),\n '+3:word.isalpha()': word13.isalpha(),\n # '+3:postag': postag13,\n # '+3:postag[:2]': postag13[:2],\n })\n else:\n features['EOS2'] = True\n if i < len(sent) - 4:\n word14 = sent[i + 4][0]\n #postag14 = sent[i + 4][1]\n features.update({\n '+4:word.lower()': word14.lower(),\n '+4:word.istitle()': word14.istitle(),\n '+4:word.isupper()': word14.isupper(),\n '+4:word.isdigit()': word14.isdigit(),\n '+4:word.isalnum()': word14.isalnum(),\n '+4:word.isalpha()': word14.isalpha(),\n # '+4:postag': postag14,\n # '+4:postag[:2]': postag14[:2],\n })\n else:\n features['EOS2'] = True\n return features","def make_text(markov_chains):\n\n random_num = generate_random_number(markov_chains.keys())\n\n random_text = []\n\n start_words = generate_start_words(random_num, markov_chains.keys())\n \n random_text.extend(start_words)\n\n\n for i in range(500):\n word_tuple = (random_text[-2],random_text[-1])\n next_word = add_next_word(word_tuple, markov_chains)\n random_text.append(next_word)\n\n return random_text","def grounding_words(self, w):\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])","def crosswordPuzzle(crossword, words):\n words = words.split(';')\n n_rows = len(crossword)\n lines = []\n columns = []\n row = 0\n twisted = twistgrid(crossword)\n while row < n_rows:\n lines.append(list(re.finditer(r'(-){2,}', crossword[row])))\n columns.append(list(re.finditer(r'(-){2,}', twisted[row])))\n row += 1\n # lines and columns are a list of lists; both are n_rows long.\n # If there are any matches in the column or row, they will appear\n # as a match object in one of the sublists\n # A match requires 2 or more blank spaces consecutively +--+\n # A single blank is not a word / match\n # print('lines', lines)\n # print(columns)\n row_words = []\n col_words = []\n blank_lengths = []\n for irow, matches in enumerate(lines):\n row_words.extend([((irow, x.span()[0]),\n (irow, x.span()[1] - 1)) for x in matches])\n # row_words is a list of 2-tuples, which have the coord of\n # start and end of blank space for a word\n # ex: ((3, 0), (3, 4)) represents a space at (row 3, col 0),\n # which extends 5 blank space to terminate on (row 3, col 4)\n # .extend method is used because we could have more than one\n # match object per line and append method only takes one\n # argument\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\n # blank_lengths is a list that counts how long each of the row\n # words is, going top to bottom in grid.\n # a match object's span()[1] coordinate is one greater than the\n # last index of the match, so subtracting gives the length\n\n for icol, matches in enumerate(columns):\n col_words.extend([((x.span()[0], icol),\n (x.span()[1] - 1, icol)) for x in matches])\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\n\n intersections = {'row_words': [], 'col_words': []}\n n_intersections = 0\n # we want coordinates of where the intersections occur of the row\n # words with column words to verify a matching letter later on\n # intersections is a dictionary of two lists and each list contains\n # 2-tuples:\n # (p, q) p = index of row_words or col_words\n # q = index of row_words[p] that corresponds to the letter\n # in the word that needs to be verified\n\n for i, rword in enumerate(row_words):\n for j, cword in enumerate(col_words):\n if rword[0][0] >= cword[0][0] and rword[0][0] <= cword[1][0] and\\\n cword[0][1] >= rword[0][1] and cword[0][1] <= rword[1][1]:\n # rword[0][0] is row of rword, which needs to fall\n # within\n # the range of the column word in order to intersect\n # cword[0][1] is column row of cword, which needs to\n # fall within of the row word in order to intersect\n intersections['row_words'].append((i,\n cword[0][1] - rword[0][1]))\n intersections['col_words'].append((j,\n rword[0][0] - cword[0][0]))\n n_intersections += 1\n\n guesses = list(permutations(words))\n # there might be better way to choose ways to check potential solutions\n # but max # words in test cases was 6, so 6x5x4x3x2 = 720 guesses\n right_length = []\n for i, guess in enumerate(guesses):\n if all((len(guess[k]) == blank_lengths[k] for k in range(len(guess)))):\n # Only pass guesses where every single word fits in the blank.\n # Rows are filled first, then columns\n right_length.append(guess)\n\n for k, guess in enumerate(right_length):\n row_intersections = []\n col_intersections = []\n i = 0\n while col_intersections == row_intersections and i < n_intersections:\n word = guess[intersections['row_words'][i][0]]\n letter_ind = intersections['row_words'][i][1]\n row_intersections.append(word[letter_ind])\n\n # now find letters of columns that are intersections\n word = guess[intersections['col_words'][i][0] + len(row_words)]\n # need offset because the first words in guess fall into rows\n letter_ind = intersections['col_words'][i][1]\n col_intersections.append(word[letter_ind])\n i += 1\n if col_intersections == row_intersections:\n # print(f'Intersections match for guess {guess}')\n break # don't keep changing guess even after you found fit\n print(f'Found correct guess on search {k+1} out of {len(guesses)} choices')\n\n # Now let's insert solution into grid, replacing the blank spaces '-'\n # with the words\n # To mutate elements of crossword, we need to mutate it\n # so we need to turn it into list.\n # We also need to transpose it to fill in the columns, then transpose\n # it back to normal orientation\n\n out = [list(row) for row in crossword]\n for i, word in enumerate(row_words):\n out[word[0][0]][word[0][1]:word[1][1] + 1] = list(guess[i])\n\n out = [''.join(row) for row in out]\n out = twistgrid(out)\n\n out = [list(row) for row in out]\n for i, word in enumerate(col_words):\n out[word[0][1]][word[0][0]:word[1][0] + 1] = list(guess[i + len(row_words)])\n # the indexing is different from row above because we need\n # to update the range of rows that column word occupies\n # need offset because row words come first in guesses list\n out = [''.join(row) for row in out]\n out = twistgrid(out)\n out = [''.join(row) for row in out]\n print('\\n'.join(out))\n\n return out","def make_pairs(txt):\r\n \r\n lista = []\r\n string = \"\" \r\n count = 0\r\n \r\n if len(txt)%2 != 0 :\r\n count = 1\r\n \r\n for i in range(len(txt)):\r\n \r\n string += txt[i]\r\n count += 1\r\n \r\n if count == 2:\r\n lista.append(string)\r\n string = \"\"\r\n count = 0\r\n \r\n return lista","def viterbi_trigrams(transition_probabilities, label_matches, prev_tag, prev_prev_tag, word, tag_possibilities):\r\n\tmax_prob = 0\r\n\tbest_tag = \"\"\r\n\ttag_counts = get_tag_counts(label_matches)\r\n\tfor tag in tag_possibilities:\r\n\t\temissions_probability = get_emissions_probability(label_matches, tag, word, tag_counts)\r\n\t\ttag_trigram = (prev_prev_tag, prev_tag,tag)\r\n\t\ttransition_probability = transition_probabilities.get(tag_trigram, 0.000027)\r\n\t\tprob = emissions_probability * transition_probability\r\n\t\tif prob > max_prob:\r\n\t\t\tmax_prob = prob\r\n\t\t\tbest_tag = tag\r\n\tif best_tag == \"\":\r\n\t\tbest_tag = \"o\"\r\n\treturn best_tag","def getComboTerms(tuples):\t\t\t\n\t\t\t#return \"[{0}]\".format('; '.join([\"({0})\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\n\t\t\treturn \"{0}\".format('; '.join((\"{0}\".format(text[indices[0]:indices[1]]) for indices in tuples)))","def make_text(chains):\n\n words = []\n\n # random_key = choice(chains.keys())\n\n # words.append(random_key[0])\n # words.append(random_key[1])\n\n # while random_key in chains.keys():\n\n # values_list = chains[random_key]\n\n # chosen_word = choice(values_list)\n\n # words.append(chosen_word)\n\n # new_key = (random_key[1], chosen_word)\n\n # random_key = new_key\n\n list_of_keys = chains.keys()\n\n random_key = choice(list_of_keys)\n\n while random_key[0].islower() or random_key[0] == \"--\":\n random_key = choice(list_of_keys)\n\n\n words.append(random_key[0])\n words.append(random_key[1])\n\n while random_key in chains.keys():\n random_value = choice(chains.get(random_key, None))\n\n words.append(random_value)\n new_key = (random_key[1], random_value)\n random_key = new_key\n if random_key[1].endswith(\".\"):\n break\n\n\n return \" \".join(words)","def make_chains(corpus):\n \n# This section reads the corpus file in to the program and splits the words in a words list. \n text = corpus.read() #this is functionally the same as the more complicated stuff below\n words = text.split()\n\n chain_dict = {}\n \"\"\"\n for line in f:\n line = line.rstrip()\n words.extend(line.split())\n \"\"\" \n#This looks at each word entry in the list that we made from original text - if the tuple does not yet exist,\n#it appends it to the dictionary as a key. If it does exist, it appends the value to the existing key.\n\n for each_number in range(len(words)-2): \n if (words[each_number], words[each_number+1]) not in chain_dict.keys():\n chain_dict[(words[each_number], words[each_number+1])] = [words[each_number+2]]\n else:\n chain_dict[(words[each_number], words[each_number+1])].append(words[each_number+2])\n \n return chain_dict","def make_chains(text_string, n):\n text_list = text_string.split()\n\n chains = {}\n\n for i in range(n):\n if text_list[i][0].isupper():\n starters = chains.get('START', [])\n starters.append(text_list[i:i+n])\n chains['START'] = starters\n\n # your code goes here\n for i in range(len(text_list)-n):\n n_gram = tuple(text_list[i:i+n])\n\n #bigram = (text_list[i], text_list[i+1])\n\n followers = chains.get(n_gram, [])\n followers.append(text_list[i+n])\n\n if n_gram[-1][-1] in {'.', '?', '!'}:\n followers.append('EOF')\n\n chains[n_gram] = followers\n\n if text_list[i+n][0].isupper():\n starters = chains.get('START', [])\n starters.append(text_list[i+n:i+(2*n)])\n chains['START'] = starters\n\n return chains","def word2vec_mapping_func():\n return {\"belonging to\": \"belonging\", \"parked on\": \"parked\", \"growing on\": \"growing\", \"standing on\": \"standing\",\n \"made of\": \"made\", \"attached to\": \"attached\", \"hanging from\": \"hanging\", \"in front of\": \"front\",\n \"lying on\": \"lying\", \"flying in\": \"flying\", \"looking at\": \"looking\", \"on back of\": \"back\",\n \"laying on\": \"laying\", \"walking on\": \"walking\", \"walking in\": \"walking\", \"sitting on\": \"sitting\",\n \"covered in\": \"covered\", \"part of\": \"part\", \"painted on\": \"painted\", \"mounted on\": \"mounted\"}","def make_text(sent, begin, end):\n lemmas = [sent.morps[begin].lemma(), ]\n for idx in range(begin+1, end):\n if sent.mid2wid[idx-1] != sent.mid2wid[idx]: # if go over word boundary\n # insert space between words\n lemmas.append(' ')\n lemmas.append(sent.morps[idx].lemma())\n return ''.join(lemmas)","def make_chains(corpus):\n c_dict = {}\n\n for x in range(len(corpus)):\n if x < (len(corpus)-2): # not in edge\n bigram_tuple = tuple([corpus[x],corpus[x+1]])\n if bigram_tuple in c_dict:\n c_dict[bigram_tuple].append(corpus[x+2])\n else:\n c_dict[bigram_tuple] = [corpus[x+2]]\n else:\n bigram_tuple = tuple([corpus[-2],corpus[-1]]) # ran twice. Why?\n c_dict.setdefault(bigram_tuple) # could set a default word? Empty list?\n\n return c_dict","def generate_babble_text(self):\n markov_chain_output = []\n for n in range(self.number_of_sentences):\n sentence_length = random.randint(self.min_sentence_length, self.max_sentence_length)\n markov_chain_output.append(self.markov_chain.generate_sentence(sentence_length))\n\n random.shuffle(markov_chain_output)\n\n to_display = ''\n for i in markov_chain_output:\n to_display += i + '\\n'\n\n # Clears any old text in the display, then inserts the newly created text\n self.display.delete('1.0', tk.END)\n self.display.insert('1.0', to_display)","def create_word(self):\n return self.random.choice(CONSONANTS) + self.random.choice(VOWELS)","def make_text(word_next_dict):\n\n final_text = []\n # randomly select a tuple from the dictionary\n start = random.choice(word_next_dict.keys())\n # If 1st word in tuple isn't capitalized, choose a new pair until one is\n while not start[0].isupper():\n start = random.choice(word_next_dict.keys())\n # Begin the list of random text with tuple (separated to 2 strings)\n final_text.append(start[0])\n final_text.append(start[1])\n\n # create random text list: find a word associated with last 2 and append list\n while len(final_text) < 12:\n # look for sentence endings and re-choose start tuple\n if '.' in final_text[-1]:\n start = random.choice(word_next_dict.keys())\n # make sure tuple begins with a capitalized string\n while not start[0].isupper():\n start = random.choice(word_next_dict.keys())\n final_text.append(start[0])\n final_text.append(start[1])\n last_words = (final_text[-2], final_text[-1]) \n next_guy = word_next_dict[last_words][random.randrange(len(word_next_dict[last_words]))] # finds length of wordlist, randomly picks \n final_text.append(next_guy)\n\n to_tweet = ' '.join(final_text) + '.'\n print to_tweet\n return to_tweet","def guess_splitwords():\n\n if t_word[:2] == 'un' and (t_pos == 'ADJD' or t_pos == 'ADJA'):\n create_splitword_tags(t_word[:2], t_word[2:])\n create_negation_frame()\n create_splitword_target(t_word[:2])\n create_splitword_focus(t_word[2:])\n create_splitword_negated(t_word[2:])\n create_splitword_scope(t_word[2:])","def correct_errors(page, labels, bboxes, model):\n\n # end_of_word = []\n\n # take every bbox and check the width between them\n # total_bboxes = len(bboxes)\n # for n in range(total_bboxes-1):\n # if (space_between(n,n+1,bboxes)):\n # end_of_word.append(n+1)\n\n # now we can make words by joining the characters where there isn't whitespace\n # so from the start until the index of the first space we should join together the characters\n\n # char_to_word = []\n # for x in range(len(end_of_word)):\n # if (x==0):\n # char_to_word.append(''.join(labels[x:(end_of_word[x])]).upper())\n # else:\n # char_to_word.append(''.join(labels[(end_of_word[x-1]):(end_of_word[x])]).upper())\n\n # We want to remove all the punctuation as it gets in the way of matching words\n # however we still want to store it's index in the labels for later.\n # punctuation_index = []\n # punctuation_value = []\n\n # for x in range(len(labels)):\n # if labels[x] in ('!','.',':',',',';','?','\\''):\n # punctuation_index.append(labels.tolist().index(labels[x]))\n # punctuation_value.append(labels[x])\n # labels[x] = remove_punctuation(labels[x])\n\n # Get the words that don't need changing out of the way (they already exist)\n # no_change_words = set(char_to_word).intersection(model['words'])\n\n # now we want to take all words that don't appear in both lists of words and change those with a few\n # misclassified chars to words that are similar in the list of actual words.\n\n # words_to_correct = [w for w in char_to_word if w not in no_change_words]\n\n # We'll need the index of the words so we can put them back.\n # wtc_index = []\n # for i in range(len(words_to_correct)):\n # wtc_index.append(char_to_word.index(words_to_correct[i]))\n\n # Start looking for similar words of the same length for a given word and input the similar word instead.\n # for y in range(len(words_to_correct)):\n # word = words_to_correct[y]\n # # filter words of the same length\n # close_word = filter(lambda x: len(x) == len(word), model['words'])\n # # replace current word with one real word with only a letters difference\n # for x, similar in enumerate(close_word):\n # if (string_difference(similar, word) == 1):\n # words_to_correct[y] = similar\n\n # using the stored index, put the words back where they need to be\n # for i in range(len(wtc_index)):\n # for n, j in enumerate(char_to_word):\n # if (n == wtc_index[i]):\n # char_to_word[n] = words_to_correct[i]\n\n # start splitting the words up again so that they're in the necessary label shape\n # possible_labels = []\n # for i in range(len(char_to_word)):\n # split_words = [x for x in char_to_word[i].lower()]\n # possible_labels.append(split_words)\n # possible_labels1 = list(itertools.chain.from_iterable(possible_labels))\n\n # add the punctuation back in and you should get the full amount of labels to return and test on\n # for i in range(len(punctuation_index)):\n # while len(possible_labels1) != len(labels):\n # possible_labels1.insert(punctuation_index[i],punctuation_value[i])\n\n return labels","def make_text(chains):\n key = choice(list(chains.keys()))\n\n words = []\n\n while key in chains:\n word = get_new_word(key, chains)\n words.append(word)\n key = get_new_key(key, word)\n\n return \" \".join(words)","def process_pair(words: tuple) -> Optional[tuple]:\n\n # Replace all reflexive forms\n to_replace = [\"[se]\", \"|se|\", \"[-și]\", \"[o]\", \"|-și|\", \"|și|\", \"[-i]\", \"[i]\", \"[și]\", \"a \"]\n raw_line = \" \".join(words)\n for sub in to_replace:\n raw_line = raw_line.replace(sub, \"\")\n\n # Replace multiple spaces, strip beginning / ending spaces\n processed_line = re.sub('\\s{2,}', ' ', raw_line).strip()\n\n words = processed_line.split(' ')\n\n # Return the new tuple\n # Or the empty string if the words are the same or contain each other, or ar capital nouns\n if len(words) != 2:\n return None\n if words[1] in words[0] or words[0] in words[1]:\n return None\n if words[1][0].isupper() or words[0][0].isupper():\n return None\n return tuple(words)","def word_subsets(self, A: List[str], B: List[str]) -> List[str]:\n res = []\n B_hashmaps = []\n for word in B:\n B_hashmaps.append(Counter(word))\n\n for word in A:\n if self.check_superset(word, B_hashmaps):\n res.append(word)\n return res","def generate_sentence(word1, word2, length, vocab, model):\n reverse_vocab = {idx: word for word, idx in vocab.items()}\n output_string = np.zeros((1, length), dtype=np.int)\n output_string[:, 0: 2] = vocab[word1], vocab[word2]\n\n for end in range(2, length):\n start = end - 2\n output_string[:, end] = np.argmax(model(output_string[:, start:end]), axis=1)\n text = [reverse_vocab[i] for i in list(output_string[0])]\n \n print(\" \".join(text))","def make_words(self,lm):\n if \" \" in self.corpus[0] and \" \" in self.corpus[1]: \n print \"assuming BLICK\"\n self.corpus = [convert_to_disc(i) for i in self.corpus]\n else:\n self.disc = 1\n print \"assuming Disc\" \n if not os.path.isfile(self.f): ##check if it already exists\n print \"generating 10 million words\"\n outfile = open(self.f, \"w\")\n outfile.write(\"word,blick,ngram,Real,T,disc\\n\")\n for word in self.corpus:\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Real\", \"1\")\n while len(self.wordlist)<10000000: \n words = lm.generate(100)\n for word in words:\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Simulated\", \"0\")\n self.wordlist[word] = 0\n return","def generate_antonym_pairs(config: SettingConfig) -> dict:\n print(f\"Generating initial antonym pairs from RoWordNet @ {datetime.now()}\")\n wn = rwn.RoWordNet()\n\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\n # the PoS and the value is a set of pairs of words of PoS specified by the key\n pairs = dict()\n\n # Iterate over the selected parts of speech\n for part_of_speech in config.pos.values():\n\n pos_pairs = list()\n\n # Return all synsets corresponding to the PoS\n synset_ids = wn.synsets(pos=part_of_speech)\n\n # Iterate all the synsets for the current PoS\n for synset_id in synset_ids:\n\n # Get the synset object specified by synset_id\n synset = wn.synset(synset_id)\n\n # Get the outbound relations of type antonym from\n outbound_relations = filter(lambda x: x[1] == 'near_antonym', wn.outbound_relations(synset_id))\n\n # Iterate outbound relations\n for relation in outbound_relations:\n # Get the synset corresponding to the target of the outbound relation\n target_synset = wn.synset(relation[0])\n\n # Get all the pairs, sort them by first word to keep set entries unique\n current_iteration_pairs = get_cross_synset_pairs(synset, target_synset)\n\n # Add the current set of pairs\n pos_pairs.extend(current_iteration_pairs)\n\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\n for key, value in config.pos.items():\n if value == part_of_speech:\n pairs[key] = unique(pos_pairs)\n\n # Return the whole dictionary\n print(f\"Successfully generated antonym paris @ {datetime.now()}\")\n return pairs","def add2chain2nd(splitted_text):\n # Our key is the unique occurrence of a pair of words\n inputText = splitted_text\n if len(inputText) > 1:\n for i, word in enumerate(inputText):\n if i == 0: # Chaining the first and second word in tweet to start key\n if (None, startKey) not in chain:\n chain[(None, startKey)] = [word]\n else:\n chain[(None, startKey)].append(word)\n elif i == 1:\n if (startKey,inputText[i-1]) not in chain:\n chain[(startKey,inputText[i-1])] = [word]\n else:\n chain[(startKey,inputText[i-1])].append(word)\n else:\n if (inputText[i-2],inputText[i-1]) not in chain:\n chain[(inputText[i-2],inputText[i-1])] = [word]\n else:\n chain[(inputText[i-2],inputText[i-1])].append(word)\n if i == len(inputText)-1: # Use last two words as key to end\n if (inputText[i-1],word) not in chain:\n chain[(inputText[i-1],word)] = [endKey]\n else:\n chain[(inputText[i-1],word)].append(endKey)\n if (None,startKey) not in chain:\n chain[(None,startKey)] = [inputText[0]]\n else:\n chain[(None,startKey)].append(inputText[0])\n if (inputText[0],endKey) not in chain:\n chain[(inputText[0],endKey)] = [None]\n else:\n chain[(inputText[0],endKey)].append(None)","def word_builder(str_lst, int_lst):\n word_lst = [None] * len(int_lst)\n for i in range(len(word_lst)):\n word_lst[i] = str_lst[int_lst[i]]\n return \"\".join(word_lst)","def get_biomarkes(abundant, xxx):\n cc = []\n bk = set()\n lvl = 0\n\n for _, t in abundant:\n cc.append(t.split('.'))\n\n while lvl < len(max(cc)):\n bk = set()\n\n for c in cc:\n if lvl < len(c):\n bk |= set([c[lvl]])\n\n if len(bk) >= xxx:\n break\n\n lvl += 1\n\n return bk","def make_chains(text_string, n):\n\n chains = {}\n\n # your code goes here\n words = text_string.split()\n #print words\n \n for i in range(len(words) - n):\n # next_word = words[i+2]\n #print \"Next Word\",next_word\n key_word_tuple = tuple(words[i:(i + n)])\n # print key_word_tuple\n #, words[i + 1])\n chains[key_word_tuple] = chains.get(key_word_tuple, [])\n # if (i + n) == (len(words) - 1):\n # next_word = words[0]\n # print \"i\", i\n # print \"BLINGGGG\"\n # print \"End of Range \",next_word, \"key word tuple \", key_word_tuple\n # # if (i + 2) < len(words):\n # else: \n next_word = words[i+n]\n # print next_word\n\n chains[key_word_tuple].append(next_word)\n \n\n \n \n \n # print chains[\"I\",\"am\"] \n # print chains\n return chains","def generateWord(self, parameters=None):\n\t\t# Initial set-up\n\t\tvowels = ['a', 'e', 'i', 'o', 'u']\n\t\tspecialVowels = ['y']\n\n\t\tconsonants = ['b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't']\n\t\tspecialConsonants = ['j', 'q', 'v', 'w', 'x', 'z']\n\n\t\tnewLetterFraction = 5\n\t\tvowelChance = 50 #percent\n\n\t\t#Determine how many words we're going to have to generate\n\t\trepeats = 1\n\t\tif parameters and len(parameters) > 0:\n\t\t\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\n\n\t\twords = []\n\t\tfor i in xrange(0, repeats):\n\t\t\tword = u\"\"\n\t\t\tcurrentVowelChance = vowelChance\n\t\t\tcurrentNewLetterFraction = newLetterFraction\n\t\t\tconsonantCount = 0\n\t\t\twhile random.randint(0, currentNewLetterFraction) <= 6:\n\t\t\t\tif random.randint(1, 100) <= currentVowelChance:\n\t\t\t\t\tconsonantCount = 0\n\t\t\t\t\t#vowel. Check if we're going to add a special or normal vowel\n\t\t\t\t\tif random.randint(1, 100) <= 10:\n\t\t\t\t\t\tword += random.choice(specialVowels)\n\t\t\t\t\t\tcurrentVowelChance -= 30\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(vowels)\n\t\t\t\t\t\tcurrentVowelChance -= 20\n\t\t\t\telse:\n\t\t\t\t\tconsonantCount += 1\n\t\t\t\t\t#consonant, same deal\n\t\t\t\t\tif random.randint(1, 100) <= 25:\n\t\t\t\t\t\tword += random.choice(specialConsonants)\n\t\t\t\t\t\tcurrentVowelChance += 30\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(consonants)\n\t\t\t\t\t\tcurrentVowelChance += 20\n\t\t\t\t\tif consonantCount > 3:\n\t\t\t\t\t\tcurrentVowelChance = 100\n\t\t\t\tcurrentNewLetterFraction += 1\n\n\t\t\t#Enough letters added. Finish up\n\t\t\tword = word[0].upper() + word[1:]\n\t\t\twords.append(word)\n\n\t\t#Enough words generated, let's return the result\n\t\treturn u\", \".join(words)"],"string":"[\n \"def generate_pairs_of_words(word_list):\\n def pair_words(word_list, i, j, connector):\\n return word_list[i] + connector + word_list[j]\\n pairs = []\\n n = len(word_list)\\n for i in range(n-1):\\n for j in range(i+1, n):\\n pairs.append(pair_words(word_list, i, j, ' '))\\n pairs.append(pair_words(word_list, j, i, ' '))\\n pairs.append(pair_words(word_list, i, j, '-'))\\n pairs.append(pair_words(word_list, j, i, '-'))\\n pairs.append(pair_words(word_list, i, j, '_'))\\n pairs.append(pair_words(word_list, j, i, '_'))\\n pairs.append(pair_words(word_list, i, j, ''))\\n pairs.append(pair_words(word_list, j, i, ''))\\n outputs = list(set(pairs)) # remove duplicates\\n return outputs\",\n \"def generate_word(model, whitelist, topk, radix=\\\"\\\"):\\n if whitelist.empty():\\n yield \\\"\\\", 0\\n else:\\n for prefix, prefix_proba in iterate_continutations(model, radix, whitelist, topk):\\n if prefix is None:\\n continue\\n for suffix, suffix_proba in generate_word(\\n model,\\n whitelist.sub(LetterBag(prefix)),\\n topk,\\n radix + prefix):\\n if suffix is None:\\n continue\\n yield prefix + suffix, prefix_proba + suffix_proba\\n yield None, 0\",\n \"def create_word(char_list):\",\n \"def make_chains(text, text2):\\n\\n list_of_words = text.split() + text2.split()\\n # Build dictionary where key = tuple and value = following word\\n word_next_dict = {}\\n pos = 0\\n #Create word pairs of every combination from within source texts\\n for word in list_of_words[0:-2]:\\n pair = (list_of_words[pos], list_of_words[pos+1])\\n if pair not in word_next_dict:\\n word_next_dict[pair] = [list_of_words[pos+2]]\\n pos += 1\\n else:\\n word_next_dict[pair].append(list_of_words[pos+2])\\n pos += 1\\n return word_next_dict\",\n \"def generateWord2(self, parameters=None):\\n\\n\\t\\t##Initial set-up\\n\\t\\t#A syllable consists of an optional onset, a nucleus, and an optional coda\\n\\t\\t#Sources:\\n\\t\\t# http://en.wikipedia.org/wiki/English_phonology#Phonotactics\\n\\t\\t# http://en.wiktionary.org/wiki/Appendix:English_pronunciation\\n\\t\\tonsets = [\\\"ch\\\", \\\"pl\\\", \\\"bl\\\", \\\"cl\\\", \\\"gl\\\", \\\"pr\\\", \\\"br\\\", \\\"tr\\\", \\\"dr\\\", \\\"cr\\\", \\\"gr\\\", \\\"tw\\\", \\\"dw\\\", \\\"qu\\\", \\\"pu\\\",\\n\\t\\t\\t\\t \\\"fl\\\", \\\"sl\\\", \\\"fr\\\", \\\"thr\\\", \\\"shr\\\", \\\"wh\\\", \\\"sw\\\",\\n\\t\\t\\t\\t \\\"sp\\\", \\\"st\\\", \\\"sk\\\", \\\"sm\\\", \\\"sn\\\", \\\"sph\\\", \\\"spl\\\", \\\"spr\\\", \\\"str\\\", \\\"scr\\\", \\\"squ\\\", \\\"sm\\\"] #Plus the normal consonants\\n\\t\\tnuclei = [\\\"ai\\\", \\\"ay\\\", \\\"ea\\\", \\\"ee\\\", \\\"y\\\", \\\"oa\\\", \\\"au\\\", \\\"oi\\\", \\\"oo\\\", \\\"ou\\\"] #Plus the normal vowels\\n\\t\\tcodas = [\\\"ch\\\", \\\"lp\\\", \\\"lb\\\", \\\"lt\\\", \\\"ld\\\", \\\"lch\\\", \\\"lg\\\", \\\"lk\\\", \\\"rp\\\", \\\"rb\\\", \\\"rt\\\", \\\"rd\\\", \\\"rch\\\", \\\"rk\\\", \\\"lf\\\", \\\"lth\\\",\\n\\t\\t\\t\\t \\\"lsh\\\", \\\"rf\\\", \\\"rth\\\", \\\"rs\\\", \\\"rsh\\\", \\\"lm\\\", \\\"ln\\\", \\\"rm\\\", \\\"rn\\\", \\\"rl\\\", \\\"mp\\\", \\\"nt\\\", \\\"nd\\\", \\\"nch\\\", \\\"nk\\\", \\\"mph\\\",\\n\\t\\t\\t\\t \\\"mth\\\", \\\"nth\\\", \\\"ngth\\\", \\\"ft\\\", \\\"sp\\\", \\\"st\\\", \\\"sk\\\", \\\"fth\\\", \\\"pt\\\", \\\"ct\\\", \\\"kt\\\", \\\"pth\\\", \\\"ghth\\\", \\\"tz\\\", \\\"dth\\\",\\n\\t\\t\\t\\t \\\"ks\\\", \\\"lpt\\\", \\\"lfth\\\", \\\"ltz\\\", \\\"lst\\\", \\\"lct\\\", \\\"lx\\\",\\\"rmth\\\", \\\"rpt\\\", \\\"rtz\\\", \\\"rst\\\", \\\"rct\\\",\\\"mpt\\\", \\\"dth\\\",\\n\\t\\t\\t\\t \\\"nct\\\", \\\"nx\\\", \\\"xth\\\", \\\"xt\\\"] #Plus normal consonants\\n\\n\\t\\tsimpleLetterChance = 65 #percent, whether a single letter is chosen instead of an onset/nucleus/coda\\n\\t\\tbasicLetterChance = 75 #percent, whether a simple consonant/vowel is chosen over a more rare one\\n\\n\\t\\t#Prevent unnecessary and ugly code repetition\\n\\n\\t\\t#Start the word\\n\\t\\trepeats = 1\\n\\t\\tif parameters and len(parameters) > 0:\\n\\t\\t\\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\\n\\n\\t\\twords = []\\n\\t\\tfor i in xrange(0, repeats):\\n\\t\\t\\tsyllableCount = 2\\n\\t\\t\\tif random.randint(1, 100) <= 50:\\n\\t\\t\\t\\tsyllableCount -= 1\\n\\t\\t\\tif random.randint(1, 100) <= 35:\\n\\t\\t\\t\\tsyllableCount += 1\\n\\n\\t\\t\\tword = u\\\"\\\"\\n\\t\\t\\tfor j in range(0, syllableCount):\\n\\t\\t\\t\\t#In most cases, add an onset\\n\\t\\t\\t\\tif random.randint(1, 100) <= 75:\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"consonant\\\", basicLetterChance)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(onsets)\\n\\n\\t\\t\\t\\t#Nucleus!\\n\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"vowel\\\", basicLetterChance)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tword += random.choice(nuclei)\\n\\n\\t\\t\\t\\t#Add a coda in most cases (Always add it if this is the last syllable of the word and it'd be too short otherwise)\\n\\t\\t\\t\\tif (j == syllableCount - 1 and len(word) < 3) or random.randint(1, 100) <= 75:\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"consonant\\\", basicLetterChance)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(codas)\\n\\n\\t\\t\\tword = word[0].upper() + word[1:]\\n\\t\\t\\twords.append(word)\\n\\n\\t\\treturn u\\\", \\\".join(words)\",\n \"def rule_nnp_vbz_rb_vb(words):\\n original_len = len(words)\\n words = mutate_tag_seq(\\n words,\\n ['NNP','VBZ','RB','VB'],\\n ['NNP','VB','RB']\\n )\\n if words is not None:\\n if len(words) < original_len:\\n i = index_tag_seq(words, ['NNP', 'VB', 'RB'])\\n words[i+1].text += 's'\\n words[i+1].tag = 'VBZ'\\n return words\",\n \"def proc_sw_both_not_empty(forward_pairs, uni_word, morphs, backward_pairs):\\n sandwich_pairs = []\\n morphs_str = ' + '.join([str(morph) for morph in morphs])\\n word_morphs_str = '%s %s' % (uni_word.encode('UTF-8'), morphs_str)\\n if word_morphs_str in _CORRECT_ALIGNS:\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs))\\n elif word_morphs_str in ['해야 하/VV + 아야/EC + 하/VX', '해야 하/XSV + 아야/EC + 하/VX', '야 아야/EC + 하/VX',\\n '야 어야/EC + 하/VX', '봐야 보/VX + 아야/EC + 하/VX', '해야 하/VX + 아야/EC + 하/VX'] \\\\\\n and backward_pairs and str(backward_pairs[0].morphs[0]) == '겠/EP':\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\\n backward_pairs[0].morphs.insert(0, morphs[-1])\\n del morphs[:]\\n elif word_morphs_str in ['졌 어/EC + 지/VX + 었/EP', '져 어/EC + 지/VX + 어/EC', '봐야 아/EC + 보/VX + 아야/EC',\\n '왔 아/EC + 오/VX + 았/EP', '왔 어/EC + 오/VX + 았/EP', '봤 아/EC + 보/VX + 았/EP',\\n '봐 아/EC + 보/VX + 아/EF', '왔 아/EC + 오/VV + 았/EP', '냈 아/EC + 내/VX + 었/EP',\\n '내 아/EC + 내/VX + 어/EC'] \\\\\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag == 'VV':\\n forward_pairs[-1].morphs.append(morphs[0])\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:]))\\n del morphs[:]\\n elif word_morphs_str == '봐야 아/EC + 보/VX + 아야/EC + 하/VX' \\\\\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag == 'VV' \\\\\\n and backward_pairs and str(backward_pairs[0].morphs[0]) == '겠/EP':\\n forward_pairs[-1].morphs.append(morphs[0])\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:-1]))\\n backward_pairs[0].morphs.insert(0, morphs[-1])\\n del morphs[:]\\n elif uni_word in [u'해졌', u'해봤', u'해했', u'해봐', u'해줬', u'해줘', u'해와', u'해져'] and len(morphs) == 4:\\n sandwich_pairs.append(WordStrMorphsPair(uni_word[0], morphs[:2]))\\n sandwich_pairs.append(WordStrMorphsPair(uni_word[1], morphs[2:]))\\n del morphs[:]\\n elif word_morphs_str == '잖 이/VCP + 지/EC + 않/VX' \\\\\\n and forward_pairs and forward_pairs[-1].morphs[-1].tag.startswith('N'):\\n forward_pairs[-1].morphs.append(morphs[0])\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[1:]))\\n del morphs[:]\\n elif word_morphs_str in ['해서 하/VV + 아서/EC + 이/VCP', '해서 하/XSV + 아서/EC + 이/VCP',\\n '해서 하/VX + 아서/EC + 이/VCP', '서] 아서/EC+이/VCP'] \\\\\\n and backward_pairs and backward_pairs[0].morphs[0].tag.startswith('E'):\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\\n backward_pairs[0].morphs.insert(0, morphs[-1])\\n del morphs[:]\\n elif word_morphs_str in ['서 아서/EC + 이/VCP'] \\\\\\n and backward_pairs and backward_pairs[0].morphs[0].tag.startswith('E'):\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs[:-1]))\\n backward_pairs[0].morphs.insert(0, morphs[-1])\\n del morphs[:]\\n else:\\n sim = calc_similarity(uni_word, unicode(''.join([morph.lex for morph in morphs]), 'UTF-8'))\\n if sim >= _SIMILARITY_MIN:\\n # string similarity is greater than threshold\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, morphs))\\n else:\\n raise AlignError()\\n return sandwich_pairs\",\n \"def create_model():\\n # Get list of all syllables: [\\\"<s>\\\", \\\"AH\\\", \\\"</s>\\\", \\\"<s>\\\", \\\"T\\\", ...]\\n syllabifier = Syllabifier()\\n all_syllables = syllabifier.all_syllables()\\n\\n # Count conditional probabilties of phoneme tuples\\n tcf = TrigramCollocationFinder.from_words(all_syllables)\\n bcf = BigramCollocationFinder.from_words(all_syllables)\\n tri_dict = dict(sorted(tcf.ngram_fd.items(), key=lambda t: (-t[1], t[0])))\\n bi_dict = dict(sorted(bcf.ngram_fd.items(), key=lambda t: (-t[1], t[0])))\\n\\n # Create dictionary to count cond prob all phoneme tuples\\n accepted_phonemes = [i[0] for i in cmudict.phones()]\\n accepted_phonemes.append('<s>')\\n accepted_phonemes.append('</s>')\\n phoneme_tups = [p for p in itertools.product(accepted_phonemes, repeat=3)]\\n cond_probs_dict = dict([(char, 0) for char in phoneme_tups])\\n\\n for t in tri_dict:\\n p1, p2, p3 = t[0], t[1], t[2]\\n tri_count = tri_dict[t]\\n bi_count = bi_dict[(p1, p2)]\\n if bi_count > 1:\\n cond_prob = tri_count * 1.0 / bi_count\\n else:\\n cond_prob = 0.0\\n cond_probs_dict[(p1, p2, p3)] = cond_prob\\n\\n pickle.dump(cond_probs_dict, open(COND_PROBS_PATH, \\\"wb\\\"))\\n return\",\n \"def equalize(pair, bias_axis, word_to_vec_map):\\n\\n ### START CODE HERE ###\\n # Step 1: Select word vector representation of \\\"word\\\". Use word_to_vec_map. (≈ 2 lines)\\n w1, w2 = pair\\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\\n\\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\\n mu = (e_w1 + e_w2) / 2\\n\\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n mu_orth = mu - mu_B\\n\\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n\\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\\n\\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\\n e1 = corrected_e_w1B + mu_orth\\n e2 = corrected_e_w2B + mu_orth\\n\\n ### END CODE HERE ###\\n\\n return e1, e2\",\n \"def w_mark2_gen(w_amount, w_length, dict_2_let):\\r\\n nword_list_m2 = []\\r\\n for i in range(w_amount):\\r\\n rand_2_let = rand_let_gen(dict_2_let)\\r\\n nword = \\\"\\\".join(rand_2_let)\\r\\n i = 0\\r\\n while len(nword) != w_length:\\r\\n prefix = nword[i:i+2:1]\\r\\n if dict_2_let.get(prefix) != None:\\r\\n nword += (dict_2_let[prefix][0])\\r\\n i += 1\\r\\n else:\\r\\n i = 0\\r\\n rand_2_let = rand_let_gen(dict_2_let)\\r\\n nword_list_m2.append(nword)\\r\\n return nword_list_m2\",\n \"def find_pairs(words): \\n pass\",\n \"def train():\\n\\tA = collections.defaultdict(dict)\\n\\tB = collections.defaultdict(dict)\\n\\tpos_list = []\\n\\tword_list = []\\n\\tstr_buf = []\\n\\n\\n\\t# read each line and count A and B\\n\\tfor line in sys.stdin:\\n\\t\\tline = line.split()\\n\\t\\t# print(line)\\n\\t\\tif len(line) == 3:\\n\\t\\t\\tstr_buf.append((str(line[0]), str(line[1])))\\n\\t\\t\\tword_list.append(str(line[0]))\\n\\t\\t\\tpos_list.append(str(line[1]))\\n\\n\\t\\telse:\\n\\t\\t\\t# if come to the end of a sentence\\n\\t\\t\\tif len(str_buf) != 0:\\n\\t\\t\\t\\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\\n\\t\\t\\t\\tword_list += ['<s>', '</s>']\\n\\t\\t\\t\\tpos_list += ['BOS', 'EOS']\\n\\n\\t\\t\\t\\tfor i, s in enumerate(str_buf):\\n\\t\\t\\t\\t\\tif s[0] in B[s[1]]:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] = 1\\n\\n\\t\\t\\t\\t\\tif s[0] != '</s>':\\n\\t\\t\\t\\t\\t\\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\\n\\t\\t\\t\\t\\t\\tif str_buf[i+1][1] in A[s[1]]:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] = 1\\n\\n\\t\\t\\t\\tstr_buf = []\\n\\n\\t# get unique POS list and word list\\n\\tpos_list_uniq = list(set(pos_list))\\n\\tword_list_uniq = list(set(word_list))\\n\\n\\n\\t# assume <UNK>, smoothing, normalize\\n\\tB_sm = collections.defaultdict(dict)\\n\\tA_sm = A.copy()\\n\\n\\t# assume words apeear less than 2 times as <UNK>\\n\\tword_count = collections.Counter(word_list)\\n\\tfor pos in B:\\n\\t\\tfor word in B[pos]:\\n\\t\\t\\tif word_count[word] > 1:\\n\\t\\t\\t\\tB_sm[pos][word] = B[pos][word]\\n\\n\\t\\t\\telse: # add <UNK> to B_sm\\n\\t\\t\\t\\tword_list_uniq.remove(word)\\n\\t\\t\\t\\tif '<UNK>' in B_sm[pos]:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] += 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] = 1\\n\\n\\tword_list_uniq += ['<UNK>']\\n\\n\\t# add 1 smoothing\\n\\tfor pos in pos_list_uniq:\\n\\t\\tfor word in word_list_uniq:\\n\\t\\t\\tif word in B_sm[pos]:\\n\\t\\t\\t\\tB_sm[pos][word] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tB_sm[pos][word] = 1\\n\\n\\tfor prev in pos_list_uniq:\\n\\t\\tfor next in pos_list_uniq:\\n\\t\\t\\tif next in A_sm[prev]:\\n\\t\\t\\t\\tA_sm[prev][next] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tA_sm[prev][next] = 1\\n\\n\\t# delete instances like A[VB][BOS], A[EOS][VB],\\n\\t# B[VB]['</s>'], B[EOS]['Jack']\\n\\n\\tfor pos in B_sm:\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif (pos == 'BOS' and word != '<s>') or \\\\\\n\\t\\t\\t(pos == 'EOS' and word != '</s>') or \\\\\\n\\t\\t\\t(word == '<s>' and pos != 'BOS') or \\\\\\n\\t\\t\\t(word == '</s>' and pos != 'EOS'):\\n\\t\\t\\t\\tB_sm[pos][word] = 0\\n\\n\\tfor prev in A_sm:\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif prev == 'EOS' or next == 'BOS':\\n\\t\\t\\t\\tA_sm[prev][next] = 0\\n\\n\\t# normalize\\n\\tfor pos in B_sm:\\n\\t\\ts = sum(B_sm[pos].values())\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif B_sm[pos][word] != 0:\\n\\t\\t\\t\\tB_sm[pos][word] /= s\\n\\n\\tfor prev in A_sm:\\n\\t\\ts = sum(A_sm[prev].values())\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif A_sm[prev][next] != 0:\\n\\t\\t\\t\\tA_sm[prev][next] /= s\\n\\n\\treturn A_sm, B_sm, word_list_uniq\",\n \"def bpe(self, word: List[str]) -> List[str]:\\n pairs = self.get_pairs(word)\\n\\n if len(pairs) == 0:\\n return word\\n\\n while True:\\n min_rank = self.bpe_ranks.get('\\\\n'.join(pairs[0]), float('inf'))\\n bigram = pairs[0]\\n for pair in pairs[1:]:\\n current_rank = self.bpe_ranks.get('\\\\n'.join(pair), float('inf'))\\n if current_rank < min_rank:\\n min_rank = current_rank\\n bigram = pair\\n if '\\\\n'.join(bigram) not in self.bpe_ranks:\\n break\\n first, second = bigram\\n new_word: List[str] = []\\n i = 0\\n while i < len(word):\\n found = False\\n for j in range(i, len(word)):\\n if word[j] == first:\\n new_word.extend(word[i:j])\\n i = j\\n found = True\\n break\\n if not found:\\n new_word.extend(word[i:])\\n break\\n\\n if word[i] == first and i < len(word) - 1 and word[i + 1] == second:\\n new_word.append(first + second)\\n i += 2\\n else:\\n new_word.append(word[i])\\n i += 1\\n word = new_word.copy()\\n if len(word) == 1:\\n break\\n else:\\n pairs = self.get_pairs(word)\\n return word\",\n \"def create_bow(sentences, vocab=None, msg_prefix=\\\"\\\\n\\\"):\\n print(\\\"{} Bow construction\\\".format(msg_prefix))\\n tokens_per_sentence = preprocess_and_split_to_tokens(sentences)\\n if vocab is None:\\n print(\\\"{} Vocab construction\\\".format(msg_prefix))\\n flattened_list = [y for x in tokens_per_sentence for y in x]\\n flattened_set_list = list(set(flattened_list))\\n vocab = {k:v for v,k in enumerate(flattened_set_list)}\\n bow_array = []\\n for sentence_word_list in tokens_per_sentence:\\n bow_array_one = [0] * len(vocab)\\n for word in sentence_word_list:\\n if vocab.get(word) is not None:\\n bow_array_one[vocab[word]] += 1\\n bow_array.append(bow_array_one)\\n return (vocab, bow_array)\",\n \"def make_chains(markov_chains, clean_words):\\n\\n for i in range(len(clean_words)-2):\\n\\n tuple_words = (clean_words[i], clean_words[i+1])\\n value = clean_words[i+2]\\n\\n if tuple_words not in markov_chains:\\n markov_chains[tuple_words] = [value]\\n else:\\n markov_chains[tuple_words].append(value)\\n\\n return markov_chains\",\n \"def viterbi(sent, dqml, eqml, S, V_CASE=-1):\\n\\n if type(sent) is list:\\n sent_words = sent\\n else:\\n sent_words = word_tokenize(sent)\\n n = len(sent_words)\\n\\n # define and initialize PI table\\n pi = defaultdict(Counter)\\n pi[0]['*'] = 1\\n bp = {}\\n\\n for k in range(1, n+1):\\n bp[k] = {}\\n for v in S:\\n eml = compute_eml(V_CASE, eqml, k, sent_words, v)\\n if k-1 is 0: # w e S_0 -> w = '*'\\n qmlr = compute_qml(dqml, v, '*')\\n pival = pi[0]['*'] * qmlr * eml\\n pi[k][v] = pival\\n bp[k][v] = '*'\\n else: # for w e S_k, S_k = S\\n max_S = None\\n max_w = -1\\n for w in S:\\n qmlr = compute_qml(dqml, v, w)\\n currmax = pi[k-1][w] * qmlr * eml\\n if currmax > 0 and currmax > max_w:\\n max_w = currmax\\n max_S = w\\n # if word is unknown use tag 'NN'\\n if max_S is None:\\n max_w = 0.0\\n max_S = UNKNOWN_TAG\\n pi[k][v] = max_w\\n bp[k][v] = max_S\\n\\n # calculate y_n\\n max_y = -1\\n yn = None\\n for v in S:\\n nextmax = pi[n][v] * compute_propability('STOP', v, dqml)\\n if nextmax > max_y:\\n max_y = nextmax\\n yn = v\\n\\n # calculate y_n-1....y1\\n yk1 = yn\\n tagSequence = list()\\n tagSequence.append(yn)\\n for k in range(n-1,0,-1):\\n yk = bp[k+1][yk1]\\n tagSequence.append(yk)\\n yk1 = yk\\n\\n tagSequence.reverse()\\n return tagSequence\",\n \"def make_bag(txt, stopw):\\n bow = re.split('\\\\s',txt.lower())\\n new_bow=[]\\n for word in bow:\\n if word not in stopw and len(word)>0 and not re.search('\\\\d',word):\\n new_bow.append(word)\\n return(new_bow)\",\n \"def sentencesToBow(documents):\\n bowSentences = []\\n dictionary = Dictionary(documents)\\n\\n numDocs = len(documents);\\n avgDocLength = sum(map(len, documents))/numDocs\\n for document in documents:\\n bowSentence = []\\n docLength = len(document)\\n bowDoc = dictionary.doc2bow(document)\\n for bowTerm in bowDoc:\\n\\n docTermFreq = bowTerm[1]\\n termDocFreq = dictionary.dfs[bowTerm[0]]\\n\\n termWeight = docTermWeight(docTermFreq, termDocFreq, docLength, avgDocLength, numDocs, k=5, b=0.1)\\n newBowTerm = (bowTerm[0], termWeight)\\n bowSentence.append(newBowTerm)\\n\\n bowSentences.append(bowSentence)\\n\\n return bowSentences, dictionary\",\n \"def generate_words(combo,scrabble_words_dict):\\n word_set = set()\\n for w in itertools.permutations(combo):\\n word = ''.join(w)\\n if word in scrabble_words_dict:\\n word_set.add(word)\\n return word_set\",\n \"def createTableBOW(self,DBcursor):\\n sql=\\\"create table if not exists BOW (bow_id INTEGER PRIMARY KEY, word TEXT, word_count INTEGER);\\\"\\n DBcursor.execute(sql)\",\n \"def make_bprod(self):\\n rhs1 = random.choice(self.nonterminals)\\n rhs2 = random.choice(self.nonterminals)\\n lhs = random.choice(self.nonterminals)\\n return (lhs, (rhs1, rhs2))\",\n \"def _gen_words(sentence, labels):\\r\\n word = \\\"\\\"\\r\\n words = []\\r\\n for token, label in zip(sentence, labels):\\r\\n word += token\\r\\n if label in [1, 3]:\\r\\n words.append(word)\\r\\n word = \\\"\\\"\\r\\n return words\",\n \"def createTableBOW(self,DBcursor):\\n sql=\\\"create table if not exists BOW (bow_id INTEGER PRIMARY KEY, word TEXT, total_count INTEGER, netloc_count INTEGER, path_count INTEGER, params_count INTEGER, query_count INTEGER, fragment_count INTEGER);\\\"\\n DBcursor.execute(sql)\",\n \"def feature_extraction_letters_pairs(name, B=676):\\n v = np.zeros(B)\\n i = 0\\n \\n ken = np.zeros((26,26))\\n while (i<(len(name)-1)):\\n zep = ord(name[i])-97\\n zap = ord(name[i+1])-97\\n ken[zep][zap] = ken[zep][zap] + 1\\n i = i+1\\n v = ken.flatten()\\n return v\",\n \"def viterbi_bigrams(transition_probabilities, label_matches, prev_tag, word, tag_possibilities):\\r\\n\\tmax_prob = 0\\r\\n\\tbest_tag = \\\"\\\"\\r\\n\\ttag_counts = get_tag_counts(label_matches)\\r\\n\\tfor tag in tag_possibilities:\\r\\n\\t\\temissions_probability = get_emissions_probability(label_matches, tag, word, tag_counts)\\r\\n\\t\\ttag_bigram = (prev_tag,tag)\\r\\n\\t\\ttransition_probability = transition_probabilities.get(tag_bigram, 0.000027)\\r\\n\\t\\tprob = emissions_probability * transition_probability\\r\\n\\t\\tif prob > max_prob:\\r\\n\\t\\t\\tmax_prob = prob\\r\\n\\t\\t\\tbest_tag = tag\\r\\n\\tif best_tag == \\\"\\\":\\r\\n\\t\\tbest_tag = \\\"o\\\"\\r\\n\\treturn best_tag\",\n \"def getBiwords(self, words):\\n bigrams_val = nltk.bigrams(words)\\n biwords = []\\n for word in bigrams_val:\\n biwords.append(word)\\n return biwords\",\n \"def crossword_words(crossword: list) -> list:\\n pass\",\n \"def generate_words(self,N):\\n for i in xrange(N):\\n prefix = \\\" \\\" * self.chainlen\\n name = \\\"\\\"\\n suffix = \\\"\\\"\\n while True:\\n suffix = self.get_suffix(prefix)\\n if suffix == \\\"\\\\n\\\" or len(name) > 9:\\n break\\n else:\\n name = name + suffix\\n prefix = prefix[1:] + suffix\\n yield name.capitalize()\",\n \"def make_text(chains):\\n\\n upper_keys = []\\n \\n for key in chains:\\n if key[0][0].isupper():\\n upper_keys.append(key)\\n\\n key = choice(upper_keys)\\n # key = choice(chains.keys())\\n words = []\\n words.append(key[0])\\n words.append(key[1])\\n word = choice(chains[key])\\n words.append(word)\\n new_key = (key[1], word)\\n \\n while new_key in chains and len(words) < 140:\\n word = choice(chains[new_key])\\n words.append(word)\\n new_key = (new_key[1], word)\\n if not word[-1].isalpha():\\n break\\n \\n\\n\\n return \\\" \\\".join(words)\",\n \"def co_gram(sa, sb):\\n gram = [(wa, wb) for wa in sa for wb in sb]\\n return gram\",\n \"def generate_word(self, length=7, upper=True):\\n \\n word = self._weighted_choice(self.beginning_freqs)\\n\\n if word[0] in self.vowels:\\n offset = 0\\n else:\\n offset = 1\\n \\n for i in range(offset, length+offset):\\t\\t\\t\\n if i%2 ==0:\\n word += self._weighted_choice(self.consonant_freqs)\\n else:\\n word += self._weighted_choice(self.vowel_freqs)\\n \\n if upper:\\n word = word[:1].upper() + word[1:]\\n \\n if word.lower() in self.blacklist:\\n # recurse and find another word\\n return self.generate_word(length, upper)\\n \\n return word\",\n \"def _choose_babble_phrases(self) -> tuple:\\n noun_choices = ('singular nouns', 'plural nouns')\\n noun_choice = self.random_element(noun_choices)\\n\\n adjective_choices = (\\n 'adjectives starting with consonant',\\n 'adjectives starting with vowel')\\n\\n if noun_choice == 'singular nouns':\\n article_choice = self.random_element(self.article_choices)\\n else:\\n article_choice = 'the'\\n\\n if article_choice == 'an':\\n adjective_choice = 'adjectives starting with vowel'\\n elif article_choice == 'a':\\n adjective_choice = 'adjectives starting with consonant'\\n else:\\n adjective_choice = self.random_element(adjective_choices)\\n\\n return (\\n self.technobabble['verbs'],\\n article_choice,\\n self.technobabble[adjective_choice],\\n self.technobabble[noun_choice])\",\n \"def make_chains(text_string):\\n\\n chains = {}\\n #create an empty dictionary\\n words = text_string.split()\\n #make text into string and then splitting it\\n \\n for i in range(len(words)-2):\\n #for every word in string except for last two words\\n bi_gram = (words[i], words[i + 1])\\n #created key variable into tuple using two adjacent words\\n if bi_gram in chains:\\n # if the key is in the dictionary add the next word into list of values/words\\n chains[bi_gram].append(words[i+2])\\n else:\\n # if word is not already in dictionary, create the list where word is placed\\n chains[bi_gram] = [words[i+2]]\\n #defining variable for last key/tuple \\n last_bi_gram = (words[-2],words[-1])\\n #if it is the last bi_gram in dictionary, add None as a value in list of words else add none/ nothing\\n if last_bi_gram in chains:\\n chains[last_bi_gram].append(None)\\n else:\\n chains[last_bi_gram] = [None]\\n\\n return chains\",\n \"def learn_bpe(strings: List[str], pair_percent_threshold: float, char_percent_threshold:float, with_position:bool) -> dict:\\n\\n vocab = get_vocab(strings)\\n percent = 1.0\\n # 待改进，这里如果 pair_percent_threshold <=0，则会死循环\\n while percent >= pair_percent_threshold:\\n pair2freq = pair_freq_stats(vocab, with_position)\\n best = max(pair2freq, key=pair2freq.get)\\n percent = pair2freq.get(best) / len(strings)\\n if percent >= pair_percent_threshold:\\n vocab = merge_vocab(best, vocab, with_position)\\n\\n bpe_tokens = get_tokens(vocab, pair_percent_threshold, len(strings), char_percent_threshold, with_position)\\n if with_position:\\n bpe_tokens = sorted(bpe_tokens, key=lambda x: len(x[0]), reverse=True)\\n else:\\n bpe_tokens = sorted(bpe_tokens, key=len, reverse=True)\\n bpe_token_dict = {'with_position':with_position,\\n 'tokens': bpe_tokens}\\n return bpe_token_dict\",\n \"def make_inferences(self,KB):\\n applied_rules={}\\n KB=list(KB)\\n for knowledge in KB:\\n applied_rules[knowledge]=[knowledge]\\n for antedecent,consequent in self.implication_rules.items(): #split in antedecent and consequent\\n if type(knowledge)==str:\\n if knowledge == antedecent: #if knowledge is the antedecent of the rule\\n for v in consequent:\\n applied_rules[antedecent]=consequent\\n KB.append(v)\\n \\n \\n elif knowledge in antedecent:\\n atoms=antedecent.split(\\\",\\\")\\n \\n if (set(atoms) & set(KB) == set(atoms)):\\n applied_rules[antedecent]=consequent\\n KB.extend(consequent)\\n return applied_rules,set(KB)\",\n \"def proc_sandwich(word, forward_pairs, uni_word, morphs, backward_pairs):\\n sandwich_pairs = []\\n if uni_word and morphs:\\n sandwich_pairs = proc_sw_both_not_empty(forward_pairs, uni_word, morphs, backward_pairs)\\n elif uni_word:\\n sandwich_pairs = proc_sw_only_word(word, uni_word, backward_pairs)\\n elif morphs:\\n sandwich_pairs = proc_sw_only_morphs(forward_pairs, morphs, backward_pairs)\\n return sandwich_pairs\",\n \"def surface_segment_data_preparation(word_dictionary: {str, str}):\\n X = []\\n Y = []\\n words = []\\n for word in word_dictionary:\\n word_list = []\\n word_label_list = []\\n for i in range(len(word)):\\n gram_dict = {}\\n gram_arr = []\\n\\n ### Unigram\\n # gram_dict[word[i]] = 1\\n gram_dict[\\\"uni_\\\" + word[i]] = 1\\n gram_arr.append(word[i])\\n\\n ### BIGRAM\\n try:\\n tmp = word[i - 1: i + 1]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 2:\\n gram_dict[\\\"bi_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n try:\\n tmp = word[i: i + 2]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 2:\\n gram_dict[\\\"bi_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n ### TRIGRAM\\n try:\\n tmp = word[i - 1: i + 2]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 3:\\n gram_dict[\\\"tri_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n ## FourGram\\n try:\\n tmp = word[i - 1: i + 3]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 4:\\n gram_dict[\\\"four_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n try:\\n tmp = word[i - 2: i + 2]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 4:\\n gram_dict[\\\"four_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n ## FiveGram\\n try:\\n tmp = word[i - 2: i + 3]\\n if tmp:\\n # gram_dict[tmp] = 1\\n if len(tmp) == 5:\\n gram_dict[\\\"five_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n ## SixGram\\n try:\\n tmp = word[i - 3: i + 3]\\n if tmp:\\n if len(tmp) == 6:\\n # gram_dict[tmp] = 1\\n gram_dict[\\\"six_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n try:\\n tmp = word[i - 2: i + 4]\\n if tmp:\\n if len(tmp) == 6:\\n # gram_dict[tmp] = 1\\n gram_dict[\\\"six_\\\" + tmp] = 1\\n gram_arr.append(tmp)\\n except IndexError:\\n continue\\n\\n if word[i] in 'aeiou':\\n gram_dict[\\\"vowel\\\"] = 1\\n else:\\n gram_dict[\\\"const\\\"] = 1\\n\\n if word[i].isupper():\\n gram_dict[\\\"upper\\\"] = 1\\n else:\\n gram_dict[\\\"lower\\\"] = 1\\n\\n word_list.append(gram_dict)\\n word_label_list.append(word_dictionary[word][i])\\n\\n X.append(word_list)\\n Y.append(word_label_list)\\n words.append([char for char in word])\\n return X, Y, words\",\n \"def make_text(chains):\\n\\n #current key is equal to a random key in the dictionary\\n current_key = choice(chains.keys())\\n #text is a string equal to the first index of the tuple and the second index of the tuple\\n text = current_key[0] + \\\" \\\" + current_key[1]\\n #create a loop that will repeat until the function reaches the last bi-gram\\n while True:\\n #created a variable for a random value of the current key\\n chosen_word = choice(chains[current_key])\\n #equivalent to: if chosen_word is None\\n if not chosen_word:\\n break\\n # if it's not the last key add the chosen_word to the text to string\\n text = text + \\\" \\\" + chosen_word\\n # select new key\\n current_key = (current_key[1], chosen_word)\\n \\n return text\",\n \"def make_text(chains):\\n words = []\\n not_end_of_list = True\\n # your code goes here\\n \\n # starts with a capital lettered word from source text\\n capitalized_ngrams = []\\n for key in chains.keys():\\n # check if the first tuple in key[0][0]\\n if key[0][0].isupper():\\n capitalized_ngrams.append(key)\\n \\n \\n\\n selected_keys = list(capitalized_ngrams)\\n count = 0\\n while not_end_of_list:\\n choice_n = choice(selected_keys)\\n\\n if count == 0:\\n words.extend(choice_n)\\n \\n if chains[choice_n] and count <= 150:\\n # as long as there is an option, picks a random element from dict list\\n choose_next = choice(chains[choice_n])\\n # adds new word to list\\n words.append(choose_next)\\n # creates a list of keys whose last item in tuple is item from list\\n selected_keys = [x for x in chains.keys() if x == tuple([*choice_n[1:], choose_next])]\\n # it is possible continues\\n if selected_keys:\\n pass\\n else:\\n not_end_of_list = False\\n\\n count += 1\\n \\n else:\\n not_end_of_list = False\\n\\n return \\\" \\\".join(words)\",\n \"def make_text(chains, n_gram):\\n words = []\\n\\n link_key = choice(chains.keys())\\n\\n\\n while True:\\n if link_key[0] != link_key[0].capitalize():\\n link_key = choice(chains.keys())\\n else:\\n break\\n #have random key from our dict\\n\\n words = list(link_key)\\n\\n while link_key in chains.keys():\\n next_word = choice(chains[link_key])\\n\\n words.append(next_word)\\n\\n next_key = list(link_key[1:]) + [next_word]\\n\\n link_key = tuple(next_key)\\n\\n return \\\" \\\".join(words)\",\n \"def get_searched_pair_words(self):\\n words = [word for word in self.searched_words if \\\" \\\" in word]\\n return [Word(word).singularize() for word in words]\",\n \"def generate_words(num_words, word_len, grid, reject_func=is_overlapping):\\n height, width = len(grid), len(grid[0])\\n restrictions = position_restrictions(word_len, height, width)\\n word_hashes = set()\\n words_positions = []\\n words = []\\n while len(word_hashes) < num_words:\\n cardinal = random.choice(list(restrictions.keys()))\\n (min_h, max_h), (min_w, max_w) = restrictions[cardinal]\\n x0, y0 = random.randint(min_h, max_h), random.randint(min_w, max_w)\\n x, y = DIRECTIONS[cardinal]\\n positions = [(x0 + x * i, y0 + y * i) for i in range(word_len)]\\n if (word_hash := (cardinal, (x0, y0))) not in word_hashes \\\\\\n and not reject_func(p_set := set(positions), words_positions):\\n words.append(\\\"\\\".join(str(grid[x][y]) for x, y in positions))\\n word_hashes.add(word_hash)\\n words_positions.append(p_set)\\n return words\",\n \"def create_word(self):\\r\\n\\r\\n template = self.word_constructions.get()\\r\\n word = \\\"\\\"\\r\\n for c in template:\\r\\n if c == \\\"v\\\":\\r\\n letter = self.get_letter(100)\\r\\n else:\\r\\n letter = self.get_letter(0)\\r\\n word += letter\\r\\n\\r\\n while not any(letter in self.vowels for letter in word):\\r\\n length = len(word)\\r\\n if length == 1:\\r\\n index = 0\\r\\n elif length == 2:\\r\\n index = random.randrange(0, 2)\\r\\n else:\\r\\n a = len(word) / 2\\r\\n index = a + random.randrange(-a / 2, a / 2)\\r\\n word = word[:index] + self.get_letter(100) + word[index + 1:]\\r\\n\\r\\n if random.random() > self.capital_chance:\\r\\n word = word.capitalize()\\r\\n self.words.append(word)\\r\\n self.word_count += 1\\r\\n return word\",\n \"def find_words(text):\\n print \\\"finding combinations\\\"\\n length = len(text)\\n n = length - 1\\n num_combos = 2 ** (length - 1)\\n\\n bins = []\\n for i in range(num_combos):\\n num = bin(i).rsplit('b', 1)[1]\\n num_str = num.zfill(n)\\n bins.append(num_str)\\n\\n total_combos = []\\n for binary_num in bins:\\n combo = []\\n for i in range(n):\\n if binary_num[i] == '1':\\n combo.append(text[i])\\n combo.append(',')\\n else:\\n combo.append(text[i])\\n\\n combo.append(text[-1])\\n combo = ''.join(combo)\\n combo = combo.split(',')\\n total_combos.append(combo)\\n\\n return total_combos\",\n \"def dictionary(word_list):\\n word_list.append(\\\"\\\")\\n for i in range(len(word_list)-2):\\n prob_dict.setdefault(word_list[i], []).append(word_list[i+1])\",\n \"def make_text(chains):\\n\\n text = []\\n nchars = 0\\n\\n # Starting ngram (as tuple), first word in tuple must be uppercase\\n start = choice(get_uppercase(chains))\\n\\n # Add starting ngram to text list\\n text.extend(start)\\n\\n # Add length of words in first bigram and two spaces to nchars\\n nchars += len(start[0]) + len(start[1]) + 2\\n\\n while nchars < 119:\\n # Choose next word randomly from list\\n new_word = choice(chains[start])\\n\\n # add length of new word to nchars\\n # add one for space between words\\n nchars += len(new_word) + 1\\n\\n if nchars > 120:\\n break\\n else:\\n # Add new word to text list\\n text.append(new_word)\\n\\n # Generate tuple for next ngram\\n new_key = start[1:] + (new_word,)\\n\\n # Break out of loop if bigram doesn't exist\\n if new_key in chains:\\n start = new_key\\n else:\\n break\\n\\n text.append(\\\"#hackbrightgracejan17\\\")\\n\\n # Find last sentence punctuation in text\\n text_string = ' '.join(text)\\n\\n # period = text_string.rfind('.')\\n # exclamation = text_string.rfind('!')\\n # question = text_string.rfind('?')\\n\\n # largest = max(period, exclamation, question)\\n\\n # # Remove everything after the last punctuation, if there is anything\\n # if len(text_string) == largest+1:\\n # return text_string\\n # else:\\n # return text_string[:largest+1]\\n\\n return text_string\",\n \"def smooth_tag_model(cls, heldout_data):\\n\\n # bi_transition_counts = defaultdict(int)\\n n = 0 # count word-tags\\n e = .0001 # stopping condition\\n L = [.25, .25, .25, .25] # initialize lambdas uniformly\\n i = 1 # iteration\\n while True:\\n # E Step (Step 1)\\n # Iterate through all occurring trigrams\\n # in the heldout.txt data (H), i.e. minimizing\\n # log likelihood\\n counts = [0, 0, 0, 0]\\n ratio = [0, 0, 0, 0]\\n nextL = 4 * [0] # next lambda\\n\\n for sent in heldout_data:\\n\\n # Handle beginning of sentence\\n t = '<s>'\\n u = '<s>'\\n # bi_transition_counts[t, u] += 1\\n\\n # if first == '<s>' and second == '<s>': # add bigram for nulls\\n\\n for word, tag in sent:\\n v = tag\\n # tri_transitions[t, u, v] += 1\\n # bi_transitions[u, v] += 1\\n # # if first == '<s>' and second == '<s>': # add bigram for nulls\\n # # tagger._bi_transitions[('<s>', '<s>')] += 1\\n # uni_transitions[v] += 1\\n # cls._emissions[word, tag] += 1\\n # tags.add(v)\\n # words.add(word)\\n # uni_words[word] += 1\\n\\n\\n # Calculate expected counts of lambdas\\n ratio = cls.calc_tag_ratio(t, u, v, L)\\n\\n # M-step (Step 2)\\n # Calculate expected counts of lambdas, i.e. weight, taking\\n # into account the number of occurrences of each trigram (cnt)\\n for j in range(len(L)):\\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\\n\\n t = u\\n u = v\\n # n += 1\\n\\n # Handle end of sentence\\n # tri_transitions[t, u, '</s>'] += 1\\n v = '</s>'\\n ratio = cls.calc_tag_ratio(t, u, v, L)\\n for j in range(len(L)):\\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\\n\\n # cls._bi_transitions[first, second] += 1\\n # cls._tri_transitions[second, '</s>', '</s>'] += 1\\n\\n\\n # Update values for parameters given current distribution\\n for k in range(len(L)):\\n total = np.sum(counts)\\n nextL[k] = counts[k] / total # next lambda\\n\\n # Check if lambda values have converged\\n converged = True\\n for l in range(len(L)):\\n if np.abs(nextL[l] - L[l]) > e: # tolerance = e\\n converged = False\\n L = nextL\\n\\n # Return values if lambdas have converged\\n if converged:\\n break\\n\\n i += 1 # increment iteration counter\\n\\n\\n return L # copy lambdas passed by reference\",\n \"def tag_word(self, words):\\n self.j += 1\\n self.i = self.j - 1\\n self.matrix[self.i][self.j] = {}\\n\\n possible_tags = self.grammar.productions(rhs=words[self.j - 1])\\n\\n if not possible_tags:\\n possible_tags = self.grammar.productions(rhs=\\\"UNK\\\")\\n\\n for rule in sorted(possible_tags, key=lambda x: x.prob()):\\n lhs = rule.lhs().symbol()\\n self.matrix[self.i][self.j][lhs] = (log(rule.prob()), Tree(lhs, [words[self.j - 1]]))\",\n \"def generate_solutions(possible_words, labels):\\r\\n return []\",\n \"def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\\n\\tglobal alpha, beta, gamma\\n\\n\\t#Standard Bayesian\\n\\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\\n\\t# muNew = u1 + u2\\n\\t# return muNew, sigNew \\n\\n\\t##In accordance with the nature papers:\\n\\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\\\\n\\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\\n\\tinv1 = 1 / float((math.pow(sig1, 2)))\\n\\tinv2 = 1 / float((math.pow(sig2, 2)))\\n\\tsumInverses = inv1 + inv2\\n\\n\\t##inverse standard deviations squared\\n\\t# w1 = inv1 / float(sumInverses)\\n\\t# w2 = inv2 / float(sumInverses)\\n\\n\\t## equal weighting\\n\\t# w1 = .5\\n\\t# w2 = .5\\n\\n\\t## weightings based off of confidence\\n\\t# summation = confidence1 + confidence2\\n\\t# w1 = confidence1 / float(summation)\\n\\t# w2 = confidence2 / float(summation)\\n\\n\\t##weightings with exponentials\\n\\t# w1 = w1**.001\\n\\t# w2 = w2**.001\\n\\t# newSummation = w1 + w2\\n\\t# w1 = w1 / float(newSummation)\\n\\t# w2 = w2 / float(newSummation)\\n\\n\\t##weightings with polynomial factors\\n\\tw1 = (beta * confidence1 + alpha)**gamma \\n\\tw2 = (beta * confidence2 + alpha)**gamma \\n\\tnewSummation = w1 + w2\\n\\tw1 = w1 / float(newSummation)\\n\\tw2 = w2 / float(newSummation)\\n\\n\\tmuNew = w1 * mu1 + w2 * mu2\\n\\treturn muNew, sigNew\",\n \"def generate_words_with_scores(rack,placed_tile,scrabble_words_dict):\\n res_set = set()\\n word_score_dict = {}\\n comb_set = generate_combinations(rack,placed_tile)\\n for combo in comb_set:\\n words_set = generate_words(combo, scrabble_words_dict)\\n for word in words_set:\\n res_set.add(word)\\n for word in res_set:\\n score = calculate_score(rack,word)\\n word_score_dict[word] = score\\n return word_score_dict\",\n \"def make_chains(text_string, n_gram):\\n\\n chains = {}\\n words = text_string.split()\\n for i in range(len(words)-n_gram):\\n temp_list = []\\n for z in range(n_gram):\\n temp_list = temp_list + [words[i + z]]\\n\\n temp_tup = tuple(temp_list)\\n\\n # if temp_tup in chains:\\n # chains[temp_tup] = chains[temp_tup] + [words[i + 2]]\\n # else:\\n # chains[temp_tup] = [words[i + 2]]\\n chains.setdefault(temp_tup, [])\\n chains[temp_tup].append(words[i + n_gram])\\n #chains[temp_tup] = chains.get(temp_tup, []) + [words[i + 2]]\\n print chains\\n return chains\",\n \"def poly_desc(W, b):\\n result = 'y = '\\n for i, w in enumerate(W):\\n result += '{:+.2f} x^{} '.format(w, len(W) - i)\\n result += '{:+.2f}'.format(b[0])\\n return result\",\n \"def make_text(chains):\\n\\n words = []\\n\\n # Set random tuple to variable key\\n key = choice(chains.keys())\\n\\n\\n # First time through key in chains, unpack X - a tuple - to get \\n # key[0], key[1] = key\\n # print key0]\\n # print key[2]\\n # Append key[0], key[1] to words\\n\\n words.append(key[0])\\n words.append(key[1])\\n\\n # While tuple is a key in chains, keep looping \\n while key in chains:\\n\\n # Randomly choose a value from chains\\n word = choice(chains[key])\\n\\n # Append word to words\\n words.append(word)\\n\\n key = (key[1], word)\\n\\n # return \\\" \\\".join(words)\\n\\n # define variable of returned \\\" \\\".join(words) as markov-tweet\\n markov_tweet = \\\" \\\".join(words)\\n\\n return markov_tweet\",\n \"def Viterbi(words:Sequence[str], train_bag:Sequence[Tuple[str, str]]=train_tagged_words)-> Sequence[Tuple[str, str]]:\\n state = []\\n tags_set = list(set([pair[1] for pair in train_bag]))\\n\\n for key, word in enumerate(words):\\n # initialise list of probability column for a given observation\\n p = []\\n for tag in tags_set:\\n if key == 0:\\n transition_p = tags_df.loc['.', tag]\\n else:\\n transition_p = tags_df.loc[state[-1], tag]\\n\\n # compute emission and state probabilities\\n emission_p_parts = word_given_tag(word, tag)\\n emission_p = emission_p_parts[0]/emission_p_parts[1]\\n state_probability = emission_p * transition_p\\n p.append(state_probability)\\n\\n p_max = max(p)\\n # getting state for which probability is maximum\\n state_max = tags_set[p.index(p_max)]\\n state.append(state_max)\\n return list(zip(words, state))\",\n \"def viterbi_segment(text, P):\\n # best[i] = best probability for text[0:i]\\n # words[i] = best word ending at position i\\n n = len(text)\\n words = [''] + list(text)\\n best = [1.0] + [0.0] * n\\n\\n # Fill in the vectors best, words via dynamic programming\\n for i in range(n + 1):\\n for j in range(0, i):\\n w = text[j:i]\\n if P[w] * best[i - len(w)] >= best[i]:\\n best[i] = P[w] * best[i - len(w)]\\n words[i] = w\\n\\n # Now recover the sequence of best words\\n sequence = [];\\n i = len(words) - 1\\n while i > 0:\\n sequence[0:0] = [words[i]]\\n i = i - len(words[i])\\n\\n # Return sequence of best words and overall probability\\n return sequence, best[-1]\",\n \"def make_chains(word_list):\\n\\n chains = {}\\n for index in range(0, len(word_list) - 2):\\n # only making small chains because I like maximum absurdity\\n key = tuple(word_list[index:index + 2])\\n if key not in chains:\\n chains[key] = [word_list[index + 2]]\\n else:\\n chains[key].append(word_list[index + 2])\\n return chains\",\n \"def pairwise_tokenize(sentence,w2v,remove_stopwords=True):\\n\\n ignore_words = stopwords.words('english')\\n\\n #Remove non-alphanumeric\\n pattern = re.compile('[\\\\W_]+') \\n sentence = pattern.sub(\\\" \\\",sentence) \\n sentence = sentence.strip()\\n words = sentence.split(\\\" \\\")\\n\\n compound_word_idx = []\\n a_idx = 0\\n for a,b in pairwise(words):\\n combined = a +\\\"_\\\" + b\\n try:\\n w2v[combined]\\n compound_word_idx.append(a_idx) #append the index of the 1st compound word\\n a_idx += 1\\n except KeyError:\\n a_idx += 1\\n\\n for idx in compound_word_idx:\\n words[idx] = words[idx] + \\\"_\\\" + words[idx + 1] #compound_word_idx stores index of 1st word, so combine with the next word\\n\\n #This cannot be combined into another loop to maintain where indices point\\n for idx in reversed(compound_word_idx):\\n words.pop(idx+1)\\n\\n if remove_stopwords == True:\\n filtered = []\\n for word in words:\\n word = word.decode(\\\"utf-8\\\")\\n if word not in ignore_words:\\n filtered.append(word)\\n\\n words = filtered\\n\\n return words\",\n \"def make_text(chains):\\n\\n # your code goes here\\n n_gram = tuple(choice(chains['START']))\\n words = [word for word in n_gram]\\n\\n while n_gram in chains:\\n\\n next_word = choice(chains[n_gram])\\n if next_word == 'EOF':\\n break\\n words.append(next_word)\\n\\n n_gram = list(n_gram)[1:]\\n n_gram.append(next_word)\\n n_gram = tuple(n_gram)\\n \\n return \\\" \\\".join(words)\",\n \"def make_chains(text_string):\\n\\n chains = {}\\n\\n words = text_string.split()\\n\\n # loop over range of length of words - 2\\n for i in range(len(words) - 2):\\n key = (words[i], words[i + 1]) # create a tuple that is the word and the word following\\n if key not in chains: # if the tuple does not exist in the dict chains:\\n chains[key] = [words[i + 2]] # add the tuple as the key and the word following the bigram as the value\\n elif key in chains: # else if tuple is in dict:\\n (chains[key]).append(words[i + 2]) # append the word following the bigram to the list that chains[key] is equal to\\n\\n return chains\",\n \"def make_chains(text_string, n):\\n \\n chains = {}\\n \\n text_string_list = text_string.split()\\n\\n\\n # Make a tuple of two adjecnt words\\n for i in range(len(text_string_list)-n):\\n chain_key = []\\n for num in range(n):\\n chain_key= text_string_list[i:i+n]\\n key_tuple = tuple(chain_key)\\n #print(key_tuple)\\n value = text_string_list[i+n]\\n #print(value)\\n if key_tuple in chains:\\n chains[key_tuple].append(value)\\n else:\\n chains[key_tuple] = [value]\\n\\n print(chains)\",\n \"def generate_text_owc(model: Dict[str, Set[str]], n: int) -> str:\\n # ACCUMULATOR: a list of the randomly-generated words so far\\n words_so_far = []\\n # We've provided this template as a starting point; you may modify it as necessary.\\n words_so_far.append(generate_new_word(model))\\n for x in range(0, n-1):\\n key = words_so_far[x]\\n new_word = generate_next_word(model,key)\\n if new_word == \\\".\\\":\\n words_so_far[x] = words_so_far[x]+'.'\\n new_word= generate_new_word(model)\\n elif new_word == {}:\\n new_word = generate_new_word(model)\\n words_so_far.append(new_word)\\n\\n return str.join(' ', words_so_far)\",\n \"def make_text(chains):\\n\\n # what word should we start on? \\\"Would you\\\"?\\n # dicitonaries are unordered, so what does \\\"first key\\\" mean?\\n # from which list you should pull out the random word?\\n\\n # key 1st word (a)\\n # key 2nd word (b)\\n # random word from value ([list]) (c)\\n # value of b, c tuple\\n\\n key_selection = choice(chains.keys())\\n\\n words = [key_selection[0], key_selection[1]]\\n\\n while key_selection in chains:\\n new_word = choice(chains[key_selection])\\n\\n words.append(new_word)\\n\\n key_selection = (key_selection[1], new_word,)\\n\\n\\n\\n # print first_word,second_word,third_word\\n\\n # random.choice(chains)\\n\\n # your code goes here\\n\\n return \\\" \\\".join(words)\",\n \"def make_text(chains, uppercase=True, break_on_first_punctuation=False, \\n character_limit=True):\\n\\n random_key = choice(chains.keys())\\n if uppercase:\\n while True:\\n if random_key[0][0].isalpha() and random_key[0][0].isupper():\\n break\\n else:\\n random_key = choice(chains.keys())\\n\\n\\n words = list(random_key)\\n #words.extend(list(random_key))\\n\\n while True:\\n random_value = choice(chains[random_key])\\n if random_value is None:\\n break \\n words.append(random_value)\\n if break_on_first_punctuation:\\n if words[-1][-1] in [\\\"?\\\", \\\".\\\", \\\":\\\", \\\"!\\\"]:\\n break \\n next_key = random_key[1:] + (random_value,)\\n random_key = next_key\\n\\n return_value = \\\" \\\".join(words)\\n \\n if character_limit:\\n tweet_custom = return_value[:140]\\n\\n for i in range(len(tweet_custom)-1, 0, -1):\\n if tweet_custom[i] in [\\\"?\\\", \\\".\\\", \\\"!\\\"]:\\n return tweet_custom[:i+1]\\n\\n\\n return return_value\",\n \"def npa_constraints(\\n assemblage: dict[tuple[int, int], cvxpy.Variable], k: int | str = 1, referee_dim: int = 1\\n) -> list[cvxpy.constraints.constraint.Constraint]:\\n a_out, a_in, b_out, b_in = _get_nonlocal_game_params(assemblage, referee_dim)\\n\\n words = _gen_words(k, a_out, a_in, b_out, b_in)\\n dim = len(words)\\n\\n r_var = cvxpy.Variable((referee_dim * dim, referee_dim * dim), PSD=True, name=\\\"R\\\")\\n # Normalization.\\n norm = sum(r_var[i * dim, i * dim] for i in range(referee_dim))\\n constraints = [norm == 1]\\n\\n seen = {}\\n for i in range(dim):\\n for j in range(i, dim):\\n w_i, w_j = words[i], words[j]\\n w_i = tuple(reversed(w_i))\\n word = _reduce(w_i + w_j)\\n\\n sub_mat = r_var[i::dim, j::dim]\\n # if i = 0 we would consider (ε, ε) as an empty word.\\n if i != 0 and _is_zero(word):\\n constraints.append(sub_mat == 0)\\n\\n elif _is_meas(word):\\n s_a, s_b = word\\n constraints.append(\\n sub_mat\\n == assemblage[s_a.question, s_b.question][\\n s_a.answer * referee_dim : (s_a.answer + 1) * referee_dim,\\n s_b.answer * referee_dim : (s_b.answer + 1) * referee_dim,\\n ]\\n )\\n\\n elif _is_meas_on_one_player(word):\\n symbol = word[0]\\n if symbol.player == \\\"Alice\\\":\\n sum_all_bob_meas = sum(\\n assemblage[symbol.question, 0][\\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n constraints.append(sub_mat == sum_all_bob_meas)\\n\\n if symbol.player == \\\"Bob\\\":\\n sum_all_alice_meas = sum(\\n assemblage[0, symbol.question][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n constraints.append(sub_mat == sum_all_alice_meas)\\n\\n elif word in seen:\\n old_i, old_j = seen[word]\\n old_sub_mat = r_var[old_i::dim, old_j::dim]\\n constraints.append(sub_mat == old_sub_mat)\\n\\n else:\\n seen[word] = (i, j)\\n\\n # now we impose constraints to the assemblage operator\\n for x_alice_in in range(a_in):\\n for y_bob_in in range(b_in):\\n sum_all_meas_and_trace = 0\\n for a_ans in range(a_out):\\n for b_ans in range(b_out):\\n sum_all_meas_and_trace += sum(\\n assemblage[x_alice_in, y_bob_in][\\n i + a_ans * referee_dim, i + b_ans * referee_dim\\n ]\\n for i in range(referee_dim)\\n )\\n\\n # r x r sub - block is PSD since it's an unnormalized quantum state.\\n constraints.append(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n >> 0\\n )\\n\\n constraints.append(sum_all_meas_and_trace == 1)\\n\\n # Bob marginal consistency\\n for y_bob_in in range(b_in):\\n for b_ans in range(b_out):\\n sum_first_question = sum(\\n assemblage[0, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n for x_alice_in in range(1, a_in):\\n sum_cur_question = sum(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n constraints.append(sum_first_question == sum_cur_question)\\n\\n # Alice marginal consistency\\n for x_alice_in in range(a_in):\\n for a_ans in range(a_out):\\n sum_first_question = sum(\\n assemblage[x_alice_in, 0][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n for y_bob_in in range(1, b_in):\\n sum_cur_question = sum(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n constraints.append(sum_first_question == sum_cur_question)\\n\\n return constraints\",\n \"def __init__(self, n, sents, corpus='', beta=None, addone=True):\\n self.n = n\\n self.beta = beta\\n self.corpus = corpus\\n self.beta_flag = True\\n self.addone = addone\\n self.smoothingtechnique = 'Back Off (Katz) with Discounting Smoothing'\\n self.counts = counts = defaultdict(int)\\n self.A_set = defaultdict(set)\\n voc = ['</s>']\\n for s in sents:\\n voc += s\\n self.voc = set(voc)\\n if beta is None:\\n self.beta_flag = False\\n\\n # if no beta given, we compute it\\n if not self.beta_flag:\\n total_sents = len(sents)\\n aux = int(total_sents * 90 / 100)\\n # 90 per cent por training\\n train_sents = sents[:aux]\\n # 10 per cent for perplexity (held out data)\\n held_out_sents = sents[-total_sents+aux:]\\n\\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\\n for sent in train_sents:\\n for j in range(n+1):\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n # for efficiency, we save the A set as a dict of sets\\n if j:\\n self.A_set[ngram[:-1]].add(ngram[-1])\\n for i in range(1, n):\\n counts[('<s>',)*i] += len(train_sents)\\n counts[('</s>',)] = len(train_sents)\\n\\n self.tocounts = counts\\n # search for the beta that gives lower perplexity\\n beta_candidates = [i*0.1 for i in range(1, 10)]\\n # xs is a list with (beta, perplexity)\\n xs = []\\n self.sents = train_sents\\n for aux_beta in beta_candidates:\\n self.beta = aux_beta\\n aux_perx = self.perplexity(held_out_sents)\\n xs.append((aux_beta, aux_perx))\\n xs.sort(key=lambda x: x[1])\\n self.beta = xs[0][0]\\n with open('old-stuff/backoff_'+str(n)+'_parameters_'+corpus, 'a') as f:\\n f.write('Order: {}\\\\n'.format(self.n))\\n f.write('Beta: {}\\\\n'.format(self.beta))\\n f.write('AddOne: {}\\\\n'.format(self.addone))\\n f.write('Perplexity observed: {}\\\\n'.format(xs[0][1]))\\n f.write('-------------------------------\\\\n')\\n f.close()\\n else:\\n sents = list(map((lambda x: x + ['</s>']), sents))\\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\\n\\n for sent in sents:\\n for j in range(n+1):\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n # for efficiency, we save the A set as a dict of sets\\n if j:\\n self.A_set[ngram[:-1]].add(ngram[-1])\\n for i in range(1, n):\\n counts[('<s>',)*i] += len(sents)\\n counts[('</s>',)] = len(sents)\",\n \"def naive_bayes_train_bis(sms_file):\\n dic, list1, list2 = tokenize_and_split_bis(sms_file)\\n nbr_words = len(list1) + len(list2)\\n spam_ratio = len(list1) / nbr_words\\n document = list1 + list2\\n\\n nbr_spam = 0\\n for line in list1:\\n for word in line:\\n nbr_spam += 1\\n \\n nbr_ham = 0\\n for line in list2:\\n for word in line:\\n nbr_ham += 1\\n \\n nbr_words = nbr_ham + nbr_spam\\n sms_ratio_list = compute_frequencies(nbr_words, document)\\n spam_ratio_list = compute_frequencies(nbr_words, list1)\\n spamicity = [0. for i in range(nbr_words)]\\n # print(sms_ratio_list)\\n # print(spam_ratio_list)\\n spamicity_no = [0. for i in range(nbr_words)]\\n spamicity_inv = [0. for i in range(nbr_words)]\\n\\n product_word_dic = 1\\n for i in range(nbr_words):\\n if sms_ratio_list[i] != 0:\\n spamicity[i] = ((spam_ratio_list[i]) / sms_ratio_list[i])\\n spamicity_no[i] = 1 - ((spam_ratio_list[i]) / sms_ratio_list[i])\\n spamicity_inv[i] = ((1 - (spam_ratio_list[i])) / (1 - sms_ratio_list[i]))\\n # print(spamicity_inv[i])\\n # if spamicity_inv[i] != 0 :\\n product_word_dic *= spamicity_inv[i]\\n \\n return spam_ratio, dic, spamicity, spamicity_no, spamicity_inv, product_word_dic\",\n \"def _generateBigrams(self,text):\\n self.bigrams=self._generateNgrams(text,2)\",\n \"def crosswordPuzzle(crossword, words):\\n words = words.split(';')\\n n_rows = len(crossword)\\n lines = []\\n columns = []\\n row = 0\\n twisted = twistgrid(crossword)\\n while row < n_rows:\\n lines.append(list(re.finditer(r'(-){2,}', crossword[row])))\\n columns.append(list(re.finditer(r'(-){2,}', twisted[row])))\\n row += 1\\n row_words = []\\n col_words = []\\n blank_lengths = []\\n for irow, matches in enumerate(lines):\\n row_words.extend([((irow, x.span()[0]),\\n (irow, x.span()[1] - 1)) for x in matches])\\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\\n\\n for icol, matches in enumerate(columns):\\n col_words.extend([((x.span()[0], icol),\\n (x.span()[1] - 1, icol)) for x in matches])\\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\\n\\n intersections = {'row_words': [], 'col_words': []}\\n n_intersections = 0\\n\\n for i, rword in enumerate(row_words):\\n for j, cword in enumerate(col_words):\\n if rword[0][0] >= cword[0][0] and rword[0][0] <= cword[1][0] and\\\\\\n cword[0][1] >= rword[0][1] and cword[0][1] <= rword[1][1]:\\n intersections['row_words'].append((i,\\n cword[0][1] - rword[0][1]))\\n intersections['col_words'].append((j,\\n rword[0][0] - cword[0][0]))\\n n_intersections += 1\\n\\n guesses = list(permutations(words))\\n right_length = []\\n for i, guess in enumerate(guesses):\\n if all((len(guess[k]) == blank_lengths[k] for k in range(len(guess)))):\\n right_length.append(guess)\\n\\n for k, guess in enumerate(right_length):\\n row_intersections = []\\n col_intersections = []\\n i = 0\\n while col_intersections == row_intersections and i < n_intersections:\\n word = guess[intersections['row_words'][i][0]]\\n letter_ind = intersections['row_words'][i][1]\\n row_intersections.append(word[letter_ind])\\n\\n # now find letters of columns that are intersections\\n word = guess[intersections['col_words'][i][0] + len(row_words)]\\n # need offset because the first words in guess fall into rows\\n letter_ind = intersections['col_words'][i][1]\\n col_intersections.append(word[letter_ind])\\n i += 1\\n if col_intersections == row_intersections:\\n print(f'Intersections match for guess {guess}')\\n break # don't keep changing guess even after you found fit\\n print(f'Found correct guess on search {k+1} out of {len(guesses)} choices')\\n\\n out = [list(row) for row in crossword]\\n for i, word in enumerate(row_words):\\n out[word[0][0]][word[0][1]:word[1][1] + 1] = list(guess[i])\\n\\n out = [''.join(row) for row in out]\\n out = twistgrid(out)\\n\\n out = [list(row) for row in out]\\n for i, word in enumerate(col_words):\\n out[word[0][1]][word[0][0]:word[1][0] + 1] = list(guess[i + len(row_words)])\\n out = [''.join(row) for row in out]\\n out = twistgrid(out)\\n out = [''.join(row) for row in out]\\n print('\\\\n'.join(out))\\n\\n return out\",\n \"def proc_sw_only_word(word, uni_word, backward_pairs):\\n sandwich_pairs = []\\n if uni_word == u'.' and word.raw.endswith('.'):\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('./SF'),]))\\n elif uni_word == u'~' and (not backward_pairs or len(backward_pairs) == 1):\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('~/SO'),]))\\n elif uni_word == u',' and not backward_pairs:\\n sandwich_pairs.append(WordStrMorphsPair(uni_word, [sejong_corpus.Morph.parse('~/SP'),]))\\n elif uni_word == u'<pause/>':\\n pass\\n else:\\n raise AlignError()\\n return sandwich_pairs\",\n \"def word_combination(wlist:list) -> list :\\r\\n\\r\\n if wlist and len(wlist)>1:\\r\\n return chain(*map(lambda x: combinations(wlist, x), range(1, len(wlist)+1)))\\r\\n else :\\r\\n return wlist\",\n \"def word2features(self,sent, i):\\n word = sent[i][0]\\n #postag = sent[i][1]\\n\\n features = {\\n 'bias': 1.0,\\n 'word.lower()': word.lower(),\\n 'word.isupper()': word.isupper(),\\n 'word.istitle()': word.istitle(),\\n 'word.isdigit()': word.isdigit(),\\n 'word.shape()':self.shape(word),\\n 'word.isalnum()':word.isalnum(),\\n 'word.isalpha()':word.isalpha(),\\n # 'postag': postag,\\n # 'postag[:2]': postag[:2],\\n }\\n if i > 0:\\n word1 = sent[i - 1][0]\\n #postag1 = sent[i - 1][1]\\n features.update({\\n '-1:word.lower()': word1.lower(),\\n '-1:word.istitle()': word1.istitle(),\\n '-1:word.isupper()': word1.isupper(),\\n '-1:word.isdigit()': word1.isdigit(),\\n '-1:word.isalnum()':word1.isalnum(),\\n '-1:word.isalpha()':word1.isalpha(),\\n # '-1:postag': postag1,\\n # '-1:postag[:2]': postag1[:2],\\n })\\n else:\\n features['BOS'] = True\\n\\n if i > 1:\\n word2 = sent[i - 2][0]\\n #postag2 = sent[i - 2][1]\\n features.update({\\n '-2:word.lower()': word2.lower(),\\n '-2:word.istitle()': word2.istitle(),\\n '-2:word.isupper()': word2.isupper(),\\n '-2:word.isdigit()': word2.isdigit(),\\n '-2:word.isalnum()': word2.isalnum(),\\n '-2:word.isalpha()': word2.isalpha(),\\n # '-2:postag': postag2,\\n # '-2:postag[:2]': postag2[:2],\\n })\\n else:\\n features['BOS1'] = True\\n if i > 2:\\n word3 = sent[i - 3][0]\\n #postag3 = sent[i - 3][1]\\n features.update({\\n '-3:word.lower()': word3.lower(),\\n '-3:word.istitle()': word3.istitle(),\\n '-3:word.isupper()': word3.isupper(),\\n '-3:word.isdigit()': word3.isdigit(),\\n '-3:word.isalnum()': word3.isalnum(),\\n '-3:word.isalpha()': word3.isalpha(),\\n # '-3:postag': postag3,\\n # '-3:postag[:2]': postag3[:2],\\n })\\n else:\\n features['BOS2'] = True\\n\\n if i > 3:\\n word4 = sent[i - 4][0]\\n #postag4 = sent[i - 4][1]\\n features.update({\\n '-4:word.lower()': word4.lower(),\\n '-4:word.istitle()': word4.istitle(),\\n '-4:word.isupper()': word4.isupper(),\\n '-4:word.isdigit()': word4.isdigit(),\\n '-4:word.isalnum()': word4.isalnum(),\\n '-4:word.isalpha()': word4.isalpha(),\\n # '-4:postag': postag4,\\n # '-4:postag[:2]': postag4[:2],\\n })\\n else:\\n features['BOS2'] = True\\n\\n if i < len(sent) - 1:\\n word1 = sent[i + 1][0]\\n features.update({\\n '+1:word.lower()': word1.lower(),\\n '+1:word.istitle()': word1.istitle(),\\n '+1:word.isupper()': word1.isupper(),\\n '+1:word.isdigit()': word1.isdigit(),\\n '+1:word.isalnum()': word1.isalnum(),\\n '+1:word.isalpha()': word1.isalpha(),\\n # '+1:postag': postag1,\\n # '+1:postag[:2]': postag1[:2],\\n })\\n else:\\n features['EOS'] = True\\n if i < len(sent) - 2:\\n word12 = sent[i + 2][0]\\n #postag12 = sent[i + 2][1]\\n features.update({\\n '+2:word.lower()': word12.lower(),\\n '+2:word.istitle()': word12.istitle(),\\n '+2:word.isupper()': word12.isupper(),\\n '+2:word.isdigit()': word12.isdigit(),\\n '+2:word.isalnum()': word12.isalnum(),\\n '+2:word.isalpha()': word12.isalpha(),\\n # '+2:postag': postag12,\\n # '+2:postag[:2]': postag12[:2],\\n })\\n else:\\n features['EOS2'] = True\\n if i < len(sent) - 3:\\n word13 = sent[i + 3][0]\\n #postag13 = sent[i + 3][1]\\n features.update({\\n '+3:word.lower()': word13.lower(),\\n '+3:word.istitle()': word13.istitle(),\\n '+3:word.isupper()': word13.isupper(),\\n '+3:word.isdigit()': word13.isdigit(),\\n '+3:word.isalnum()': word13.isalnum(),\\n '+3:word.isalpha()': word13.isalpha(),\\n # '+3:postag': postag13,\\n # '+3:postag[:2]': postag13[:2],\\n })\\n else:\\n features['EOS2'] = True\\n if i < len(sent) - 4:\\n word14 = sent[i + 4][0]\\n #postag14 = sent[i + 4][1]\\n features.update({\\n '+4:word.lower()': word14.lower(),\\n '+4:word.istitle()': word14.istitle(),\\n '+4:word.isupper()': word14.isupper(),\\n '+4:word.isdigit()': word14.isdigit(),\\n '+4:word.isalnum()': word14.isalnum(),\\n '+4:word.isalpha()': word14.isalpha(),\\n # '+4:postag': postag14,\\n # '+4:postag[:2]': postag14[:2],\\n })\\n else:\\n features['EOS2'] = True\\n return features\",\n \"def make_text(markov_chains):\\n\\n random_num = generate_random_number(markov_chains.keys())\\n\\n random_text = []\\n\\n start_words = generate_start_words(random_num, markov_chains.keys())\\n \\n random_text.extend(start_words)\\n\\n\\n for i in range(500):\\n word_tuple = (random_text[-2],random_text[-1])\\n next_word = add_next_word(word_tuple, markov_chains)\\n random_text.append(next_word)\\n\\n return random_text\",\n \"def grounding_words(self, w):\\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])\",\n \"def crosswordPuzzle(crossword, words):\\n words = words.split(';')\\n n_rows = len(crossword)\\n lines = []\\n columns = []\\n row = 0\\n twisted = twistgrid(crossword)\\n while row < n_rows:\\n lines.append(list(re.finditer(r'(-){2,}', crossword[row])))\\n columns.append(list(re.finditer(r'(-){2,}', twisted[row])))\\n row += 1\\n # lines and columns are a list of lists; both are n_rows long.\\n # If there are any matches in the column or row, they will appear\\n # as a match object in one of the sublists\\n # A match requires 2 or more blank spaces consecutively +--+\\n # A single blank is not a word / match\\n # print('lines', lines)\\n # print(columns)\\n row_words = []\\n col_words = []\\n blank_lengths = []\\n for irow, matches in enumerate(lines):\\n row_words.extend([((irow, x.span()[0]),\\n (irow, x.span()[1] - 1)) for x in matches])\\n # row_words is a list of 2-tuples, which have the coord of\\n # start and end of blank space for a word\\n # ex: ((3, 0), (3, 4)) represents a space at (row 3, col 0),\\n # which extends 5 blank space to terminate on (row 3, col 4)\\n # .extend method is used because we could have more than one\\n # match object per line and append method only takes one\\n # argument\\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\\n # blank_lengths is a list that counts how long each of the row\\n # words is, going top to bottom in grid.\\n # a match object's span()[1] coordinate is one greater than the\\n # last index of the match, so subtracting gives the length\\n\\n for icol, matches in enumerate(columns):\\n col_words.extend([((x.span()[0], icol),\\n (x.span()[1] - 1, icol)) for x in matches])\\n blank_lengths.extend([x.span()[1] - x.span()[0] for x in matches])\\n\\n intersections = {'row_words': [], 'col_words': []}\\n n_intersections = 0\\n # we want coordinates of where the intersections occur of the row\\n # words with column words to verify a matching letter later on\\n # intersections is a dictionary of two lists and each list contains\\n # 2-tuples:\\n # (p, q) p = index of row_words or col_words\\n # q = index of row_words[p] that corresponds to the letter\\n # in the word that needs to be verified\\n\\n for i, rword in enumerate(row_words):\\n for j, cword in enumerate(col_words):\\n if rword[0][0] >= cword[0][0] and rword[0][0] <= cword[1][0] and\\\\\\n cword[0][1] >= rword[0][1] and cword[0][1] <= rword[1][1]:\\n # rword[0][0] is row of rword, which needs to fall\\n # within\\n # the range of the column word in order to intersect\\n # cword[0][1] is column row of cword, which needs to\\n # fall within of the row word in order to intersect\\n intersections['row_words'].append((i,\\n cword[0][1] - rword[0][1]))\\n intersections['col_words'].append((j,\\n rword[0][0] - cword[0][0]))\\n n_intersections += 1\\n\\n guesses = list(permutations(words))\\n # there might be better way to choose ways to check potential solutions\\n # but max # words in test cases was 6, so 6x5x4x3x2 = 720 guesses\\n right_length = []\\n for i, guess in enumerate(guesses):\\n if all((len(guess[k]) == blank_lengths[k] for k in range(len(guess)))):\\n # Only pass guesses where every single word fits in the blank.\\n # Rows are filled first, then columns\\n right_length.append(guess)\\n\\n for k, guess in enumerate(right_length):\\n row_intersections = []\\n col_intersections = []\\n i = 0\\n while col_intersections == row_intersections and i < n_intersections:\\n word = guess[intersections['row_words'][i][0]]\\n letter_ind = intersections['row_words'][i][1]\\n row_intersections.append(word[letter_ind])\\n\\n # now find letters of columns that are intersections\\n word = guess[intersections['col_words'][i][0] + len(row_words)]\\n # need offset because the first words in guess fall into rows\\n letter_ind = intersections['col_words'][i][1]\\n col_intersections.append(word[letter_ind])\\n i += 1\\n if col_intersections == row_intersections:\\n # print(f'Intersections match for guess {guess}')\\n break # don't keep changing guess even after you found fit\\n print(f'Found correct guess on search {k+1} out of {len(guesses)} choices')\\n\\n # Now let's insert solution into grid, replacing the blank spaces '-'\\n # with the words\\n # To mutate elements of crossword, we need to mutate it\\n # so we need to turn it into list.\\n # We also need to transpose it to fill in the columns, then transpose\\n # it back to normal orientation\\n\\n out = [list(row) for row in crossword]\\n for i, word in enumerate(row_words):\\n out[word[0][0]][word[0][1]:word[1][1] + 1] = list(guess[i])\\n\\n out = [''.join(row) for row in out]\\n out = twistgrid(out)\\n\\n out = [list(row) for row in out]\\n for i, word in enumerate(col_words):\\n out[word[0][1]][word[0][0]:word[1][0] + 1] = list(guess[i + len(row_words)])\\n # the indexing is different from row above because we need\\n # to update the range of rows that column word occupies\\n # need offset because row words come first in guesses list\\n out = [''.join(row) for row in out]\\n out = twistgrid(out)\\n out = [''.join(row) for row in out]\\n print('\\\\n'.join(out))\\n\\n return out\",\n \"def make_pairs(txt):\\r\\n \\r\\n lista = []\\r\\n string = \\\"\\\" \\r\\n count = 0\\r\\n \\r\\n if len(txt)%2 != 0 :\\r\\n count = 1\\r\\n \\r\\n for i in range(len(txt)):\\r\\n \\r\\n string += txt[i]\\r\\n count += 1\\r\\n \\r\\n if count == 2:\\r\\n lista.append(string)\\r\\n string = \\\"\\\"\\r\\n count = 0\\r\\n \\r\\n return lista\",\n \"def viterbi_trigrams(transition_probabilities, label_matches, prev_tag, prev_prev_tag, word, tag_possibilities):\\r\\n\\tmax_prob = 0\\r\\n\\tbest_tag = \\\"\\\"\\r\\n\\ttag_counts = get_tag_counts(label_matches)\\r\\n\\tfor tag in tag_possibilities:\\r\\n\\t\\temissions_probability = get_emissions_probability(label_matches, tag, word, tag_counts)\\r\\n\\t\\ttag_trigram = (prev_prev_tag, prev_tag,tag)\\r\\n\\t\\ttransition_probability = transition_probabilities.get(tag_trigram, 0.000027)\\r\\n\\t\\tprob = emissions_probability * transition_probability\\r\\n\\t\\tif prob > max_prob:\\r\\n\\t\\t\\tmax_prob = prob\\r\\n\\t\\t\\tbest_tag = tag\\r\\n\\tif best_tag == \\\"\\\":\\r\\n\\t\\tbest_tag = \\\"o\\\"\\r\\n\\treturn best_tag\",\n \"def getComboTerms(tuples):\\t\\t\\t\\n\\t\\t\\t#return \\\"[{0}]\\\".format('; '.join([\\\"({0})\\\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\\n\\t\\t\\treturn \\\"{0}\\\".format('; '.join((\\\"{0}\\\".format(text[indices[0]:indices[1]]) for indices in tuples)))\",\n \"def make_text(chains):\\n\\n words = []\\n\\n # random_key = choice(chains.keys())\\n\\n # words.append(random_key[0])\\n # words.append(random_key[1])\\n\\n # while random_key in chains.keys():\\n\\n # values_list = chains[random_key]\\n\\n # chosen_word = choice(values_list)\\n\\n # words.append(chosen_word)\\n\\n # new_key = (random_key[1], chosen_word)\\n\\n # random_key = new_key\\n\\n list_of_keys = chains.keys()\\n\\n random_key = choice(list_of_keys)\\n\\n while random_key[0].islower() or random_key[0] == \\\"--\\\":\\n random_key = choice(list_of_keys)\\n\\n\\n words.append(random_key[0])\\n words.append(random_key[1])\\n\\n while random_key in chains.keys():\\n random_value = choice(chains.get(random_key, None))\\n\\n words.append(random_value)\\n new_key = (random_key[1], random_value)\\n random_key = new_key\\n if random_key[1].endswith(\\\".\\\"):\\n break\\n\\n\\n return \\\" \\\".join(words)\",\n \"def make_chains(corpus):\\n \\n# This section reads the corpus file in to the program and splits the words in a words list. \\n text = corpus.read() #this is functionally the same as the more complicated stuff below\\n words = text.split()\\n\\n chain_dict = {}\\n \\\"\\\"\\\"\\n for line in f:\\n line = line.rstrip()\\n words.extend(line.split())\\n \\\"\\\"\\\" \\n#This looks at each word entry in the list that we made from original text - if the tuple does not yet exist,\\n#it appends it to the dictionary as a key. If it does exist, it appends the value to the existing key.\\n\\n for each_number in range(len(words)-2): \\n if (words[each_number], words[each_number+1]) not in chain_dict.keys():\\n chain_dict[(words[each_number], words[each_number+1])] = [words[each_number+2]]\\n else:\\n chain_dict[(words[each_number], words[each_number+1])].append(words[each_number+2])\\n \\n return chain_dict\",\n \"def make_chains(text_string, n):\\n text_list = text_string.split()\\n\\n chains = {}\\n\\n for i in range(n):\\n if text_list[i][0].isupper():\\n starters = chains.get('START', [])\\n starters.append(text_list[i:i+n])\\n chains['START'] = starters\\n\\n # your code goes here\\n for i in range(len(text_list)-n):\\n n_gram = tuple(text_list[i:i+n])\\n\\n #bigram = (text_list[i], text_list[i+1])\\n\\n followers = chains.get(n_gram, [])\\n followers.append(text_list[i+n])\\n\\n if n_gram[-1][-1] in {'.', '?', '!'}:\\n followers.append('EOF')\\n\\n chains[n_gram] = followers\\n\\n if text_list[i+n][0].isupper():\\n starters = chains.get('START', [])\\n starters.append(text_list[i+n:i+(2*n)])\\n chains['START'] = starters\\n\\n return chains\",\n \"def word2vec_mapping_func():\\n return {\\\"belonging to\\\": \\\"belonging\\\", \\\"parked on\\\": \\\"parked\\\", \\\"growing on\\\": \\\"growing\\\", \\\"standing on\\\": \\\"standing\\\",\\n \\\"made of\\\": \\\"made\\\", \\\"attached to\\\": \\\"attached\\\", \\\"hanging from\\\": \\\"hanging\\\", \\\"in front of\\\": \\\"front\\\",\\n \\\"lying on\\\": \\\"lying\\\", \\\"flying in\\\": \\\"flying\\\", \\\"looking at\\\": \\\"looking\\\", \\\"on back of\\\": \\\"back\\\",\\n \\\"laying on\\\": \\\"laying\\\", \\\"walking on\\\": \\\"walking\\\", \\\"walking in\\\": \\\"walking\\\", \\\"sitting on\\\": \\\"sitting\\\",\\n \\\"covered in\\\": \\\"covered\\\", \\\"part of\\\": \\\"part\\\", \\\"painted on\\\": \\\"painted\\\", \\\"mounted on\\\": \\\"mounted\\\"}\",\n \"def make_text(sent, begin, end):\\n lemmas = [sent.morps[begin].lemma(), ]\\n for idx in range(begin+1, end):\\n if sent.mid2wid[idx-1] != sent.mid2wid[idx]: # if go over word boundary\\n # insert space between words\\n lemmas.append(' ')\\n lemmas.append(sent.morps[idx].lemma())\\n return ''.join(lemmas)\",\n \"def make_chains(corpus):\\n c_dict = {}\\n\\n for x in range(len(corpus)):\\n if x < (len(corpus)-2): # not in edge\\n bigram_tuple = tuple([corpus[x],corpus[x+1]])\\n if bigram_tuple in c_dict:\\n c_dict[bigram_tuple].append(corpus[x+2])\\n else:\\n c_dict[bigram_tuple] = [corpus[x+2]]\\n else:\\n bigram_tuple = tuple([corpus[-2],corpus[-1]]) # ran twice. Why?\\n c_dict.setdefault(bigram_tuple) # could set a default word? Empty list?\\n\\n return c_dict\",\n \"def generate_babble_text(self):\\n markov_chain_output = []\\n for n in range(self.number_of_sentences):\\n sentence_length = random.randint(self.min_sentence_length, self.max_sentence_length)\\n markov_chain_output.append(self.markov_chain.generate_sentence(sentence_length))\\n\\n random.shuffle(markov_chain_output)\\n\\n to_display = ''\\n for i in markov_chain_output:\\n to_display += i + '\\\\n'\\n\\n # Clears any old text in the display, then inserts the newly created text\\n self.display.delete('1.0', tk.END)\\n self.display.insert('1.0', to_display)\",\n \"def create_word(self):\\n return self.random.choice(CONSONANTS) + self.random.choice(VOWELS)\",\n \"def make_text(word_next_dict):\\n\\n final_text = []\\n # randomly select a tuple from the dictionary\\n start = random.choice(word_next_dict.keys())\\n # If 1st word in tuple isn't capitalized, choose a new pair until one is\\n while not start[0].isupper():\\n start = random.choice(word_next_dict.keys())\\n # Begin the list of random text with tuple (separated to 2 strings)\\n final_text.append(start[0])\\n final_text.append(start[1])\\n\\n # create random text list: find a word associated with last 2 and append list\\n while len(final_text) < 12:\\n # look for sentence endings and re-choose start tuple\\n if '.' in final_text[-1]:\\n start = random.choice(word_next_dict.keys())\\n # make sure tuple begins with a capitalized string\\n while not start[0].isupper():\\n start = random.choice(word_next_dict.keys())\\n final_text.append(start[0])\\n final_text.append(start[1])\\n last_words = (final_text[-2], final_text[-1]) \\n next_guy = word_next_dict[last_words][random.randrange(len(word_next_dict[last_words]))] # finds length of wordlist, randomly picks \\n final_text.append(next_guy)\\n\\n to_tweet = ' '.join(final_text) + '.'\\n print to_tweet\\n return to_tweet\",\n \"def guess_splitwords():\\n\\n if t_word[:2] == 'un' and (t_pos == 'ADJD' or t_pos == 'ADJA'):\\n create_splitword_tags(t_word[:2], t_word[2:])\\n create_negation_frame()\\n create_splitword_target(t_word[:2])\\n create_splitword_focus(t_word[2:])\\n create_splitword_negated(t_word[2:])\\n create_splitword_scope(t_word[2:])\",\n \"def correct_errors(page, labels, bboxes, model):\\n\\n # end_of_word = []\\n\\n # take every bbox and check the width between them\\n # total_bboxes = len(bboxes)\\n # for n in range(total_bboxes-1):\\n # if (space_between(n,n+1,bboxes)):\\n # end_of_word.append(n+1)\\n\\n # now we can make words by joining the characters where there isn't whitespace\\n # so from the start until the index of the first space we should join together the characters\\n\\n # char_to_word = []\\n # for x in range(len(end_of_word)):\\n # if (x==0):\\n # char_to_word.append(''.join(labels[x:(end_of_word[x])]).upper())\\n # else:\\n # char_to_word.append(''.join(labels[(end_of_word[x-1]):(end_of_word[x])]).upper())\\n\\n # We want to remove all the punctuation as it gets in the way of matching words\\n # however we still want to store it's index in the labels for later.\\n # punctuation_index = []\\n # punctuation_value = []\\n\\n # for x in range(len(labels)):\\n # if labels[x] in ('!','.',':',',',';','?','\\\\''):\\n # punctuation_index.append(labels.tolist().index(labels[x]))\\n # punctuation_value.append(labels[x])\\n # labels[x] = remove_punctuation(labels[x])\\n\\n # Get the words that don't need changing out of the way (they already exist)\\n # no_change_words = set(char_to_word).intersection(model['words'])\\n\\n # now we want to take all words that don't appear in both lists of words and change those with a few\\n # misclassified chars to words that are similar in the list of actual words.\\n\\n # words_to_correct = [w for w in char_to_word if w not in no_change_words]\\n\\n # We'll need the index of the words so we can put them back.\\n # wtc_index = []\\n # for i in range(len(words_to_correct)):\\n # wtc_index.append(char_to_word.index(words_to_correct[i]))\\n\\n # Start looking for similar words of the same length for a given word and input the similar word instead.\\n # for y in range(len(words_to_correct)):\\n # word = words_to_correct[y]\\n # # filter words of the same length\\n # close_word = filter(lambda x: len(x) == len(word), model['words'])\\n # # replace current word with one real word with only a letters difference\\n # for x, similar in enumerate(close_word):\\n # if (string_difference(similar, word) == 1):\\n # words_to_correct[y] = similar\\n\\n # using the stored index, put the words back where they need to be\\n # for i in range(len(wtc_index)):\\n # for n, j in enumerate(char_to_word):\\n # if (n == wtc_index[i]):\\n # char_to_word[n] = words_to_correct[i]\\n\\n # start splitting the words up again so that they're in the necessary label shape\\n # possible_labels = []\\n # for i in range(len(char_to_word)):\\n # split_words = [x for x in char_to_word[i].lower()]\\n # possible_labels.append(split_words)\\n # possible_labels1 = list(itertools.chain.from_iterable(possible_labels))\\n\\n # add the punctuation back in and you should get the full amount of labels to return and test on\\n # for i in range(len(punctuation_index)):\\n # while len(possible_labels1) != len(labels):\\n # possible_labels1.insert(punctuation_index[i],punctuation_value[i])\\n\\n return labels\",\n \"def make_text(chains):\\n key = choice(list(chains.keys()))\\n\\n words = []\\n\\n while key in chains:\\n word = get_new_word(key, chains)\\n words.append(word)\\n key = get_new_key(key, word)\\n\\n return \\\" \\\".join(words)\",\n \"def process_pair(words: tuple) -> Optional[tuple]:\\n\\n # Replace all reflexive forms\\n to_replace = [\\\"[se]\\\", \\\"|se|\\\", \\\"[-și]\\\", \\\"[o]\\\", \\\"|-și|\\\", \\\"|și|\\\", \\\"[-i]\\\", \\\"[i]\\\", \\\"[și]\\\", \\\"a \\\"]\\n raw_line = \\\" \\\".join(words)\\n for sub in to_replace:\\n raw_line = raw_line.replace(sub, \\\"\\\")\\n\\n # Replace multiple spaces, strip beginning / ending spaces\\n processed_line = re.sub('\\\\s{2,}', ' ', raw_line).strip()\\n\\n words = processed_line.split(' ')\\n\\n # Return the new tuple\\n # Or the empty string if the words are the same or contain each other, or ar capital nouns\\n if len(words) != 2:\\n return None\\n if words[1] in words[0] or words[0] in words[1]:\\n return None\\n if words[1][0].isupper() or words[0][0].isupper():\\n return None\\n return tuple(words)\",\n \"def word_subsets(self, A: List[str], B: List[str]) -> List[str]:\\n res = []\\n B_hashmaps = []\\n for word in B:\\n B_hashmaps.append(Counter(word))\\n\\n for word in A:\\n if self.check_superset(word, B_hashmaps):\\n res.append(word)\\n return res\",\n \"def generate_sentence(word1, word2, length, vocab, model):\\n reverse_vocab = {idx: word for word, idx in vocab.items()}\\n output_string = np.zeros((1, length), dtype=np.int)\\n output_string[:, 0: 2] = vocab[word1], vocab[word2]\\n\\n for end in range(2, length):\\n start = end - 2\\n output_string[:, end] = np.argmax(model(output_string[:, start:end]), axis=1)\\n text = [reverse_vocab[i] for i in list(output_string[0])]\\n \\n print(\\\" \\\".join(text))\",\n \"def make_words(self,lm):\\n if \\\" \\\" in self.corpus[0] and \\\" \\\" in self.corpus[1]: \\n print \\\"assuming BLICK\\\"\\n self.corpus = [convert_to_disc(i) for i in self.corpus]\\n else:\\n self.disc = 1\\n print \\\"assuming Disc\\\" \\n if not os.path.isfile(self.f): ##check if it already exists\\n print \\\"generating 10 million words\\\"\\n outfile = open(self.f, \\\"w\\\")\\n outfile.write(\\\"word,blick,ngram,Real,T,disc\\\\n\\\")\\n for word in self.corpus:\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Real\\\", \\\"1\\\")\\n while len(self.wordlist)<10000000: \\n words = lm.generate(100)\\n for word in words:\\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Simulated\\\", \\\"0\\\")\\n self.wordlist[word] = 0\\n return\",\n \"def generate_antonym_pairs(config: SettingConfig) -> dict:\\n print(f\\\"Generating initial antonym pairs from RoWordNet @ {datetime.now()}\\\")\\n wn = rwn.RoWordNet()\\n\\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\\n # the PoS and the value is a set of pairs of words of PoS specified by the key\\n pairs = dict()\\n\\n # Iterate over the selected parts of speech\\n for part_of_speech in config.pos.values():\\n\\n pos_pairs = list()\\n\\n # Return all synsets corresponding to the PoS\\n synset_ids = wn.synsets(pos=part_of_speech)\\n\\n # Iterate all the synsets for the current PoS\\n for synset_id in synset_ids:\\n\\n # Get the synset object specified by synset_id\\n synset = wn.synset(synset_id)\\n\\n # Get the outbound relations of type antonym from\\n outbound_relations = filter(lambda x: x[1] == 'near_antonym', wn.outbound_relations(synset_id))\\n\\n # Iterate outbound relations\\n for relation in outbound_relations:\\n # Get the synset corresponding to the target of the outbound relation\\n target_synset = wn.synset(relation[0])\\n\\n # Get all the pairs, sort them by first word to keep set entries unique\\n current_iteration_pairs = get_cross_synset_pairs(synset, target_synset)\\n\\n # Add the current set of pairs\\n pos_pairs.extend(current_iteration_pairs)\\n\\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\\n for key, value in config.pos.items():\\n if value == part_of_speech:\\n pairs[key] = unique(pos_pairs)\\n\\n # Return the whole dictionary\\n print(f\\\"Successfully generated antonym paris @ {datetime.now()}\\\")\\n return pairs\",\n \"def add2chain2nd(splitted_text):\\n # Our key is the unique occurrence of a pair of words\\n inputText = splitted_text\\n if len(inputText) > 1:\\n for i, word in enumerate(inputText):\\n if i == 0: # Chaining the first and second word in tweet to start key\\n if (None, startKey) not in chain:\\n chain[(None, startKey)] = [word]\\n else:\\n chain[(None, startKey)].append(word)\\n elif i == 1:\\n if (startKey,inputText[i-1]) not in chain:\\n chain[(startKey,inputText[i-1])] = [word]\\n else:\\n chain[(startKey,inputText[i-1])].append(word)\\n else:\\n if (inputText[i-2],inputText[i-1]) not in chain:\\n chain[(inputText[i-2],inputText[i-1])] = [word]\\n else:\\n chain[(inputText[i-2],inputText[i-1])].append(word)\\n if i == len(inputText)-1: # Use last two words as key to end\\n if (inputText[i-1],word) not in chain:\\n chain[(inputText[i-1],word)] = [endKey]\\n else:\\n chain[(inputText[i-1],word)].append(endKey)\\n if (None,startKey) not in chain:\\n chain[(None,startKey)] = [inputText[0]]\\n else:\\n chain[(None,startKey)].append(inputText[0])\\n if (inputText[0],endKey) not in chain:\\n chain[(inputText[0],endKey)] = [None]\\n else:\\n chain[(inputText[0],endKey)].append(None)\",\n \"def word_builder(str_lst, int_lst):\\n word_lst = [None] * len(int_lst)\\n for i in range(len(word_lst)):\\n word_lst[i] = str_lst[int_lst[i]]\\n return \\\"\\\".join(word_lst)\",\n \"def get_biomarkes(abundant, xxx):\\n cc = []\\n bk = set()\\n lvl = 0\\n\\n for _, t in abundant:\\n cc.append(t.split('.'))\\n\\n while lvl < len(max(cc)):\\n bk = set()\\n\\n for c in cc:\\n if lvl < len(c):\\n bk |= set([c[lvl]])\\n\\n if len(bk) >= xxx:\\n break\\n\\n lvl += 1\\n\\n return bk\",\n \"def make_chains(text_string, n):\\n\\n chains = {}\\n\\n # your code goes here\\n words = text_string.split()\\n #print words\\n \\n for i in range(len(words) - n):\\n # next_word = words[i+2]\\n #print \\\"Next Word\\\",next_word\\n key_word_tuple = tuple(words[i:(i + n)])\\n # print key_word_tuple\\n #, words[i + 1])\\n chains[key_word_tuple] = chains.get(key_word_tuple, [])\\n # if (i + n) == (len(words) - 1):\\n # next_word = words[0]\\n # print \\\"i\\\", i\\n # print \\\"BLINGGGG\\\"\\n # print \\\"End of Range \\\",next_word, \\\"key word tuple \\\", key_word_tuple\\n # # if (i + 2) < len(words):\\n # else: \\n next_word = words[i+n]\\n # print next_word\\n\\n chains[key_word_tuple].append(next_word)\\n \\n\\n \\n \\n \\n # print chains[\\\"I\\\",\\\"am\\\"] \\n # print chains\\n return chains\",\n \"def generateWord(self, parameters=None):\\n\\t\\t# Initial set-up\\n\\t\\tvowels = ['a', 'e', 'i', 'o', 'u']\\n\\t\\tspecialVowels = ['y']\\n\\n\\t\\tconsonants = ['b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't']\\n\\t\\tspecialConsonants = ['j', 'q', 'v', 'w', 'x', 'z']\\n\\n\\t\\tnewLetterFraction = 5\\n\\t\\tvowelChance = 50 #percent\\n\\n\\t\\t#Determine how many words we're going to have to generate\\n\\t\\trepeats = 1\\n\\t\\tif parameters and len(parameters) > 0:\\n\\t\\t\\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\\n\\n\\t\\twords = []\\n\\t\\tfor i in xrange(0, repeats):\\n\\t\\t\\tword = u\\\"\\\"\\n\\t\\t\\tcurrentVowelChance = vowelChance\\n\\t\\t\\tcurrentNewLetterFraction = newLetterFraction\\n\\t\\t\\tconsonantCount = 0\\n\\t\\t\\twhile random.randint(0, currentNewLetterFraction) <= 6:\\n\\t\\t\\t\\tif random.randint(1, 100) <= currentVowelChance:\\n\\t\\t\\t\\t\\tconsonantCount = 0\\n\\t\\t\\t\\t\\t#vowel. Check if we're going to add a special or normal vowel\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= 10:\\n\\t\\t\\t\\t\\t\\tword += random.choice(specialVowels)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance -= 30\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(vowels)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance -= 20\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tconsonantCount += 1\\n\\t\\t\\t\\t\\t#consonant, same deal\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= 25:\\n\\t\\t\\t\\t\\t\\tword += random.choice(specialConsonants)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance += 30\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(consonants)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance += 20\\n\\t\\t\\t\\t\\tif consonantCount > 3:\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance = 100\\n\\t\\t\\t\\tcurrentNewLetterFraction += 1\\n\\n\\t\\t\\t#Enough letters added. Finish up\\n\\t\\t\\tword = word[0].upper() + word[1:]\\n\\t\\t\\twords.append(word)\\n\\n\\t\\t#Enough words generated, let's return the result\\n\\t\\treturn u\\\", \\\".join(words)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6379959","0.6285808","0.6200078","0.61135346","0.6090671","0.6088368","0.6056059","0.60499376","0.6005667","0.5910683","0.59056056","0.590162","0.5847353","0.58410585","0.5787261","0.5781655","0.5771898","0.57667893","0.57136333","0.5706423","0.56973606","0.5691066","0.5684014","0.5662684","0.5661277","0.563275","0.5628754","0.562696","0.5608161","0.5590812","0.55867964","0.55847895","0.55780333","0.5562643","0.5560901","0.5559936","0.5538874","0.5500039","0.5497652","0.54965675","0.54576993","0.54562855","0.5439132","0.54220945","0.5418815","0.541215","0.5410861","0.540887","0.5395524","0.53954077","0.5394335","0.53873354","0.5385286","0.5382635","0.53793013","0.5376429","0.53580725","0.5353354","0.53523874","0.5350444","0.5349327","0.53480226","0.53429884","0.53356636","0.5335394","0.5329415","0.53254515","0.53252816","0.5321327","0.53121805","0.53104895","0.52882993","0.52882904","0.52834547","0.52832144","0.52701056","0.526917","0.52658284","0.5250031","0.524666","0.52459663","0.5244528","0.5242138","0.5240216","0.5236576","0.5235684","0.5232063","0.52233434","0.5218279","0.52030224","0.52014893","0.5198542","0.51984954","0.51920223","0.5186513","0.5185822","0.5179289","0.51774395","0.51692384","0.51687753"],"string":"[\n \"0.6379959\",\n \"0.6285808\",\n \"0.6200078\",\n \"0.61135346\",\n \"0.6090671\",\n \"0.6088368\",\n \"0.6056059\",\n \"0.60499376\",\n \"0.6005667\",\n \"0.5910683\",\n \"0.59056056\",\n \"0.590162\",\n \"0.5847353\",\n \"0.58410585\",\n \"0.5787261\",\n \"0.5781655\",\n \"0.5771898\",\n \"0.57667893\",\n \"0.57136333\",\n \"0.5706423\",\n \"0.56973606\",\n \"0.5691066\",\n \"0.5684014\",\n \"0.5662684\",\n \"0.5661277\",\n \"0.563275\",\n \"0.5628754\",\n \"0.562696\",\n \"0.5608161\",\n \"0.5590812\",\n \"0.55867964\",\n \"0.55847895\",\n \"0.55780333\",\n \"0.5562643\",\n \"0.5560901\",\n \"0.5559936\",\n \"0.5538874\",\n \"0.5500039\",\n \"0.5497652\",\n \"0.54965675\",\n \"0.54576993\",\n \"0.54562855\",\n \"0.5439132\",\n \"0.54220945\",\n \"0.5418815\",\n \"0.541215\",\n \"0.5410861\",\n \"0.540887\",\n \"0.5395524\",\n \"0.53954077\",\n \"0.5394335\",\n \"0.53873354\",\n \"0.5385286\",\n \"0.5382635\",\n \"0.53793013\",\n \"0.5376429\",\n \"0.53580725\",\n \"0.5353354\",\n \"0.53523874\",\n \"0.5350444\",\n \"0.5349327\",\n \"0.53480226\",\n \"0.53429884\",\n \"0.53356636\",\n \"0.5335394\",\n \"0.5329415\",\n \"0.53254515\",\n \"0.53252816\",\n \"0.5321327\",\n \"0.53121805\",\n \"0.53104895\",\n \"0.52882993\",\n \"0.52882904\",\n \"0.52834547\",\n \"0.52832144\",\n \"0.52701056\",\n \"0.526917\",\n \"0.52658284\",\n \"0.5250031\",\n \"0.524666\",\n \"0.52459663\",\n \"0.5244528\",\n \"0.5242138\",\n \"0.5240216\",\n \"0.5236576\",\n \"0.5235684\",\n \"0.5232063\",\n \"0.52233434\",\n \"0.5218279\",\n \"0.52030224\",\n \"0.52014893\",\n \"0.5198542\",\n \"0.51984954\",\n \"0.51920223\",\n \"0.5186513\",\n \"0.5185822\",\n \"0.5179289\",\n \"0.51774395\",\n \"0.51692384\",\n \"0.51687753\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6256183"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":81394,"cells":{"query":{"kind":"string","value":"We call new, when we want to apply the pipeline to something unrelated"},"document":{"kind":"string","value":"def new(self):\n self.interesting_mask = None\n self.previous_lines = None"},"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 build_own_pipeline() -> Pipeline:\n nn_pipeline = None\n\n nn_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('tfidf', TfidfTransformer()),\n ('clf', MLPClassifier()) \n ])\n \n return nn_pipeline","def pipeline(self) -> Pipeline:\n if self._to_pipeline is None:\n raise AttributeError(\n \"pipeline not available because `to_pipeline` was not set on __init__.\"\n )\n return self._to_pipeline(self)","def __init__(self, pipeline, config=None):\n self.config = config\n self.pipeline = pipeline","def from_pipeline(cls, pipeline, proba=None, repeat=None):\n if proba is None:\n if repeat is None:\n new_p = cls(pipeline=pipeline)\n else:\n if pipeline.num_actions == 1 and pipeline.get_last_action_proba() is None:\n new_p = cls(pipeline=pipeline, repeat=repeat)\n else:\n new_p = cls()\n new_p.append_pipeline(pipeline, repeat=repeat)\n else:\n if pipeline.num_actions == 1 and pipeline.get_last_action_repeat() is None:\n new_p = cls(pipeline=pipeline, proba=proba)\n else:\n new_p = cls()\n new_p.append_pipeline(pipeline, proba=proba)\n return new_p","def __init__(self, pipeline=PIPELINE, name=\"fake_estimator\"):\n super().__init__(pipeline=pipeline, name=name)","def build_own_pipeline() -> Pipeline:\n clf = svm.LinearSVC(C=2, loss='hinge')\n vect = TfidfVectorizer(ngram_range=(1, 2))\n\n pipeline = None\n ##### Write code here #######\n pipeline = Pipeline([\n ('vect', vect),\n ('tfidf', TfidfTransformer()),\n ('clf', clf)\n ])\n ##### End of your work ######\n return pipeline","def pipeline():\n\n test_pipeline = (Pipeline()\n .init_variable('current_loss')\n .init_model('model', C('model_class'),\n 'dynamic', C('model_config'))\n .to_array(dtype='float32')\n .train_model('model',\n inputs=B('images'),\n targets=B('labels'),\n outputs='loss',\n save_to=V('current_loss'))\n )\n return test_pipeline","def make_full_pipeline(\n preprocess_pipe: ColumnTransformer, model: BaseEstimator\n) -> Pipeline:\n full_pipe = sklearn.pipeline.Pipeline(\n [(\"preprocess\", preprocess_pipe), (\"model\", model)]\n )\n return full_pipe","def pipeline(self):\n # gotta avoid circular imports by deferring\n from .pipeline import Pipeline\n return Pipeline().from_source(self._collection)","def _construct(self, dataflow):\n dataflow = copy_dataflow(dataflow, self.container)\n return dataflow","def __init__(self, pipeline, **kwargs):\n self.pipeline = pipeline\n\n self.batch_size = pipeline.batch_size\n self.X_train = None\n self.y_train = None\n self.X_valid = None\n self.y_valid = None\n\n # Child classes should have init signature:\n # (self, batch_size, **kwargs), should call this __init__ and then\n # define self.X_train, self.y_train, self.X_valid, and self.y_valid","def set_pipeline(self):\n pipe_distance = make_pipeline(DistanceTransformer(), RobustScaler())\n pipe_time = make_pipeline(TimeFeaturesEncoder(time_column='pickup_datetime'), OneHotEncoder(handle_unknown='ignore'))\n dist_cols = ['pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'dropoff_longitude']\n time_cols = ['pickup_datetime']\n feat_eng_bloc = ColumnTransformer([('time', pipe_time, time_cols),\n ('distance', pipe_distance, dist_cols)]\n )\n self.pipeline = Pipeline(steps=[('feat_eng_bloc', feat_eng_bloc),\n ('regressor', RandomForestRegressor())])\n return self.pipeline","def run(self):\n pipeline = set_pipeline()\n pipeline.fit(self.X_train, self.y_train)\n return pipeline","def make_pipeline():\n # exchange = Fundamentals.exchange_id.latest\n # nyse_filter = exchange.eq('NYS')\n symbol_filter = StaticSids([TRADING_SID])\n set_benchmark(TRADING_SID) \n # volume_filter = VolumeFilter(\n # inputs=[USEquityPricing.volume],\n # window_length=1,\n # mask=symbol_filter\n # )\n\n # is_setup = volume_filter & alpha_long_weekly & alpha_long_daily\n weekly_high = WeeklyHigh(\n inputs=[USEquityPricing.high],\n mask=symbol_filter\n )\n weekly_low = WeeklyLow(\n inputs=[USEquityPricing.low],\n mask=symbol_filter\n )\n weekly_classifier = WeeklyClassifier(\n inputs=[\n USEquityPricing.open,\n USEquityPricing.high,\n USEquityPricing.low,\n USEquityPricing.close\n ],\n mask=symbol_filter\n )\n daily_classifier = DailyClassifier(\n inputs=[\n USEquityPricing.open,\n USEquityPricing.high,\n USEquityPricing.low,\n USEquityPricing.close\n ],\n mask=symbol_filter\n\n )\n\n pipe = Pipeline(\n screen=symbol_filter, # & (daily_classifier > 0),\n columns={\n 'daily_classifier': daily_classifier,\n 'daily_high': USEquityPricing.high.latest,\n 'daily_low': USEquityPricing.low.latest,\n 'weekly_classifier': weekly_classifier,\n 'weekly_high': weekly_high,\n 'weekly_low': weekly_low\n }\n )\n return pipe","def create_pipeline(self, train: LAMLDataset) -> LAMLTransformer:\n raise NotImplementedError","def construct(args,\n **kwargs):\n kw = parse_args(args)\n kw.update(kwargs)\n return (build_pipeline(**kw),\n kw)","def pipeline(args) :\n from pipeliner import create_pipeline\n create_pipeline(args)","def create_fake_pipeline(*_args, **_kwargs):\n return Pipeline(\n [\n node(match.clean_match_data, \"fake_match_data\", \"clean_match_data\"),\n node(\n common.convert_match_rows_to_teammatch_rows,\n \"clean_match_data\",\n \"match_data_b\",\n ),\n node(match.add_out_of_state, \"match_data_b\", \"match_data_c\"),\n node(match.add_travel_distance, \"match_data_c\", \"match_data_d\"),\n node(match.add_result, \"match_data_d\", \"match_data_e\"),\n node(match.add_margin, \"match_data_e\", \"match_data_f\"),\n node(\n match.add_shifted_team_features(\n shift_columns=[\n \"score\",\n \"oppo_score\",\n \"result\",\n \"margin\",\n \"team_goals\",\n \"team_behinds\",\n ]\n ),\n \"match_data_f\",\n \"match_data_g\",\n ),\n node(match.add_cum_win_points, \"match_data_g\", \"match_data_h\"),\n node(match.add_win_streak, \"match_data_h\", \"match_data_i\"),\n ]\n )","def __init__(self, *pipeline: Iterable[WarningDiscriminator]):\n if not pipeline:\n pipeline = []\n\n self.pipeline = list(pipeline)","def copy_me(self):\n signature = inspect.getfullargspec(OutputSettings.__init__)[0]\n settings = OutputSettings()\n for attr in signature:\n if hasattr(self.output_settings, attr):\n setattr(settings, attr, getattr(self.output_settings, attr))\n settings.initialize_log_file()\n\n # create new Hyperpipe instance\n pipe_copy = Hyperpipe(\n name=self.name,\n inner_cv=deepcopy(self.cross_validation.inner_cv),\n outer_cv=deepcopy(self.cross_validation.outer_cv),\n best_config_metric=self.optimization.best_config_metric,\n metrics=self.optimization.metrics,\n optimizer=self.optimization.optimizer_input_str,\n optimizer_params=self.optimization.optimizer_params,\n output_settings=settings,\n )\n\n signature = inspect.getfullargspec(self.__init__)[0]\n for attr in signature:\n if hasattr(self, attr) and attr != \"output_settings\":\n setattr(pipe_copy, attr, getattr(self, attr))\n\n if hasattr(self, \"preprocessing\") and self.preprocessing:\n preprocessing = Preprocessing()\n for element in self.preprocessing.elements:\n preprocessing += element.copy_me()\n pipe_copy += preprocessing\n if hasattr(self, \"elements\"):\n for element in self.elements:\n pipe_copy += element.copy_me()\n return pipe_copy","def new(self, **kwargs):\n return self.__model__(**self._preprocess_params(kwargs))","def fill_pipeline():\n\n # m1_pca = PCA()\n m1_pca = PCA(svd_solver='randomized', whiten=True) # 与官网里子一致的后2个参数，否则分数很差\n # m1_pca.fit(X_train)\n\n m2_svc = SVC(kernel='rbf', class_weight='balanced')\n\n pipe = Pipeline(steps=[('pca', m1_pca),\n ('svc', m2_svc)])\n print('\\n===================原 estimator')\n pprint(pipe.named_steps)\n return pipe","def _make_filtered_pipeline(\n input_pipeline: p_pb2.Pipeline,\n node_map: 'collections.OrderedDict[str, p_pb2.PipelineNode]',\n fixed_deployment_config: Optional[any_pb2.Any] = None) -> p_pb2.Pipeline:\n result_pipeline = p_pb2.Pipeline()\n result_pipeline.CopyFrom(input_pipeline)\n del result_pipeline.nodes[:]\n result_pipeline.nodes.extend(\n p_pb2.Pipeline.PipelineOrNode(pipeline_node=node_map[node_id])\n for node_id in node_map)\n if fixed_deployment_config:\n result_pipeline.deployment_config.CopyFrom(fixed_deployment_config)\n return result_pipeline","def _get_pipeline(self, params_dict):\n p = Pipeline(steps=[('normalise', StandardScaler()),\n ('add_noise', NoiseAdder()),\n ('dim_reduce', PCA()),\n ('cluster', KMeans())])\n p.set_params(**params_dict)\n return p","def _create_pipeline(self) -> TfmIterator:\n # 1. Initialise TubRecord -> x, y transformations\n def get_x(record: TubRecord) -> Dict[str, Union[float, np.ndarray]]:\n \"\"\" Extracting x from record for training\"\"\"\n out_dict = self.model.x_transform(record, self.image_processor)\n # apply the normalisation here on the fly to go from uint8 -> float\n out_dict['img_in'] = normalize_image(out_dict['img_in'])\n return out_dict\n\n def get_y(record: TubRecord) -> Dict[str, Union[float, np.ndarray]]:\n \"\"\" Extracting y from record for training \"\"\"\n y = self.model.y_transform(record)\n return y\n\n # 2. Build pipeline using the transformations\n pipeline = self.sequence.build_pipeline(x_transform=get_x,\n y_transform=get_y)\n return pipeline","def _create_pipeline(self) -> codepipeline.Pipeline:\n source_output = codepipeline.Artifact()\n build_output = codepipeline.Artifact()\n return codepipeline.Pipeline(\n self,\n 'Pipeline',\n stages=[\n self._create_source_stage('Source', source_output),\n # self._create_image_build_stage(\n # 'Build', source_output, build_output),\n # self._create_deploy_stage('Deploy', build_output)\n ]\n )","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def __new__(*args):","def make_pipeline():\n \n # Base universe set to the QTradableStocksUS\n base_universe = QTradableStocksUS()#Q500US()\n base_universe = (base_universe & Q500US())\n base_universe = (base_universe & Fundamentals.market_cap.latest.top(150))\n \n # Factor of yesterday's close price.\n #yesterday_close = USEquityPricing.close.latest\n \n pipe = Pipeline(\n columns={\n #'close': yesterday_close,\n 'sector': Sector(),\n },\n screen=base_universe\n )\n return pipe","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ...","def __new__(*args, **kwargs):\n ..."],"string":"[\n \"def build_own_pipeline() -> Pipeline:\\n nn_pipeline = None\\n\\n nn_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('tfidf', TfidfTransformer()),\\n ('clf', MLPClassifier()) \\n ])\\n \\n return nn_pipeline\",\n \"def pipeline(self) -> Pipeline:\\n if self._to_pipeline is None:\\n raise AttributeError(\\n \\\"pipeline not available because `to_pipeline` was not set on __init__.\\\"\\n )\\n return self._to_pipeline(self)\",\n \"def __init__(self, pipeline, config=None):\\n self.config = config\\n self.pipeline = pipeline\",\n \"def from_pipeline(cls, pipeline, proba=None, repeat=None):\\n if proba is None:\\n if repeat is None:\\n new_p = cls(pipeline=pipeline)\\n else:\\n if pipeline.num_actions == 1 and pipeline.get_last_action_proba() is None:\\n new_p = cls(pipeline=pipeline, repeat=repeat)\\n else:\\n new_p = cls()\\n new_p.append_pipeline(pipeline, repeat=repeat)\\n else:\\n if pipeline.num_actions == 1 and pipeline.get_last_action_repeat() is None:\\n new_p = cls(pipeline=pipeline, proba=proba)\\n else:\\n new_p = cls()\\n new_p.append_pipeline(pipeline, proba=proba)\\n return new_p\",\n \"def __init__(self, pipeline=PIPELINE, name=\\\"fake_estimator\\\"):\\n super().__init__(pipeline=pipeline, name=name)\",\n \"def build_own_pipeline() -> Pipeline:\\n clf = svm.LinearSVC(C=2, loss='hinge')\\n vect = TfidfVectorizer(ngram_range=(1, 2))\\n\\n pipeline = None\\n ##### Write code here #######\\n pipeline = Pipeline([\\n ('vect', vect),\\n ('tfidf', TfidfTransformer()),\\n ('clf', clf)\\n ])\\n ##### End of your work ######\\n return pipeline\",\n \"def pipeline():\\n\\n test_pipeline = (Pipeline()\\n .init_variable('current_loss')\\n .init_model('model', C('model_class'),\\n 'dynamic', C('model_config'))\\n .to_array(dtype='float32')\\n .train_model('model',\\n inputs=B('images'),\\n targets=B('labels'),\\n outputs='loss',\\n save_to=V('current_loss'))\\n )\\n return test_pipeline\",\n \"def make_full_pipeline(\\n preprocess_pipe: ColumnTransformer, model: BaseEstimator\\n) -> Pipeline:\\n full_pipe = sklearn.pipeline.Pipeline(\\n [(\\\"preprocess\\\", preprocess_pipe), (\\\"model\\\", model)]\\n )\\n return full_pipe\",\n \"def pipeline(self):\\n # gotta avoid circular imports by deferring\\n from .pipeline import Pipeline\\n return Pipeline().from_source(self._collection)\",\n \"def _construct(self, dataflow):\\n dataflow = copy_dataflow(dataflow, self.container)\\n return dataflow\",\n \"def __init__(self, pipeline, **kwargs):\\n self.pipeline = pipeline\\n\\n self.batch_size = pipeline.batch_size\\n self.X_train = None\\n self.y_train = None\\n self.X_valid = None\\n self.y_valid = None\\n\\n # Child classes should have init signature:\\n # (self, batch_size, **kwargs), should call this __init__ and then\\n # define self.X_train, self.y_train, self.X_valid, and self.y_valid\",\n \"def set_pipeline(self):\\n pipe_distance = make_pipeline(DistanceTransformer(), RobustScaler())\\n pipe_time = make_pipeline(TimeFeaturesEncoder(time_column='pickup_datetime'), OneHotEncoder(handle_unknown='ignore'))\\n dist_cols = ['pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'dropoff_longitude']\\n time_cols = ['pickup_datetime']\\n feat_eng_bloc = ColumnTransformer([('time', pipe_time, time_cols),\\n ('distance', pipe_distance, dist_cols)]\\n )\\n self.pipeline = Pipeline(steps=[('feat_eng_bloc', feat_eng_bloc),\\n ('regressor', RandomForestRegressor())])\\n return self.pipeline\",\n \"def run(self):\\n pipeline = set_pipeline()\\n pipeline.fit(self.X_train, self.y_train)\\n return pipeline\",\n \"def make_pipeline():\\n # exchange = Fundamentals.exchange_id.latest\\n # nyse_filter = exchange.eq('NYS')\\n symbol_filter = StaticSids([TRADING_SID])\\n set_benchmark(TRADING_SID) \\n # volume_filter = VolumeFilter(\\n # inputs=[USEquityPricing.volume],\\n # window_length=1,\\n # mask=symbol_filter\\n # )\\n\\n # is_setup = volume_filter & alpha_long_weekly & alpha_long_daily\\n weekly_high = WeeklyHigh(\\n inputs=[USEquityPricing.high],\\n mask=symbol_filter\\n )\\n weekly_low = WeeklyLow(\\n inputs=[USEquityPricing.low],\\n mask=symbol_filter\\n )\\n weekly_classifier = WeeklyClassifier(\\n inputs=[\\n USEquityPricing.open,\\n USEquityPricing.high,\\n USEquityPricing.low,\\n USEquityPricing.close\\n ],\\n mask=symbol_filter\\n )\\n daily_classifier = DailyClassifier(\\n inputs=[\\n USEquityPricing.open,\\n USEquityPricing.high,\\n USEquityPricing.low,\\n USEquityPricing.close\\n ],\\n mask=symbol_filter\\n\\n )\\n\\n pipe = Pipeline(\\n screen=symbol_filter, # & (daily_classifier > 0),\\n columns={\\n 'daily_classifier': daily_classifier,\\n 'daily_high': USEquityPricing.high.latest,\\n 'daily_low': USEquityPricing.low.latest,\\n 'weekly_classifier': weekly_classifier,\\n 'weekly_high': weekly_high,\\n 'weekly_low': weekly_low\\n }\\n )\\n return pipe\",\n \"def create_pipeline(self, train: LAMLDataset) -> LAMLTransformer:\\n raise NotImplementedError\",\n \"def construct(args,\\n **kwargs):\\n kw = parse_args(args)\\n kw.update(kwargs)\\n return (build_pipeline(**kw),\\n kw)\",\n \"def pipeline(args) :\\n from pipeliner import create_pipeline\\n create_pipeline(args)\",\n \"def create_fake_pipeline(*_args, **_kwargs):\\n return Pipeline(\\n [\\n node(match.clean_match_data, \\\"fake_match_data\\\", \\\"clean_match_data\\\"),\\n node(\\n common.convert_match_rows_to_teammatch_rows,\\n \\\"clean_match_data\\\",\\n \\\"match_data_b\\\",\\n ),\\n node(match.add_out_of_state, \\\"match_data_b\\\", \\\"match_data_c\\\"),\\n node(match.add_travel_distance, \\\"match_data_c\\\", \\\"match_data_d\\\"),\\n node(match.add_result, \\\"match_data_d\\\", \\\"match_data_e\\\"),\\n node(match.add_margin, \\\"match_data_e\\\", \\\"match_data_f\\\"),\\n node(\\n match.add_shifted_team_features(\\n shift_columns=[\\n \\\"score\\\",\\n \\\"oppo_score\\\",\\n \\\"result\\\",\\n \\\"margin\\\",\\n \\\"team_goals\\\",\\n \\\"team_behinds\\\",\\n ]\\n ),\\n \\\"match_data_f\\\",\\n \\\"match_data_g\\\",\\n ),\\n node(match.add_cum_win_points, \\\"match_data_g\\\", \\\"match_data_h\\\"),\\n node(match.add_win_streak, \\\"match_data_h\\\", \\\"match_data_i\\\"),\\n ]\\n )\",\n \"def __init__(self, *pipeline: Iterable[WarningDiscriminator]):\\n if not pipeline:\\n pipeline = []\\n\\n self.pipeline = list(pipeline)\",\n \"def copy_me(self):\\n signature = inspect.getfullargspec(OutputSettings.__init__)[0]\\n settings = OutputSettings()\\n for attr in signature:\\n if hasattr(self.output_settings, attr):\\n setattr(settings, attr, getattr(self.output_settings, attr))\\n settings.initialize_log_file()\\n\\n # create new Hyperpipe instance\\n pipe_copy = Hyperpipe(\\n name=self.name,\\n inner_cv=deepcopy(self.cross_validation.inner_cv),\\n outer_cv=deepcopy(self.cross_validation.outer_cv),\\n best_config_metric=self.optimization.best_config_metric,\\n metrics=self.optimization.metrics,\\n optimizer=self.optimization.optimizer_input_str,\\n optimizer_params=self.optimization.optimizer_params,\\n output_settings=settings,\\n )\\n\\n signature = inspect.getfullargspec(self.__init__)[0]\\n for attr in signature:\\n if hasattr(self, attr) and attr != \\\"output_settings\\\":\\n setattr(pipe_copy, attr, getattr(self, attr))\\n\\n if hasattr(self, \\\"preprocessing\\\") and self.preprocessing:\\n preprocessing = Preprocessing()\\n for element in self.preprocessing.elements:\\n preprocessing += element.copy_me()\\n pipe_copy += preprocessing\\n if hasattr(self, \\\"elements\\\"):\\n for element in self.elements:\\n pipe_copy += element.copy_me()\\n return pipe_copy\",\n \"def new(self, **kwargs):\\n return self.__model__(**self._preprocess_params(kwargs))\",\n \"def fill_pipeline():\\n\\n # m1_pca = PCA()\\n m1_pca = PCA(svd_solver='randomized', whiten=True) # 与官网里子一致的后2个参数，否则分数很差\\n # m1_pca.fit(X_train)\\n\\n m2_svc = SVC(kernel='rbf', class_weight='balanced')\\n\\n pipe = Pipeline(steps=[('pca', m1_pca),\\n ('svc', m2_svc)])\\n print('\\\\n===================原 estimator')\\n pprint(pipe.named_steps)\\n return pipe\",\n \"def _make_filtered_pipeline(\\n input_pipeline: p_pb2.Pipeline,\\n node_map: 'collections.OrderedDict[str, p_pb2.PipelineNode]',\\n fixed_deployment_config: Optional[any_pb2.Any] = None) -> p_pb2.Pipeline:\\n result_pipeline = p_pb2.Pipeline()\\n result_pipeline.CopyFrom(input_pipeline)\\n del result_pipeline.nodes[:]\\n result_pipeline.nodes.extend(\\n p_pb2.Pipeline.PipelineOrNode(pipeline_node=node_map[node_id])\\n for node_id in node_map)\\n if fixed_deployment_config:\\n result_pipeline.deployment_config.CopyFrom(fixed_deployment_config)\\n return result_pipeline\",\n \"def _get_pipeline(self, params_dict):\\n p = Pipeline(steps=[('normalise', StandardScaler()),\\n ('add_noise', NoiseAdder()),\\n ('dim_reduce', PCA()),\\n ('cluster', KMeans())])\\n p.set_params(**params_dict)\\n return p\",\n \"def _create_pipeline(self) -> TfmIterator:\\n # 1. Initialise TubRecord -> x, y transformations\\n def get_x(record: TubRecord) -> Dict[str, Union[float, np.ndarray]]:\\n \\\"\\\"\\\" Extracting x from record for training\\\"\\\"\\\"\\n out_dict = self.model.x_transform(record, self.image_processor)\\n # apply the normalisation here on the fly to go from uint8 -> float\\n out_dict['img_in'] = normalize_image(out_dict['img_in'])\\n return out_dict\\n\\n def get_y(record: TubRecord) -> Dict[str, Union[float, np.ndarray]]:\\n \\\"\\\"\\\" Extracting y from record for training \\\"\\\"\\\"\\n y = self.model.y_transform(record)\\n return y\\n\\n # 2. Build pipeline using the transformations\\n pipeline = self.sequence.build_pipeline(x_transform=get_x,\\n y_transform=get_y)\\n return pipeline\",\n \"def _create_pipeline(self) -> codepipeline.Pipeline:\\n source_output = codepipeline.Artifact()\\n build_output = codepipeline.Artifact()\\n return codepipeline.Pipeline(\\n self,\\n 'Pipeline',\\n stages=[\\n self._create_source_stage('Source', source_output),\\n # self._create_image_build_stage(\\n # 'Build', source_output, build_output),\\n # self._create_deploy_stage('Deploy', build_output)\\n ]\\n )\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def __new__(*args):\",\n \"def make_pipeline():\\n \\n # Base universe set to the QTradableStocksUS\\n base_universe = QTradableStocksUS()#Q500US()\\n base_universe = (base_universe & Q500US())\\n base_universe = (base_universe & Fundamentals.market_cap.latest.top(150))\\n \\n # Factor of yesterday's close price.\\n #yesterday_close = USEquityPricing.close.latest\\n \\n pipe = Pipeline(\\n columns={\\n #'close': yesterday_close,\\n 'sector': Sector(),\\n },\\n screen=base_universe\\n )\\n return pipe\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\",\n \"def __new__(*args, **kwargs):\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6718284","0.6605446","0.64793473","0.63921684","0.6358232","0.63030565","0.6258657","0.62482244","0.6221897","0.62135386","0.62027407","0.61847925","0.6180768","0.61727595","0.61503994","0.6145696","0.61375916","0.6078692","0.6036495","0.60242677","0.6003921","0.5989956","0.59778464","0.5977369","0.5972336","0.59573793","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952896","0.5952783","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009","0.5934009"],"string":"[\n \"0.6718284\",\n \"0.6605446\",\n \"0.64793473\",\n \"0.63921684\",\n \"0.6358232\",\n \"0.63030565\",\n \"0.6258657\",\n \"0.62482244\",\n \"0.6221897\",\n \"0.62135386\",\n \"0.62027407\",\n \"0.61847925\",\n \"0.6180768\",\n \"0.61727595\",\n \"0.61503994\",\n \"0.6145696\",\n \"0.61375916\",\n \"0.6078692\",\n \"0.6036495\",\n \"0.60242677\",\n \"0.6003921\",\n \"0.5989956\",\n \"0.59778464\",\n \"0.5977369\",\n \"0.5972336\",\n \"0.59573793\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952896\",\n \"0.5952783\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\",\n \"0.5934009\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81395,"cells":{"query":{"kind":"string","value":"Helper method that calls ``tokenizer.batch_encode`` if possible, and if not, falls back to calling ``tokenizer.encode`` for each input."},"document":{"kind":"string","value":"def tokenize(self, inputs):\n if hasattr(self.tokenizer, \"batch_encode\"):\n return self.tokenizer.batch_encode(inputs)\n else:\n return [self.tokenizer.encode(x) for x in inputs]"},"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 encode(batch, tokenizer):\n return tokenizer.batch_encode_plus(batch['sentence'], padding='max_length')","def _batch_encode(self, text: List[str]) -> List[List[str]]:\n token_ids: List[List[int]] = self.bert_model.batch_encode([t.strip() for t in text])\n tokens_ids_str: List[List[str]] = [[str(t) for t in token_id] for token_id in token_ids]\n return tokens_ids_str","def encode(self, phrases, **kwargs):\n\n if not phrases:\n return []\n\n if not isinstance(phrases, (str, list)):\n raise TypeError(f\"argument phrases must be of type str or list, not {type(phrases)}\")\n\n batch_size = kwargs.get(\"batch_size\", 16)\n _len_phrases = len(phrases) if isinstance(phrases, list) else 1\n show_progress_bar = kwargs.get(\"show_progress_bar\", False) and _len_phrases > 1\n output_value = kwargs.get(\"output_value\", 'sentence_embedding')\n convert_to_numpy = kwargs.get(\"convert_to_numpy\", True)\n convert_to_tensor = kwargs.get(\"convert_to_tensor\", False)\n device = kwargs.get(\"device\", self.device)\n concat_last_n_layers = kwargs.get(\"concat_last_n_layers\", 1)\n normalize_token_embs = kwargs.get(\"normalize_token_embs\", False)\n\n # `False` for first call but might not for the subsequent calls\n _use_sbert_model = getattr(self, \"_use_sbert_model\", False)\n\n if not _use_sbert_model:\n try:\n # this snippet is to reduce dependency on sentence-transformers library\n # note that currently, the dependency is not fully eliminated due to backwards\n # compatability issues in huggingface-transformers between older (python 3.6)\n # and newer (python >=3.7) versions which needs more conditions to be implemented\n # in `_encode_local` and hence will be addressed in future work\n # TODO: eliminate depedency on sentence-transformers library\n results = self._encode_local(phrases,\n batch_size=batch_size,\n show_progress_bar=show_progress_bar,\n output_value=output_value,\n convert_to_numpy=convert_to_numpy,\n convert_to_tensor=convert_to_tensor,\n device=device,\n concat_last_n_layers=concat_last_n_layers,\n normalize_token_embs=normalize_token_embs)\n setattr(self, \"_use_sbert_model\", False)\n except TypeError as e:\n logger.error(e)\n if concat_last_n_layers != 1 or normalize_token_embs:\n msg = f\"{'concat_last_n_layers,' if concat_last_n_layers != 1 else ''} \" \\\n f\"{'normalize_token_embs' if normalize_token_embs else ''} \" \\\n f\"ignored as resorting to using encode methods from sentence-transformers\"\n logger.warning(msg)\n setattr(self, \"_use_sbert_model\", True)\n\n if getattr(self, \"_use_sbert_model\"):\n results = self.sbert_model.encode(phrases,\n batch_size=batch_size,\n show_progress_bar=show_progress_bar,\n output_value=output_value,\n convert_to_numpy=convert_to_numpy,\n convert_to_tensor=convert_to_tensor,\n device=device)\n\n return results","def encode_all(self, inputs, encoder):\n input_shape = tf.shape(inputs)\n num_timesteps, batch_size = input_shape[0], input_shape[1]\n reshaped_inputs = tf.reshape(inputs, [-1, inputs.shape[-1]])\n inputs_encoded = encoder(reshaped_inputs)\n inputs_encoded = tf.reshape(inputs_encoded, [num_timesteps, batch_size, encoder.output_size])\n return inputs_encoded","def encode_batch(self, sentences: List[str], field_name, features=None) -> List[SequentialField]:\n # We need to set this so that `tokenizers` package does not complain about detecting forks.\n os.environ['TOKENIZERS_PARALLELISM'] = \"true\"\n\n if features is None:\n features = []\n extract_word_pieces = False\n else:\n assert all([len(sentence.split()) == len(feature) for sentence, feature in zip(sentences, features)])\n extract_word_pieces = True\n\n batch_size = len(sentences)\n\n if field_name != 'answer':\n sentences = [self.input_prefix + sent for sent in sentences]\n\n if self._preprocess_special_tokens:\n if len(sentences) > MULTIPROCESSING_THRESHOLD:\n multiprocessing_factor = multiprocessing.cpu_count() // len(get_devices(self.args.devices))\n logger.info('multiprocessing factor for special token preprocessing is %d', multiprocessing_factor)\n with multiprocessing.Pool(multiprocessing_factor) as p:\n sentences, index2expansions = list(\n zip(\n *p.map(\n functools.partial(self._apply_special_token_preprocessing, return_idx2exp=bool(len(features))),\n sentences,\n )\n )\n )\n else:\n sentences, index2expansions = list(\n zip(\n *map(\n functools.partial(self._apply_special_token_preprocessing, return_idx2exp=bool(len(features))),\n sentences,\n )\n )\n )\n\n all_input_features = []\n if features:\n for i, (sentence, index2expansion) in enumerate(zip(sentences, index2expansions)):\n feat = features[i]\n new_feat = []\n keys = set(index2expansion.keys())\n for j in range(len(feat)):\n repeat = 1\n if j in keys:\n repeat = index2expansion[j]\n\n new_feat.extend(feat[j] * repeat)\n\n assert len(new_feat) == len(sentence.split(' '))\n\n all_input_features.append(new_feat)\n\n features = all_input_features\n\n # batch_encode_plus for fast tokenizers returns tokenized text\n # whereas slow version do not. We breakdown slow tokenization into two steps\n # extract tokenized text first, use that to adjust features\n # then pass tokenized text to `_batch_prepare_for_model`\n def do_fast_tokenization(extract_word_pieces):\n all_wp_tokenized = []\n batch_encoded = self._tokenizer.batch_encode_plus(\n list(sentences),\n add_special_tokens=True,\n max_length=None,\n return_length=True,\n return_attention_mask=False,\n return_special_tokens_mask=True,\n )\n if extract_word_pieces:\n for encoding in batch_encoded.encodings:\n # remove special tokens\n num_prefix_special_tokens, num_suffix_special_tokens = self.get_num_special_tokens(\n encoding.special_tokens_mask\n )\n wp_tokens = encoding.tokens[num_prefix_special_tokens:-num_suffix_special_tokens]\n all_wp_tokenized.append(wp_tokens)\n\n return batch_encoded, all_wp_tokenized\n\n def do_slow_tokenization(extract_word_pieces):\n all_input_ids = []\n all_wp_tokenized = []\n if extract_word_pieces:\n for i in range(batch_size):\n text = sentences[i]\n wp_tokenized = self._tokenizer.tokenize(text)\n all_wp_tokenized.append(wp_tokenized)\n\n # None indicates encoding single instance not paired inputs\n all_input_ids.append((self._tokenizer.convert_tokens_to_ids(wp_tokenized), None))\n\n batch_encoded = self._tokenizer._batch_prepare_for_model(\n all_input_ids,\n add_special_tokens=True,\n max_length=None,\n return_length=True,\n return_attention_mask=False,\n return_special_tokens_mask=True,\n )\n else:\n batch_encoded = self._tokenizer.batch_encode_plus(\n list(sentences),\n add_special_tokens=True,\n max_length=None,\n return_length=True,\n return_attention_mask=False,\n return_special_tokens_mask=True,\n )\n return batch_encoded, all_wp_tokenized\n\n if self._use_fast():\n if field_name == 'answer':\n with self._tokenizer.as_target_tokenizer():\n batch_encoded, all_wp_tokenized = do_fast_tokenization(extract_word_pieces)\n else:\n batch_encoded, all_wp_tokenized = do_fast_tokenization(extract_word_pieces)\n\n else:\n if field_name == 'answer':\n with self._tokenizer.as_target_tokenizer():\n batch_encoded, all_wp_tokenized = do_slow_tokenization(extract_word_pieces)\n else:\n batch_encoded, all_wp_tokenized = do_slow_tokenization(extract_word_pieces)\n\n all_input_features = []\n\n if features:\n for i in range(batch_size):\n wp_features = []\n wp_tokenized = all_wp_tokenized[i]\n\n feat = features[i]\n\n # first token is always not a piece\n is_wp = [0] + [int(self._tokenizer.is_piece_fn(wp)) for wp in wp_tokenized[1:]]\n k = -1\n for j, wp in enumerate(wp_tokenized):\n if not is_wp[j]:\n k += 1\n wp_features.append(feat[k])\n\n assert len(wp_tokenized) == len(wp_features)\n\n all_input_features.append(wp_features)\n\n features = all_input_features\n\n batch_special_tokens_mask = batch_encoded.special_tokens_mask\n\n batch_features = []\n\n if features:\n for i in range(batch_size):\n feat = features[i]\n special_tokens_mask = batch_special_tokens_mask[i]\n num_prefix_special_tokens, num_suffix_special_tokens = self.get_num_special_tokens(special_tokens_mask)\n\n pad_feat = Entity.get_pad_entity(self.args.max_features_size)\n feat = [pad_feat] * num_prefix_special_tokens + feat + [pad_feat] * num_suffix_special_tokens\n\n batch_features.append(feat)\n\n batch_numerical = batch_encoded.input_ids\n batch_length = batch_encoded.length\n\n batch_decoder_numerical = []\n if self.decoder_vocab:\n for i in range(batch_size):\n batch_decoder_numerical.append(self.decoder_vocab.encode(batch_numerical[i]))\n else:\n batch_decoder_numerical = [[]] * len(batch_numerical)\n\n sequential_fields = []\n for i in range(batch_size):\n if features:\n feature = [feat.flatten() for feat in batch_features[i]]\n assert len(batch_numerical[i]) == len(feature)\n else:\n feature = None\n\n sequential_fields.append(\n SequentialField(\n value=batch_numerical[i],\n length=batch_length[i],\n limited=batch_decoder_numerical[i],\n feature=feature,\n )\n )\n return sequential_fields","def batch_encode(self,\n batch_text_or_text_pairs,\n max_seq_len=512,\n pad_to_max_seq_len=False,\n stride=0,\n is_split_into_words=False,\n truncation_strategy=\"longest_first\",\n return_position_ids=False,\n return_token_type_ids=True,\n return_attention_mask=False,\n return_length=False,\n return_overflowing_tokens=False,\n return_special_tokens_mask=False):\n\n def get_input_ids(text):\n if isinstance(text, str):\n tokens = self._tokenize(text)\n return self.convert_tokens_to_ids(tokens)\n elif isinstance(text,\n (list, tuple)) and len(text) > 0 and isinstance(\n text[0], str):\n return self.convert_tokens_to_ids(text)\n elif isinstance(text,\n (list, tuple)) and len(text) > 0 and isinstance(\n text[0], int):\n return text\n else:\n raise ValueError(\n \"Input is not valid. Should be a string, a list/tuple of strings or a list/tuple of integers.\"\n )\n\n batch_encode_inputs = []\n for example_id, tokens_or_pair_tokens in enumerate(\n batch_text_or_text_pairs):\n if not isinstance(tokens_or_pair_tokens, (list, tuple)):\n text, text_pair = tokens_or_pair_tokens, None\n elif is_split_into_words and not isinstance(\n tokens_or_pair_tokens[0], (list, tuple)):\n text, text_pair = tokens_or_pair_tokens, None\n else:\n text, text_pair = tokens_or_pair_tokens\n\n first_ids = get_input_ids(text)\n second_ids = get_input_ids(\n text_pair) if text_pair is not None else None\n\n if stride > 0 and second_ids is not None:\n\n max_len_for_pair = max_seq_len - len(first_ids) - self.num_special_tokens_to_add(\n pair=True) # need -4 <sep> A </sep> </sep> B <sep>\n\n token_offset_mapping = self.rematch(text)\n token_pair_offset_mapping = self.rematch(text_pair)\n\n while True:\n encoded_inputs = {}\n\n ids = first_ids\n mapping = token_offset_mapping\n if len(second_ids) <= max_len_for_pair:\n pair_ids = second_ids\n pair_mapping = token_pair_offset_mapping\n else:\n pair_ids = second_ids[:max_len_for_pair]\n pair_mapping = token_pair_offset_mapping[:max_len_for_pair]\n\n offset_mapping = self.build_offset_mapping_with_special_tokens(\n mapping, pair_mapping)\n sequence = self.build_inputs_with_special_tokens(ids,\n pair_ids)\n token_type_ids = self.create_token_type_ids_from_sequences(\n ids, pair_ids)\n\n # Build output dictionnary\n encoded_inputs[\"input_ids\"] = sequence\n if return_token_type_ids:\n encoded_inputs[\"token_type_ids\"] = token_type_ids\n if return_special_tokens_mask:\n encoded_inputs[\n \"special_tokens_mask\"] = self.get_special_tokens_mask(\n ids, pair_ids)\n if return_length:\n encoded_inputs[\"seq_len\"] = len(encoded_inputs[\n \"input_ids\"])\n\n # Check lengths\n assert max_seq_len is None or len(encoded_inputs[\n \"input_ids\"]) <= max_seq_len\n\n # Padding\n needs_to_be_padded = pad_to_max_seq_len and \\\n max_seq_len and len(encoded_inputs[\"input_ids\"]) < max_seq_len\n\n encoded_inputs['offset_mapping'] = offset_mapping\n\n if needs_to_be_padded:\n difference = max_seq_len - len(encoded_inputs[\n \"input_ids\"])\n if self.padding_side == 'right':\n if return_attention_mask:\n encoded_inputs[\"attention_mask\"] = [1] * len(\n encoded_inputs[\n \"input_ids\"]) + [0] * difference\n if return_token_type_ids:\n # 0 for padding token mask\n encoded_inputs[\"token_type_ids\"] = (\n encoded_inputs[\"token_type_ids\"] +\n [self.pad_token_type_id] * difference)\n if return_special_tokens_mask:\n encoded_inputs[\n \"special_tokens_mask\"] = encoded_inputs[\n \"special_tokens_mask\"] + [1\n ] * difference\n encoded_inputs[\"input_ids\"] = encoded_inputs[\n \"input_ids\"] + [self.pad_token_id] * difference\n encoded_inputs['offset_mapping'] = encoded_inputs[\n 'offset_mapping'] + [(0, 0)] * difference\n elif self.padding_side == 'left':\n if return_attention_mask:\n encoded_inputs[\"attention_mask\"] = [\n 0\n ] * difference + [1] * len(encoded_inputs[\n \"input_ids\"])\n if return_token_type_ids:\n # 0 for padding token mask\n encoded_inputs[\"token_type_ids\"] = (\n [self.pad_token_type_id] * difference +\n encoded_inputs[\"token_type_ids\"])\n if return_special_tokens_mask:\n encoded_inputs[\"special_tokens_mask\"] = [\n 1\n ] * difference + encoded_inputs[\n \"special_tokens_mask\"]\n encoded_inputs[\"input_ids\"] = [\n self.pad_token_id\n ] * difference + encoded_inputs[\"input_ids\"]\n encoded_inputs['offset_mapping'] = [\n (0, 0)\n ] * difference + encoded_inputs['offset_mapping']\n else:\n if return_attention_mask:\n encoded_inputs[\"attention_mask\"] = [1] * len(\n encoded_inputs[\"input_ids\"])\n\n if return_position_ids:\n encoded_inputs[\"position_ids\"] = list(\n range(len(encoded_inputs[\"input_ids\"])))\n\n encoded_inputs['overflow_to_sample'] = example_id\n batch_encode_inputs.append(encoded_inputs)\n\n if len(second_ids) <= max_len_for_pair:\n break\n else:\n second_ids = second_ids[max_len_for_pair - stride:]\n token_pair_offset_mapping = token_pair_offset_mapping[max_len_for_pair - stride:]\n\n else:\n batch_encode_inputs.append(\n self.encode(\n first_ids,\n second_ids,\n max_seq_len=max_seq_len,\n pad_to_max_seq_len=pad_to_max_seq_len,\n truncation_strategy=truncation_strategy,\n return_position_ids=return_position_ids,\n return_token_type_ids=return_token_type_ids,\n return_attention_mask=return_attention_mask,\n return_length=return_length,\n return_overflowing_tokens=return_overflowing_tokens,\n return_special_tokens_mask=return_special_tokens_mask))\n\n return batch_encode_inputs","def __call__(\n self,\n text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]],\n text_pair: Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None,\n boxes: Union[List[List[int]], List[List[List[int]]]] = None,\n word_labels: Optional[Union[List[int], List[List[int]]]] = None,\n add_special_tokens: bool = True,\n padding: Union[bool, str, PaddingStrategy] = False,\n truncation: Union[bool, str, TruncationStrategy] = None,\n max_length: Optional[int] = None,\n stride: int = 0,\n pad_to_multiple_of: Optional[int] = None,\n return_tensors: Optional[Union[str, TensorType]] = None,\n return_token_type_ids: Optional[bool] = None,\n return_attention_mask: Optional[bool] = None,\n return_overflowing_tokens: bool = False,\n return_special_tokens_mask: bool = False,\n return_offsets_mapping: bool = False,\n return_length: bool = False,\n verbose: bool = True,\n **kwargs,\n ) -> BatchEncoding:\n\n # Input type checking for clearer error\n def _is_valid_text_input(t):\n if isinstance(t, str):\n # Strings are fine\n return True\n elif isinstance(t, (list, tuple)):\n # List are fine as long as they are...\n if len(t) == 0:\n # ... empty\n return True\n elif isinstance(t[0], str):\n # ... list of strings\n return True\n elif isinstance(t[0], (list, tuple)):\n # ... list with an empty list or with a list of strings\n return len(t[0]) == 0 or isinstance(t[0][0], str)\n else:\n return False\n else:\n return False\n\n if text_pair is not None:\n # in case text + text_pair are provided, text = questions, text_pair = words\n if not _is_valid_text_input(text):\n raise ValueError(\"text input must of type `str` (single example) or `List[str]` (batch of examples). \")\n if not isinstance(text_pair, (list, tuple)):\n raise ValueError(\n \"words must of type `List[str]` (single pretokenized example), \"\n \"or `List[List[str]]` (batch of pretokenized examples).\"\n )\n else:\n # in case only text is provided => must be words\n if not isinstance(text, (list, tuple)):\n raise ValueError(\n \"Words must of type `List[str]` (single pretokenized example), \"\n \"or `List[List[str]]` (batch of pretokenized examples).\"\n )\n\n if text_pair is not None:\n is_batched = isinstance(text, (list, tuple))\n else:\n is_batched = isinstance(text, (list, tuple)) and text and isinstance(text[0], (list, tuple))\n\n words = text if text_pair is None else text_pair\n if boxes is None:\n raise ValueError(\"You must provide corresponding bounding boxes\")\n if is_batched:\n if len(words) != len(boxes):\n raise ValueError(\"You must provide words and boxes for an equal amount of examples\")\n for words_example, boxes_example in zip(words, boxes):\n if len(words_example) != len(boxes_example):\n raise ValueError(\"You must provide as many words as there are bounding boxes\")\n else:\n if len(words) != len(boxes):\n raise ValueError(\"You must provide as many words as there are bounding boxes\")\n\n if is_batched:\n if text_pair is not None and len(text) != len(text_pair):\n raise ValueError(\n f\"batch length of `text`: {len(text)} does not match batch length of `text_pair`:\"\n f\" {len(text_pair)}.\"\n )\n batch_text_or_text_pairs = list(zip(text, text_pair)) if text_pair is not None else text\n is_pair = bool(text_pair is not None)\n return self.batch_encode_plus(\n batch_text_or_text_pairs=batch_text_or_text_pairs,\n is_pair=is_pair,\n boxes=boxes,\n word_labels=word_labels,\n add_special_tokens=add_special_tokens,\n padding=padding,\n truncation=truncation,\n max_length=max_length,\n stride=stride,\n pad_to_multiple_of=pad_to_multiple_of,\n return_tensors=return_tensors,\n return_token_type_ids=return_token_type_ids,\n return_attention_mask=return_attention_mask,\n return_overflowing_tokens=return_overflowing_tokens,\n return_special_tokens_mask=return_special_tokens_mask,\n return_offsets_mapping=return_offsets_mapping,\n return_length=return_length,\n verbose=verbose,\n **kwargs,\n )\n else:\n return self.encode_plus(\n text=text,\n text_pair=text_pair,\n boxes=boxes,\n word_labels=word_labels,\n add_special_tokens=add_special_tokens,\n padding=padding,\n truncation=truncation,\n max_length=max_length,\n stride=stride,\n pad_to_multiple_of=pad_to_multiple_of,\n return_tensors=return_tensors,\n return_token_type_ids=return_token_type_ids,\n return_attention_mask=return_attention_mask,\n return_overflowing_tokens=return_overflowing_tokens,\n return_special_tokens_mask=return_special_tokens_mask,\n return_offsets_mapping=return_offsets_mapping,\n return_length=return_length,\n verbose=verbose,\n **kwargs,\n )","def _encode(self, src_token_ids, padding_mask, training=False):\n src_seq_len = tf.shape(src_token_ids)[1]\n\n # [batch_size, src_seq_len, hidden_size]\n src_token_embeddings = self._embedding_logits_layer(\n src_token_ids, 'embedding')\n\n # [src_seq_len, hidden_size]\n positional_encoding = utils.get_positional_encoding(\n src_seq_len, self._hidden_size)\n src_token_embeddings += positional_encoding\n src_token_embeddings = self._encoder_dropout_layer(\n src_token_embeddings, training)\n\n encoder_outputs = self._encoder(\n src_token_embeddings, padding_mask, training)\n return encoder_outputs","def encoder(self, inputs):\n pass","def encode_and_flatten(\n raw_text_iter: IterableDataset[str],\n tokenizer: Callable[[str], list[str]],\n vocab: Vocab,\n) -> torch.Tensor:\n data = [\n torch.tensor(vocab(tokenizer(item)), dtype=torch.long)\n for item in raw_text_iter\n ]\n return torch.cat(tuple(filter(lambda t: t.numel() > 0, data)))","def encode(self, text):\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\n batch_max_length = self.opt.model_params.max_len + 1\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\n batch_text = np.zeros((len(text), batch_max_length + 1), dtype=int)\n for i, t in enumerate(text):\n cur_text = list(t)\n cur_text.append('[s]')\n cur_text = [self.dict[char] for char in cur_text]\n batch_text[i][1:1 + len(cur_text)] = cur_text\n return tf.convert_to_tensor(batch_text, dtype=tf.int32), tf.convert_to_tensor(length, dtype=tf.int32)","def prepare_for_model(\n self,\n text: Union[TextInput, PreTokenizedInput],\n text_pair: Optional[PreTokenizedInput] = None,\n boxes: Optional[List[List[int]]] = None,\n word_labels: Optional[List[int]] = None,\n add_special_tokens: bool = True,\n padding: Union[bool, str, PaddingStrategy] = False,\n truncation: Union[bool, str, TruncationStrategy] = None,\n max_length: Optional[int] = None,\n stride: int = 0,\n pad_to_multiple_of: Optional[int] = None,\n return_tensors: Optional[Union[str, TensorType]] = None,\n return_token_type_ids: Optional[bool] = None,\n return_attention_mask: Optional[bool] = None,\n return_overflowing_tokens: bool = False,\n return_special_tokens_mask: bool = False,\n return_offsets_mapping: bool = False,\n return_length: bool = False,\n verbose: bool = True,\n prepend_batch_axis: bool = False,\n **kwargs,\n ) -> BatchEncoding:\n\n # Backward compatibility for 'truncation_strategy', 'pad_to_max_length'\n padding_strategy, truncation_strategy, max_length, kwargs = self._get_padding_truncation_strategies(\n padding=padding,\n truncation=truncation,\n max_length=max_length,\n pad_to_multiple_of=pad_to_multiple_of,\n verbose=verbose,\n **kwargs,\n )\n\n tokens = []\n pair_tokens = []\n token_boxes = []\n pair_token_boxes = []\n labels = []\n\n if text_pair is None:\n if word_labels is None:\n # CASE 1: document image classification (training + inference) + CASE 2: token classification (inference)\n for word, box in zip(text, boxes):\n if len(word) < 1: # skip empty words\n continue\n word_tokens = self.tokenize(word)\n tokens.extend(word_tokens)\n token_boxes.extend([box] * len(word_tokens))\n else:\n # CASE 2: token classification (training)\n for word, box, label in zip(text, boxes, word_labels):\n if len(word) < 1: # skip empty words\n continue\n word_tokens = self.tokenize(word)\n tokens.extend(word_tokens)\n token_boxes.extend([box] * len(word_tokens))\n if self.only_label_first_subword:\n # Use the real label id for the first token of the word, and padding ids for the remaining tokens\n labels.extend([label] + [self.pad_token_label] * (len(word_tokens) - 1))\n else:\n labels.extend([label] * len(word_tokens))\n else:\n # CASE 3: document visual question answering (inference)\n # text = question\n # text_pair = words\n tokens = self.tokenize(text)\n token_boxes = [self.pad_token_box for _ in range(len(tokens))] + [self.sep_token_box]\n\n for word, box in zip(text_pair, boxes):\n if len(word) < 1: # skip empty words\n continue\n word_tokens = self.tokenize(word)\n pair_tokens.extend(word_tokens)\n pair_token_boxes.extend([box] * len(word_tokens))\n\n # Create ids + pair_ids\n ids = self.convert_tokens_to_ids(tokens)\n pair_ids = self.convert_tokens_to_ids(pair_tokens) if pair_tokens else None\n\n # Compute the total size of the returned encodings\n pair = bool(pair_ids is not None)\n len_ids = len(ids)\n len_pair_ids = len(pair_ids) if pair else 0\n total_len = len_ids + len_pair_ids + (self.num_special_tokens_to_add(pair=pair) if add_special_tokens else 0)\n\n # Truncation: Handle max sequence length\n overflowing_tokens = []\n overflowing_token_boxes = []\n overflowing_labels = []\n if truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE and max_length and total_len > max_length:\n (\n ids,\n token_boxes,\n pair_ids,\n pair_token_boxes,\n labels,\n overflowing_tokens,\n overflowing_token_boxes,\n overflowing_labels,\n ) = self.truncate_sequences(\n ids,\n token_boxes,\n pair_ids=pair_ids,\n pair_token_boxes=pair_token_boxes,\n labels=labels,\n num_tokens_to_remove=total_len - max_length,\n truncation_strategy=truncation_strategy,\n stride=stride,\n )\n\n if return_token_type_ids and not add_special_tokens:\n raise ValueError(\n \"Asking to return token_type_ids while setting add_special_tokens to False \"\n \"results in an undefined behavior. Please set add_special_tokens to True or \"\n \"set return_token_type_ids to None.\"\n )\n\n # Load from model defaults\n if return_token_type_ids is None:\n return_token_type_ids = \"token_type_ids\" in self.model_input_names\n if return_attention_mask is None:\n return_attention_mask = \"attention_mask\" in self.model_input_names\n\n encoded_inputs = {}\n\n if return_overflowing_tokens:\n encoded_inputs[\"overflowing_tokens\"] = overflowing_tokens\n encoded_inputs[\"overflowing_token_boxes\"] = overflowing_token_boxes\n encoded_inputs[\"overflowing_labels\"] = overflowing_labels\n encoded_inputs[\"num_truncated_tokens\"] = total_len - max_length\n\n # Add special tokens\n if add_special_tokens:\n sequence = self.build_inputs_with_special_tokens(ids, pair_ids)\n token_type_ids = self.create_token_type_ids_from_sequences(ids, pair_ids)\n token_boxes = [self.cls_token_box] + token_boxes + [self.sep_token_box]\n if pair_token_boxes:\n pair_token_boxes = pair_token_boxes + [self.sep_token_box]\n if labels:\n labels = [self.pad_token_label] + labels + [self.pad_token_label]\n else:\n sequence = ids + pair_ids if pair else ids\n token_type_ids = [0] * len(ids) + ([0] * len(pair_ids) if pair else [])\n\n # Build output dictionary\n encoded_inputs[\"input_ids\"] = sequence\n encoded_inputs[\"bbox\"] = token_boxes + pair_token_boxes\n if return_token_type_ids:\n encoded_inputs[\"token_type_ids\"] = token_type_ids\n if return_special_tokens_mask:\n if add_special_tokens:\n encoded_inputs[\"special_tokens_mask\"] = self.get_special_tokens_mask(ids, pair_ids)\n else:\n encoded_inputs[\"special_tokens_mask\"] = [0] * len(sequence)\n\n if labels:\n encoded_inputs[\"labels\"] = labels\n\n # Check lengths\n self._eventual_warn_about_too_long_sequence(encoded_inputs[\"input_ids\"], max_length, verbose)\n\n # Padding\n if padding_strategy != PaddingStrategy.DO_NOT_PAD or return_attention_mask:\n encoded_inputs = self.pad(\n encoded_inputs,\n max_length=max_length,\n padding=padding_strategy.value,\n pad_to_multiple_of=pad_to_multiple_of,\n return_attention_mask=return_attention_mask,\n )\n\n if return_length:\n encoded_inputs[\"length\"] = len(encoded_inputs[\"input_ids\"])\n\n batch_outputs = BatchEncoding(\n encoded_inputs, tensor_type=return_tensors, prepend_batch_axis=prepend_batch_axis\n )\n\n return batch_outputs","def _encode_transformed_data_batch(\n data: Tuple[pa.RecordBatch, Dict[str, pa.Array]],\n coder: example_coder.RecordBatchToExamplesEncoder) -> List[bytes]:\n # Drop unary pass-through features that are not relevant for this testing\n # framework.\n record_batch, _ = data\n return coder.encode(record_batch)","def __call__(\n self, data_batch: Dict[str, List[str]]\n ) -> Tuple[\n BatchEncoding,\n List[Dict[str, Union[int, str]]],\n List[SquadExample],\n List[SquadFeatures],\n ]:\n self._check_values_len(data_batch)\n concatenated_batch, evidences = self._concatenate_batch(data_batch)\n dataset, examples, features = load_examples(\n concatenated_batch, self.tokenizer, evaluate=True, output_examples=True\n )\n\n input_ids = [torch.unsqueeze(instance[0], 0) for instance in dataset]\n attention_mask = [torch.unsqueeze(instance[1], 0) for instance in dataset]\n token_type_ids = [torch.unsqueeze(instance[2], 0) for instance in dataset]\n\n output = {\n \"input_ids\": torch.cat(input_ids, axis=0),\n \"attention_mask\": torch.cat(attention_mask, axis=0),\n \"token_type_ids\": torch.cat(token_type_ids, axis=0),\n }\n output = BatchEncoding(output)\n\n return output, evidences, examples, features","def fixed_encode_ja(self, tokens, labels: list = None, dummy: str = '@'):\n # get special tokens at start/end of sentence based on first token\n encode_all = self.tokenizer.batch_encode_plus(tokens)\n # token_ids without prefix/special tokens\n # `wifi` will be treated as `_wifi` and change the tokenize result, so add dummy on top of the sentence to fix\n token_ids_all = [[self.tokenizer.convert_tokens_to_ids(_t.replace(self.prefix, '').replace(dummy, ''))\n for _t in self.tokenizer.tokenize(dummy+t)\n if len(_t.replace(self.prefix, '').replace(dummy, '')) > 0]\n for t in tokens]\n\n for n in range(len(tokens)):\n if n == 0:\n encode = {k: v[n][:-len(self.sp_token_end[k])] for k, v in encode_all.items()}\n if labels:\n encode['labels'] = [self.pad_ids['labels']] * len(self.sp_token_start['labels']) + [labels[n]]\n encode['labels'] += [self.pad_ids['labels']] * (len(encode['input_ids']) - len(encode['labels']))\n else:\n encode['input_ids'] += token_ids_all[n]\n # other attribution without prefix/special tokens\n tmp_encode = {k: v[n] for k, v in encode_all.items()}\n input_ids_with_prefix = \\\n tmp_encode.pop('input_ids')[len(self.sp_token_start['input_ids']):-len(self.sp_token_end['input_ids'])]\n prefix_length = len(input_ids_with_prefix) - len(token_ids_all[n])\n for k, v in tmp_encode.items():\n encode[k] += v[len(self.sp_token_start['input_ids']) + prefix_length:-len(self.sp_token_end['input_ids'])]\n if labels:\n encode['labels'] += [labels[n]] + [self.pad_ids['labels']] * (len((token_ids_all[n])) - 1)\n\n # add special token at the end and padding/truncate accordingly\n for k in encode.keys():\n encode[k] = encode[k][:min(len(encode[k]), self.max_seq_length - len(self.sp_token_end[k]))]\n encode[k] += self.sp_token_end[k]\n pad_id = self.pad_ids[k] if k in self.pad_ids.keys() else self.pad_ids['__default__']\n encode[k] += [pad_id] * (self.max_seq_length - len(encode[k]))\n return encode","def encode(self,\n encoder_input_tokens,\n encoder_segment_ids=None,\n enable_dropout=True):\n cfg = self.config\n assert encoder_input_tokens.ndim == 2 # (batch, len)\n\n # Make padding attention mask.\n encoder_mask = layers.make_attention_mask(\n encoder_input_tokens > 0, encoder_input_tokens > 0, dtype=cfg.dtype)\n # Add segmentation block-diagonal attention mask if using segmented data.\n if encoder_segment_ids is not None:\n encoder_mask = layers.combine_masks(\n encoder_mask,\n layers.make_attention_mask(\n encoder_segment_ids,\n encoder_segment_ids,\n jnp.equal,\n dtype=cfg.dtype))\n\n return self.encoder(\n encoder_input_tokens, encoder_mask, deterministic=not enable_dropout)","def encode(self, text, batch_max_length=25):\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\n batch_max_length += 1\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\n batch_text = torch.LongTensor(len(text), batch_max_length + 1).fill_(0)\n for i, t in enumerate(text):\n text = list(t)\n text.append('[s]')\n text = [self.dict[char] for char in text]\n batch_text[i][1:1 + len(text)] = torch.LongTensor(text) # batch_text[:, 0] = [GO] token\n return (batch_text.to(device), torch.IntTensor(length).to(device))","def encode(self, text, batch_max_length=25):\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\n batch_max_length += 1\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\n batch_text = torch.LongTensor(len(text), batch_max_length + 1).fill_(0)\n for i, t in enumerate(text):\n text = list(t)\n text.append('[s]')\n text = [self.dict[char] for char in text]\n batch_text[i][1:1 + len(text)] = torch.LongTensor(text) # batch_text[:, 0] = [GO] token\n return (batch_text.to(device), torch.IntTensor(length).to(device))","def __encode_token(self, text: list) -> dict:\n encoded_input = self.tokenizer(\n [str(string) for string in text],\n truncation=True,\n padding=True,\n return_tensors=\"pt\",\n )\n\n return encoded_input","def encode(self, text):\n length = [len(s) for s in text]\n batch_max_length = self.opt.model_params.max_len\n # The index used for padding (=0) would not affect the CTC loss calculation.\n batch_text = np.zeros((len(text), batch_max_length), dtype=int)\n for i, t in enumerate(text):\n cur_text = list(t)\n cur_text = [self.dict[char] for char in cur_text]\n batch_text[i][:len(cur_text)] = cur_text\n\n return tf.convert_to_tensor(batch_text, dtype=tf.int32), tf.convert_to_tensor(length, dtype=tf.int32)","def compute_encoding(self):\n for input_quantizer in self._input_quantizers.values():\n input_quantizer.compute_encoding()\n\n for quantizer in self.param_quantizers.values():\n # NOTE: If quantizer.enabled is True but quantizer.encoding is None,\n # quantizer.compute_encoding() will set quantizer.enabled to False.\n # Otherwise, quantizer.compute_encodings() is equivalent to no-op.\n quantizer.compute_encoding()\n\n for output_quantizer in self._output_quantizers.values():\n output_quantizer.compute_encoding()","def __call__(self, batch: List[List[str]], tags_batch: Optional[List[List[str]]] = None, mean: bool = None,\n *args, **kwargs) -> List[Union[list, np.ndarray]]:\n\n if self.tags_vocab:\n if tags_batch is None:\n raise ConfigError(\"TfidfWeightedEmbedder got 'tags_vocab_path' but __call__ did not get tags_batch.\")\n batch = [self._tags_encode(sample, tags_sample, mean=mean) for sample, tags_sample in\n zip(batch, tags_batch)]\n else:\n if tags_batch:\n raise ConfigError(\"TfidfWeightedEmbedder got tags batch, but 'tags_vocab_path' is empty.\")\n batch = [self._encode(sample, mean=mean) for sample in batch]\n\n if self.pad_zero:\n batch = zero_pad(batch)\n\n return batch","def translate_batch(self, x, trans_args, char_list=None, rnnlm=None):\n raise NotImplementedError(\"Batch decoding is not supported yet.\")","def encode(self, text):\n length = [self.mylen(s) + 1 for s in text] # +1 for [s] at end of sentence.\n batch_max_length=self.batch_max_length\n #print('---------------------',batch_max_length)\n batch_max_length += 1\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\n batch_text = torch.cuda.LongTensor(len(text), batch_max_length + 1).fill_(0)\n for i, t in enumerate(text):\n #print(\"LOAD TEXT\", t)\n text_one = list(t)\n text_one.append('[s]')\n #text_one = [self.dict[char] for char in text_one]\n text_one = self.myIndex(text_one)\n batch_text[i][1:1 + len(text_one)] = torch.cuda.LongTensor(text_one) \n return (batch_text, torch.cuda.IntTensor(length))","def tokenize_pretraining(self, inputs):\n\n ref_ids = prepare_ref([inputs], self.tokenizer_ltp, self.tokenizer_cn)\n\n tokens = self.tokenizer_cn.tokenize(inputs)\n\n if len(tokens) > self.max_seq_length - 2:\n tokens = tokens[:(self.max_seq_length - 2)]\n ref_ids = ref_ids[:(self.max_seq_length - 2)]\n\n ref_ids = cn_whole_word_mask(tokens, ref_ids[0])\n tokens, labels = random_word_wwm(tokens, ref_ids, self.tokenizer_cn)\n\n tokens = ['[CLS]'] + tokens + ['[SEP]']\n lm_label_ids = ([-100] + labels + [-100])\n\n input_ids = self.tokenizer_cn.convert_tokens_to_ids(tokens)\n\n attention_mask = [1] * len(input_ids)\n token_type_ids = [0] * len(input_ids)\n\n while len(input_ids) < self.max_seq_length:\n input_ids.append(0)\n attention_mask.append(0)\n token_type_ids.append(0)\n lm_label_ids.append(-100)\n\n assert len(input_ids) == self.max_seq_length\n assert len(attention_mask) == self.max_seq_length\n assert len(token_type_ids) == self.max_seq_length\n assert len(lm_label_ids) == self.max_seq_length\n\n\n outputs = {'input_ids': tf.constant(input_ids), 'attention_mask': tf.constant(attention_mask), \n 'token_type_ids': tf.constant(token_type_ids), 'lm_label_ids': tf.constant(lm_label_ids)}\n\n return outputs","def preprocessing_for_bert(self, data):\n # Create empty lists to store outputs\n input_ids = []\n attention_masks = []\n MAX_LEN = self.opt.MAX_QUESTION_LEN\n # For every sentence...\n for sent in data:\n \n encoded_sent = self.tokenizer.encode_plus(\n text=self.text_preprocessing(sent), # Preprocess sentence\n add_special_tokens=True, # Add `[CLS]` and `[SEP]`\n max_length=MAX_LEN, # Max length to truncate/pad\n pad_to_max_length=True, # Pad sentence to max length\n #return_tensors='pt', # Return PyTorch tensor\n truncation=True,\n return_attention_mask=True # Return attention mask\n )\n \n # Add the outputs to the lists\n input_ids.append(encoded_sent.get('input_ids'))\n attention_masks.append(encoded_sent.get('attention_mask'))\n\n # Convert lists to tensors\n input_ids = torch.tensor(input_ids)\n attention_masks = torch.tensor(attention_masks)\n\n return input_ids, attention_masks","def batch_decode(self, *args, **kwargs):\n return self.tokenizer.batch_decode(*args, **kwargs)","def batch_decode(self, *args, **kwargs):\n return self.tokenizer.batch_decode(*args, **kwargs)","def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\n return self.bert_model.batch_tokenize([t.strip() for t in text])","def fit_transform(self):\n if self.enc_types == \"label\":\n return self._label_encoding()\n elif self.enc_types == \"ohe\":\n return self._one_hot_encoder()\n elif self.enc_types == \"binary\":\n return self._binarization()\n else:\n raise Exception(\"Encoding type not understood\")","def _encode(self):\n with tf.variable_scope('encoding'):\n self.sep_p_encodes, _ = bilstm_layer(self.p_emb, self.p_length, self.hidden_size)\n tf.get_variable_scope().reuse_variables()\n self.sep_q_encodes, _ = bilstm_layer(self.q_emb, self.q_length, self.hidden_size)\n if self.use_dropout:\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, 1-self.dropout)\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, 1-self.dropout)","def call(self, inputs, *args, **kwargs):\n outputs = self.encoder(inputs, *args, **kwargs)\n return outputs","def collate_batch(self) -> Dict[str, Any]:\n pass","def encode(\n self,\n docs: Optional[DocumentArray] = None,\n parameters: dict = {},\n *args,\n **kwargs\n ) -> None:\n if not docs:\n return\n\n batch_generator = docs.batch(\n traversal_paths=parameters.get('traversal_paths', self.traversal_paths),\n batch_size=parameters.get('batch_size', self.batch_size),\n require_attr='text',\n )\n\n with torch.inference_mode():\n for batch in batch_generator:\n embeddings = self.model.encode_text(text=[[doc.text] for doc in batch])\n embeddings = embeddings.cpu().numpy()\n\n for idx, doc in enumerate(batch):\n doc.embedding = embeddings[idx]","def _batch_prepare_for_model(\n self,\n batch_text_or_text_pairs,\n is_pair: bool = None,\n boxes: Optional[List[List[int]]] = None,\n word_labels: Optional[List[List[int]]] = None,\n add_special_tokens: bool = True,\n padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,\n truncation_strategy: TruncationStrategy = TruncationStrategy.DO_NOT_TRUNCATE,\n max_length: Optional[int] = None,\n stride: int = 0,\n pad_to_multiple_of: Optional[int] = None,\n return_tensors: Optional[str] = None,\n return_token_type_ids: Optional[bool] = None,\n return_attention_mask: Optional[bool] = None,\n return_overflowing_tokens: bool = False,\n return_special_tokens_mask: bool = False,\n return_length: bool = False,\n verbose: bool = True,\n ) -> BatchEncoding:\n\n batch_outputs = {}\n for idx, example in enumerate(zip(batch_text_or_text_pairs, boxes)):\n batch_text_or_text_pair, boxes_example = example\n outputs = self.prepare_for_model(\n batch_text_or_text_pair[0] if is_pair else batch_text_or_text_pair,\n batch_text_or_text_pair[1] if is_pair else None,\n boxes_example,\n word_labels=word_labels[idx] if word_labels is not None else None,\n add_special_tokens=add_special_tokens,\n padding=PaddingStrategy.DO_NOT_PAD.value, # we pad in batch afterward\n truncation=truncation_strategy.value,\n max_length=max_length,\n stride=stride,\n pad_to_multiple_of=None, # we pad in batch afterward\n return_attention_mask=False, # we pad in batch afterward\n return_token_type_ids=return_token_type_ids,\n return_overflowing_tokens=return_overflowing_tokens,\n return_special_tokens_mask=return_special_tokens_mask,\n return_length=return_length,\n return_tensors=None, # We convert the whole batch to tensors at the end\n prepend_batch_axis=False,\n verbose=verbose,\n )\n\n for key, value in outputs.items():\n if key not in batch_outputs:\n batch_outputs[key] = []\n batch_outputs[key].append(value)\n\n batch_outputs = self.pad(\n batch_outputs,\n padding=padding_strategy.value,\n max_length=max_length,\n pad_to_multiple_of=pad_to_multiple_of,\n return_attention_mask=return_attention_mask,\n )\n\n batch_outputs = BatchEncoding(batch_outputs, tensor_type=return_tensors)\n\n return batch_outputs","def collate_fn(batch):\n all_input_ids, all_attention_mask, all_token_type_ids, all_lens, all_labels = map(torch.stack, zip(*batch))\n max_len = max(all_lens).item()\n all_input_ids = all_input_ids[:, :max_len]\n all_attention_mask = all_attention_mask[:, :max_len]\n all_token_type_ids = all_token_type_ids[:, :max_len]\n return all_input_ids, all_attention_mask, all_token_type_ids, all_labels","def bert_text_encoding(self, text, take_bert_pooler=True):\n # Encode text\n print('starting BERT encoding', datetime.datetime.now())\n tokenized = self.tokenizer.tokenize(text)\n tokenized.insert(0, 'CLS')\n input_ids = self.tokenizer.convert_tokens_to_ids(tokenized)\n with torch.no_grad():\n if take_bert_pooler:\n pooler = self.model(torch.tensor([input_ids]))[0][0][0]\n print('finished BERT encoding, returning BERT pooler', datetime.datetime.now())\n return pooler\n else:\n # TODO: validate tokens [1:]\n tokens_embedding = self.model(torch.tensor([input_ids]))[0][0][1:]\n print('finished BERT encoding, returning BERT sentence', datetime.datetime.now())\n return tokens_embedding","def encode(self):\n with tf.name_scope(\"encode\"):\n self.encoder_inputs = tf.layers.dense(\n inputs=self.encoder_inputs,\n units=self.options['hidden_size'], activation=None, use_bias=True,\n kernel_initializer=tf.keras.initializers.he_normal(seed=None),\n bias_initializer=tf.zeros_initializer(),\n kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\n kernel_constraint=None, bias_constraint=None, trainable=True,\n name=None, reuse=None)\n self.encoder_inputs = tf.layers.batch_normalization(self.encoder_inputs,\n axis=-1,\n momentum=0.99,\n epsilon=0.001,\n center=True,\n scale=True,\n beta_initializer=tf.zeros_initializer(),\n gamma_initializer=tf.ones_initializer(),\n moving_mean_initializer=tf.zeros_initializer(),\n moving_variance_initializer=tf.ones_initializer(),\n training=self.is_training,\n trainable=True,\n renorm=False,\n renorm_momentum=0.99)\n # Prepare inputs to the layer stack by adding positional encodings and\n # applying dropout.\n # embedded_inputs = self.embedding_softmax_layer(inputs)\n #\n inputs_padding = transformer_model_utils.get_padding(tf.cast(\n tf.reduce_max(100*self.encoder_inputs, [-1]),\n dtype=tf.int32))\n\n with tf.name_scope(\"add_pos_encoding\"):\n length = tf.shape(self.encoder_inputs)[1]\n pos_encoding = transformer_model_utils.get_position_encoding(\n length, self.options[\"hidden_size\"])\n encoder_inputs = self.encoder_inputs + pos_encoding\n\n if self.is_training:\n encoder_inputs = tf.nn.dropout(\n encoder_inputs, 1 - self.options[\"layer_postprocess_dropout\"])\n\n return self.encoder_stack(encoder_inputs, self.attention_bias, inputs_padding)","def encode(self, pt, en):\n pt = [self.tokenizer_pt.vocab_size] +\\\n self.tokenizer_pt.encode(pt.numpy()) +\\\n [self.tokenizer_pt.vocab_size+1]\n en = [self.tokenizer_en.vocab_size] +\\\n self.tokenizer_en.encode(en.numpy()) +\\\n [self.tokenizer_en.vocab_size+1]\n return (pt, en)","def encode(self, docs: Optional[DocumentArray], parameters: Dict, **kwargs):\n if docs:\n docs_batch_generator = get_docs_batch_generator(\n docs,\n traversal_path=parameters.get(\n 'traversal_paths', self.default_traversal_path\n ),\n batch_size=parameters.get('batch_size', self.default_batch_size),\n needs_attr='blob',\n )\n self._compute_embeddings(docs_batch_generator)","def preprocess(batch):\n batch_size = batch[\"idx\"].shape[0]\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n\n for i in range(batch_size):\n sentence_a = batch[key_a][i]\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\n input_ids[i, :len(tokens_a)] = tokens_a[:max_len]\n\n return {\n \"input_ids\": input_ids,\n \"type_ids\": type_ids,\n \"idx\": batch[\"idx\"].astype(np.int32),\n \"label\": batch[\"label\"],\n }","def encode(self, text, batch_max_length=25):\n length = [len(s) for s in text]\n\n # The index used for padding (=0) would not affect the CTC loss calculation.\n batch_text = torch.LongTensor(len(text), batch_max_length).fill_(0)\n for i, t in enumerate(text):\n text = list(t)\n text = [self.dict[char] for char in text]\n batch_text[i][:len(text)] = torch.LongTensor(text)\n return (batch_text.to(device), torch.IntTensor(length).to(device))","def _encode(self):\n with tf.variable_scope('passage_encoding'):\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\n with tf.variable_scope('question_encoding'):\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\n if self.use_dropout:\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)","def encode(self, xs, task='all', streaming=False, cnn_lookback=False, cnn_lookahead=False, xlen_block=-1):\n if self.input_type == 'speech':\n if self.n_stacks > 1:\n xs = [stack_frame(x, self.n_stacks, self.n_skips) for x in xs]\n if self.n_splices > 1:\n xs = [splice(x, self.n_splices, self.n_stacks) for x in xs]\n if streaming:\n xlens = torch.IntTensor([xlen_block])\n else:\n xlens = torch.IntTensor([len(x) for x in xs])\n xs = pad_list([np2tensor(x, self.device).float() for x in xs], 0.0)\n if self.specaug is not None and self.training:\n xs = self.specaug(xs)\n if self.weight_noise_std > 0 and self.training:\n self.add_weight_noise(std=self.weight_noise_std)\n if self.input_noise_std > 0 and self.training:\n xs = add_input_noise(xs, std=self.input_noise_std)\n if self.ssn is not None:\n xs = self.ssn(xs, xlens)\n elif self.input_type == 'text':\n xlens = torch.IntTensor([len(x) for x in xs])\n xs = [np2tensor(np.fromiter(x, dtype=np.int64), self.device) for x in xs]\n xs = pad_list(xs, self.pad)\n xs = self.dropout_emb(self.embed(xs))\n eout_dict = self.enc(xs, xlens, task.split('.')[0], streaming, cnn_lookback, cnn_lookahead)\n if self.main_weight < 1 and self.enc_type in ['conv', 'tds', 'gated_conv']:\n for sub in ['sub1', 'sub2']:\n eout_dict['ys_' + sub]['xs'] = eout_dict['ys']['xs'].clone()\n eout_dict['ys_' + sub]['xlens'] = eout_dict['ys']['xlens'][:]\n return eout_dict","def encode(self, inputs, masks):\n with tf.variable_scope(\"encoder\") as scope_encoder:\n #compute sequence length\n sequence_lengths = tf.reduce_sum(masks, axis = 1) \n #create a forward cell\n fw_cell = tf.contrib.rnn.LSTMCell(self.size)\n\n #pass the cells to bilstm and create the bilstm\n bw_cell = tf.contrib.rnn.LSTMCell(self.size)\n output, final_state = tf.nn.bidirectional_dynamic_rnn(fw_cell, \\\n bw_cell, inputs, \\\n sequence_length = sequence_lengths, \\\n dtype = tf.float32, \\\n parallel_iterations = 256)\n output_lstm = tf.concat([output[0], output[1]], axis = -1)\n final_state_lstm = tf.concat([final_state[0], final_state[1]], axis = -1)\n return output_lstm, final_state_lstm","def encode(\n self,\n sentences: Union[str, List[str]],\n batch_size: int = 32,\n show_progress_bar: bool = False,\n convert_to_numpy: bool = True,\n normalize_embeddings: bool = False\n ):\n self.model.eval()\n input_was_string = False\n if isinstance(sentences, str) or not hasattr(sentences, '__len__'):\n sentences = [sentences]\n input_was_string = True\n self.model.to(device)\n\n all_embeddings = []\n length_sorted_idx = np.argsort([-self._text_length(sent) for sent in sentences])\n sentences_sorted = [sentences[idx] for idx in length_sorted_idx]\n\n for start_index in trange(0, len(sentences), batch_size, desc=\"Batches\", disable=not show_progress_bar):\n sentences_batch = sentences_sorted[start_index:start_index + batch_size]\n features = self.tokenize(sentences_batch)\n features = self.batch_to_device(features)\n\n with torch.no_grad():\n out_features = self.forward(features)\n embeddings = out_features['embedding']\n embeddings = embeddings.detach()\n if normalize_embeddings:\n embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)\n # fixes for #522 and #487 to avoid oom problems on gpu with large datasets\n if convert_to_numpy:\n embeddings = embeddings.cpu()\n all_embeddings.extend(embeddings)\n\n all_embeddings = [all_embeddings[idx] for idx in np.argsort(length_sorted_idx)]\n if convert_to_numpy:\n all_embeddings = np.asarray([emb.numpy() for emb in all_embeddings])\n else:\n all_embeddings = torch.stack(all_embeddings)\n if input_was_string:\n all_embeddings = all_embeddings[0]\n\n return all_embeddings","def _encode(self, text: str) -> List[str]:\n token_ids: List[int] = self.bert_model.encode(text.strip())\n tokens_ids_str: List[str] = [str(token_id) for token_id in token_ids]\n return tokens_ids_str","def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \\\n -> IterEncodeType[Any]:\n raise NotImplementedError()","def encode(self, docs: Optional[DocumentArray], parameters: dict, **kwargs):\n if docs:\n document_batches_generator = get_docs_batch_generator(\n docs,\n traversal_path=parameters.get('traversal_paths', self.default_traversal_paths),\n batch_size=parameters.get('batch_size', self.default_batch_size),\n needs_attr='text',\n )\n self._create_embeddings(document_batches_generator)","def preprocess(batch):\n batch_size = batch[\"idx\"].shape[0]\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n\n for i in range(batch_size):\n sentence_a = batch[key_a][i]\n sentence_b = batch[key_b][i]\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\n tokens_b = tokenizer.EncodeAsIds(sentence_b)[1:] # Strip start token\n\n ex_input_ids = (tokens_a + tokens_b)[:max_len]\n ex_type_ids = ([0] * len(tokens_a) + [1] * len(tokens_b))[:max_len]\n\n input_ids[i, :len(ex_input_ids)] = ex_input_ids\n type_ids[i, :len(ex_type_ids)] = ex_type_ids\n\n return {\n \"input_ids\": input_ids,\n \"type_ids\": type_ids,\n \"idx\": batch[\"idx\"].astype(np.int32),\n \"label\": batch[\"label\"],\n }","def vectorize_texts(self, encoder) -> NoReturn:\n self.encoder = encoder\n self.vectorized_texts = [self.encoder.encode(t) for t in self.tokenized_texts]","def encode(self, pt, en):\n tok_pt = [self.tokenizer_pt.vocab_size]+self.tokenizer_pt.encode(\n pt.numpy())+[(self.tokenizer_pt.vocab_size) + 1]\n tok_en = [self.tokenizer_en.vocab_size]+self.tokenizer_en.encode(\n en.numpy())+[(self.tokenizer_en.vocab_size) + 1]\n return tok_pt, tok_en","def __call__(\n self,\n images: Optional[ImageInput] = None,\n text: Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None,\n add_special_tokens: bool = True,\n padding: Union[bool, str, PaddingStrategy] = False,\n truncation: Union[bool, str, TruncationStrategy] = False,\n max_length: Optional[int] = None,\n stride: int = 0,\n pad_to_multiple_of: Optional[int] = None,\n return_image_mask: Optional[bool] = None,\n return_codebook_pixels: Optional[bool] = None,\n return_token_type_ids: Optional[bool] = None,\n return_attention_mask: Optional[bool] = None,\n return_overflowing_tokens: bool = False,\n return_special_tokens_mask: bool = False,\n return_offsets_mapping: bool = False,\n return_length: bool = False,\n verbose: bool = True,\n return_tensors: Optional[Union[str, TensorType]] = None,\n **kwargs,\n ):\n\n if text is None and images is None:\n raise ValueError(\"You have to specify either text or images. Both cannot be none.\")\n\n if text is not None:\n encoding = self.tokenizer(\n text=text,\n add_special_tokens=add_special_tokens,\n padding=padding,\n truncation=truncation,\n max_length=max_length,\n stride=stride,\n pad_to_multiple_of=pad_to_multiple_of,\n return_token_type_ids=return_token_type_ids,\n return_attention_mask=return_attention_mask,\n return_overflowing_tokens=return_overflowing_tokens,\n return_special_tokens_mask=return_special_tokens_mask,\n return_offsets_mapping=return_offsets_mapping,\n return_length=return_length,\n verbose=verbose,\n return_tensors=return_tensors,\n **kwargs,\n )\n if images is not None:\n image_features = self.image_processor(\n images,\n return_image_mask=return_image_mask,\n return_codebook_pixels=return_codebook_pixels,\n return_tensors=return_tensors,\n **kwargs,\n )\n\n if text is not None and images is not None:\n encoding.update(image_features)\n return encoding\n elif text is not None:\n return encoding\n else:\n return BatchEncoding(data=dict(**image_features), tensor_type=return_tensors)","def _encode(self, sentence: str, **kwargs) -> Sequence[int]:\r\n return NotImplemented","def fixed_encode_en(self, tokens, labels: list = None):\n encode = self.tokenizer.encode_plus(\n ' '.join(tokens), max_length=self.max_seq_length, pad_to_max_length=self.pad_to_max_length, truncation=self.pad_to_max_length)\n if labels:\n assert len(tokens) == len(labels)\n fixed_labels = list(chain(*[\n [label] + [self.pad_ids['labels']] * (len(self.tokenizer.tokenize(word)) - 1)\n for label, word in zip(labels, tokens)]))\n fixed_labels = [self.pad_ids['labels']] * len(self.sp_token_start['labels']) + fixed_labels\n fixed_labels = fixed_labels[:min(len(fixed_labels), self.max_seq_length - len(self.sp_token_end['labels']))]\n fixed_labels = fixed_labels + [self.pad_ids['labels']] * (self.max_seq_length - len(fixed_labels))\n encode['labels'] = fixed_labels\n return encode","def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):\n chunked_data = self._get_chunk_data(\n map(self.pipeline, inputs), batch_size)\n yield from map(self.collate_fn, chunked_data)","def encode_input(sent, lemmas, pos_tags, predicates, vocab_preds, vocab_lemmas, vocab_pos_tags, bert_embedder, task_234):\n sentence = bert_embedder.embed_sentence([sent])[0]\n lens = torch.LongTensor([len(sent)])\n pos_tags = torch.tensor([vocab_pos_tags[pos_tag] for pos_tag in pos_tags])\n lemmas = torch.tensor([vocab_lemmas[lemma] if lemma in vocab_lemmas else vocab_lemmas['<unk>'] for lemma in lemmas])\n vocab_preds = {word: int(idx) for idx, word in vocab_preds.items()}\n predicate_null_token = vocab_preds['_']\n if task_234:\n # if the task is predicate disambiguation, predicates indicates only the position of the predicates in the sentence\n predicates = torch.LongTensor(predicates)\n positions = (predicates == 1).nonzero()\n else:\n # otherwise predicates must be encoded with the value stored in the vocabulary\n predicates = torch.tensor([vocab_preds[predicate] for predicate in predicates])\n positions = (predicates != predicate_null_token).nonzero()\n\n return sentence[None,...], lens, pos_tags[None,...], lemmas[None,...], predicates[None,...], positions.view(-1).tolist(), predicate_null_token","def __call__(self,\n encoder_input_tokens,\n decoder_input_tokens,\n decoder_target_tokens,\n encoder_segment_ids=None,\n decoder_segment_ids=None,\n encoder_positions=None,\n decoder_positions=None,\n *,\n enable_dropout: bool = True,\n decode: bool = False):\n encoded = self.encode(\n encoder_input_tokens,\n encoder_segment_ids=encoder_segment_ids,\n enable_dropout=enable_dropout)\n\n return self.decode(\n encoded,\n encoder_input_tokens, # only used for masks\n decoder_input_tokens,\n decoder_target_tokens,\n encoder_segment_ids=encoder_segment_ids,\n decoder_segment_ids=decoder_segment_ids,\n decoder_positions=decoder_positions,\n enable_dropout=enable_dropout,\n decode=decode)","def glue_inputs(dataset_name, split, batch_size, tokenizer, data_dir=None,\n max_len=128, training=True):\n keys_lookup = {\n \"glue/cola\": (\"sentence\", None),\n \"glue/sst2\": (\"sentence\", None),\n \"glue/mrpc\": (\"sentence1\", \"sentence2\"),\n \"glue/qqp\": (\"question1\", \"question2\"),\n \"glue/stsb\": (\"sentence1\", \"sentence2\"),\n \"glue/mnli\": (\"premise\", \"hypothesis\"), # TODO(kitaev): swap the two?\n \"glue/qnli\": (\"question\", \"sentence\"), # TODO(kitaev) swap the two?\n \"glue/rte\": (\"sentence1\", \"sentence2\"),\n \"glue/wnli\": (\"sentence1\", \"sentence2\"),\n }\n\n key_a, key_b = keys_lookup[dataset_name]\n\n if key_b is None:\n def preprocess(batch):\n \"\"\"Tokenize and convert text to model inputs.\"\"\"\n batch_size = batch[\"idx\"].shape[0]\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n\n for i in range(batch_size):\n sentence_a = batch[key_a][i]\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\n input_ids[i, :len(tokens_a)] = tokens_a[:max_len]\n\n return {\n \"input_ids\": input_ids,\n \"type_ids\": type_ids,\n \"idx\": batch[\"idx\"].astype(np.int32),\n \"label\": batch[\"label\"],\n }\n else:\n def preprocess(batch):\n \"\"\"Tokenize and convert text to model inputs.\"\"\"\n batch_size = batch[\"idx\"].shape[0]\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\n\n for i in range(batch_size):\n sentence_a = batch[key_a][i]\n sentence_b = batch[key_b][i]\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\n tokens_b = tokenizer.EncodeAsIds(sentence_b)[1:] # Strip start token\n\n ex_input_ids = (tokens_a + tokens_b)[:max_len]\n ex_type_ids = ([0] * len(tokens_a) + [1] * len(tokens_b))[:max_len]\n\n input_ids[i, :len(ex_input_ids)] = ex_input_ids\n type_ids[i, :len(ex_type_ids)] = ex_type_ids\n\n return {\n \"input_ids\": input_ids,\n \"type_ids\": type_ids,\n \"idx\": batch[\"idx\"].astype(np.int32),\n \"label\": batch[\"label\"],\n }\n\n return tfds_stream(\n dataset_name=dataset_name,\n split=split,\n batch_size=batch_size,\n data_dir=data_dir,\n shuffle_files=training,\n shuffle_buffer_size=1024 if training else None,\n batch_shuffle_size=128 if training else None,\n preprocess_fun=preprocess,\n repeat=training,\n )","def batchify(self, i, iterator):\n print(f'Starting Batch {i}')\n iterator = [item.strip() for item in iterator]\n max_length = self.max_seq_length - 2 # for special tokens\n\n batches = []\n n = len(iterator)\n sentence_count = 0\n index_start = 0\n index_stop = 0\n\n while index_stop < n:\n if (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length):\n index_start += 1\n index_stop += 1\n while (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length) and (index_stop<n):\n index_stop += 1\n batches.append(iterator[index_start:index_stop])\n index_start = index_stop\n print(f'Batch {i} Done')\n return batches","def encode(self, seq):","def encode(self, input_):\n return self.encoder(input_)","def encode(lang1, lang2):\n lang1 = [tokenizer_pt.vocab_size] + tokenizer_pt.encode(\n lang1.numpy()) + [tokenizer_pt.vocab_size + 1]\n\n lang2 = [tokenizer_en.vocab_size] + tokenizer_en.encode(\n lang2.numpy()) + [tokenizer_en.vocab_size + 1]\n\n return lang1, lang2","def encoder(list_of_str, key):\n tokenized = self.tokenizer.encode_commands(list_of_str)\n hidden = self.tokenizer.tokenize(tokenized)\n hidden = hidden.permute(1, 0, 2).reshape(hidden.size(1), -1) # correct for bididrectional\n return hidden","def collate_fn(\n self,\n batch: List[\n Tuple[\n np.ndarray,\n np.ndarray,\n np.ndarray,\n np.ndarray,\n int,\n int,\n bool,\n bool,\n Optional[np.ndarray],\n Optional[np.ndarray],\n ]\n ],\n ) -> Union[\n Tuple[Tensor, Tensor, Tensor, Tensor, Any, Any, Any, Any],\n Tuple[Tensor, Tensor, Tensor, Tensor, Any, Any, Any, Any, Any, Any],\n ]:\n if not self.use_audio:\n inp_ids, segment_ids, inp_mask, st_mask, n_preceding, query_ids, is_first, is_last = zip(*batch)\n return (\n pad_sequence([torch.tensor(x) for x in inp_ids], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in segment_ids], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in inp_mask], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in st_mask], batch_first=True, padding_value=0),\n n_preceding,\n query_ids,\n is_first,\n is_last,\n )\n (\n inp_ids,\n segment_ids,\n inp_mask,\n st_mask,\n n_preceding,\n query_ids,\n is_first,\n is_last,\n features,\n features_length,\n ) = zip(*batch)\n return (\n pad_sequence([torch.tensor(x) for x in inp_ids], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in segment_ids], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in inp_mask], batch_first=True, padding_value=0),\n pad_sequence([torch.tensor(x) for x in st_mask], batch_first=True, padding_value=0),\n n_preceding,\n query_ids,\n is_first,\n is_last,\n pad_sequence([torch.tensor(x) for x in features], batch_first=True, padding_value=0).float(),\n torch.tensor(features_length, dtype=torch.long),\n )","def handle_encode(self, results):\n \n config.COD_PROMPT = config.ENC_PROMPT\n print config.ENC_PROMPT + \" encoding results...\"\n \n # while there is another decoder, run each item through the next decoder\n data = results\n success = False\n for encoder in self.encoder_list:\n current_encoder = encoder()\n full_body = getattr(current_encoder,'full_body_encode',False)\n success, data = self.recursive_decoder(current_encoder.encode, data, full_body)\n if not success:\n break\n print config.ENC_PROMPT + \"%s encoded to '%s'\" % ( current_encoder.name(),data)\n return success, data","def set_encodings(questions, candidates,\n question_encoder, response_encoder):\n for i, chunk in enumerate(chunks(questions, 100)):\n question_strs = [q.question for q in chunk]\n question_encodings = np.array(question_encoder(question_strs))\n\n for j in range(question_encodings.shape[0]):\n questions[i * 100 + j].encoding = question_encodings[j]\n if i % 50 == 0:\n print(\"Questions: encoded %s of %s...\" % (i * 100, len(questions)))\n\n for i, chunk in enumerate(chunks(candidates, 50)):\n candidate_strs = [(c.sentence, c.context) for c in chunk]\n candidate_encodings = np.array(response_encoder(candidate_strs))\n for j in range(candidate_encodings.shape[0]):\n candidates[i * 50 + j].encoding = candidate_encodings[j]\n if i % 100 == 0:\n print(\"Candidates: encoded %s of %s...\" % (i * 50, len(candidates)))","def encode_input(self, x_tensor, inp_lens_tensor):\r\n input_emb = self.input_emb.forward(x_tensor)\r\n enc_output_each_word, enc_context_mask, enc_final_states = self.encoder(input_emb, inp_lens_tensor)\r\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\r\n # print('lest go', enc_final_states_reshaped[1].shape)\r\n return enc_output_each_word, enc_context_mask, enc_final_states_reshaped","def encode_inputs(self, sents):\n word_inputs = []\n pred_inputs = []\n pos_inputs = []\n\n # Preproc to get all preds per run_id\n # Sanity check - make sure that all sents agree on run_id\n assert(all([len(set(sent.run_id.values)) == 1\n for sent in sents]))\n run_id_to_pred = dict([(int(sent.run_id.values[0]),\n self.get_head_pred_word(sent))\n for sent in sents])\n\n # Construct a mapping from running word index to pos\n word_id_to_pos = {}\n for sent in sents:\n indices = sent.index.values\n words = sent.word.values\n\n for index, word in zip(indices,\n nlpir_ws(\"\".join(words))):\n word_id_to_pos[index] = word['tag']\n\n fixed_size_sents = self.get_fixed_size(sents)\n\n\n for sent in fixed_size_sents:\n\n assert(len(set(sent.run_id.values)) == 1)\n\n word_indices = sent.index.values\n sent_words = sent.word.values\n\n sent_str = \"\".join(sent_words)\n\n\n\n pos_tags_encodings = [(CN_POS_TAGS.index(word_id_to_pos[word_ind]) \\\n if word_id_to_pos[word_ind] in CN_POS_TAGS \\\n else 0)\n for word_ind\n in word_indices]\n\n word_encodings = [self.emb.get_word_index(w)\n for w in sent_words]\n\n # Same pred word encodings for all words in the sentence\n pred_word = run_id_to_pred[int(sent.run_id.values[0])]\n pred_word_encodings = [self.emb.get_word_index(pred_word)\n for _ in sent_words]\n\n word_inputs.append([Sample(w) for w in word_encodings])\n pred_inputs.append([Sample(w) for w in pred_word_encodings])\n pos_inputs.append([Sample(pos) for pos in pos_tags_encodings])\n\n # Pad / truncate to desired maximum length\n ret = defaultdict(lambda: [])\n\n for name, sequence in zip([\"word_inputs\", \"predicate_inputs\", \"postags_inputs\"],\n [word_inputs, pred_inputs, pos_inputs]):\n for samples in pad_sequences(sequence,\n pad_func = lambda : Pad_sample(),\n maxlen = self.sent_maxlen):\n ret[name].append([sample.encode() for sample in samples])\n\n return {k: np.array(v) for k, v in ret.iteritems()}","def encoder(enc_input, attn_bias, n_layer, n_head,\n d_key, d_value, d_model, d_inner_hid, pos_enc,\n preporstprocess_dropout, attention_dropout,\n relu_dropout, preprocess_cmd='n',\n postprocess_cmd='da'):\n for i in range(n_layer):\n enc_output = encoder_layer(enc_input, attn_bias, n_head,\n d_key, d_value, d_model,d_inner_hid, pos_enc,\n prepostprocess_dropout, attention_dropout,relu_dropout,\n preprocess_cmd, postprocess_cmd\n )\n enc_input = enc_output\n enc_output = pre_process_layer(enc_output,\n preprocess_cmd, preporstprocess_dropout)\n return enc_output","def collate_fn_Siamese(batch):\n all_input_ids, all_attention_mask, all_token_type_ids, all_lens_a, all_lens_b, all_labels = map(torch.stack,\n zip(*batch))\n max_len_a = max(all_lens_a).item()\n max_len_b = max(all_lens_b).item()\n if max_len_b == 2:\n all_input_ids = all_input_ids[:, :max_len_a]\n all_attention_mask = all_attention_mask[:, :max_len_a]\n all_token_type_ids = all_token_type_ids[:, :max_len_a]\n else:\n all_input_ids = all_input_ids[:, :512 + max_len_b]\n all_attention_mask = all_attention_mask[:, :512 + max_len_b]\n all_token_type_ids = all_token_type_ids[:, :512 + max_len_b]\n return all_input_ids, all_attention_mask, all_token_type_ids, all_labels","def encode(self, features, training=True):\n conditioning = self.preprocessor(features, training=training)\n return conditioning if self.encoder is None else self.encoder(conditioning)","def _encode(self, tokens: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:\n if self.vectorizer:\n detokenized_sample = self.tokenizer([tokens])[0] # str\n vectorized_sample = self.vectorizer([detokenized_sample]) # (voc_size,)\n\n weights = np.array([vectorized_sample[0, np.where(self.vocabulary == token)[0][0]]\n if len(np.where(self.vocabulary == token)[0]) else 0.\n for token in tokens])\n else:\n weights = np.array([self.get_weight(max(self.counter_vocab.get(token, 0), self.idf_base_count))\n for token in tokens])\n\n if sum(weights) == 0:\n weights = np.ones(len(tokens))\n\n embedded_tokens = np.array(self.embedder([tokens]))[0, :, :]\n\n if mean is None:\n mean = self.mean\n\n if mean:\n embedded_tokens = np.average(embedded_tokens, weights=weights, axis=0)\n else:\n embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])\n\n return embedded_tokens","def common_process_pipeline(self, batch):\n vocab_path = os.path.abspath(self.text_vocab_file_path)\n token_ids = self.text_pipeline_func(batch, self.max_enc_len, vocab_path)\n return token_ids","def encode(self, inputs, target_space, hparams, features=None, losses=None):\n del losses\n\n inputs = common_layers.flatten4d3d(inputs)\n\n encoder_input, self_attention_bias, encoder_decoder_attention_bias = (\n transformer.transformer_prepare_encoder(\n inputs, target_space, hparams, features=features))\n\n encoder_input = tf.nn.dropout(encoder_input,\n 1.0 - hparams.layer_prepostprocess_dropout)\n\n (encoder_output, encoder_extra_output) = (\n my_universal_transformer_util.universal_transformer_encoder(\n encoder_input,\n self_attention_bias,\n hparams,\n nonpadding=transformer.features_to_nonpadding(features, \"inputs\"),\n save_weights_to=self.attention_weights))\n\n return encoder_output, encoder_decoder_attention_bias, encoder_extra_output","def encode(self, text: str) -> Union[List[int], List[str]]:\n encoded_tokens = [\n self._encoder.get(bpe_token, self._encoder.get(self._unk_token))\n if self._unk_token\n else self._encoder[bpe_token]\n for bpe_token in self._tokenize(text)\n ]\n return encoded_tokens","def __call__(self, sequences):\n\n # Get all texts from sequences list.\n texts = [sequence['text'] for sequence in sequences]\n\n # Get all labels from sequences list.\n labels = [sequence['label'] for sequence in sequences]\n # Encode all labels using label encoder.\n labels = [self.labels_encoder[label] for label in labels]\n # Call tokenizer on all texts to convert into tensors of numbers with\n # appropriate padding.\n inputs = self.use_tokenizer(text=texts, return_tensors=\"pt\", padding=True, truncation=True,\n max_length=self.max_sequence_len)\n # Update the inputs with the associated encoded labels as tensor.\n inputs.update({'labels': torch.tensor(labels)})\n\n return inputs","def pack_batch(self, batch, device=None):\n return pack_batch(self.label_encoder, batch, device or self.device)","def fit_tokenizer(self, texts):\n if not isinstance(texts, str) or not isinstance(texts, list):\n print(\"The sample you have provided is not correctly formatted. \" \\\n \"Must be a string or an array of strings.\")\n return\n else:\n if isinstance(texts, str):\n texts = [texts]\n\n self.tokenizer.fit_on_texts(texts)","def encode(input):\n return ModelEncoder().encode(input)","def collate_batch(batch, max_len, pad=0, decode_start_token=0, is_classifier=False):\n source_ids, target_ids = zip(*batch)\n source_ids, src_mask = optimize_sequence(source_ids, pad, max_len)\n if not is_classifier:\n target_ids, target_mask = optimize_sequence(target_ids, pad, max_len)\n shifted_target_ids = target_ids.new_zeros(target_ids.shape)\n shifted_target_ids[..., 1:] = target_ids[..., :-1].clone()\n shifted_target_ids[..., 0] = decode_start_token\n return (\n {\n \"input_ids\": source_ids, \"attention_mask\": src_mask,\n \"decoder_input_ids\": shifted_target_ids\n },\n {\"ids\": target_ids, \"mask\": target_mask}\n )\n # is classifier\n target_ids = torch.stack(target_ids)\n shifted_target_ids = target_ids.new_zeros(target_ids.shape[0], 1) + decode_start_token\n return (\n {\n \"input_ids\": source_ids, \"attention_mask\": src_mask,\n \"decoder_input_ids\": shifted_target_ids\n },\n {\"ids\": target_ids}\n )","def encode_decode(self, batch_inputs: Tensor,\n batch_data_samples: SampleList) -> Tensor:\n pass","def encode(\n self,\n docs: Optional[DocumentArray] = None,\n parameters: dict = {},\n *args,\n **kwargs,\n ) -> None:\n if not docs:\n return\n\n batch_generator = docs.batch(\n traversal_paths=parameters.get('traversal_paths', self.traversal_paths),\n batch_size=parameters.get('batch_size', self.batch_size),\n require_attr='blob',\n )\n\n with torch.inference_mode():\n for batch in batch_generator:\n images = []\n for doc in batch:\n if self.use_preprocessing:\n if doc.blob.shape[2] != 3:\n raise ValueError(\n \"If `use_preprocessing=True`, your image must\"\n \" be of the format [H, W, C], in the RGB format (C=3),\"\n f\" but got C={doc.blob.shape[2]} instead.\"\n )\n images.append(self._default_transforms(doc.blob))\n else:\n if doc.blob.shape[0] != 3:\n raise ValueError(\n \"If `use_preprocessing=False`, your image must\"\n \" be of the format [C, H, W], in the RGB format (C=3),\"\n f\" but got C={doc.blob.shape[0]} instead.\"\n )\n\n images.append(torch.tensor(doc.blob, dtype=torch.float32))\n\n images = torch.stack(images)\n embeddings = self.model.encode_image(image=images.to(self.device))\n embeddings = embeddings.cpu().numpy()\n\n for idx, doc in enumerate(batch):\n doc.embedding = embeddings[idx]","def batch_tokenize_fn(examples):\n sources = examples[config.source_lang]\n targets = examples[config.target_lang]\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\n\n # setup the tokenizer for targets,\n # huggingface expects the target tokenized ids to be stored in the labels field\n with config.tokenizer.as_target_tokenizer():\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\n\n model_inputs[\"labels\"] = labels[\"input_ids\"]\n return model_inputs","def create_bleurt_preprocessing_ops(tokenizer, max_seq_length):\n\n def _py_encode(references, candidates):\n input_ids, input_mask, segment_ids = encoding.encode_batch(\n references, candidates, tokenizer, max_seq_length)\n return input_ids, input_mask, segment_ids\n\n def bleurt_preprocessing_ops(references, candidates):\n \"\"\"Builds a computation graph for BLEURT tokenization and encoding.\"\"\"\n return tf.numpy_function(\n func=_py_encode,\n inp=[references, candidates],\n Tout=(tf.int64, tf.int64, tf.int64))\n\n return bleurt_preprocessing_ops","def prep_and_tokenize_generator(string_iterable, encoder, normalize_with_ftfy, normalize_with_wikitext_detokenize):\n for doc in string_iterable:\n if normalize_with_ftfy: # fix text with ftfy if specified\n doc = ftfy.fix_text(doc, normalization='NFKC')\n if normalize_with_wikitext_detokenize:\n doc = wikitext_detokenizer(doc)\n tokens = encoder.encode(doc) + [encoder.eos_token_id]\n yield tokens","def encode(self, x, encode_params, name=None):\n values = [x] + list(encode_params)\n with tf.compat.v1.name_scope(name, 'gather_encoder_encode', values):\n x = tf.convert_to_tensor(x)\n encode_params = tf.nest.map_structure(tf.convert_to_tensor, encode_params)\n return self._encode_fn(x, encode_params)","def forward(self, input: Union[str, List[str]]) -> Union[List, List[List]]:\n if isinstance(input, List):\n tokens: List[List[str]] = []\n for text in input:\n if self._return_tokens:\n tokens.append(self._tokenize(text))\n else:\n tokens.append(self.encode(text))\n return tokens\n elif isinstance(input, str):\n if self._return_tokens:\n return self._tokenize(input)\n else:\n return self.encode(input)\n else:\n raise TypeError(\"Input type not supported\")","def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \n \n depth = len(token_mapping)\n one_hot_tokens = []\n for sentence in tokens:\n one_hot_sentence = []\n for i, token in enumerate(sentence):\n if token != token_mapping['#UNK#']:\n one_hot_sentence.append(one_hot_encode(token, depth))\n else:\n if i <= 2:\n context_tokens = sentence[:i] + sentence[i+1:i+3]\n else:\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\n one_hot_sentence.append(context_mean)\n one_hot_tokens.append(one_hot_sentence)\n \n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\n return vec_tokens","def encode(self, text, batch_max_length=25):\n length = [len(s) for s in text]\n text = ''.join(text)\n text = [self.dict[char] for char in text]\n\n return (torch.IntTensor(text), torch.IntTensor(length))","def pack_batch(label_encoder, batch, device=None):\n (word, char), tasks = label_encoder.transform(batch)\n\n word = torch_utils.pad_batch(word, label_encoder.word.get_pad(), device=device)\n char = torch_utils.pad_batch(char, label_encoder.char.get_pad(), device=device)\n\n output_tasks = {}\n for task, data in tasks.items():\n output_tasks[task] = torch_utils.pad_batch(\n data, label_encoder.tasks[task].get_pad(), device=device)\n\n return (word, char), output_tasks","def _decode_batch_input_fn(num_decode_batches, sorted_inputs, vocabulary,\n batch_size, max_input_size,\n task_id=-1, has_input=True, use_static_shapes=False):\n tf.logging.info(\" batch %d\" % num_decode_batches)\n\n if use_static_shapes:\n global_max_length = max([len(vocabulary.encode(i)) for i in sorted_inputs]) + 1\n\n for b in range(num_decode_batches):\n tf.logging.info(f\"Decoding batch {b+1}/{num_decode_batches}\")\n batch_inputs = []\n for inputs in sorted_inputs[b * batch_size:(b + 1) * batch_size]:\n input_ids = vocabulary.encode(inputs)\n if max_input_size > 0:\n # Subtract 1 for the EOS_ID.\n input_ids = input_ids[:max_input_size - 1]\n if has_input or task_id > -1: # Do not append EOS for pure LM tasks.\n final_id = text_encoder.EOS_ID if task_id < 0 else task_id\n input_ids.append(final_id)\n batch_inputs.append(input_ids)\n\n final_batch_inputs = []\n if use_static_shapes:\n batch_length = global_max_length\n else:\n batch_length = max([len(ids) for ids in batch_inputs])\n\n for input_ids in batch_inputs:\n assert len(input_ids) <= batch_length\n x = input_ids + [0] * (batch_length - len(input_ids))\n final_batch_inputs.append(x)\n full_batch_padding = [[text_encoder.EOS_ID] * batch_length] * (batch_size - len(final_batch_inputs))\n final_batch_inputs = final_batch_inputs + full_batch_padding\n\n yield {\n \"inputs\": np.array(final_batch_inputs).astype(np.int32),\n }","def base_encoder(cls, data, init_encoder, downsize_encoder, input_encoder):\n #todo: maybe do positional encoding before passing to init_encoder\n data = downsize_encoder(init_encoder(data))\n return input_encoder(data)","def transform_batch(self, batch: Dict[str, Any], results: Dict[str, Any] = None, cls_is_bos=False,\n sep_is_eos=False) -> Dict[str, Any]:\n return batch","def preprocess_for_bert(\n self, text, max_len=MAX_SEQ_LEN, labels=None, label_map=None, trailing_piece_tag=\"X\"\n ):\n\n def _is_iterable_but_not_string(obj):\n return isinstance(obj, Iterable) and not isinstance(obj, str)\n\n if max_len > MAX_SEQ_LEN:\n logging.warning(\n \"Setting max_len to max allowed sequence length: {}\".format(MAX_SEQ_LEN)\n )\n max_len = MAX_SEQ_LEN\n\n if not _is_iterable_but_not_string(text):\n # The input text must be an non-string Iterable\n raise ValueError(\"Input text must be an iterable and not a string.\")\n else:\n # If the input text is a single list of words, convert it to\n # list of lists for later iteration\n if not _is_iterable_but_not_string(text[0]):\n text = [text]\n\n if labels is not None:\n if not _is_iterable_but_not_string(labels):\n raise ValueError(\"labels must be an iterable and not a string.\")\n else:\n if not _is_iterable_but_not_string(labels[0]):\n labels = [labels]\n\n label_available = True\n if labels is None:\n label_available = False\n # create an artificial label list for creating trailing token mask\n labels = [[\"O\"] * len(t) for t in text]\n\n input_ids_all = []\n input_mask_all = []\n label_ids_all = []\n trailing_token_mask_all = []\n\n for t, t_labels in zip(text, labels):\n if len(t) != len(t_labels):\n raise ValueError(\n \"The number of words is {0}, but the number of labels is {1}.\".format(\n len(t), len(t_labels)\n )\n )\n\n new_labels = []\n new_tokens = []\n for word, tag in zip(t, t_labels):\n sub_words = self.tokenizer.tokenize(word)\n for count, sub_word in enumerate(sub_words):\n if count > 0:\n tag = trailing_piece_tag\n new_labels.append(tag)\n new_tokens.append(sub_word)\n\n if len(new_tokens) > max_len:\n logging.warn(\n \"Text after tokenization with length {} has been truncated\".format(\n len(new_tokens)\n )\n )\n new_tokens = new_tokens[:max_len]\n new_labels = new_labels[:max_len]\n input_ids = self.tokenizer.convert_tokens_to_ids(new_tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens.\n # Only real tokens are attended to.\n input_mask = [1.0] * len(input_ids)\n\n # Zero-pad up to the max sequence length.\n padding = [0.0] * (max_len - len(input_ids))\n label_padding = [\"O\"] * (max_len - len(input_ids))\n\n input_ids += padding\n input_mask += padding\n new_labels += label_padding\n\n trailing_token_mask_all.append(\n [True if label != trailing_piece_tag else False for label in new_labels]\n )\n\n if label_map:\n label_ids = [label_map[label] for label in new_labels]\n else:\n label_ids = new_labels\n\n input_ids_all.append(input_ids)\n input_mask_all.append(input_mask)\n label_ids_all.append(label_ids)\n\n if label_available:\n td = TensorDataset(\n torch.tensor(input_ids_all, dtype=torch.long),\n torch.tensor(input_mask_all, dtype=torch.long),\n torch.tensor(trailing_token_mask_all, dtype=torch.bool),\n torch.tensor(label_ids_all, dtype=torch.long),\n )\n else:\n td = TensorDataset(\n torch.tensor(input_ids_all, dtype=torch.long),\n torch.tensor(input_mask_all, dtype=torch.long),\n torch.tensor(trailing_token_mask_all, dtype=torch.bool),\n )\n return td","def _generate(self, encoder_inputs, srcs_ids, beam_size=None, maxlen=None, prefix_tokens=None, src_weights=None):\n n_srcs = len(srcs_ids)\n srcs_tokens = encoder_inputs[0]\n align_src_tokens = srcs_tokens.index_select(0, srcs_ids[self.align_to])\n bsz, srclen = align_src_tokens.size()\n maxlen = min(maxlen, self.maxlen) if maxlen is not None else self.maxlen\n beam_size = beam_size if beam_size is not None else self.beam_size\n assert beam_size < self.vocab_size, 'Beam size must be smaller than target vocabulary'\n encoder_outs = self._encode(encoder_inputs, beam_size, srcs_ids)\n incremental_states = self._init_incremental_states(n_srcs)\n scores = align_src_tokens.new(bsz * beam_size, maxlen + 1).float().fill_(0)\n scores_buf = scores.clone()\n tokens = align_src_tokens.new(bsz * beam_size, maxlen + 2).fill_(self.pad)\n tokens_buf = tokens.clone()\n tokens[:, 0] = self.eos\n src_encoding_len = encoder_outs[self.align_to][0][0].size(0)\n attn = scores.new(bsz * beam_size, src_encoding_len, maxlen + 2)\n attn_buf = attn.clone()\n finalized = [[] for i in range(bsz)]\n finished = [(False) for i in range(bsz)]\n worst_finalized = [{'idx': None, 'score': -math.inf} for i in range(bsz)]\n num_remaining_sent = bsz\n cand_size = 2 * beam_size\n bbsz_offsets = (torch.arange(0, bsz) * beam_size).unsqueeze(1).type_as(tokens)\n cand_offsets = torch.arange(0, cand_size).type_as(tokens)\n buffers = {}\n\n def buffer(name, type_of=tokens):\n if name not in buffers:\n buffers[name] = type_of.new()\n return buffers[name]\n\n def is_finished(sent, step, unfinalized_scores=None):\n \"\"\"\n Check whether we've finished generation for a given sentence, by\n comparing the worst score among finalized hypotheses to the best\n possible score among unfinalized hypotheses.\n \"\"\"\n assert len(finalized[sent]) <= beam_size\n if len(finalized[sent]) == beam_size:\n if self.stop_early or step == maxlen or unfinalized_scores is None:\n return True\n best_unfinalized_score = unfinalized_scores[sent].max()\n if self.normalize_scores:\n best_unfinalized_score /= (maxlen + 1) ** self.len_penalty\n if worst_finalized[sent]['score'] >= best_unfinalized_score:\n return True\n return False\n\n def finalize_hypos(step, bbsz_idx, eos_scores, unfinalized_scores=None):\n \"\"\"\n Finalize the given hypotheses at this step, while keeping the total\n number of finalized hypotheses per sentence <= beam_size.\n\n Note: the input must be in the desired finalization order, so that\n hypotheses that appear earlier in the input are preferred to those\n that appear later.\n\n Args:\n step: current time step\n bbsz_idx: A vector of indices in the range [0, bsz*beam_size),\n indicating which hypotheses to finalize\n eos_scores: A vector of the same size as bbsz_idx containing\n scores for each hypothesis\n unfinalized_scores: A vector containing scores for all\n unfinalized hypotheses\n \"\"\"\n assert bbsz_idx.numel() == eos_scores.numel()\n tokens_clone = tokens.index_select(0, bbsz_idx)\n tokens_clone = tokens_clone[:, 1:step + 2]\n tokens_clone[:, step] = self.eos\n attn_clone = attn.index_select(0, bbsz_idx)[:, :, 1:step + 2]\n pos_scores = scores.index_select(0, bbsz_idx)[:, :step + 1]\n pos_scores[:, step] = eos_scores\n pos_scores[:, 1:] = pos_scores[:, 1:] - pos_scores[:, :-1]\n if self.normalize_scores:\n eos_scores /= (step + 1) ** self.len_penalty\n sents_seen = set()\n for i, (idx, score) in enumerate(zip(bbsz_idx.tolist(), eos_scores.tolist())):\n sent = idx // beam_size\n sents_seen.add(sent)\n\n def get_hypo():\n _, alignment = attn_clone[i].max(dim=0)\n return {'tokens': tokens_clone[i], 'score': score, 'attention': attn_clone[i], 'alignment': alignment, 'positional_scores': pos_scores[i]}\n if len(finalized[sent]) < beam_size:\n finalized[sent].append(get_hypo())\n elif not self.stop_early and score > worst_finalized[sent]['score']:\n worst_idx = worst_finalized[sent]['idx']\n if worst_idx is not None:\n finalized[sent][worst_idx] = get_hypo()\n idx, s = min(enumerate(finalized[sent]), key=lambda r: r[1]['score'])\n worst_finalized[sent] = {'score': s['score'], 'idx': idx}\n num_finished = 0\n for sent in sents_seen:\n if not finished[sent] and is_finished(sent, step, unfinalized_scores):\n finished[sent] = True\n num_finished += 1\n return num_finished\n reorder_state = None\n for step in range(maxlen + 1):\n if reorder_state is not None:\n for model_id, model in enumerate(self.models):\n if isinstance(model.decoder, FairseqIncrementalDecoder):\n for src_id in range(n_srcs):\n model.decoder.reorder_incremental_state(incremental_states[src_id, model_id], reorder_state)\n logprobs, avg_attn, possible_translation_tokens = self._decode(tokens[:, :step + 1], encoder_outs, incremental_states, n_srcs)\n if step == 0:\n logprobs = logprobs.unfold(0, 1, beam_size).squeeze(2).contiguous()\n scores = scores.type_as(logprobs)\n scores_buf = scores_buf.type_as(logprobs)\n else:\n logprobs.add_(scores[:, step - 1].view(-1, 1))\n logprobs[:, self.pad] = -math.inf\n if possible_translation_tokens is None:\n unk_index = self.unk\n else:\n unk_index = torch.nonzero(possible_translation_tokens == self.unk)[0, 0]\n logprobs[:, unk_index] += self.unk_reward\n logprobs[:, self.lexicon_indices] += self.lexicon_reward\n logprobs += self.word_reward\n logprobs[:, self.eos] -= self.word_reward\n attn[:, :, step + 1].copy_(avg_attn)\n cand_scores = buffer('cand_scores', type_of=scores)\n cand_indices = buffer('cand_indices')\n cand_beams = buffer('cand_beams')\n eos_bbsz_idx = buffer('eos_bbsz_idx')\n eos_scores = buffer('eos_scores', type_of=scores)\n if step < maxlen:\n if prefix_tokens is not None and step < prefix_tokens.size(1):\n logprobs_slice = logprobs.view(bsz, -1, logprobs.size(-1))[:, 0, :]\n cand_scores = torch.gather(logprobs_slice, dim=1, index=prefix_tokens[:, step].view(-1, 1)).expand(-1, cand_size)\n cand_indices = prefix_tokens[:, step].view(-1, 1).expand(bsz, cand_size)\n cand_beams.resize_as_(cand_indices).fill_(0)\n else:\n torch.topk(logprobs.view(bsz, -1), k=min(cand_size, logprobs.view(bsz, -1).size(1) - 1), out=(cand_scores, cand_indices))\n possible_tokens_size = self.vocab_size\n if possible_translation_tokens is not None:\n possible_tokens_size = possible_translation_tokens.size(0)\n torch.div(cand_indices, possible_tokens_size, out=cand_beams)\n cand_indices.fmod_(possible_tokens_size)\n if possible_translation_tokens is not None:\n possible_translation_tokens = possible_translation_tokens.view(1, possible_tokens_size).expand(cand_indices.size(0), possible_tokens_size)\n cand_indices = torch.gather(possible_translation_tokens, dim=1, index=cand_indices, out=cand_indices)\n else:\n torch.sort(logprobs[:, self.eos], descending=True, out=(eos_scores, eos_bbsz_idx))\n num_remaining_sent -= finalize_hypos(step, eos_bbsz_idx, eos_scores)\n assert num_remaining_sent == 0\n break\n cand_bbsz_idx = cand_beams.add_(bbsz_offsets)\n eos_mask = cand_indices.eq(self.eos)\n if step >= self.minlen:\n torch.masked_select(cand_bbsz_idx[:, :beam_size], mask=eos_mask[:, :beam_size], out=eos_bbsz_idx)\n if eos_bbsz_idx.numel() > 0:\n torch.masked_select(cand_scores[:, :beam_size], mask=eos_mask[:, :beam_size], out=eos_scores)\n num_remaining_sent -= finalize_hypos(step, eos_bbsz_idx, eos_scores, cand_scores)\n assert num_remaining_sent >= 0\n if num_remaining_sent == 0:\n break\n assert step < maxlen\n active_mask = buffer('active_mask')\n torch.add(eos_mask.type_as(cand_offsets) * cand_size, cand_offsets[:eos_mask.size(1)], out=active_mask)\n active_hypos, _ignore = buffer('active_hypos'), buffer('_ignore')\n torch.topk(active_mask, k=beam_size, dim=1, largest=False, out=(_ignore, active_hypos))\n active_bbsz_idx = buffer('active_bbsz_idx')\n torch.gather(cand_bbsz_idx, dim=1, index=active_hypos, out=active_bbsz_idx)\n active_scores = torch.gather(cand_scores, dim=1, index=active_hypos, out=scores[:, step].view(bsz, beam_size))\n active_bbsz_idx = active_bbsz_idx.view(-1)\n active_scores = active_scores.view(-1)\n torch.index_select(tokens[:, :step + 1], dim=0, index=active_bbsz_idx, out=tokens_buf[:, :step + 1])\n torch.gather(cand_indices, dim=1, index=active_hypos, out=tokens_buf.view(bsz, beam_size, -1)[:, :, step + 1])\n if step > 0:\n torch.index_select(scores[:, :step], dim=0, index=active_bbsz_idx, out=scores_buf[:, :step])\n torch.gather(cand_scores, dim=1, index=active_hypos, out=scores_buf.view(bsz, beam_size, -1)[:, :, step])\n torch.index_select(attn[:, :, :step + 2], dim=0, index=active_bbsz_idx, out=attn_buf[:, :, :step + 2])\n tokens, tokens_buf = tokens_buf, tokens\n scores, scores_buf = scores_buf, scores\n attn, attn_buf = attn_buf, attn\n reorder_state = active_bbsz_idx\n for sent in range(bsz):\n finalized[sent] = sorted(finalized[sent], key=lambda r: r['score'], reverse=True)\n return finalized","def encode(self, images):\n\n i = 0\n N = len(images)\n embs = None\n\n while True:\n end = min(N, i + self.batch_size)\n batch = images[i: end]\n\n size = end - i\n if size < self.batch_size:\n batch += self._input_padding[:self.batch_size - size]\n\n if embs is None:\n embs = self.sess.run(self.embed_layer, feed_dict={self.x: batch})\n else:\n _embs = self.sess.run(self.embed_layer, feed_dict={self.x: batch})\n embs = np.vstack((embs, _embs))\n\n i += self.batch_size\n\n if i >= N - 1:\n break\n\n return embs","def encode(self, data, mask, batch_size=128):\n features = np.zeros((len(data), self.feature_dim))\n n_batches = int(len(data) / batch_size)\n\n for i in tqdm(range(n_batches)):\n cur_data = data[i * batch_size:(i + 1) * batch_size]\n cur_mask = mask[i * batch_size:(i + 1) * batch_size]\n features[i * batch_size:(i + 1) * batch_size] = self.encode_fn(cur_data, cur_mask)\n if n_batches * batch_size < len(data):\n cur_data = data[n_batches * batch_size:]\n cur_mask = mask[n_batches * batch_size:]\n features[n_batches * batch_size:] = self.encode_fn(cur_data, cur_mask)\n\n return features","def encode(self, text, batch_max_length=25):\n length = [len(s) for s in text]\n text = ''.join(text)\n text = [self.dict[char] for char in text]\n\n return (torch.IntTensor(text).to(device), torch.IntTensor(length).to(device))","def preprocess_input(text, tokenizer, max_id):\n X = np.array(tokenizer.texts_to_sequences(text)) - 1\n encoded = tf.one_hot(X, depth=max_id)\n return encoded"],"string":"[\n \"def encode(batch, tokenizer):\\n return tokenizer.batch_encode_plus(batch['sentence'], padding='max_length')\",\n \"def _batch_encode(self, text: List[str]) -> List[List[str]]:\\n token_ids: List[List[int]] = self.bert_model.batch_encode([t.strip() for t in text])\\n tokens_ids_str: List[List[str]] = [[str(t) for t in token_id] for token_id in token_ids]\\n return tokens_ids_str\",\n \"def encode(self, phrases, **kwargs):\\n\\n if not phrases:\\n return []\\n\\n if not isinstance(phrases, (str, list)):\\n raise TypeError(f\\\"argument phrases must be of type str or list, not {type(phrases)}\\\")\\n\\n batch_size = kwargs.get(\\\"batch_size\\\", 16)\\n _len_phrases = len(phrases) if isinstance(phrases, list) else 1\\n show_progress_bar = kwargs.get(\\\"show_progress_bar\\\", False) and _len_phrases > 1\\n output_value = kwargs.get(\\\"output_value\\\", 'sentence_embedding')\\n convert_to_numpy = kwargs.get(\\\"convert_to_numpy\\\", True)\\n convert_to_tensor = kwargs.get(\\\"convert_to_tensor\\\", False)\\n device = kwargs.get(\\\"device\\\", self.device)\\n concat_last_n_layers = kwargs.get(\\\"concat_last_n_layers\\\", 1)\\n normalize_token_embs = kwargs.get(\\\"normalize_token_embs\\\", False)\\n\\n # `False` for first call but might not for the subsequent calls\\n _use_sbert_model = getattr(self, \\\"_use_sbert_model\\\", False)\\n\\n if not _use_sbert_model:\\n try:\\n # this snippet is to reduce dependency on sentence-transformers library\\n # note that currently, the dependency is not fully eliminated due to backwards\\n # compatability issues in huggingface-transformers between older (python 3.6)\\n # and newer (python >=3.7) versions which needs more conditions to be implemented\\n # in `_encode_local` and hence will be addressed in future work\\n # TODO: eliminate depedency on sentence-transformers library\\n results = self._encode_local(phrases,\\n batch_size=batch_size,\\n show_progress_bar=show_progress_bar,\\n output_value=output_value,\\n convert_to_numpy=convert_to_numpy,\\n convert_to_tensor=convert_to_tensor,\\n device=device,\\n concat_last_n_layers=concat_last_n_layers,\\n normalize_token_embs=normalize_token_embs)\\n setattr(self, \\\"_use_sbert_model\\\", False)\\n except TypeError as e:\\n logger.error(e)\\n if concat_last_n_layers != 1 or normalize_token_embs:\\n msg = f\\\"{'concat_last_n_layers,' if concat_last_n_layers != 1 else ''} \\\" \\\\\\n f\\\"{'normalize_token_embs' if normalize_token_embs else ''} \\\" \\\\\\n f\\\"ignored as resorting to using encode methods from sentence-transformers\\\"\\n logger.warning(msg)\\n setattr(self, \\\"_use_sbert_model\\\", True)\\n\\n if getattr(self, \\\"_use_sbert_model\\\"):\\n results = self.sbert_model.encode(phrases,\\n batch_size=batch_size,\\n show_progress_bar=show_progress_bar,\\n output_value=output_value,\\n convert_to_numpy=convert_to_numpy,\\n convert_to_tensor=convert_to_tensor,\\n device=device)\\n\\n return results\",\n \"def encode_all(self, inputs, encoder):\\n input_shape = tf.shape(inputs)\\n num_timesteps, batch_size = input_shape[0], input_shape[1]\\n reshaped_inputs = tf.reshape(inputs, [-1, inputs.shape[-1]])\\n inputs_encoded = encoder(reshaped_inputs)\\n inputs_encoded = tf.reshape(inputs_encoded, [num_timesteps, batch_size, encoder.output_size])\\n return inputs_encoded\",\n \"def encode_batch(self, sentences: List[str], field_name, features=None) -> List[SequentialField]:\\n # We need to set this so that `tokenizers` package does not complain about detecting forks.\\n os.environ['TOKENIZERS_PARALLELISM'] = \\\"true\\\"\\n\\n if features is None:\\n features = []\\n extract_word_pieces = False\\n else:\\n assert all([len(sentence.split()) == len(feature) for sentence, feature in zip(sentences, features)])\\n extract_word_pieces = True\\n\\n batch_size = len(sentences)\\n\\n if field_name != 'answer':\\n sentences = [self.input_prefix + sent for sent in sentences]\\n\\n if self._preprocess_special_tokens:\\n if len(sentences) > MULTIPROCESSING_THRESHOLD:\\n multiprocessing_factor = multiprocessing.cpu_count() // len(get_devices(self.args.devices))\\n logger.info('multiprocessing factor for special token preprocessing is %d', multiprocessing_factor)\\n with multiprocessing.Pool(multiprocessing_factor) as p:\\n sentences, index2expansions = list(\\n zip(\\n *p.map(\\n functools.partial(self._apply_special_token_preprocessing, return_idx2exp=bool(len(features))),\\n sentences,\\n )\\n )\\n )\\n else:\\n sentences, index2expansions = list(\\n zip(\\n *map(\\n functools.partial(self._apply_special_token_preprocessing, return_idx2exp=bool(len(features))),\\n sentences,\\n )\\n )\\n )\\n\\n all_input_features = []\\n if features:\\n for i, (sentence, index2expansion) in enumerate(zip(sentences, index2expansions)):\\n feat = features[i]\\n new_feat = []\\n keys = set(index2expansion.keys())\\n for j in range(len(feat)):\\n repeat = 1\\n if j in keys:\\n repeat = index2expansion[j]\\n\\n new_feat.extend(feat[j] * repeat)\\n\\n assert len(new_feat) == len(sentence.split(' '))\\n\\n all_input_features.append(new_feat)\\n\\n features = all_input_features\\n\\n # batch_encode_plus for fast tokenizers returns tokenized text\\n # whereas slow version do not. We breakdown slow tokenization into two steps\\n # extract tokenized text first, use that to adjust features\\n # then pass tokenized text to `_batch_prepare_for_model`\\n def do_fast_tokenization(extract_word_pieces):\\n all_wp_tokenized = []\\n batch_encoded = self._tokenizer.batch_encode_plus(\\n list(sentences),\\n add_special_tokens=True,\\n max_length=None,\\n return_length=True,\\n return_attention_mask=False,\\n return_special_tokens_mask=True,\\n )\\n if extract_word_pieces:\\n for encoding in batch_encoded.encodings:\\n # remove special tokens\\n num_prefix_special_tokens, num_suffix_special_tokens = self.get_num_special_tokens(\\n encoding.special_tokens_mask\\n )\\n wp_tokens = encoding.tokens[num_prefix_special_tokens:-num_suffix_special_tokens]\\n all_wp_tokenized.append(wp_tokens)\\n\\n return batch_encoded, all_wp_tokenized\\n\\n def do_slow_tokenization(extract_word_pieces):\\n all_input_ids = []\\n all_wp_tokenized = []\\n if extract_word_pieces:\\n for i in range(batch_size):\\n text = sentences[i]\\n wp_tokenized = self._tokenizer.tokenize(text)\\n all_wp_tokenized.append(wp_tokenized)\\n\\n # None indicates encoding single instance not paired inputs\\n all_input_ids.append((self._tokenizer.convert_tokens_to_ids(wp_tokenized), None))\\n\\n batch_encoded = self._tokenizer._batch_prepare_for_model(\\n all_input_ids,\\n add_special_tokens=True,\\n max_length=None,\\n return_length=True,\\n return_attention_mask=False,\\n return_special_tokens_mask=True,\\n )\\n else:\\n batch_encoded = self._tokenizer.batch_encode_plus(\\n list(sentences),\\n add_special_tokens=True,\\n max_length=None,\\n return_length=True,\\n return_attention_mask=False,\\n return_special_tokens_mask=True,\\n )\\n return batch_encoded, all_wp_tokenized\\n\\n if self._use_fast():\\n if field_name == 'answer':\\n with self._tokenizer.as_target_tokenizer():\\n batch_encoded, all_wp_tokenized = do_fast_tokenization(extract_word_pieces)\\n else:\\n batch_encoded, all_wp_tokenized = do_fast_tokenization(extract_word_pieces)\\n\\n else:\\n if field_name == 'answer':\\n with self._tokenizer.as_target_tokenizer():\\n batch_encoded, all_wp_tokenized = do_slow_tokenization(extract_word_pieces)\\n else:\\n batch_encoded, all_wp_tokenized = do_slow_tokenization(extract_word_pieces)\\n\\n all_input_features = []\\n\\n if features:\\n for i in range(batch_size):\\n wp_features = []\\n wp_tokenized = all_wp_tokenized[i]\\n\\n feat = features[i]\\n\\n # first token is always not a piece\\n is_wp = [0] + [int(self._tokenizer.is_piece_fn(wp)) for wp in wp_tokenized[1:]]\\n k = -1\\n for j, wp in enumerate(wp_tokenized):\\n if not is_wp[j]:\\n k += 1\\n wp_features.append(feat[k])\\n\\n assert len(wp_tokenized) == len(wp_features)\\n\\n all_input_features.append(wp_features)\\n\\n features = all_input_features\\n\\n batch_special_tokens_mask = batch_encoded.special_tokens_mask\\n\\n batch_features = []\\n\\n if features:\\n for i in range(batch_size):\\n feat = features[i]\\n special_tokens_mask = batch_special_tokens_mask[i]\\n num_prefix_special_tokens, num_suffix_special_tokens = self.get_num_special_tokens(special_tokens_mask)\\n\\n pad_feat = Entity.get_pad_entity(self.args.max_features_size)\\n feat = [pad_feat] * num_prefix_special_tokens + feat + [pad_feat] * num_suffix_special_tokens\\n\\n batch_features.append(feat)\\n\\n batch_numerical = batch_encoded.input_ids\\n batch_length = batch_encoded.length\\n\\n batch_decoder_numerical = []\\n if self.decoder_vocab:\\n for i in range(batch_size):\\n batch_decoder_numerical.append(self.decoder_vocab.encode(batch_numerical[i]))\\n else:\\n batch_decoder_numerical = [[]] * len(batch_numerical)\\n\\n sequential_fields = []\\n for i in range(batch_size):\\n if features:\\n feature = [feat.flatten() for feat in batch_features[i]]\\n assert len(batch_numerical[i]) == len(feature)\\n else:\\n feature = None\\n\\n sequential_fields.append(\\n SequentialField(\\n value=batch_numerical[i],\\n length=batch_length[i],\\n limited=batch_decoder_numerical[i],\\n feature=feature,\\n )\\n )\\n return sequential_fields\",\n \"def batch_encode(self,\\n batch_text_or_text_pairs,\\n max_seq_len=512,\\n pad_to_max_seq_len=False,\\n stride=0,\\n is_split_into_words=False,\\n truncation_strategy=\\\"longest_first\\\",\\n return_position_ids=False,\\n return_token_type_ids=True,\\n return_attention_mask=False,\\n return_length=False,\\n return_overflowing_tokens=False,\\n return_special_tokens_mask=False):\\n\\n def get_input_ids(text):\\n if isinstance(text, str):\\n tokens = self._tokenize(text)\\n return self.convert_tokens_to_ids(tokens)\\n elif isinstance(text,\\n (list, tuple)) and len(text) > 0 and isinstance(\\n text[0], str):\\n return self.convert_tokens_to_ids(text)\\n elif isinstance(text,\\n (list, tuple)) and len(text) > 0 and isinstance(\\n text[0], int):\\n return text\\n else:\\n raise ValueError(\\n \\\"Input is not valid. Should be a string, a list/tuple of strings or a list/tuple of integers.\\\"\\n )\\n\\n batch_encode_inputs = []\\n for example_id, tokens_or_pair_tokens in enumerate(\\n batch_text_or_text_pairs):\\n if not isinstance(tokens_or_pair_tokens, (list, tuple)):\\n text, text_pair = tokens_or_pair_tokens, None\\n elif is_split_into_words and not isinstance(\\n tokens_or_pair_tokens[0], (list, tuple)):\\n text, text_pair = tokens_or_pair_tokens, None\\n else:\\n text, text_pair = tokens_or_pair_tokens\\n\\n first_ids = get_input_ids(text)\\n second_ids = get_input_ids(\\n text_pair) if text_pair is not None else None\\n\\n if stride > 0 and second_ids is not None:\\n\\n max_len_for_pair = max_seq_len - len(first_ids) - self.num_special_tokens_to_add(\\n pair=True) # need -4 <sep> A </sep> </sep> B <sep>\\n\\n token_offset_mapping = self.rematch(text)\\n token_pair_offset_mapping = self.rematch(text_pair)\\n\\n while True:\\n encoded_inputs = {}\\n\\n ids = first_ids\\n mapping = token_offset_mapping\\n if len(second_ids) <= max_len_for_pair:\\n pair_ids = second_ids\\n pair_mapping = token_pair_offset_mapping\\n else:\\n pair_ids = second_ids[:max_len_for_pair]\\n pair_mapping = token_pair_offset_mapping[:max_len_for_pair]\\n\\n offset_mapping = self.build_offset_mapping_with_special_tokens(\\n mapping, pair_mapping)\\n sequence = self.build_inputs_with_special_tokens(ids,\\n pair_ids)\\n token_type_ids = self.create_token_type_ids_from_sequences(\\n ids, pair_ids)\\n\\n # Build output dictionnary\\n encoded_inputs[\\\"input_ids\\\"] = sequence\\n if return_token_type_ids:\\n encoded_inputs[\\\"token_type_ids\\\"] = token_type_ids\\n if return_special_tokens_mask:\\n encoded_inputs[\\n \\\"special_tokens_mask\\\"] = self.get_special_tokens_mask(\\n ids, pair_ids)\\n if return_length:\\n encoded_inputs[\\\"seq_len\\\"] = len(encoded_inputs[\\n \\\"input_ids\\\"])\\n\\n # Check lengths\\n assert max_seq_len is None or len(encoded_inputs[\\n \\\"input_ids\\\"]) <= max_seq_len\\n\\n # Padding\\n needs_to_be_padded = pad_to_max_seq_len and \\\\\\n max_seq_len and len(encoded_inputs[\\\"input_ids\\\"]) < max_seq_len\\n\\n encoded_inputs['offset_mapping'] = offset_mapping\\n\\n if needs_to_be_padded:\\n difference = max_seq_len - len(encoded_inputs[\\n \\\"input_ids\\\"])\\n if self.padding_side == 'right':\\n if return_attention_mask:\\n encoded_inputs[\\\"attention_mask\\\"] = [1] * len(\\n encoded_inputs[\\n \\\"input_ids\\\"]) + [0] * difference\\n if return_token_type_ids:\\n # 0 for padding token mask\\n encoded_inputs[\\\"token_type_ids\\\"] = (\\n encoded_inputs[\\\"token_type_ids\\\"] +\\n [self.pad_token_type_id] * difference)\\n if return_special_tokens_mask:\\n encoded_inputs[\\n \\\"special_tokens_mask\\\"] = encoded_inputs[\\n \\\"special_tokens_mask\\\"] + [1\\n ] * difference\\n encoded_inputs[\\\"input_ids\\\"] = encoded_inputs[\\n \\\"input_ids\\\"] + [self.pad_token_id] * difference\\n encoded_inputs['offset_mapping'] = encoded_inputs[\\n 'offset_mapping'] + [(0, 0)] * difference\\n elif self.padding_side == 'left':\\n if return_attention_mask:\\n encoded_inputs[\\\"attention_mask\\\"] = [\\n 0\\n ] * difference + [1] * len(encoded_inputs[\\n \\\"input_ids\\\"])\\n if return_token_type_ids:\\n # 0 for padding token mask\\n encoded_inputs[\\\"token_type_ids\\\"] = (\\n [self.pad_token_type_id] * difference +\\n encoded_inputs[\\\"token_type_ids\\\"])\\n if return_special_tokens_mask:\\n encoded_inputs[\\\"special_tokens_mask\\\"] = [\\n 1\\n ] * difference + encoded_inputs[\\n \\\"special_tokens_mask\\\"]\\n encoded_inputs[\\\"input_ids\\\"] = [\\n self.pad_token_id\\n ] * difference + encoded_inputs[\\\"input_ids\\\"]\\n encoded_inputs['offset_mapping'] = [\\n (0, 0)\\n ] * difference + encoded_inputs['offset_mapping']\\n else:\\n if return_attention_mask:\\n encoded_inputs[\\\"attention_mask\\\"] = [1] * len(\\n encoded_inputs[\\\"input_ids\\\"])\\n\\n if return_position_ids:\\n encoded_inputs[\\\"position_ids\\\"] = list(\\n range(len(encoded_inputs[\\\"input_ids\\\"])))\\n\\n encoded_inputs['overflow_to_sample'] = example_id\\n batch_encode_inputs.append(encoded_inputs)\\n\\n if len(second_ids) <= max_len_for_pair:\\n break\\n else:\\n second_ids = second_ids[max_len_for_pair - stride:]\\n token_pair_offset_mapping = token_pair_offset_mapping[max_len_for_pair - stride:]\\n\\n else:\\n batch_encode_inputs.append(\\n self.encode(\\n first_ids,\\n second_ids,\\n max_seq_len=max_seq_len,\\n pad_to_max_seq_len=pad_to_max_seq_len,\\n truncation_strategy=truncation_strategy,\\n return_position_ids=return_position_ids,\\n return_token_type_ids=return_token_type_ids,\\n return_attention_mask=return_attention_mask,\\n return_length=return_length,\\n return_overflowing_tokens=return_overflowing_tokens,\\n return_special_tokens_mask=return_special_tokens_mask))\\n\\n return batch_encode_inputs\",\n \"def __call__(\\n self,\\n text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]],\\n text_pair: Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None,\\n boxes: Union[List[List[int]], List[List[List[int]]]] = None,\\n word_labels: Optional[Union[List[int], List[List[int]]]] = None,\\n add_special_tokens: bool = True,\\n padding: Union[bool, str, PaddingStrategy] = False,\\n truncation: Union[bool, str, TruncationStrategy] = None,\\n max_length: Optional[int] = None,\\n stride: int = 0,\\n pad_to_multiple_of: Optional[int] = None,\\n return_tensors: Optional[Union[str, TensorType]] = None,\\n return_token_type_ids: Optional[bool] = None,\\n return_attention_mask: Optional[bool] = None,\\n return_overflowing_tokens: bool = False,\\n return_special_tokens_mask: bool = False,\\n return_offsets_mapping: bool = False,\\n return_length: bool = False,\\n verbose: bool = True,\\n **kwargs,\\n ) -> BatchEncoding:\\n\\n # Input type checking for clearer error\\n def _is_valid_text_input(t):\\n if isinstance(t, str):\\n # Strings are fine\\n return True\\n elif isinstance(t, (list, tuple)):\\n # List are fine as long as they are...\\n if len(t) == 0:\\n # ... empty\\n return True\\n elif isinstance(t[0], str):\\n # ... list of strings\\n return True\\n elif isinstance(t[0], (list, tuple)):\\n # ... list with an empty list or with a list of strings\\n return len(t[0]) == 0 or isinstance(t[0][0], str)\\n else:\\n return False\\n else:\\n return False\\n\\n if text_pair is not None:\\n # in case text + text_pair are provided, text = questions, text_pair = words\\n if not _is_valid_text_input(text):\\n raise ValueError(\\\"text input must of type `str` (single example) or `List[str]` (batch of examples). \\\")\\n if not isinstance(text_pair, (list, tuple)):\\n raise ValueError(\\n \\\"words must of type `List[str]` (single pretokenized example), \\\"\\n \\\"or `List[List[str]]` (batch of pretokenized examples).\\\"\\n )\\n else:\\n # in case only text is provided => must be words\\n if not isinstance(text, (list, tuple)):\\n raise ValueError(\\n \\\"Words must of type `List[str]` (single pretokenized example), \\\"\\n \\\"or `List[List[str]]` (batch of pretokenized examples).\\\"\\n )\\n\\n if text_pair is not None:\\n is_batched = isinstance(text, (list, tuple))\\n else:\\n is_batched = isinstance(text, (list, tuple)) and text and isinstance(text[0], (list, tuple))\\n\\n words = text if text_pair is None else text_pair\\n if boxes is None:\\n raise ValueError(\\\"You must provide corresponding bounding boxes\\\")\\n if is_batched:\\n if len(words) != len(boxes):\\n raise ValueError(\\\"You must provide words and boxes for an equal amount of examples\\\")\\n for words_example, boxes_example in zip(words, boxes):\\n if len(words_example) != len(boxes_example):\\n raise ValueError(\\\"You must provide as many words as there are bounding boxes\\\")\\n else:\\n if len(words) != len(boxes):\\n raise ValueError(\\\"You must provide as many words as there are bounding boxes\\\")\\n\\n if is_batched:\\n if text_pair is not None and len(text) != len(text_pair):\\n raise ValueError(\\n f\\\"batch length of `text`: {len(text)} does not match batch length of `text_pair`:\\\"\\n f\\\" {len(text_pair)}.\\\"\\n )\\n batch_text_or_text_pairs = list(zip(text, text_pair)) if text_pair is not None else text\\n is_pair = bool(text_pair is not None)\\n return self.batch_encode_plus(\\n batch_text_or_text_pairs=batch_text_or_text_pairs,\\n is_pair=is_pair,\\n boxes=boxes,\\n word_labels=word_labels,\\n add_special_tokens=add_special_tokens,\\n padding=padding,\\n truncation=truncation,\\n max_length=max_length,\\n stride=stride,\\n pad_to_multiple_of=pad_to_multiple_of,\\n return_tensors=return_tensors,\\n return_token_type_ids=return_token_type_ids,\\n return_attention_mask=return_attention_mask,\\n return_overflowing_tokens=return_overflowing_tokens,\\n return_special_tokens_mask=return_special_tokens_mask,\\n return_offsets_mapping=return_offsets_mapping,\\n return_length=return_length,\\n verbose=verbose,\\n **kwargs,\\n )\\n else:\\n return self.encode_plus(\\n text=text,\\n text_pair=text_pair,\\n boxes=boxes,\\n word_labels=word_labels,\\n add_special_tokens=add_special_tokens,\\n padding=padding,\\n truncation=truncation,\\n max_length=max_length,\\n stride=stride,\\n pad_to_multiple_of=pad_to_multiple_of,\\n return_tensors=return_tensors,\\n return_token_type_ids=return_token_type_ids,\\n return_attention_mask=return_attention_mask,\\n return_overflowing_tokens=return_overflowing_tokens,\\n return_special_tokens_mask=return_special_tokens_mask,\\n return_offsets_mapping=return_offsets_mapping,\\n return_length=return_length,\\n verbose=verbose,\\n **kwargs,\\n )\",\n \"def _encode(self, src_token_ids, padding_mask, training=False):\\n src_seq_len = tf.shape(src_token_ids)[1]\\n\\n # [batch_size, src_seq_len, hidden_size]\\n src_token_embeddings = self._embedding_logits_layer(\\n src_token_ids, 'embedding')\\n\\n # [src_seq_len, hidden_size]\\n positional_encoding = utils.get_positional_encoding(\\n src_seq_len, self._hidden_size)\\n src_token_embeddings += positional_encoding\\n src_token_embeddings = self._encoder_dropout_layer(\\n src_token_embeddings, training)\\n\\n encoder_outputs = self._encoder(\\n src_token_embeddings, padding_mask, training)\\n return encoder_outputs\",\n \"def encoder(self, inputs):\\n pass\",\n \"def encode_and_flatten(\\n raw_text_iter: IterableDataset[str],\\n tokenizer: Callable[[str], list[str]],\\n vocab: Vocab,\\n) -> torch.Tensor:\\n data = [\\n torch.tensor(vocab(tokenizer(item)), dtype=torch.long)\\n for item in raw_text_iter\\n ]\\n return torch.cat(tuple(filter(lambda t: t.numel() > 0, data)))\",\n \"def encode(self, text):\\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\\n batch_max_length = self.opt.model_params.max_len + 1\\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\\n batch_text = np.zeros((len(text), batch_max_length + 1), dtype=int)\\n for i, t in enumerate(text):\\n cur_text = list(t)\\n cur_text.append('[s]')\\n cur_text = [self.dict[char] for char in cur_text]\\n batch_text[i][1:1 + len(cur_text)] = cur_text\\n return tf.convert_to_tensor(batch_text, dtype=tf.int32), tf.convert_to_tensor(length, dtype=tf.int32)\",\n \"def prepare_for_model(\\n self,\\n text: Union[TextInput, PreTokenizedInput],\\n text_pair: Optional[PreTokenizedInput] = None,\\n boxes: Optional[List[List[int]]] = None,\\n word_labels: Optional[List[int]] = None,\\n add_special_tokens: bool = True,\\n padding: Union[bool, str, PaddingStrategy] = False,\\n truncation: Union[bool, str, TruncationStrategy] = None,\\n max_length: Optional[int] = None,\\n stride: int = 0,\\n pad_to_multiple_of: Optional[int] = None,\\n return_tensors: Optional[Union[str, TensorType]] = None,\\n return_token_type_ids: Optional[bool] = None,\\n return_attention_mask: Optional[bool] = None,\\n return_overflowing_tokens: bool = False,\\n return_special_tokens_mask: bool = False,\\n return_offsets_mapping: bool = False,\\n return_length: bool = False,\\n verbose: bool = True,\\n prepend_batch_axis: bool = False,\\n **kwargs,\\n ) -> BatchEncoding:\\n\\n # Backward compatibility for 'truncation_strategy', 'pad_to_max_length'\\n padding_strategy, truncation_strategy, max_length, kwargs = self._get_padding_truncation_strategies(\\n padding=padding,\\n truncation=truncation,\\n max_length=max_length,\\n pad_to_multiple_of=pad_to_multiple_of,\\n verbose=verbose,\\n **kwargs,\\n )\\n\\n tokens = []\\n pair_tokens = []\\n token_boxes = []\\n pair_token_boxes = []\\n labels = []\\n\\n if text_pair is None:\\n if word_labels is None:\\n # CASE 1: document image classification (training + inference) + CASE 2: token classification (inference)\\n for word, box in zip(text, boxes):\\n if len(word) < 1: # skip empty words\\n continue\\n word_tokens = self.tokenize(word)\\n tokens.extend(word_tokens)\\n token_boxes.extend([box] * len(word_tokens))\\n else:\\n # CASE 2: token classification (training)\\n for word, box, label in zip(text, boxes, word_labels):\\n if len(word) < 1: # skip empty words\\n continue\\n word_tokens = self.tokenize(word)\\n tokens.extend(word_tokens)\\n token_boxes.extend([box] * len(word_tokens))\\n if self.only_label_first_subword:\\n # Use the real label id for the first token of the word, and padding ids for the remaining tokens\\n labels.extend([label] + [self.pad_token_label] * (len(word_tokens) - 1))\\n else:\\n labels.extend([label] * len(word_tokens))\\n else:\\n # CASE 3: document visual question answering (inference)\\n # text = question\\n # text_pair = words\\n tokens = self.tokenize(text)\\n token_boxes = [self.pad_token_box for _ in range(len(tokens))] + [self.sep_token_box]\\n\\n for word, box in zip(text_pair, boxes):\\n if len(word) < 1: # skip empty words\\n continue\\n word_tokens = self.tokenize(word)\\n pair_tokens.extend(word_tokens)\\n pair_token_boxes.extend([box] * len(word_tokens))\\n\\n # Create ids + pair_ids\\n ids = self.convert_tokens_to_ids(tokens)\\n pair_ids = self.convert_tokens_to_ids(pair_tokens) if pair_tokens else None\\n\\n # Compute the total size of the returned encodings\\n pair = bool(pair_ids is not None)\\n len_ids = len(ids)\\n len_pair_ids = len(pair_ids) if pair else 0\\n total_len = len_ids + len_pair_ids + (self.num_special_tokens_to_add(pair=pair) if add_special_tokens else 0)\\n\\n # Truncation: Handle max sequence length\\n overflowing_tokens = []\\n overflowing_token_boxes = []\\n overflowing_labels = []\\n if truncation_strategy != TruncationStrategy.DO_NOT_TRUNCATE and max_length and total_len > max_length:\\n (\\n ids,\\n token_boxes,\\n pair_ids,\\n pair_token_boxes,\\n labels,\\n overflowing_tokens,\\n overflowing_token_boxes,\\n overflowing_labels,\\n ) = self.truncate_sequences(\\n ids,\\n token_boxes,\\n pair_ids=pair_ids,\\n pair_token_boxes=pair_token_boxes,\\n labels=labels,\\n num_tokens_to_remove=total_len - max_length,\\n truncation_strategy=truncation_strategy,\\n stride=stride,\\n )\\n\\n if return_token_type_ids and not add_special_tokens:\\n raise ValueError(\\n \\\"Asking to return token_type_ids while setting add_special_tokens to False \\\"\\n \\\"results in an undefined behavior. Please set add_special_tokens to True or \\\"\\n \\\"set return_token_type_ids to None.\\\"\\n )\\n\\n # Load from model defaults\\n if return_token_type_ids is None:\\n return_token_type_ids = \\\"token_type_ids\\\" in self.model_input_names\\n if return_attention_mask is None:\\n return_attention_mask = \\\"attention_mask\\\" in self.model_input_names\\n\\n encoded_inputs = {}\\n\\n if return_overflowing_tokens:\\n encoded_inputs[\\\"overflowing_tokens\\\"] = overflowing_tokens\\n encoded_inputs[\\\"overflowing_token_boxes\\\"] = overflowing_token_boxes\\n encoded_inputs[\\\"overflowing_labels\\\"] = overflowing_labels\\n encoded_inputs[\\\"num_truncated_tokens\\\"] = total_len - max_length\\n\\n # Add special tokens\\n if add_special_tokens:\\n sequence = self.build_inputs_with_special_tokens(ids, pair_ids)\\n token_type_ids = self.create_token_type_ids_from_sequences(ids, pair_ids)\\n token_boxes = [self.cls_token_box] + token_boxes + [self.sep_token_box]\\n if pair_token_boxes:\\n pair_token_boxes = pair_token_boxes + [self.sep_token_box]\\n if labels:\\n labels = [self.pad_token_label] + labels + [self.pad_token_label]\\n else:\\n sequence = ids + pair_ids if pair else ids\\n token_type_ids = [0] * len(ids) + ([0] * len(pair_ids) if pair else [])\\n\\n # Build output dictionary\\n encoded_inputs[\\\"input_ids\\\"] = sequence\\n encoded_inputs[\\\"bbox\\\"] = token_boxes + pair_token_boxes\\n if return_token_type_ids:\\n encoded_inputs[\\\"token_type_ids\\\"] = token_type_ids\\n if return_special_tokens_mask:\\n if add_special_tokens:\\n encoded_inputs[\\\"special_tokens_mask\\\"] = self.get_special_tokens_mask(ids, pair_ids)\\n else:\\n encoded_inputs[\\\"special_tokens_mask\\\"] = [0] * len(sequence)\\n\\n if labels:\\n encoded_inputs[\\\"labels\\\"] = labels\\n\\n # Check lengths\\n self._eventual_warn_about_too_long_sequence(encoded_inputs[\\\"input_ids\\\"], max_length, verbose)\\n\\n # Padding\\n if padding_strategy != PaddingStrategy.DO_NOT_PAD or return_attention_mask:\\n encoded_inputs = self.pad(\\n encoded_inputs,\\n max_length=max_length,\\n padding=padding_strategy.value,\\n pad_to_multiple_of=pad_to_multiple_of,\\n return_attention_mask=return_attention_mask,\\n )\\n\\n if return_length:\\n encoded_inputs[\\\"length\\\"] = len(encoded_inputs[\\\"input_ids\\\"])\\n\\n batch_outputs = BatchEncoding(\\n encoded_inputs, tensor_type=return_tensors, prepend_batch_axis=prepend_batch_axis\\n )\\n\\n return batch_outputs\",\n \"def _encode_transformed_data_batch(\\n data: Tuple[pa.RecordBatch, Dict[str, pa.Array]],\\n coder: example_coder.RecordBatchToExamplesEncoder) -> List[bytes]:\\n # Drop unary pass-through features that are not relevant for this testing\\n # framework.\\n record_batch, _ = data\\n return coder.encode(record_batch)\",\n \"def __call__(\\n self, data_batch: Dict[str, List[str]]\\n ) -> Tuple[\\n BatchEncoding,\\n List[Dict[str, Union[int, str]]],\\n List[SquadExample],\\n List[SquadFeatures],\\n ]:\\n self._check_values_len(data_batch)\\n concatenated_batch, evidences = self._concatenate_batch(data_batch)\\n dataset, examples, features = load_examples(\\n concatenated_batch, self.tokenizer, evaluate=True, output_examples=True\\n )\\n\\n input_ids = [torch.unsqueeze(instance[0], 0) for instance in dataset]\\n attention_mask = [torch.unsqueeze(instance[1], 0) for instance in dataset]\\n token_type_ids = [torch.unsqueeze(instance[2], 0) for instance in dataset]\\n\\n output = {\\n \\\"input_ids\\\": torch.cat(input_ids, axis=0),\\n \\\"attention_mask\\\": torch.cat(attention_mask, axis=0),\\n \\\"token_type_ids\\\": torch.cat(token_type_ids, axis=0),\\n }\\n output = BatchEncoding(output)\\n\\n return output, evidences, examples, features\",\n \"def fixed_encode_ja(self, tokens, labels: list = None, dummy: str = '@'):\\n # get special tokens at start/end of sentence based on first token\\n encode_all = self.tokenizer.batch_encode_plus(tokens)\\n # token_ids without prefix/special tokens\\n # `wifi` will be treated as `_wifi` and change the tokenize result, so add dummy on top of the sentence to fix\\n token_ids_all = [[self.tokenizer.convert_tokens_to_ids(_t.replace(self.prefix, '').replace(dummy, ''))\\n for _t in self.tokenizer.tokenize(dummy+t)\\n if len(_t.replace(self.prefix, '').replace(dummy, '')) > 0]\\n for t in tokens]\\n\\n for n in range(len(tokens)):\\n if n == 0:\\n encode = {k: v[n][:-len(self.sp_token_end[k])] for k, v in encode_all.items()}\\n if labels:\\n encode['labels'] = [self.pad_ids['labels']] * len(self.sp_token_start['labels']) + [labels[n]]\\n encode['labels'] += [self.pad_ids['labels']] * (len(encode['input_ids']) - len(encode['labels']))\\n else:\\n encode['input_ids'] += token_ids_all[n]\\n # other attribution without prefix/special tokens\\n tmp_encode = {k: v[n] for k, v in encode_all.items()}\\n input_ids_with_prefix = \\\\\\n tmp_encode.pop('input_ids')[len(self.sp_token_start['input_ids']):-len(self.sp_token_end['input_ids'])]\\n prefix_length = len(input_ids_with_prefix) - len(token_ids_all[n])\\n for k, v in tmp_encode.items():\\n encode[k] += v[len(self.sp_token_start['input_ids']) + prefix_length:-len(self.sp_token_end['input_ids'])]\\n if labels:\\n encode['labels'] += [labels[n]] + [self.pad_ids['labels']] * (len((token_ids_all[n])) - 1)\\n\\n # add special token at the end and padding/truncate accordingly\\n for k in encode.keys():\\n encode[k] = encode[k][:min(len(encode[k]), self.max_seq_length - len(self.sp_token_end[k]))]\\n encode[k] += self.sp_token_end[k]\\n pad_id = self.pad_ids[k] if k in self.pad_ids.keys() else self.pad_ids['__default__']\\n encode[k] += [pad_id] * (self.max_seq_length - len(encode[k]))\\n return encode\",\n \"def encode(self,\\n encoder_input_tokens,\\n encoder_segment_ids=None,\\n enable_dropout=True):\\n cfg = self.config\\n assert encoder_input_tokens.ndim == 2 # (batch, len)\\n\\n # Make padding attention mask.\\n encoder_mask = layers.make_attention_mask(\\n encoder_input_tokens > 0, encoder_input_tokens > 0, dtype=cfg.dtype)\\n # Add segmentation block-diagonal attention mask if using segmented data.\\n if encoder_segment_ids is not None:\\n encoder_mask = layers.combine_masks(\\n encoder_mask,\\n layers.make_attention_mask(\\n encoder_segment_ids,\\n encoder_segment_ids,\\n jnp.equal,\\n dtype=cfg.dtype))\\n\\n return self.encoder(\\n encoder_input_tokens, encoder_mask, deterministic=not enable_dropout)\",\n \"def encode(self, text, batch_max_length=25):\\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\\n batch_max_length += 1\\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\\n batch_text = torch.LongTensor(len(text), batch_max_length + 1).fill_(0)\\n for i, t in enumerate(text):\\n text = list(t)\\n text.append('[s]')\\n text = [self.dict[char] for char in text]\\n batch_text[i][1:1 + len(text)] = torch.LongTensor(text) # batch_text[:, 0] = [GO] token\\n return (batch_text.to(device), torch.IntTensor(length).to(device))\",\n \"def encode(self, text, batch_max_length=25):\\n length = [len(s) + 1 for s in text] # +1 for [s] at end of sentence.\\n # batch_max_length = max(length) # this is not allowed for multi-gpu setting\\n batch_max_length += 1\\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\\n batch_text = torch.LongTensor(len(text), batch_max_length + 1).fill_(0)\\n for i, t in enumerate(text):\\n text = list(t)\\n text.append('[s]')\\n text = [self.dict[char] for char in text]\\n batch_text[i][1:1 + len(text)] = torch.LongTensor(text) # batch_text[:, 0] = [GO] token\\n return (batch_text.to(device), torch.IntTensor(length).to(device))\",\n \"def __encode_token(self, text: list) -> dict:\\n encoded_input = self.tokenizer(\\n [str(string) for string in text],\\n truncation=True,\\n padding=True,\\n return_tensors=\\\"pt\\\",\\n )\\n\\n return encoded_input\",\n \"def encode(self, text):\\n length = [len(s) for s in text]\\n batch_max_length = self.opt.model_params.max_len\\n # The index used for padding (=0) would not affect the CTC loss calculation.\\n batch_text = np.zeros((len(text), batch_max_length), dtype=int)\\n for i, t in enumerate(text):\\n cur_text = list(t)\\n cur_text = [self.dict[char] for char in cur_text]\\n batch_text[i][:len(cur_text)] = cur_text\\n\\n return tf.convert_to_tensor(batch_text, dtype=tf.int32), tf.convert_to_tensor(length, dtype=tf.int32)\",\n \"def compute_encoding(self):\\n for input_quantizer in self._input_quantizers.values():\\n input_quantizer.compute_encoding()\\n\\n for quantizer in self.param_quantizers.values():\\n # NOTE: If quantizer.enabled is True but quantizer.encoding is None,\\n # quantizer.compute_encoding() will set quantizer.enabled to False.\\n # Otherwise, quantizer.compute_encodings() is equivalent to no-op.\\n quantizer.compute_encoding()\\n\\n for output_quantizer in self._output_quantizers.values():\\n output_quantizer.compute_encoding()\",\n \"def __call__(self, batch: List[List[str]], tags_batch: Optional[List[List[str]]] = None, mean: bool = None,\\n *args, **kwargs) -> List[Union[list, np.ndarray]]:\\n\\n if self.tags_vocab:\\n if tags_batch is None:\\n raise ConfigError(\\\"TfidfWeightedEmbedder got 'tags_vocab_path' but __call__ did not get tags_batch.\\\")\\n batch = [self._tags_encode(sample, tags_sample, mean=mean) for sample, tags_sample in\\n zip(batch, tags_batch)]\\n else:\\n if tags_batch:\\n raise ConfigError(\\\"TfidfWeightedEmbedder got tags batch, but 'tags_vocab_path' is empty.\\\")\\n batch = [self._encode(sample, mean=mean) for sample in batch]\\n\\n if self.pad_zero:\\n batch = zero_pad(batch)\\n\\n return batch\",\n \"def translate_batch(self, x, trans_args, char_list=None, rnnlm=None):\\n raise NotImplementedError(\\\"Batch decoding is not supported yet.\\\")\",\n \"def encode(self, text):\\n length = [self.mylen(s) + 1 for s in text] # +1 for [s] at end of sentence.\\n batch_max_length=self.batch_max_length\\n #print('---------------------',batch_max_length)\\n batch_max_length += 1\\n # additional +1 for [GO] at first step. batch_text is padded with [GO] token after [s] token.\\n batch_text = torch.cuda.LongTensor(len(text), batch_max_length + 1).fill_(0)\\n for i, t in enumerate(text):\\n #print(\\\"LOAD TEXT\\\", t)\\n text_one = list(t)\\n text_one.append('[s]')\\n #text_one = [self.dict[char] for char in text_one]\\n text_one = self.myIndex(text_one)\\n batch_text[i][1:1 + len(text_one)] = torch.cuda.LongTensor(text_one) \\n return (batch_text, torch.cuda.IntTensor(length))\",\n \"def tokenize_pretraining(self, inputs):\\n\\n ref_ids = prepare_ref([inputs], self.tokenizer_ltp, self.tokenizer_cn)\\n\\n tokens = self.tokenizer_cn.tokenize(inputs)\\n\\n if len(tokens) > self.max_seq_length - 2:\\n tokens = tokens[:(self.max_seq_length - 2)]\\n ref_ids = ref_ids[:(self.max_seq_length - 2)]\\n\\n ref_ids = cn_whole_word_mask(tokens, ref_ids[0])\\n tokens, labels = random_word_wwm(tokens, ref_ids, self.tokenizer_cn)\\n\\n tokens = ['[CLS]'] + tokens + ['[SEP]']\\n lm_label_ids = ([-100] + labels + [-100])\\n\\n input_ids = self.tokenizer_cn.convert_tokens_to_ids(tokens)\\n\\n attention_mask = [1] * len(input_ids)\\n token_type_ids = [0] * len(input_ids)\\n\\n while len(input_ids) < self.max_seq_length:\\n input_ids.append(0)\\n attention_mask.append(0)\\n token_type_ids.append(0)\\n lm_label_ids.append(-100)\\n\\n assert len(input_ids) == self.max_seq_length\\n assert len(attention_mask) == self.max_seq_length\\n assert len(token_type_ids) == self.max_seq_length\\n assert len(lm_label_ids) == self.max_seq_length\\n\\n\\n outputs = {'input_ids': tf.constant(input_ids), 'attention_mask': tf.constant(attention_mask), \\n 'token_type_ids': tf.constant(token_type_ids), 'lm_label_ids': tf.constant(lm_label_ids)}\\n\\n return outputs\",\n \"def preprocessing_for_bert(self, data):\\n # Create empty lists to store outputs\\n input_ids = []\\n attention_masks = []\\n MAX_LEN = self.opt.MAX_QUESTION_LEN\\n # For every sentence...\\n for sent in data:\\n \\n encoded_sent = self.tokenizer.encode_plus(\\n text=self.text_preprocessing(sent), # Preprocess sentence\\n add_special_tokens=True, # Add `[CLS]` and `[SEP]`\\n max_length=MAX_LEN, # Max length to truncate/pad\\n pad_to_max_length=True, # Pad sentence to max length\\n #return_tensors='pt', # Return PyTorch tensor\\n truncation=True,\\n return_attention_mask=True # Return attention mask\\n )\\n \\n # Add the outputs to the lists\\n input_ids.append(encoded_sent.get('input_ids'))\\n attention_masks.append(encoded_sent.get('attention_mask'))\\n\\n # Convert lists to tensors\\n input_ids = torch.tensor(input_ids)\\n attention_masks = torch.tensor(attention_masks)\\n\\n return input_ids, attention_masks\",\n \"def batch_decode(self, *args, **kwargs):\\n return self.tokenizer.batch_decode(*args, **kwargs)\",\n \"def batch_decode(self, *args, **kwargs):\\n return self.tokenizer.batch_decode(*args, **kwargs)\",\n \"def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\\n return self.bert_model.batch_tokenize([t.strip() for t in text])\",\n \"def fit_transform(self):\\n if self.enc_types == \\\"label\\\":\\n return self._label_encoding()\\n elif self.enc_types == \\\"ohe\\\":\\n return self._one_hot_encoder()\\n elif self.enc_types == \\\"binary\\\":\\n return self._binarization()\\n else:\\n raise Exception(\\\"Encoding type not understood\\\")\",\n \"def _encode(self):\\n with tf.variable_scope('encoding'):\\n self.sep_p_encodes, _ = bilstm_layer(self.p_emb, self.p_length, self.hidden_size)\\n tf.get_variable_scope().reuse_variables()\\n self.sep_q_encodes, _ = bilstm_layer(self.q_emb, self.q_length, self.hidden_size)\\n if self.use_dropout:\\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, 1-self.dropout)\\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, 1-self.dropout)\",\n \"def call(self, inputs, *args, **kwargs):\\n outputs = self.encoder(inputs, *args, **kwargs)\\n return outputs\",\n \"def collate_batch(self) -> Dict[str, Any]:\\n pass\",\n \"def encode(\\n self,\\n docs: Optional[DocumentArray] = None,\\n parameters: dict = {},\\n *args,\\n **kwargs\\n ) -> None:\\n if not docs:\\n return\\n\\n batch_generator = docs.batch(\\n traversal_paths=parameters.get('traversal_paths', self.traversal_paths),\\n batch_size=parameters.get('batch_size', self.batch_size),\\n require_attr='text',\\n )\\n\\n with torch.inference_mode():\\n for batch in batch_generator:\\n embeddings = self.model.encode_text(text=[[doc.text] for doc in batch])\\n embeddings = embeddings.cpu().numpy()\\n\\n for idx, doc in enumerate(batch):\\n doc.embedding = embeddings[idx]\",\n \"def _batch_prepare_for_model(\\n self,\\n batch_text_or_text_pairs,\\n is_pair: bool = None,\\n boxes: Optional[List[List[int]]] = None,\\n word_labels: Optional[List[List[int]]] = None,\\n add_special_tokens: bool = True,\\n padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,\\n truncation_strategy: TruncationStrategy = TruncationStrategy.DO_NOT_TRUNCATE,\\n max_length: Optional[int] = None,\\n stride: int = 0,\\n pad_to_multiple_of: Optional[int] = None,\\n return_tensors: Optional[str] = None,\\n return_token_type_ids: Optional[bool] = None,\\n return_attention_mask: Optional[bool] = None,\\n return_overflowing_tokens: bool = False,\\n return_special_tokens_mask: bool = False,\\n return_length: bool = False,\\n verbose: bool = True,\\n ) -> BatchEncoding:\\n\\n batch_outputs = {}\\n for idx, example in enumerate(zip(batch_text_or_text_pairs, boxes)):\\n batch_text_or_text_pair, boxes_example = example\\n outputs = self.prepare_for_model(\\n batch_text_or_text_pair[0] if is_pair else batch_text_or_text_pair,\\n batch_text_or_text_pair[1] if is_pair else None,\\n boxes_example,\\n word_labels=word_labels[idx] if word_labels is not None else None,\\n add_special_tokens=add_special_tokens,\\n padding=PaddingStrategy.DO_NOT_PAD.value, # we pad in batch afterward\\n truncation=truncation_strategy.value,\\n max_length=max_length,\\n stride=stride,\\n pad_to_multiple_of=None, # we pad in batch afterward\\n return_attention_mask=False, # we pad in batch afterward\\n return_token_type_ids=return_token_type_ids,\\n return_overflowing_tokens=return_overflowing_tokens,\\n return_special_tokens_mask=return_special_tokens_mask,\\n return_length=return_length,\\n return_tensors=None, # We convert the whole batch to tensors at the end\\n prepend_batch_axis=False,\\n verbose=verbose,\\n )\\n\\n for key, value in outputs.items():\\n if key not in batch_outputs:\\n batch_outputs[key] = []\\n batch_outputs[key].append(value)\\n\\n batch_outputs = self.pad(\\n batch_outputs,\\n padding=padding_strategy.value,\\n max_length=max_length,\\n pad_to_multiple_of=pad_to_multiple_of,\\n return_attention_mask=return_attention_mask,\\n )\\n\\n batch_outputs = BatchEncoding(batch_outputs, tensor_type=return_tensors)\\n\\n return batch_outputs\",\n \"def collate_fn(batch):\\n all_input_ids, all_attention_mask, all_token_type_ids, all_lens, all_labels = map(torch.stack, zip(*batch))\\n max_len = max(all_lens).item()\\n all_input_ids = all_input_ids[:, :max_len]\\n all_attention_mask = all_attention_mask[:, :max_len]\\n all_token_type_ids = all_token_type_ids[:, :max_len]\\n return all_input_ids, all_attention_mask, all_token_type_ids, all_labels\",\n \"def bert_text_encoding(self, text, take_bert_pooler=True):\\n # Encode text\\n print('starting BERT encoding', datetime.datetime.now())\\n tokenized = self.tokenizer.tokenize(text)\\n tokenized.insert(0, 'CLS')\\n input_ids = self.tokenizer.convert_tokens_to_ids(tokenized)\\n with torch.no_grad():\\n if take_bert_pooler:\\n pooler = self.model(torch.tensor([input_ids]))[0][0][0]\\n print('finished BERT encoding, returning BERT pooler', datetime.datetime.now())\\n return pooler\\n else:\\n # TODO: validate tokens [1:]\\n tokens_embedding = self.model(torch.tensor([input_ids]))[0][0][1:]\\n print('finished BERT encoding, returning BERT sentence', datetime.datetime.now())\\n return tokens_embedding\",\n \"def encode(self):\\n with tf.name_scope(\\\"encode\\\"):\\n self.encoder_inputs = tf.layers.dense(\\n inputs=self.encoder_inputs,\\n units=self.options['hidden_size'], activation=None, use_bias=True,\\n kernel_initializer=tf.keras.initializers.he_normal(seed=None),\\n bias_initializer=tf.zeros_initializer(),\\n kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\\n kernel_constraint=None, bias_constraint=None, trainable=True,\\n name=None, reuse=None)\\n self.encoder_inputs = tf.layers.batch_normalization(self.encoder_inputs,\\n axis=-1,\\n momentum=0.99,\\n epsilon=0.001,\\n center=True,\\n scale=True,\\n beta_initializer=tf.zeros_initializer(),\\n gamma_initializer=tf.ones_initializer(),\\n moving_mean_initializer=tf.zeros_initializer(),\\n moving_variance_initializer=tf.ones_initializer(),\\n training=self.is_training,\\n trainable=True,\\n renorm=False,\\n renorm_momentum=0.99)\\n # Prepare inputs to the layer stack by adding positional encodings and\\n # applying dropout.\\n # embedded_inputs = self.embedding_softmax_layer(inputs)\\n #\\n inputs_padding = transformer_model_utils.get_padding(tf.cast(\\n tf.reduce_max(100*self.encoder_inputs, [-1]),\\n dtype=tf.int32))\\n\\n with tf.name_scope(\\\"add_pos_encoding\\\"):\\n length = tf.shape(self.encoder_inputs)[1]\\n pos_encoding = transformer_model_utils.get_position_encoding(\\n length, self.options[\\\"hidden_size\\\"])\\n encoder_inputs = self.encoder_inputs + pos_encoding\\n\\n if self.is_training:\\n encoder_inputs = tf.nn.dropout(\\n encoder_inputs, 1 - self.options[\\\"layer_postprocess_dropout\\\"])\\n\\n return self.encoder_stack(encoder_inputs, self.attention_bias, inputs_padding)\",\n \"def encode(self, pt, en):\\n pt = [self.tokenizer_pt.vocab_size] +\\\\\\n self.tokenizer_pt.encode(pt.numpy()) +\\\\\\n [self.tokenizer_pt.vocab_size+1]\\n en = [self.tokenizer_en.vocab_size] +\\\\\\n self.tokenizer_en.encode(en.numpy()) +\\\\\\n [self.tokenizer_en.vocab_size+1]\\n return (pt, en)\",\n \"def encode(self, docs: Optional[DocumentArray], parameters: Dict, **kwargs):\\n if docs:\\n docs_batch_generator = get_docs_batch_generator(\\n docs,\\n traversal_path=parameters.get(\\n 'traversal_paths', self.default_traversal_path\\n ),\\n batch_size=parameters.get('batch_size', self.default_batch_size),\\n needs_attr='blob',\\n )\\n self._compute_embeddings(docs_batch_generator)\",\n \"def preprocess(batch):\\n batch_size = batch[\\\"idx\\\"].shape[0]\\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n\\n for i in range(batch_size):\\n sentence_a = batch[key_a][i]\\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\\n input_ids[i, :len(tokens_a)] = tokens_a[:max_len]\\n\\n return {\\n \\\"input_ids\\\": input_ids,\\n \\\"type_ids\\\": type_ids,\\n \\\"idx\\\": batch[\\\"idx\\\"].astype(np.int32),\\n \\\"label\\\": batch[\\\"label\\\"],\\n }\",\n \"def encode(self, text, batch_max_length=25):\\n length = [len(s) for s in text]\\n\\n # The index used for padding (=0) would not affect the CTC loss calculation.\\n batch_text = torch.LongTensor(len(text), batch_max_length).fill_(0)\\n for i, t in enumerate(text):\\n text = list(t)\\n text = [self.dict[char] for char in text]\\n batch_text[i][:len(text)] = torch.LongTensor(text)\\n return (batch_text.to(device), torch.IntTensor(length).to(device))\",\n \"def _encode(self):\\n with tf.variable_scope('passage_encoding'):\\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\\n with tf.variable_scope('question_encoding'):\\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\\n if self.use_dropout:\\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)\",\n \"def encode(self, xs, task='all', streaming=False, cnn_lookback=False, cnn_lookahead=False, xlen_block=-1):\\n if self.input_type == 'speech':\\n if self.n_stacks > 1:\\n xs = [stack_frame(x, self.n_stacks, self.n_skips) for x in xs]\\n if self.n_splices > 1:\\n xs = [splice(x, self.n_splices, self.n_stacks) for x in xs]\\n if streaming:\\n xlens = torch.IntTensor([xlen_block])\\n else:\\n xlens = torch.IntTensor([len(x) for x in xs])\\n xs = pad_list([np2tensor(x, self.device).float() for x in xs], 0.0)\\n if self.specaug is not None and self.training:\\n xs = self.specaug(xs)\\n if self.weight_noise_std > 0 and self.training:\\n self.add_weight_noise(std=self.weight_noise_std)\\n if self.input_noise_std > 0 and self.training:\\n xs = add_input_noise(xs, std=self.input_noise_std)\\n if self.ssn is not None:\\n xs = self.ssn(xs, xlens)\\n elif self.input_type == 'text':\\n xlens = torch.IntTensor([len(x) for x in xs])\\n xs = [np2tensor(np.fromiter(x, dtype=np.int64), self.device) for x in xs]\\n xs = pad_list(xs, self.pad)\\n xs = self.dropout_emb(self.embed(xs))\\n eout_dict = self.enc(xs, xlens, task.split('.')[0], streaming, cnn_lookback, cnn_lookahead)\\n if self.main_weight < 1 and self.enc_type in ['conv', 'tds', 'gated_conv']:\\n for sub in ['sub1', 'sub2']:\\n eout_dict['ys_' + sub]['xs'] = eout_dict['ys']['xs'].clone()\\n eout_dict['ys_' + sub]['xlens'] = eout_dict['ys']['xlens'][:]\\n return eout_dict\",\n \"def encode(self, inputs, masks):\\n with tf.variable_scope(\\\"encoder\\\") as scope_encoder:\\n #compute sequence length\\n sequence_lengths = tf.reduce_sum(masks, axis = 1) \\n #create a forward cell\\n fw_cell = tf.contrib.rnn.LSTMCell(self.size)\\n\\n #pass the cells to bilstm and create the bilstm\\n bw_cell = tf.contrib.rnn.LSTMCell(self.size)\\n output, final_state = tf.nn.bidirectional_dynamic_rnn(fw_cell, \\\\\\n bw_cell, inputs, \\\\\\n sequence_length = sequence_lengths, \\\\\\n dtype = tf.float32, \\\\\\n parallel_iterations = 256)\\n output_lstm = tf.concat([output[0], output[1]], axis = -1)\\n final_state_lstm = tf.concat([final_state[0], final_state[1]], axis = -1)\\n return output_lstm, final_state_lstm\",\n \"def encode(\\n self,\\n sentences: Union[str, List[str]],\\n batch_size: int = 32,\\n show_progress_bar: bool = False,\\n convert_to_numpy: bool = True,\\n normalize_embeddings: bool = False\\n ):\\n self.model.eval()\\n input_was_string = False\\n if isinstance(sentences, str) or not hasattr(sentences, '__len__'):\\n sentences = [sentences]\\n input_was_string = True\\n self.model.to(device)\\n\\n all_embeddings = []\\n length_sorted_idx = np.argsort([-self._text_length(sent) for sent in sentences])\\n sentences_sorted = [sentences[idx] for idx in length_sorted_idx]\\n\\n for start_index in trange(0, len(sentences), batch_size, desc=\\\"Batches\\\", disable=not show_progress_bar):\\n sentences_batch = sentences_sorted[start_index:start_index + batch_size]\\n features = self.tokenize(sentences_batch)\\n features = self.batch_to_device(features)\\n\\n with torch.no_grad():\\n out_features = self.forward(features)\\n embeddings = out_features['embedding']\\n embeddings = embeddings.detach()\\n if normalize_embeddings:\\n embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)\\n # fixes for #522 and #487 to avoid oom problems on gpu with large datasets\\n if convert_to_numpy:\\n embeddings = embeddings.cpu()\\n all_embeddings.extend(embeddings)\\n\\n all_embeddings = [all_embeddings[idx] for idx in np.argsort(length_sorted_idx)]\\n if convert_to_numpy:\\n all_embeddings = np.asarray([emb.numpy() for emb in all_embeddings])\\n else:\\n all_embeddings = torch.stack(all_embeddings)\\n if input_was_string:\\n all_embeddings = all_embeddings[0]\\n\\n return all_embeddings\",\n \"def _encode(self, text: str) -> List[str]:\\n token_ids: List[int] = self.bert_model.encode(text.strip())\\n tokens_ids_str: List[str] = [str(token_id) for token_id in token_ids]\\n return tokens_ids_str\",\n \"def iter_encode(self, obj: Any, validation: str = 'lax', **kwargs: Any) \\\\\\n -> IterEncodeType[Any]:\\n raise NotImplementedError()\",\n \"def encode(self, docs: Optional[DocumentArray], parameters: dict, **kwargs):\\n if docs:\\n document_batches_generator = get_docs_batch_generator(\\n docs,\\n traversal_path=parameters.get('traversal_paths', self.default_traversal_paths),\\n batch_size=parameters.get('batch_size', self.default_batch_size),\\n needs_attr='text',\\n )\\n self._create_embeddings(document_batches_generator)\",\n \"def preprocess(batch):\\n batch_size = batch[\\\"idx\\\"].shape[0]\\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n\\n for i in range(batch_size):\\n sentence_a = batch[key_a][i]\\n sentence_b = batch[key_b][i]\\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\\n tokens_b = tokenizer.EncodeAsIds(sentence_b)[1:] # Strip start token\\n\\n ex_input_ids = (tokens_a + tokens_b)[:max_len]\\n ex_type_ids = ([0] * len(tokens_a) + [1] * len(tokens_b))[:max_len]\\n\\n input_ids[i, :len(ex_input_ids)] = ex_input_ids\\n type_ids[i, :len(ex_type_ids)] = ex_type_ids\\n\\n return {\\n \\\"input_ids\\\": input_ids,\\n \\\"type_ids\\\": type_ids,\\n \\\"idx\\\": batch[\\\"idx\\\"].astype(np.int32),\\n \\\"label\\\": batch[\\\"label\\\"],\\n }\",\n \"def vectorize_texts(self, encoder) -> NoReturn:\\n self.encoder = encoder\\n self.vectorized_texts = [self.encoder.encode(t) for t in self.tokenized_texts]\",\n \"def encode(self, pt, en):\\n tok_pt = [self.tokenizer_pt.vocab_size]+self.tokenizer_pt.encode(\\n pt.numpy())+[(self.tokenizer_pt.vocab_size) + 1]\\n tok_en = [self.tokenizer_en.vocab_size]+self.tokenizer_en.encode(\\n en.numpy())+[(self.tokenizer_en.vocab_size) + 1]\\n return tok_pt, tok_en\",\n \"def __call__(\\n self,\\n images: Optional[ImageInput] = None,\\n text: Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None,\\n add_special_tokens: bool = True,\\n padding: Union[bool, str, PaddingStrategy] = False,\\n truncation: Union[bool, str, TruncationStrategy] = False,\\n max_length: Optional[int] = None,\\n stride: int = 0,\\n pad_to_multiple_of: Optional[int] = None,\\n return_image_mask: Optional[bool] = None,\\n return_codebook_pixels: Optional[bool] = None,\\n return_token_type_ids: Optional[bool] = None,\\n return_attention_mask: Optional[bool] = None,\\n return_overflowing_tokens: bool = False,\\n return_special_tokens_mask: bool = False,\\n return_offsets_mapping: bool = False,\\n return_length: bool = False,\\n verbose: bool = True,\\n return_tensors: Optional[Union[str, TensorType]] = None,\\n **kwargs,\\n ):\\n\\n if text is None and images is None:\\n raise ValueError(\\\"You have to specify either text or images. Both cannot be none.\\\")\\n\\n if text is not None:\\n encoding = self.tokenizer(\\n text=text,\\n add_special_tokens=add_special_tokens,\\n padding=padding,\\n truncation=truncation,\\n max_length=max_length,\\n stride=stride,\\n pad_to_multiple_of=pad_to_multiple_of,\\n return_token_type_ids=return_token_type_ids,\\n return_attention_mask=return_attention_mask,\\n return_overflowing_tokens=return_overflowing_tokens,\\n return_special_tokens_mask=return_special_tokens_mask,\\n return_offsets_mapping=return_offsets_mapping,\\n return_length=return_length,\\n verbose=verbose,\\n return_tensors=return_tensors,\\n **kwargs,\\n )\\n if images is not None:\\n image_features = self.image_processor(\\n images,\\n return_image_mask=return_image_mask,\\n return_codebook_pixels=return_codebook_pixels,\\n return_tensors=return_tensors,\\n **kwargs,\\n )\\n\\n if text is not None and images is not None:\\n encoding.update(image_features)\\n return encoding\\n elif text is not None:\\n return encoding\\n else:\\n return BatchEncoding(data=dict(**image_features), tensor_type=return_tensors)\",\n \"def _encode(self, sentence: str, **kwargs) -> Sequence[int]:\\r\\n return NotImplemented\",\n \"def fixed_encode_en(self, tokens, labels: list = None):\\n encode = self.tokenizer.encode_plus(\\n ' '.join(tokens), max_length=self.max_seq_length, pad_to_max_length=self.pad_to_max_length, truncation=self.pad_to_max_length)\\n if labels:\\n assert len(tokens) == len(labels)\\n fixed_labels = list(chain(*[\\n [label] + [self.pad_ids['labels']] * (len(self.tokenizer.tokenize(word)) - 1)\\n for label, word in zip(labels, tokens)]))\\n fixed_labels = [self.pad_ids['labels']] * len(self.sp_token_start['labels']) + fixed_labels\\n fixed_labels = fixed_labels[:min(len(fixed_labels), self.max_seq_length - len(self.sp_token_end['labels']))]\\n fixed_labels = fixed_labels + [self.pad_ids['labels']] * (self.max_seq_length - len(fixed_labels))\\n encode['labels'] = fixed_labels\\n return encode\",\n \"def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):\\n chunked_data = self._get_chunk_data(\\n map(self.pipeline, inputs), batch_size)\\n yield from map(self.collate_fn, chunked_data)\",\n \"def encode_input(sent, lemmas, pos_tags, predicates, vocab_preds, vocab_lemmas, vocab_pos_tags, bert_embedder, task_234):\\n sentence = bert_embedder.embed_sentence([sent])[0]\\n lens = torch.LongTensor([len(sent)])\\n pos_tags = torch.tensor([vocab_pos_tags[pos_tag] for pos_tag in pos_tags])\\n lemmas = torch.tensor([vocab_lemmas[lemma] if lemma in vocab_lemmas else vocab_lemmas['<unk>'] for lemma in lemmas])\\n vocab_preds = {word: int(idx) for idx, word in vocab_preds.items()}\\n predicate_null_token = vocab_preds['_']\\n if task_234:\\n # if the task is predicate disambiguation, predicates indicates only the position of the predicates in the sentence\\n predicates = torch.LongTensor(predicates)\\n positions = (predicates == 1).nonzero()\\n else:\\n # otherwise predicates must be encoded with the value stored in the vocabulary\\n predicates = torch.tensor([vocab_preds[predicate] for predicate in predicates])\\n positions = (predicates != predicate_null_token).nonzero()\\n\\n return sentence[None,...], lens, pos_tags[None,...], lemmas[None,...], predicates[None,...], positions.view(-1).tolist(), predicate_null_token\",\n \"def __call__(self,\\n encoder_input_tokens,\\n decoder_input_tokens,\\n decoder_target_tokens,\\n encoder_segment_ids=None,\\n decoder_segment_ids=None,\\n encoder_positions=None,\\n decoder_positions=None,\\n *,\\n enable_dropout: bool = True,\\n decode: bool = False):\\n encoded = self.encode(\\n encoder_input_tokens,\\n encoder_segment_ids=encoder_segment_ids,\\n enable_dropout=enable_dropout)\\n\\n return self.decode(\\n encoded,\\n encoder_input_tokens, # only used for masks\\n decoder_input_tokens,\\n decoder_target_tokens,\\n encoder_segment_ids=encoder_segment_ids,\\n decoder_segment_ids=decoder_segment_ids,\\n decoder_positions=decoder_positions,\\n enable_dropout=enable_dropout,\\n decode=decode)\",\n \"def glue_inputs(dataset_name, split, batch_size, tokenizer, data_dir=None,\\n max_len=128, training=True):\\n keys_lookup = {\\n \\\"glue/cola\\\": (\\\"sentence\\\", None),\\n \\\"glue/sst2\\\": (\\\"sentence\\\", None),\\n \\\"glue/mrpc\\\": (\\\"sentence1\\\", \\\"sentence2\\\"),\\n \\\"glue/qqp\\\": (\\\"question1\\\", \\\"question2\\\"),\\n \\\"glue/stsb\\\": (\\\"sentence1\\\", \\\"sentence2\\\"),\\n \\\"glue/mnli\\\": (\\\"premise\\\", \\\"hypothesis\\\"), # TODO(kitaev): swap the two?\\n \\\"glue/qnli\\\": (\\\"question\\\", \\\"sentence\\\"), # TODO(kitaev) swap the two?\\n \\\"glue/rte\\\": (\\\"sentence1\\\", \\\"sentence2\\\"),\\n \\\"glue/wnli\\\": (\\\"sentence1\\\", \\\"sentence2\\\"),\\n }\\n\\n key_a, key_b = keys_lookup[dataset_name]\\n\\n if key_b is None:\\n def preprocess(batch):\\n \\\"\\\"\\\"Tokenize and convert text to model inputs.\\\"\\\"\\\"\\n batch_size = batch[\\\"idx\\\"].shape[0]\\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n\\n for i in range(batch_size):\\n sentence_a = batch[key_a][i]\\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\\n input_ids[i, :len(tokens_a)] = tokens_a[:max_len]\\n\\n return {\\n \\\"input_ids\\\": input_ids,\\n \\\"type_ids\\\": type_ids,\\n \\\"idx\\\": batch[\\\"idx\\\"].astype(np.int32),\\n \\\"label\\\": batch[\\\"label\\\"],\\n }\\n else:\\n def preprocess(batch):\\n \\\"\\\"\\\"Tokenize and convert text to model inputs.\\\"\\\"\\\"\\n batch_size = batch[\\\"idx\\\"].shape[0]\\n input_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n type_ids = np.zeros((batch_size, max_len), dtype=np.int32)\\n\\n for i in range(batch_size):\\n sentence_a = batch[key_a][i]\\n sentence_b = batch[key_b][i]\\n tokens_a = tokenizer.EncodeAsIds(sentence_a)\\n tokens_b = tokenizer.EncodeAsIds(sentence_b)[1:] # Strip start token\\n\\n ex_input_ids = (tokens_a + tokens_b)[:max_len]\\n ex_type_ids = ([0] * len(tokens_a) + [1] * len(tokens_b))[:max_len]\\n\\n input_ids[i, :len(ex_input_ids)] = ex_input_ids\\n type_ids[i, :len(ex_type_ids)] = ex_type_ids\\n\\n return {\\n \\\"input_ids\\\": input_ids,\\n \\\"type_ids\\\": type_ids,\\n \\\"idx\\\": batch[\\\"idx\\\"].astype(np.int32),\\n \\\"label\\\": batch[\\\"label\\\"],\\n }\\n\\n return tfds_stream(\\n dataset_name=dataset_name,\\n split=split,\\n batch_size=batch_size,\\n data_dir=data_dir,\\n shuffle_files=training,\\n shuffle_buffer_size=1024 if training else None,\\n batch_shuffle_size=128 if training else None,\\n preprocess_fun=preprocess,\\n repeat=training,\\n )\",\n \"def batchify(self, i, iterator):\\n print(f'Starting Batch {i}')\\n iterator = [item.strip() for item in iterator]\\n max_length = self.max_seq_length - 2 # for special tokens\\n\\n batches = []\\n n = len(iterator)\\n sentence_count = 0\\n index_start = 0\\n index_stop = 0\\n\\n while index_stop < n:\\n if (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length):\\n index_start += 1\\n index_stop += 1\\n while (len(self.tokenizer.encode(' '.join(iterator[index_start:index_stop+1])).tokens) < max_length) and (index_stop<n):\\n index_stop += 1\\n batches.append(iterator[index_start:index_stop])\\n index_start = index_stop\\n print(f'Batch {i} Done')\\n return batches\",\n \"def encode(self, seq):\",\n \"def encode(self, input_):\\n return self.encoder(input_)\",\n \"def encode(lang1, lang2):\\n lang1 = [tokenizer_pt.vocab_size] + tokenizer_pt.encode(\\n lang1.numpy()) + [tokenizer_pt.vocab_size + 1]\\n\\n lang2 = [tokenizer_en.vocab_size] + tokenizer_en.encode(\\n lang2.numpy()) + [tokenizer_en.vocab_size + 1]\\n\\n return lang1, lang2\",\n \"def encoder(list_of_str, key):\\n tokenized = self.tokenizer.encode_commands(list_of_str)\\n hidden = self.tokenizer.tokenize(tokenized)\\n hidden = hidden.permute(1, 0, 2).reshape(hidden.size(1), -1) # correct for bididrectional\\n return hidden\",\n \"def collate_fn(\\n self,\\n batch: List[\\n Tuple[\\n np.ndarray,\\n np.ndarray,\\n np.ndarray,\\n np.ndarray,\\n int,\\n int,\\n bool,\\n bool,\\n Optional[np.ndarray],\\n Optional[np.ndarray],\\n ]\\n ],\\n ) -> Union[\\n Tuple[Tensor, Tensor, Tensor, Tensor, Any, Any, Any, Any],\\n Tuple[Tensor, Tensor, Tensor, Tensor, Any, Any, Any, Any, Any, Any],\\n ]:\\n if not self.use_audio:\\n inp_ids, segment_ids, inp_mask, st_mask, n_preceding, query_ids, is_first, is_last = zip(*batch)\\n return (\\n pad_sequence([torch.tensor(x) for x in inp_ids], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in segment_ids], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in inp_mask], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in st_mask], batch_first=True, padding_value=0),\\n n_preceding,\\n query_ids,\\n is_first,\\n is_last,\\n )\\n (\\n inp_ids,\\n segment_ids,\\n inp_mask,\\n st_mask,\\n n_preceding,\\n query_ids,\\n is_first,\\n is_last,\\n features,\\n features_length,\\n ) = zip(*batch)\\n return (\\n pad_sequence([torch.tensor(x) for x in inp_ids], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in segment_ids], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in inp_mask], batch_first=True, padding_value=0),\\n pad_sequence([torch.tensor(x) for x in st_mask], batch_first=True, padding_value=0),\\n n_preceding,\\n query_ids,\\n is_first,\\n is_last,\\n pad_sequence([torch.tensor(x) for x in features], batch_first=True, padding_value=0).float(),\\n torch.tensor(features_length, dtype=torch.long),\\n )\",\n \"def handle_encode(self, results):\\n \\n config.COD_PROMPT = config.ENC_PROMPT\\n print config.ENC_PROMPT + \\\" encoding results...\\\"\\n \\n # while there is another decoder, run each item through the next decoder\\n data = results\\n success = False\\n for encoder in self.encoder_list:\\n current_encoder = encoder()\\n full_body = getattr(current_encoder,'full_body_encode',False)\\n success, data = self.recursive_decoder(current_encoder.encode, data, full_body)\\n if not success:\\n break\\n print config.ENC_PROMPT + \\\"%s encoded to '%s'\\\" % ( current_encoder.name(),data)\\n return success, data\",\n \"def set_encodings(questions, candidates,\\n question_encoder, response_encoder):\\n for i, chunk in enumerate(chunks(questions, 100)):\\n question_strs = [q.question for q in chunk]\\n question_encodings = np.array(question_encoder(question_strs))\\n\\n for j in range(question_encodings.shape[0]):\\n questions[i * 100 + j].encoding = question_encodings[j]\\n if i % 50 == 0:\\n print(\\\"Questions: encoded %s of %s...\\\" % (i * 100, len(questions)))\\n\\n for i, chunk in enumerate(chunks(candidates, 50)):\\n candidate_strs = [(c.sentence, c.context) for c in chunk]\\n candidate_encodings = np.array(response_encoder(candidate_strs))\\n for j in range(candidate_encodings.shape[0]):\\n candidates[i * 50 + j].encoding = candidate_encodings[j]\\n if i % 100 == 0:\\n print(\\\"Candidates: encoded %s of %s...\\\" % (i * 50, len(candidates)))\",\n \"def encode_input(self, x_tensor, inp_lens_tensor):\\r\\n input_emb = self.input_emb.forward(x_tensor)\\r\\n enc_output_each_word, enc_context_mask, enc_final_states = self.encoder(input_emb, inp_lens_tensor)\\r\\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\\r\\n # print('lest go', enc_final_states_reshaped[1].shape)\\r\\n return enc_output_each_word, enc_context_mask, enc_final_states_reshaped\",\n \"def encode_inputs(self, sents):\\n word_inputs = []\\n pred_inputs = []\\n pos_inputs = []\\n\\n # Preproc to get all preds per run_id\\n # Sanity check - make sure that all sents agree on run_id\\n assert(all([len(set(sent.run_id.values)) == 1\\n for sent in sents]))\\n run_id_to_pred = dict([(int(sent.run_id.values[0]),\\n self.get_head_pred_word(sent))\\n for sent in sents])\\n\\n # Construct a mapping from running word index to pos\\n word_id_to_pos = {}\\n for sent in sents:\\n indices = sent.index.values\\n words = sent.word.values\\n\\n for index, word in zip(indices,\\n nlpir_ws(\\\"\\\".join(words))):\\n word_id_to_pos[index] = word['tag']\\n\\n fixed_size_sents = self.get_fixed_size(sents)\\n\\n\\n for sent in fixed_size_sents:\\n\\n assert(len(set(sent.run_id.values)) == 1)\\n\\n word_indices = sent.index.values\\n sent_words = sent.word.values\\n\\n sent_str = \\\"\\\".join(sent_words)\\n\\n\\n\\n pos_tags_encodings = [(CN_POS_TAGS.index(word_id_to_pos[word_ind]) \\\\\\n if word_id_to_pos[word_ind] in CN_POS_TAGS \\\\\\n else 0)\\n for word_ind\\n in word_indices]\\n\\n word_encodings = [self.emb.get_word_index(w)\\n for w in sent_words]\\n\\n # Same pred word encodings for all words in the sentence\\n pred_word = run_id_to_pred[int(sent.run_id.values[0])]\\n pred_word_encodings = [self.emb.get_word_index(pred_word)\\n for _ in sent_words]\\n\\n word_inputs.append([Sample(w) for w in word_encodings])\\n pred_inputs.append([Sample(w) for w in pred_word_encodings])\\n pos_inputs.append([Sample(pos) for pos in pos_tags_encodings])\\n\\n # Pad / truncate to desired maximum length\\n ret = defaultdict(lambda: [])\\n\\n for name, sequence in zip([\\\"word_inputs\\\", \\\"predicate_inputs\\\", \\\"postags_inputs\\\"],\\n [word_inputs, pred_inputs, pos_inputs]):\\n for samples in pad_sequences(sequence,\\n pad_func = lambda : Pad_sample(),\\n maxlen = self.sent_maxlen):\\n ret[name].append([sample.encode() for sample in samples])\\n\\n return {k: np.array(v) for k, v in ret.iteritems()}\",\n \"def encoder(enc_input, attn_bias, n_layer, n_head,\\n d_key, d_value, d_model, d_inner_hid, pos_enc,\\n preporstprocess_dropout, attention_dropout,\\n relu_dropout, preprocess_cmd='n',\\n postprocess_cmd='da'):\\n for i in range(n_layer):\\n enc_output = encoder_layer(enc_input, attn_bias, n_head,\\n d_key, d_value, d_model,d_inner_hid, pos_enc,\\n prepostprocess_dropout, attention_dropout,relu_dropout,\\n preprocess_cmd, postprocess_cmd\\n )\\n enc_input = enc_output\\n enc_output = pre_process_layer(enc_output,\\n preprocess_cmd, preporstprocess_dropout)\\n return enc_output\",\n \"def collate_fn_Siamese(batch):\\n all_input_ids, all_attention_mask, all_token_type_ids, all_lens_a, all_lens_b, all_labels = map(torch.stack,\\n zip(*batch))\\n max_len_a = max(all_lens_a).item()\\n max_len_b = max(all_lens_b).item()\\n if max_len_b == 2:\\n all_input_ids = all_input_ids[:, :max_len_a]\\n all_attention_mask = all_attention_mask[:, :max_len_a]\\n all_token_type_ids = all_token_type_ids[:, :max_len_a]\\n else:\\n all_input_ids = all_input_ids[:, :512 + max_len_b]\\n all_attention_mask = all_attention_mask[:, :512 + max_len_b]\\n all_token_type_ids = all_token_type_ids[:, :512 + max_len_b]\\n return all_input_ids, all_attention_mask, all_token_type_ids, all_labels\",\n \"def encode(self, features, training=True):\\n conditioning = self.preprocessor(features, training=training)\\n return conditioning if self.encoder is None else self.encoder(conditioning)\",\n \"def _encode(self, tokens: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:\\n if self.vectorizer:\\n detokenized_sample = self.tokenizer([tokens])[0] # str\\n vectorized_sample = self.vectorizer([detokenized_sample]) # (voc_size,)\\n\\n weights = np.array([vectorized_sample[0, np.where(self.vocabulary == token)[0][0]]\\n if len(np.where(self.vocabulary == token)[0]) else 0.\\n for token in tokens])\\n else:\\n weights = np.array([self.get_weight(max(self.counter_vocab.get(token, 0), self.idf_base_count))\\n for token in tokens])\\n\\n if sum(weights) == 0:\\n weights = np.ones(len(tokens))\\n\\n embedded_tokens = np.array(self.embedder([tokens]))[0, :, :]\\n\\n if mean is None:\\n mean = self.mean\\n\\n if mean:\\n embedded_tokens = np.average(embedded_tokens, weights=weights, axis=0)\\n else:\\n embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])\\n\\n return embedded_tokens\",\n \"def common_process_pipeline(self, batch):\\n vocab_path = os.path.abspath(self.text_vocab_file_path)\\n token_ids = self.text_pipeline_func(batch, self.max_enc_len, vocab_path)\\n return token_ids\",\n \"def encode(self, inputs, target_space, hparams, features=None, losses=None):\\n del losses\\n\\n inputs = common_layers.flatten4d3d(inputs)\\n\\n encoder_input, self_attention_bias, encoder_decoder_attention_bias = (\\n transformer.transformer_prepare_encoder(\\n inputs, target_space, hparams, features=features))\\n\\n encoder_input = tf.nn.dropout(encoder_input,\\n 1.0 - hparams.layer_prepostprocess_dropout)\\n\\n (encoder_output, encoder_extra_output) = (\\n my_universal_transformer_util.universal_transformer_encoder(\\n encoder_input,\\n self_attention_bias,\\n hparams,\\n nonpadding=transformer.features_to_nonpadding(features, \\\"inputs\\\"),\\n save_weights_to=self.attention_weights))\\n\\n return encoder_output, encoder_decoder_attention_bias, encoder_extra_output\",\n \"def encode(self, text: str) -> Union[List[int], List[str]]:\\n encoded_tokens = [\\n self._encoder.get(bpe_token, self._encoder.get(self._unk_token))\\n if self._unk_token\\n else self._encoder[bpe_token]\\n for bpe_token in self._tokenize(text)\\n ]\\n return encoded_tokens\",\n \"def __call__(self, sequences):\\n\\n # Get all texts from sequences list.\\n texts = [sequence['text'] for sequence in sequences]\\n\\n # Get all labels from sequences list.\\n labels = [sequence['label'] for sequence in sequences]\\n # Encode all labels using label encoder.\\n labels = [self.labels_encoder[label] for label in labels]\\n # Call tokenizer on all texts to convert into tensors of numbers with\\n # appropriate padding.\\n inputs = self.use_tokenizer(text=texts, return_tensors=\\\"pt\\\", padding=True, truncation=True,\\n max_length=self.max_sequence_len)\\n # Update the inputs with the associated encoded labels as tensor.\\n inputs.update({'labels': torch.tensor(labels)})\\n\\n return inputs\",\n \"def pack_batch(self, batch, device=None):\\n return pack_batch(self.label_encoder, batch, device or self.device)\",\n \"def fit_tokenizer(self, texts):\\n if not isinstance(texts, str) or not isinstance(texts, list):\\n print(\\\"The sample you have provided is not correctly formatted. \\\" \\\\\\n \\\"Must be a string or an array of strings.\\\")\\n return\\n else:\\n if isinstance(texts, str):\\n texts = [texts]\\n\\n self.tokenizer.fit_on_texts(texts)\",\n \"def encode(input):\\n return ModelEncoder().encode(input)\",\n \"def collate_batch(batch, max_len, pad=0, decode_start_token=0, is_classifier=False):\\n source_ids, target_ids = zip(*batch)\\n source_ids, src_mask = optimize_sequence(source_ids, pad, max_len)\\n if not is_classifier:\\n target_ids, target_mask = optimize_sequence(target_ids, pad, max_len)\\n shifted_target_ids = target_ids.new_zeros(target_ids.shape)\\n shifted_target_ids[..., 1:] = target_ids[..., :-1].clone()\\n shifted_target_ids[..., 0] = decode_start_token\\n return (\\n {\\n \\\"input_ids\\\": source_ids, \\\"attention_mask\\\": src_mask,\\n \\\"decoder_input_ids\\\": shifted_target_ids\\n },\\n {\\\"ids\\\": target_ids, \\\"mask\\\": target_mask}\\n )\\n # is classifier\\n target_ids = torch.stack(target_ids)\\n shifted_target_ids = target_ids.new_zeros(target_ids.shape[0], 1) + decode_start_token\\n return (\\n {\\n \\\"input_ids\\\": source_ids, \\\"attention_mask\\\": src_mask,\\n \\\"decoder_input_ids\\\": shifted_target_ids\\n },\\n {\\\"ids\\\": target_ids}\\n )\",\n \"def encode_decode(self, batch_inputs: Tensor,\\n batch_data_samples: SampleList) -> Tensor:\\n pass\",\n \"def encode(\\n self,\\n docs: Optional[DocumentArray] = None,\\n parameters: dict = {},\\n *args,\\n **kwargs,\\n ) -> None:\\n if not docs:\\n return\\n\\n batch_generator = docs.batch(\\n traversal_paths=parameters.get('traversal_paths', self.traversal_paths),\\n batch_size=parameters.get('batch_size', self.batch_size),\\n require_attr='blob',\\n )\\n\\n with torch.inference_mode():\\n for batch in batch_generator:\\n images = []\\n for doc in batch:\\n if self.use_preprocessing:\\n if doc.blob.shape[2] != 3:\\n raise ValueError(\\n \\\"If `use_preprocessing=True`, your image must\\\"\\n \\\" be of the format [H, W, C], in the RGB format (C=3),\\\"\\n f\\\" but got C={doc.blob.shape[2]} instead.\\\"\\n )\\n images.append(self._default_transforms(doc.blob))\\n else:\\n if doc.blob.shape[0] != 3:\\n raise ValueError(\\n \\\"If `use_preprocessing=False`, your image must\\\"\\n \\\" be of the format [C, H, W], in the RGB format (C=3),\\\"\\n f\\\" but got C={doc.blob.shape[0]} instead.\\\"\\n )\\n\\n images.append(torch.tensor(doc.blob, dtype=torch.float32))\\n\\n images = torch.stack(images)\\n embeddings = self.model.encode_image(image=images.to(self.device))\\n embeddings = embeddings.cpu().numpy()\\n\\n for idx, doc in enumerate(batch):\\n doc.embedding = embeddings[idx]\",\n \"def batch_tokenize_fn(examples):\\n sources = examples[config.source_lang]\\n targets = examples[config.target_lang]\\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\\n\\n # setup the tokenizer for targets,\\n # huggingface expects the target tokenized ids to be stored in the labels field\\n with config.tokenizer.as_target_tokenizer():\\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\\n\\n model_inputs[\\\"labels\\\"] = labels[\\\"input_ids\\\"]\\n return model_inputs\",\n \"def create_bleurt_preprocessing_ops(tokenizer, max_seq_length):\\n\\n def _py_encode(references, candidates):\\n input_ids, input_mask, segment_ids = encoding.encode_batch(\\n references, candidates, tokenizer, max_seq_length)\\n return input_ids, input_mask, segment_ids\\n\\n def bleurt_preprocessing_ops(references, candidates):\\n \\\"\\\"\\\"Builds a computation graph for BLEURT tokenization and encoding.\\\"\\\"\\\"\\n return tf.numpy_function(\\n func=_py_encode,\\n inp=[references, candidates],\\n Tout=(tf.int64, tf.int64, tf.int64))\\n\\n return bleurt_preprocessing_ops\",\n \"def prep_and_tokenize_generator(string_iterable, encoder, normalize_with_ftfy, normalize_with_wikitext_detokenize):\\n for doc in string_iterable:\\n if normalize_with_ftfy: # fix text with ftfy if specified\\n doc = ftfy.fix_text(doc, normalization='NFKC')\\n if normalize_with_wikitext_detokenize:\\n doc = wikitext_detokenizer(doc)\\n tokens = encoder.encode(doc) + [encoder.eos_token_id]\\n yield tokens\",\n \"def encode(self, x, encode_params, name=None):\\n values = [x] + list(encode_params)\\n with tf.compat.v1.name_scope(name, 'gather_encoder_encode', values):\\n x = tf.convert_to_tensor(x)\\n encode_params = tf.nest.map_structure(tf.convert_to_tensor, encode_params)\\n return self._encode_fn(x, encode_params)\",\n \"def forward(self, input: Union[str, List[str]]) -> Union[List, List[List]]:\\n if isinstance(input, List):\\n tokens: List[List[str]] = []\\n for text in input:\\n if self._return_tokens:\\n tokens.append(self._tokenize(text))\\n else:\\n tokens.append(self.encode(text))\\n return tokens\\n elif isinstance(input, str):\\n if self._return_tokens:\\n return self._tokenize(input)\\n else:\\n return self.encode(input)\\n else:\\n raise TypeError(\\\"Input type not supported\\\")\",\n \"def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \\n \\n depth = len(token_mapping)\\n one_hot_tokens = []\\n for sentence in tokens:\\n one_hot_sentence = []\\n for i, token in enumerate(sentence):\\n if token != token_mapping['#UNK#']:\\n one_hot_sentence.append(one_hot_encode(token, depth))\\n else:\\n if i <= 2:\\n context_tokens = sentence[:i] + sentence[i+1:i+3]\\n else:\\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\\n one_hot_sentence.append(context_mean)\\n one_hot_tokens.append(one_hot_sentence)\\n \\n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\\n return vec_tokens\",\n \"def encode(self, text, batch_max_length=25):\\n length = [len(s) for s in text]\\n text = ''.join(text)\\n text = [self.dict[char] for char in text]\\n\\n return (torch.IntTensor(text), torch.IntTensor(length))\",\n \"def pack_batch(label_encoder, batch, device=None):\\n (word, char), tasks = label_encoder.transform(batch)\\n\\n word = torch_utils.pad_batch(word, label_encoder.word.get_pad(), device=device)\\n char = torch_utils.pad_batch(char, label_encoder.char.get_pad(), device=device)\\n\\n output_tasks = {}\\n for task, data in tasks.items():\\n output_tasks[task] = torch_utils.pad_batch(\\n data, label_encoder.tasks[task].get_pad(), device=device)\\n\\n return (word, char), output_tasks\",\n \"def _decode_batch_input_fn(num_decode_batches, sorted_inputs, vocabulary,\\n batch_size, max_input_size,\\n task_id=-1, has_input=True, use_static_shapes=False):\\n tf.logging.info(\\\" batch %d\\\" % num_decode_batches)\\n\\n if use_static_shapes:\\n global_max_length = max([len(vocabulary.encode(i)) for i in sorted_inputs]) + 1\\n\\n for b in range(num_decode_batches):\\n tf.logging.info(f\\\"Decoding batch {b+1}/{num_decode_batches}\\\")\\n batch_inputs = []\\n for inputs in sorted_inputs[b * batch_size:(b + 1) * batch_size]:\\n input_ids = vocabulary.encode(inputs)\\n if max_input_size > 0:\\n # Subtract 1 for the EOS_ID.\\n input_ids = input_ids[:max_input_size - 1]\\n if has_input or task_id > -1: # Do not append EOS for pure LM tasks.\\n final_id = text_encoder.EOS_ID if task_id < 0 else task_id\\n input_ids.append(final_id)\\n batch_inputs.append(input_ids)\\n\\n final_batch_inputs = []\\n if use_static_shapes:\\n batch_length = global_max_length\\n else:\\n batch_length = max([len(ids) for ids in batch_inputs])\\n\\n for input_ids in batch_inputs:\\n assert len(input_ids) <= batch_length\\n x = input_ids + [0] * (batch_length - len(input_ids))\\n final_batch_inputs.append(x)\\n full_batch_padding = [[text_encoder.EOS_ID] * batch_length] * (batch_size - len(final_batch_inputs))\\n final_batch_inputs = final_batch_inputs + full_batch_padding\\n\\n yield {\\n \\\"inputs\\\": np.array(final_batch_inputs).astype(np.int32),\\n }\",\n \"def base_encoder(cls, data, init_encoder, downsize_encoder, input_encoder):\\n #todo: maybe do positional encoding before passing to init_encoder\\n data = downsize_encoder(init_encoder(data))\\n return input_encoder(data)\",\n \"def transform_batch(self, batch: Dict[str, Any], results: Dict[str, Any] = None, cls_is_bos=False,\\n sep_is_eos=False) -> Dict[str, Any]:\\n return batch\",\n \"def preprocess_for_bert(\\n self, text, max_len=MAX_SEQ_LEN, labels=None, label_map=None, trailing_piece_tag=\\\"X\\\"\\n ):\\n\\n def _is_iterable_but_not_string(obj):\\n return isinstance(obj, Iterable) and not isinstance(obj, str)\\n\\n if max_len > MAX_SEQ_LEN:\\n logging.warning(\\n \\\"Setting max_len to max allowed sequence length: {}\\\".format(MAX_SEQ_LEN)\\n )\\n max_len = MAX_SEQ_LEN\\n\\n if not _is_iterable_but_not_string(text):\\n # The input text must be an non-string Iterable\\n raise ValueError(\\\"Input text must be an iterable and not a string.\\\")\\n else:\\n # If the input text is a single list of words, convert it to\\n # list of lists for later iteration\\n if not _is_iterable_but_not_string(text[0]):\\n text = [text]\\n\\n if labels is not None:\\n if not _is_iterable_but_not_string(labels):\\n raise ValueError(\\\"labels must be an iterable and not a string.\\\")\\n else:\\n if not _is_iterable_but_not_string(labels[0]):\\n labels = [labels]\\n\\n label_available = True\\n if labels is None:\\n label_available = False\\n # create an artificial label list for creating trailing token mask\\n labels = [[\\\"O\\\"] * len(t) for t in text]\\n\\n input_ids_all = []\\n input_mask_all = []\\n label_ids_all = []\\n trailing_token_mask_all = []\\n\\n for t, t_labels in zip(text, labels):\\n if len(t) != len(t_labels):\\n raise ValueError(\\n \\\"The number of words is {0}, but the number of labels is {1}.\\\".format(\\n len(t), len(t_labels)\\n )\\n )\\n\\n new_labels = []\\n new_tokens = []\\n for word, tag in zip(t, t_labels):\\n sub_words = self.tokenizer.tokenize(word)\\n for count, sub_word in enumerate(sub_words):\\n if count > 0:\\n tag = trailing_piece_tag\\n new_labels.append(tag)\\n new_tokens.append(sub_word)\\n\\n if len(new_tokens) > max_len:\\n logging.warn(\\n \\\"Text after tokenization with length {} has been truncated\\\".format(\\n len(new_tokens)\\n )\\n )\\n new_tokens = new_tokens[:max_len]\\n new_labels = new_labels[:max_len]\\n input_ids = self.tokenizer.convert_tokens_to_ids(new_tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens.\\n # Only real tokens are attended to.\\n input_mask = [1.0] * len(input_ids)\\n\\n # Zero-pad up to the max sequence length.\\n padding = [0.0] * (max_len - len(input_ids))\\n label_padding = [\\\"O\\\"] * (max_len - len(input_ids))\\n\\n input_ids += padding\\n input_mask += padding\\n new_labels += label_padding\\n\\n trailing_token_mask_all.append(\\n [True if label != trailing_piece_tag else False for label in new_labels]\\n )\\n\\n if label_map:\\n label_ids = [label_map[label] for label in new_labels]\\n else:\\n label_ids = new_labels\\n\\n input_ids_all.append(input_ids)\\n input_mask_all.append(input_mask)\\n label_ids_all.append(label_ids)\\n\\n if label_available:\\n td = TensorDataset(\\n torch.tensor(input_ids_all, dtype=torch.long),\\n torch.tensor(input_mask_all, dtype=torch.long),\\n torch.tensor(trailing_token_mask_all, dtype=torch.bool),\\n torch.tensor(label_ids_all, dtype=torch.long),\\n )\\n else:\\n td = TensorDataset(\\n torch.tensor(input_ids_all, dtype=torch.long),\\n torch.tensor(input_mask_all, dtype=torch.long),\\n torch.tensor(trailing_token_mask_all, dtype=torch.bool),\\n )\\n return td\",\n \"def _generate(self, encoder_inputs, srcs_ids, beam_size=None, maxlen=None, prefix_tokens=None, src_weights=None):\\n n_srcs = len(srcs_ids)\\n srcs_tokens = encoder_inputs[0]\\n align_src_tokens = srcs_tokens.index_select(0, srcs_ids[self.align_to])\\n bsz, srclen = align_src_tokens.size()\\n maxlen = min(maxlen, self.maxlen) if maxlen is not None else self.maxlen\\n beam_size = beam_size if beam_size is not None else self.beam_size\\n assert beam_size < self.vocab_size, 'Beam size must be smaller than target vocabulary'\\n encoder_outs = self._encode(encoder_inputs, beam_size, srcs_ids)\\n incremental_states = self._init_incremental_states(n_srcs)\\n scores = align_src_tokens.new(bsz * beam_size, maxlen + 1).float().fill_(0)\\n scores_buf = scores.clone()\\n tokens = align_src_tokens.new(bsz * beam_size, maxlen + 2).fill_(self.pad)\\n tokens_buf = tokens.clone()\\n tokens[:, 0] = self.eos\\n src_encoding_len = encoder_outs[self.align_to][0][0].size(0)\\n attn = scores.new(bsz * beam_size, src_encoding_len, maxlen + 2)\\n attn_buf = attn.clone()\\n finalized = [[] for i in range(bsz)]\\n finished = [(False) for i in range(bsz)]\\n worst_finalized = [{'idx': None, 'score': -math.inf} for i in range(bsz)]\\n num_remaining_sent = bsz\\n cand_size = 2 * beam_size\\n bbsz_offsets = (torch.arange(0, bsz) * beam_size).unsqueeze(1).type_as(tokens)\\n cand_offsets = torch.arange(0, cand_size).type_as(tokens)\\n buffers = {}\\n\\n def buffer(name, type_of=tokens):\\n if name not in buffers:\\n buffers[name] = type_of.new()\\n return buffers[name]\\n\\n def is_finished(sent, step, unfinalized_scores=None):\\n \\\"\\\"\\\"\\n Check whether we've finished generation for a given sentence, by\\n comparing the worst score among finalized hypotheses to the best\\n possible score among unfinalized hypotheses.\\n \\\"\\\"\\\"\\n assert len(finalized[sent]) <= beam_size\\n if len(finalized[sent]) == beam_size:\\n if self.stop_early or step == maxlen or unfinalized_scores is None:\\n return True\\n best_unfinalized_score = unfinalized_scores[sent].max()\\n if self.normalize_scores:\\n best_unfinalized_score /= (maxlen + 1) ** self.len_penalty\\n if worst_finalized[sent]['score'] >= best_unfinalized_score:\\n return True\\n return False\\n\\n def finalize_hypos(step, bbsz_idx, eos_scores, unfinalized_scores=None):\\n \\\"\\\"\\\"\\n Finalize the given hypotheses at this step, while keeping the total\\n number of finalized hypotheses per sentence <= beam_size.\\n\\n Note: the input must be in the desired finalization order, so that\\n hypotheses that appear earlier in the input are preferred to those\\n that appear later.\\n\\n Args:\\n step: current time step\\n bbsz_idx: A vector of indices in the range [0, bsz*beam_size),\\n indicating which hypotheses to finalize\\n eos_scores: A vector of the same size as bbsz_idx containing\\n scores for each hypothesis\\n unfinalized_scores: A vector containing scores for all\\n unfinalized hypotheses\\n \\\"\\\"\\\"\\n assert bbsz_idx.numel() == eos_scores.numel()\\n tokens_clone = tokens.index_select(0, bbsz_idx)\\n tokens_clone = tokens_clone[:, 1:step + 2]\\n tokens_clone[:, step] = self.eos\\n attn_clone = attn.index_select(0, bbsz_idx)[:, :, 1:step + 2]\\n pos_scores = scores.index_select(0, bbsz_idx)[:, :step + 1]\\n pos_scores[:, step] = eos_scores\\n pos_scores[:, 1:] = pos_scores[:, 1:] - pos_scores[:, :-1]\\n if self.normalize_scores:\\n eos_scores /= (step + 1) ** self.len_penalty\\n sents_seen = set()\\n for i, (idx, score) in enumerate(zip(bbsz_idx.tolist(), eos_scores.tolist())):\\n sent = idx // beam_size\\n sents_seen.add(sent)\\n\\n def get_hypo():\\n _, alignment = attn_clone[i].max(dim=0)\\n return {'tokens': tokens_clone[i], 'score': score, 'attention': attn_clone[i], 'alignment': alignment, 'positional_scores': pos_scores[i]}\\n if len(finalized[sent]) < beam_size:\\n finalized[sent].append(get_hypo())\\n elif not self.stop_early and score > worst_finalized[sent]['score']:\\n worst_idx = worst_finalized[sent]['idx']\\n if worst_idx is not None:\\n finalized[sent][worst_idx] = get_hypo()\\n idx, s = min(enumerate(finalized[sent]), key=lambda r: r[1]['score'])\\n worst_finalized[sent] = {'score': s['score'], 'idx': idx}\\n num_finished = 0\\n for sent in sents_seen:\\n if not finished[sent] and is_finished(sent, step, unfinalized_scores):\\n finished[sent] = True\\n num_finished += 1\\n return num_finished\\n reorder_state = None\\n for step in range(maxlen + 1):\\n if reorder_state is not None:\\n for model_id, model in enumerate(self.models):\\n if isinstance(model.decoder, FairseqIncrementalDecoder):\\n for src_id in range(n_srcs):\\n model.decoder.reorder_incremental_state(incremental_states[src_id, model_id], reorder_state)\\n logprobs, avg_attn, possible_translation_tokens = self._decode(tokens[:, :step + 1], encoder_outs, incremental_states, n_srcs)\\n if step == 0:\\n logprobs = logprobs.unfold(0, 1, beam_size).squeeze(2).contiguous()\\n scores = scores.type_as(logprobs)\\n scores_buf = scores_buf.type_as(logprobs)\\n else:\\n logprobs.add_(scores[:, step - 1].view(-1, 1))\\n logprobs[:, self.pad] = -math.inf\\n if possible_translation_tokens is None:\\n unk_index = self.unk\\n else:\\n unk_index = torch.nonzero(possible_translation_tokens == self.unk)[0, 0]\\n logprobs[:, unk_index] += self.unk_reward\\n logprobs[:, self.lexicon_indices] += self.lexicon_reward\\n logprobs += self.word_reward\\n logprobs[:, self.eos] -= self.word_reward\\n attn[:, :, step + 1].copy_(avg_attn)\\n cand_scores = buffer('cand_scores', type_of=scores)\\n cand_indices = buffer('cand_indices')\\n cand_beams = buffer('cand_beams')\\n eos_bbsz_idx = buffer('eos_bbsz_idx')\\n eos_scores = buffer('eos_scores', type_of=scores)\\n if step < maxlen:\\n if prefix_tokens is not None and step < prefix_tokens.size(1):\\n logprobs_slice = logprobs.view(bsz, -1, logprobs.size(-1))[:, 0, :]\\n cand_scores = torch.gather(logprobs_slice, dim=1, index=prefix_tokens[:, step].view(-1, 1)).expand(-1, cand_size)\\n cand_indices = prefix_tokens[:, step].view(-1, 1).expand(bsz, cand_size)\\n cand_beams.resize_as_(cand_indices).fill_(0)\\n else:\\n torch.topk(logprobs.view(bsz, -1), k=min(cand_size, logprobs.view(bsz, -1).size(1) - 1), out=(cand_scores, cand_indices))\\n possible_tokens_size = self.vocab_size\\n if possible_translation_tokens is not None:\\n possible_tokens_size = possible_translation_tokens.size(0)\\n torch.div(cand_indices, possible_tokens_size, out=cand_beams)\\n cand_indices.fmod_(possible_tokens_size)\\n if possible_translation_tokens is not None:\\n possible_translation_tokens = possible_translation_tokens.view(1, possible_tokens_size).expand(cand_indices.size(0), possible_tokens_size)\\n cand_indices = torch.gather(possible_translation_tokens, dim=1, index=cand_indices, out=cand_indices)\\n else:\\n torch.sort(logprobs[:, self.eos], descending=True, out=(eos_scores, eos_bbsz_idx))\\n num_remaining_sent -= finalize_hypos(step, eos_bbsz_idx, eos_scores)\\n assert num_remaining_sent == 0\\n break\\n cand_bbsz_idx = cand_beams.add_(bbsz_offsets)\\n eos_mask = cand_indices.eq(self.eos)\\n if step >= self.minlen:\\n torch.masked_select(cand_bbsz_idx[:, :beam_size], mask=eos_mask[:, :beam_size], out=eos_bbsz_idx)\\n if eos_bbsz_idx.numel() > 0:\\n torch.masked_select(cand_scores[:, :beam_size], mask=eos_mask[:, :beam_size], out=eos_scores)\\n num_remaining_sent -= finalize_hypos(step, eos_bbsz_idx, eos_scores, cand_scores)\\n assert num_remaining_sent >= 0\\n if num_remaining_sent == 0:\\n break\\n assert step < maxlen\\n active_mask = buffer('active_mask')\\n torch.add(eos_mask.type_as(cand_offsets) * cand_size, cand_offsets[:eos_mask.size(1)], out=active_mask)\\n active_hypos, _ignore = buffer('active_hypos'), buffer('_ignore')\\n torch.topk(active_mask, k=beam_size, dim=1, largest=False, out=(_ignore, active_hypos))\\n active_bbsz_idx = buffer('active_bbsz_idx')\\n torch.gather(cand_bbsz_idx, dim=1, index=active_hypos, out=active_bbsz_idx)\\n active_scores = torch.gather(cand_scores, dim=1, index=active_hypos, out=scores[:, step].view(bsz, beam_size))\\n active_bbsz_idx = active_bbsz_idx.view(-1)\\n active_scores = active_scores.view(-1)\\n torch.index_select(tokens[:, :step + 1], dim=0, index=active_bbsz_idx, out=tokens_buf[:, :step + 1])\\n torch.gather(cand_indices, dim=1, index=active_hypos, out=tokens_buf.view(bsz, beam_size, -1)[:, :, step + 1])\\n if step > 0:\\n torch.index_select(scores[:, :step], dim=0, index=active_bbsz_idx, out=scores_buf[:, :step])\\n torch.gather(cand_scores, dim=1, index=active_hypos, out=scores_buf.view(bsz, beam_size, -1)[:, :, step])\\n torch.index_select(attn[:, :, :step + 2], dim=0, index=active_bbsz_idx, out=attn_buf[:, :, :step + 2])\\n tokens, tokens_buf = tokens_buf, tokens\\n scores, scores_buf = scores_buf, scores\\n attn, attn_buf = attn_buf, attn\\n reorder_state = active_bbsz_idx\\n for sent in range(bsz):\\n finalized[sent] = sorted(finalized[sent], key=lambda r: r['score'], reverse=True)\\n return finalized\",\n \"def encode(self, images):\\n\\n i = 0\\n N = len(images)\\n embs = None\\n\\n while True:\\n end = min(N, i + self.batch_size)\\n batch = images[i: end]\\n\\n size = end - i\\n if size < self.batch_size:\\n batch += self._input_padding[:self.batch_size - size]\\n\\n if embs is None:\\n embs = self.sess.run(self.embed_layer, feed_dict={self.x: batch})\\n else:\\n _embs = self.sess.run(self.embed_layer, feed_dict={self.x: batch})\\n embs = np.vstack((embs, _embs))\\n\\n i += self.batch_size\\n\\n if i >= N - 1:\\n break\\n\\n return embs\",\n \"def encode(self, data, mask, batch_size=128):\\n features = np.zeros((len(data), self.feature_dim))\\n n_batches = int(len(data) / batch_size)\\n\\n for i in tqdm(range(n_batches)):\\n cur_data = data[i * batch_size:(i + 1) * batch_size]\\n cur_mask = mask[i * batch_size:(i + 1) * batch_size]\\n features[i * batch_size:(i + 1) * batch_size] = self.encode_fn(cur_data, cur_mask)\\n if n_batches * batch_size < len(data):\\n cur_data = data[n_batches * batch_size:]\\n cur_mask = mask[n_batches * batch_size:]\\n features[n_batches * batch_size:] = self.encode_fn(cur_data, cur_mask)\\n\\n return features\",\n \"def encode(self, text, batch_max_length=25):\\n length = [len(s) for s in text]\\n text = ''.join(text)\\n text = [self.dict[char] for char in text]\\n\\n return (torch.IntTensor(text).to(device), torch.IntTensor(length).to(device))\",\n \"def preprocess_input(text, tokenizer, max_id):\\n X = np.array(tokenizer.texts_to_sequences(text)) - 1\\n encoded = tf.one_hot(X, depth=max_id)\\n return encoded\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7312299","0.62325454","0.62248653","0.62079835","0.61744493","0.60844237","0.60585696","0.5993476","0.59909976","0.59304714","0.5894535","0.5890986","0.5826842","0.5709089","0.57029486","0.5684606","0.56439316","0.56439316","0.55587023","0.55517715","0.5513023","0.55082524","0.5504261","0.5498209","0.5486363","0.54767233","0.54498345","0.54498345","0.54260164","0.5420736","0.53861207","0.532371","0.531835","0.5306819","0.5289156","0.5274306","0.52588403","0.525617","0.52380574","0.5238021","0.52378976","0.5219361","0.5216731","0.5211228","0.52097726","0.52091634","0.52002937","0.5181646","0.51793647","0.51769996","0.51709884","0.51561606","0.5142741","0.5134287","0.5124382","0.5123541","0.51200414","0.5112421","0.5111625","0.51093835","0.51073843","0.5102443","0.50980914","0.5088422","0.50747716","0.50651973","0.50638735","0.5063615","0.50567824","0.5052109","0.5051427","0.5048964","0.50486237","0.50367814","0.5034876","0.5033754","0.50268394","0.5026792","0.50036544","0.49946195","0.4988955","0.49860236","0.49824134","0.4981721","0.4981282","0.4980336","0.49634418","0.4960695","0.4950391","0.4949941","0.4947081","0.49380127","0.49220392","0.4921577","0.4919993","0.4910574","0.4889626","0.48745465","0.48740757","0.48726514"],"string":"[\n \"0.7312299\",\n \"0.62325454\",\n \"0.62248653\",\n \"0.62079835\",\n \"0.61744493\",\n \"0.60844237\",\n \"0.60585696\",\n \"0.5993476\",\n \"0.59909976\",\n \"0.59304714\",\n \"0.5894535\",\n \"0.5890986\",\n \"0.5826842\",\n \"0.5709089\",\n \"0.57029486\",\n \"0.5684606\",\n \"0.56439316\",\n \"0.56439316\",\n \"0.55587023\",\n \"0.55517715\",\n \"0.5513023\",\n \"0.55082524\",\n \"0.5504261\",\n \"0.5498209\",\n \"0.5486363\",\n \"0.54767233\",\n \"0.54498345\",\n \"0.54498345\",\n \"0.54260164\",\n \"0.5420736\",\n \"0.53861207\",\n \"0.532371\",\n \"0.531835\",\n \"0.5306819\",\n \"0.5289156\",\n \"0.5274306\",\n \"0.52588403\",\n \"0.525617\",\n \"0.52380574\",\n \"0.5238021\",\n \"0.52378976\",\n \"0.5219361\",\n \"0.5216731\",\n \"0.5211228\",\n \"0.52097726\",\n \"0.52091634\",\n \"0.52002937\",\n \"0.5181646\",\n \"0.51793647\",\n \"0.51769996\",\n \"0.51709884\",\n \"0.51561606\",\n \"0.5142741\",\n \"0.5134287\",\n \"0.5124382\",\n \"0.5123541\",\n \"0.51200414\",\n \"0.5112421\",\n \"0.5111625\",\n \"0.51093835\",\n \"0.51073843\",\n \"0.5102443\",\n \"0.50980914\",\n \"0.5088422\",\n \"0.50747716\",\n \"0.50651973\",\n \"0.50638735\",\n \"0.5063615\",\n \"0.50567824\",\n \"0.5052109\",\n \"0.5051427\",\n \"0.5048964\",\n \"0.50486237\",\n \"0.50367814\",\n \"0.5034876\",\n \"0.5033754\",\n \"0.50268394\",\n \"0.5026792\",\n \"0.50036544\",\n \"0.49946195\",\n \"0.4988955\",\n \"0.49860236\",\n \"0.49824134\",\n \"0.4981721\",\n \"0.4981282\",\n \"0.4980336\",\n \"0.49634418\",\n \"0.4960695\",\n \"0.4950391\",\n \"0.4949941\",\n \"0.4947081\",\n \"0.49380127\",\n \"0.49220392\",\n \"0.4921577\",\n \"0.4919993\",\n \"0.4910574\",\n \"0.4889626\",\n \"0.48745465\",\n \"0.48740757\",\n \"0.48726514\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71921265"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":81396,"cells":{"query":{"kind":"string","value":"parses the command line args for options/parameters"},"document":{"kind":"string","value":"def parse_options(self):\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-i\",\n \"--input_csv\",\n type=str,\n help=\"Input CSV path(s)\",\n required=True,\n nargs=\"+\",\n )\n parser.add_argument(\n \"-o\", \"--output_csv\", type=str, help=\"Output CSV path\", required=True\n )\n parser.add_argument(\n \"-k\",\n \"--kernel\",\n type=str,\n default=\"rbf\",\n help='SVM kernel type (\"rbf\", \"linear\", \"poly\" or \"sigmoid\")',\n )\n parser.add_argument(\n \"-c\", type=float, default=1.0, help=\"Penalty parameter C of the error term\"\n )\n parser.add_argument(\n \"-g\",\n \"--gamma\",\n type=str,\n default=\"auto\",\n help=\"Gamma parameter of the SVM.\",\n )\n parser.add_argument(\n \"-r\",\n \"--mb_ram\",\n type=float,\n default=4000,\n help=\"Available RAM in megabytes, for SVM calculation\",\n )\n parser.add_argument(\n \"-f\",\n \"--fdr_cutoff\",\n type=float,\n default=0.01,\n help=\"Target PSMs with a lower FDR will be used as a \"\n \"positive training set\",\n )\n parser.add_argument(\n \"-x\",\n \"--columns_as_features\",\n type=str,\n nargs=\"+\",\n default=[\n \"MS-GF:RawScore\",\n \"MS-GF:DeNovoScore\",\n \"MS-GF:SpecEValue\",\n \"MS-GF:EValue\",\n \"OMSSA:evalue\",\n \"OMSSA:pvalue\",\n \"X\\!Tandem:expect\",\n \"X\\!Tandem:hyperscore\",\n ],\n help=\"Columns that should be used as a feature directly \"\n \"(e.g. secondary scores). Will be converted to float\",\n )\n parser.add_argument(\n \"-d\",\n \"--dump_svm_matrix\",\n type=str,\n default=False,\n help=\"Dump SVM matrix in PIN (Percolator input) format \"\n \"to the specified path, mostly for debugging \"\n \"and benchmarking.\",\n )\n\n arg_dict = vars(parser.parse_args()) # convert to dict\n self.update(arg_dict)\n try:\n self[\"gamma\"] = float(self[\"gamma\"])\n except ValueError:\n assert (\n self[\"gamma\"] == \"auto\"\n ), \"Invalid gamma param: \" '\"{0}\", using \"auto\" instead.'.format(\n self[\"gamma\"]\n )"},"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 parse_arguments(args):","def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()","def _parse_args():\n args = sys.argv[1:]\n cmd_parser = argparse.ArgumentParser()\n cmd_parser.add_argument(\n '--produce-sub',\n dest='produce_sub',\n help='Produce submision file',\n default=False,\n action='store_true',\n )\n cmd_parser.add_argument(\n '--search-cv',\n dest='search_cv',\n help='Perform Search of parameters',\n default=False,\n action='store_true',\n )\n cmd_opts = cmd_parser.parse_args(args=args)\n return cmd_opts","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory","def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)","def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale","def __parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--force', action=\"store_true\", default=False,\n help='overwrite existing database files during import')\n parser.add_argument('-e', '--extension', action=\"store\", default='txt',\n help='specify file extension. default is \"txt\"')\n parser.add_argument('-d', '--delimiter', action=\"store\", default='\\t',\n help='specify column delimiter. default is tab (\\\\t)')\n parser.add_argument('-m', '--mark', action=\"store\", default='.',\n help='specify decimal mark for numeric data. default is'\n ' dot (.)')\n parser.add_argument('-o', '--outformat', action=\"store\", default='npz',\n help='specify output database format. default is \"npz\"'\n ' for numpy database. use \"mat\" for matlab '\n ' database format.')\n parser.add_argument('-r', '--recursive', action=\"store_true\", default=False,\n help='recursively walk through all sub-directories of'\n ' current working directory')\n parser.add_argument('-p', '--pcs', action=\"store_true\", default=True,\n help='indicate if files are pcs files.')\n parser.add_argument('-c', '--colheadlines', action=\"store\", default='1',\n help='number of lines spanned by the column headers')\n args = parser.parse_args()\n return args","def _parse_args():\n parser = optparse.OptionParser(usage=\"\", description=\"\")\n parser.add_option(\"-o\", dest=\"outfile\", default=None, help=\"File to write to\")\n parser.add_option(\"-w\", dest=\"write_format\", default=\"pidgin\", help=\"Write format. [default: %default]\")\n parser.add_option(\"-r\", dest=\"read_format\", default=\"adium\", help=\"Read format. [default: %default]\")\n\n return parser.parse_args()","def parse_args():\n parser = default_argument_parser()\n parser.add_argument(\"--label-map\",\n dest=\"label_map\",\n type=pathlib.Path,\n help=\"Label map in YAML format which maps from category \"\n \"ID to name.\")\n parser.add_argument(\"--train-csv\",\n dest=\"train_csv\",\n required=True,\n type=pathlib.Path,\n help=\"Path to training data CSV file.\")\n parser.add_argument(\"--valid-csv\",\n dest=\"valid_csv\",\n required=False,\n type=pathlib.Path,\n help=\"Optional path to validation data CSV file.\")\n parser.add_argument(\n \"--image-width\",\n type=int,\n help=\"Image width (optional, used to speed up dataset processing).\")\n parser.add_argument(\n \"--image-height\",\n type=int,\n help=\"Image height (optional, used to speed up dataset processing).\")\n return parser.parse_args()","def parse_args():\n parser = OptionParser()\n parser.add_option('--data-file', '-f', default='train_data.hdf5',\n help=\"The path to the data file\")\n parser.add_option('--runs-per-epoch', '-r', type='int',\n help=\"The number of runs per epoch (train samples count)\")\n parser.add_option('--avg-window-size', '-w', default='1', type='int',\n help=\"The window size for moving average\")\n\n (options, args) = parser.parse_args()\n return options","def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()","def parse_options():\n global parser\n parser.add_option(\"-r\", \"--regions\", dest=\"input_brain_regions\",\n help=\"Input file for brain region data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-g\", \"--gray\", dest=\"input_gray_levels\",\n help=\"Input file for gray level data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-n\", \"--nissl\", dest=\"input_nissl\",\n help=\"Input file for nissl data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-o\", \"--output\", dest=\"output_folder_path\",\n help=\"Output folder for extracted data files\",\n action=\"store\", type='string')\n\n return parser.parse_args()","def _parse_command_line_arguments():\n parser = ArgumentParser(\n description=(\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\n ),\n )\n parser.add_argument(\n 'ts-file',\n type=str,\n help=(\n 'A file containing the TS sky map'\n ),\n )\n parser.add_argument('--skiprows',\n type=int,\n help='number of rows to skip at the top (default 0)',\n required=False)\n parser.set_defaults(skiprows=0)\n arguments = vars(parser.parse_args())\n return arguments","def parse_command_line():\n\n parser=OptionParser(usage=\"%prog [options] \",\n description=\" updates tracker\" )\n parser.add_option(\"-c\", \"--candidate\", action=\"store\", type=\"string\",\n dest=\"candidate\", default=\"\", help=\"candidate name\")\n parser.add_option(\"-u\", \"--username\", action=\"store\", type=\"string\",\n dest=\"username\", default=\"gzhou\",\n help=\"username\")\n parser.add_option(\"-p\",\"--password\", action=\"store\",\n dest=\"password\", default=\"egghead\", help=\"password\")\n parser.add_option(\"-i\",\"--input\", action=\"store\",\n dest=\"input\", default=\"tracker_temp.txt\", help=\"Input file\") \n parser.add_option(\"-l\",\"--upload\", action=\"store\",\n dest=\"upload\", default=None, help=\"upload file\") \n parser.add_option(\"-d\",\"--description\", action=\"store\",\n dest=\"description\", default=None, help=\"descirption\") \n (options, args)=parser.parse_args()\n\n return options, args","def parse_cmdline():\n\tparser = ArgumentParser(prog=\"FastP_QC.py\", description=\"\"\"Script collects stats from fastp jsons.\"\"\")\n\tparser.add_argument(\"-r1\", \"--r1_stats\", dest=\"r1_stats\", action=\"store\", required=True, help=\"Text file with r1 stats, from q30.py script.\")\n\tparser.add_argument(\"-r2\", \"--r2_stats\", dest=\"r2_stats\", action=\"store\", required=True, help=\"Text file with r2 stats, from q30.py script.\")\n\tparser.add_argument(\"-n\", \"--name\", dest=\"name\", action=\"store\", required=True, help=\"Sample name\")\n\targs = parser.parse_args()\n\treturn args","def __parse_args(self):\n for argument in self.args:\n source_arg = re.match(\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n input_arg = re.match(\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n stats_arg = re.match(\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n help_arg = re.match(\"^--help$\", argument)\n vars_arg = re.match(\"^--vars$\", argument)\n insts_arg = re.match(\"^--insts$\", argument)\n if source_arg:\n self.sourceFile = source_arg.group(2)\n self.passedArgs.append(\"source\")\n elif input_arg:\n self.inputFile = input_arg.group(2)\n self.passedArgs.append(\"input\")\n elif help_arg:\n print(\"napoveda\")\n sys.exit(0)\n elif stats_arg:\n self.statsFile = stats_arg.group(2)\n self.passedArgs.append(\"stats\")\n elif vars_arg:\n self.passedArgs.append(\"vars\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"vars\"\n elif insts_arg:\n self.passedArgs.append(\"insts\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"insts\"\n else:\n raise ArgError(\"Unknown argument or format of the argument! (\" + argument + \")\")","def handle_cmdline_args():\n\n parser = argparse.ArgumentParser(\n description='Generate synthetic data from a specification in a json '\n 'file using the \"synth-method\" described in the json file. ')\n\n parser.add_argument(\n '-i', dest='infile', required=True,\n help='The input json file. Must contain a \"synth-method\" property')\n\n parser.add_argument(\n '-o', dest='outfile_prefix', required=True, help='The prefix of the output paths (data json and csv), relative to the QUIPP-pipeline root directory')\n\n args = parser.parse_args()\n return args","def parse_cmdline_args():\n parser = argparse.ArgumentParser(description=\"Guesses the functional element for host.\")\n ##\n ## Internal options\n ##\n parser.add_argument(\"--json\", dest=\"json\", action='store_true', help=\"output in JSON\")\n\n ##\n ## PuppetDB options\n ##\n pdbconf = PdbConfig()\n pdbconf.add_standard_args(parser)\n\n parser.add_argument(\"host\", metavar=\"HOST\",\n help=\"hostnames to query for FE\")\n\n return parser.parse_args()","def parseArgs():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', default='fsod', help='training dataset') # use fsod dataset for default\n parser.add_argument('--cfg', dest='cfg_file', required=True, help='optional config file')\n parser.add_argument('--load_ckpt', help='path to load checkpoint')\n parser.add_argument('--load_detectron', help='path to load detectron weight pickle file')\n parser.add_argument('--output_dir', help='output directory to save the testing results.')\n parser.add_argument('--range', help='[start, end)', type=int, nargs=2)\n parser.add_argument('--visualize', dest='visualize', help='output images of detection', action='store_true')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()","def parse_args(self, args):\n (options, args) = optparse.OptionParser.parse_args(self, args)\n return options","def parse_args():\n parser = argparse.ArgumentParser(description=\"SLOWFAST for AVA Dataset\")\n parser.add_argument(\"--pipeline\", type=str,\n default=\"../data/config/slowfast.pipeline\", help=\"SDK infer pipeline\")\n parser.add_argument(\"--data_dir\", type=str, default=\"../data/input\",\n help=\"Dataset contain frames and ava_annotations\")\n args_opt = parser.parse_args()\n return args_opt","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n help_str = \\\n 'The collection folder to sort files into. ' \\\n 'If the folder does not exist, it will be created along with the ' \\\n 'necessary contents.'\n parser.add_argument('-c', '--collection', help=help_str)\n\n help_str = \\\n 'The source folder to import files from. Has to exist and ' \\\n 'has to be a folder.'\n parser.add_argument('-s', '--source', help=help_str, required=False)\n\n help_str = \\\n 'View the gallery in random order auto skpping after the' \\\n 'given amount of seconds'\n parser.add_argument('-v', '--view', help=help_str, required=False)\n\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # All reference encoders\n parser.add_argument(\"--step\", dest=\"step\", default=\"10\", type=int, help=\"step size\")\n parser.add_argument(\"--repeats\", dest=\"repeats\", type=int, default=1, help=\"repeats\")\n\n parser.add_argument(dest=\"image\", default=None,\n help=\"select the test image to run\")\n\n args = parser.parse_args()\n return args","def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()","def _parse_args():\n usage = \"usage: %prog [options] arg1 arg2\"\n parser = optparse.OptionParser()\n parser.add_option(\n '--platform', dest='platform', default=\"\", type = \"string\",\n help='platform name: UC 360 baidu etc.')\n parser.add_option(\n '--workspace', dest='workspace', default=\"./\", type = \"string\",\n help='project directory.')\n parser.add_option(\n '--project', dest='projectDir', default=\"./destProject\", type = \"string\",\n help='project directory.')\n # parser.add_option(\n # \"-t\", dest=\"test\", action=\"store_const\", const=lambda:_test, default=_test2, help=\"////////////\"\n # )\n options, args = parser.parse_args()\n # positional arguments are ignored\n return options, args","def _parseArgs():\n # HINT: If you consider adding an option,\n # please consider adding a config file option first.\n parser = ArgumentParser(description=STRING_USAGE_DESCRIPTION,\n epilog=STRING_USAGE_EPILOG)\n parser.add_argument('--version', action='version',\n version='%(prog)s (' + VERSIONSTRING + ')')\n parser.add_argument('-c', '--configfile', action='store',\n dest='configfile',\n default=DEFAULT_CONFIGFILE,\n help=STRING_USAGE_CONFIGFILE)\n parser.add_argument('-e', '--editconfig', action='store_true',\n dest='invoke_editconfig',\n default=False,\n help=STRING_USAGE_EDITCONFIG)\n parser.add_argument('--defaultconfig', action='store_true',\n dest='invoke_defaultconfig',\n default=False,\n help=STRING_USAGE_DEFAULTCONFIG)\n parser.add_argument('--printconfig', action='store_true',\n dest='invoke_printconfig',\n default=False,\n help=STRING_USAGE_PRINTCONFIG)\n _addOverwriteBool(parser, 'gui', 'gui', 'enable')\n parser.add_argument('-s', '--sources', section='wesen',\n dest='sources',\n action=_OverwriteConfigAction)\n parser.add_argument('-r', '--resume',\n dest='resume', action='store_true',\n default=False, help=STRING_USAGE_RESUME)\n return parser.parse_known_args()","def _parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n #parser.add_argument(\"args\", metavar=\"N\", type=str, nargs=\"*\", help=\"Positional arguments.\")\n #parser.add_argument(\"\", dest=\"\", type=\"\", default=, help=)\n #parser.add_argument(\"--version\", action=\"version\", version=\"<the version>\")\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input-model\", help=\"Path to read input model from\")\n options = parser.parse_args()\n return options","def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()","def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()","def parse_cmdline(args):\n usage = \"usage: %prog [options] <name> <snpfile> <human asm build No> \" +\\\n \"<database>\"\n parser = OptionParser(usage)\n parser.add_option(\"-v\", \"--verbose\", dest=\"verbose\",\n action=\"store_true\", default=False,\n help=\"Give verbose output\")\n return parser.parse_args()","def parse_args():\n\tparser = argparse.ArgumentParser(description='Show video statistics.')\n\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\n\t default='views',\n\t help='sort by the specified field. Options are views, likes and dislikes.')\n\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\n\tparser.add_argument('--csv', action='store_true', default=False,\n\t help='output the data in CSV format.')\n\tparser.add_argument('--table', action='store_true', default=False,\n\t help='output the data in an ascii table.')\n\tparser.add_argument('--workers', type=int, default=8,\n\t help='number of workers to use, 8 by default.')\n\treturn parser.parse_args()","def parse_cli():\n parser = OptionParser()\n return parser.parse_args()","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument('session', help='Session Label')\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\n default='/tmp')\n return ap.parse_args()","def parseArgs():\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\n parser.add_argument('config', help='configuration file')\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\n parser.add_argument('-u', help='update database', action='store_true')\n args = parser.parse_args()\n return args.config, args.d, args.u","def parse_args():\n parser = argparse.ArgumentParser(description=\"generate training data of apks\")\n parser.add_argument(\"-i\", action=\"store\", dest=\"input_file\",\n required=True, help=\"input json file to predict\")\n parser.add_argument(\"-o\", action=\"store\", dest=\"output_file\",\n required=True, help=\"file path to store predicted data\")\n parser.add_argument(\"-server\", action=\"store\", dest=\"server_url\", default=\"http://localhost:5745\",\n required=False, help=\"url of nice2predict server\")\n options = parser.parse_args()\n print options\n return options","def _parse_args(argv):\n parser = make_parser()\n args = parser.parse_args(argv)\n LOGGER.setLevel(to_log_level(args.loglevel))\n\n if not args.inputs:\n if args.list:\n tlist = \", \".join(API.list_types())\n _exit_with_output(\"Supported config types: \" + tlist)\n elif args.env:\n cnf = os.environ.copy()\n _output_result(cnf, args.output, args.otype or \"json\", None, None)\n sys.exit(0)\n else:\n parser.print_usage()\n sys.exit(1)\n\n if args.validate and args.schema is None:\n _exit_with_output(\"--validate option requires --scheme option\", 1)\n\n return args","def parse_args():\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\n parser.add_argument('--prepare', action='store_true',\n help='create the directories, prepare the vocabulary and embeddings')\n parser.add_argument('--train', action='store_true',\n help='train the model')\n parser.add_argument('--generate', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gentest', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gpu', type=str, default='0',\n help='specify gpu device')\n\n train_settings = parser.add_argument_group('train settings')\n train_settings.add_argument('--optim', default='Adam',\n help='optimizer type')\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\n help='learning rate')\n train_settings.add_argument('--weight_decay', type=float, default=0,\n help='weight decay')\n train_settings.add_argument('--dropout', type=float, default=0,\n help='dropout keep rate')\n train_settings.add_argument('--batch_size', type=int, default=128,\n help='train batch size')\n train_settings.add_argument('--epochs', type=int, default=10,\n help='train epochs')\n\n model_settings = parser.add_argument_group('model settings')\n model_settings.add_argument('--embed_size', type=int, default=128,\n help='size of the embeddings')\n model_settings.add_argument('--hidden_size', type=int, default=256,\n help='size of LSTM hidden units')\n model_settings.add_argument('--max_seq_len', type=int, default=50,\n help='max passage num in one sample')\n model_settings.add_argument('--max_gen_len', type=int, default=50,\n help='max length of passage')\n\n path_settings = parser.add_argument_group('path settings')\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\n help='the dir to save vocabulary')\n path_settings.add_argument('--model_dir', default='../data/models/',\n help='the dir to store models')\n path_settings.add_argument('--result_dir', default='../data/results/',\n help='the dir to output the results')\n path_settings.add_argument('--summary_dir', default='../data/summary/',\n help='the dir to write tensorboard summary')\n path_settings.add_argument('--log_path',\n help='path of the log file. If not set, logs are printed to console')\n return parser.parse_args()","def parse_arguments():\n parser = ArgumentParser()\n\n # For development/testing\n parser.add_argument(\"--dev\", help=\"run the code of the developers tag\")\n\n return parser.parse_args()","def parse_arguments(self,parser):\r\n return parser.parse_args()","def parse_args():\n parser = ArgumentParser(\n description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter\n )\n parser.add_argument(\n '-i', '--infile', type=is_valid_file, action=FullPaths,\n metavar='FILE', required=True, help='''Settings file'''\n )\n parser.add_argument(\n '-d', '--ddc_file', type=is_valid_file, action=FullPaths,\n metavar='FILE', default='ddc2_nios2_sw.elf',\n help='''DDC2 download file'''\n )\n parser.add_argument(\n '-t', '--time', type=int, metavar='INT', default=5,\n help='''Number of seconds to run DDC2'''\n )\n parser.add_argument(\n '-o', '--outfile', type=str, default='./data/test/test',\n metavar='FILE', required=False,\n help='''Output location of data (no need to include file extension)'''\n )\n parser.add_argument(\n '--live', action='store_true', default=False,\n help='''Live visualisation'''\n )\n parser.add_argument(\n '-v', '--verbose', action='store_true', default=False,\n help='''Verbose'''\n )\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--version',\n metavar=\"<str>\",\n help=\"Input data version number\",\n type=str,\n required=True\n )\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=_program_description)\n parser.add_argument('input_file', help=_input_file_description)\n #parser.add_argument('-v', '--verbose', action='store_true', \n # default=False, help='show progress')\n args = parser.parse_args()\n return args","def parse_args():\n parser = ArgumentParser()\n parser.add_argument('-t', '--timer', action='store_true', \\\n help='Time the first random generation')\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\n return parser.parse_args()","def parseArguments():\n # Create argument parser\n parser = argparse.ArgumentParser()\n\n # Optional arguments\n parser.add_argument(\"-t\", \"--test\", help=\"Optionally test algorithm on subsample of the data. Set to 1 for testing\", type=int, default=0)\n\n parser.add_argument(\"--cores\", help=\"Optimized code for a server with a lot of RAM, set to the number of available cores\", type=int, default=40)\n\n\n # Print version\n parser.add_argument(\"--version\", action=\"version\", version='%(prog)s - Version 2.0') #version 1.0 is for the observations in June 2018\n #version 1.1 contains the optimizations made after the june observations (mainly the switch to stackmags)\n #version 1.2 changed sim class to NOT include the list of failed candidates (not qsos)\n #... copied changes made to crossval version\n #version 1.5 added check for duplicate quasars and remove them\n #version 1.6 new simulated quasars (december)\n ##-------------------\n #version 2.0: combined training of classifier and regressor, streamlined input\n #version 2.1: Tryied to updates excluded area to a little more than stripe 82 but decided not to keep it, so no change\n\n # Parse arguments\n args = parser.parse_args()\n\n return args","def Args(parser):","def parse_args():\n parser = argparse.ArgumentParser(description='Parse flags to configure the json parsing')\n parser.add_argument(\"-f\", \"--format\", help=\"output format: (csv|tsv|json)\", choices=[\"csv\", \"tsv\", \"json\"],\n default=\"tsv\")\n parser.add_argument(\"-p\", \"--parallelized\", help=\"save output in parallelized or single file format\",\n action=\"store_true\")\n parser.add_argument(\"-i\", \"--input\", help=\"folder where input documents are\", default=\"data\")\n parser.add_argument(\"-o\", \"--output\", help=\"folder where output documents are\", default=\"cleaned\")\n parser.add_argument(\"-d\", \"--documentformat\", help=\"combine all features into a single text per post\",\n action=\"store_true\")\n parser.add_argument(\"-pa\", \"--partitions\", help=\"number of spark partitions\",\n default=1)\n args = parser.parse_args()\n return args","def parse_args():\n\tparser = argparse.ArgumentParser(description=\"comparing proguard-generated and predict mappings\")\n\tparser.add_argument(\"--proguard\", action=\"store\", dest=\"proguard_mappings_dir\",\n\t\t\t\t\t\trequired=True, help=\"directory of proguard-generated mappings file\")\n\tparser.add_argument(\"--predict\", action=\"store\", dest=\"predict_mappings_dir\",\n\t\t\t\t\t\trequired=True, help=\"directory of predict mappings file\")\n\tparser.add_argument(\"-o\", action=\"store\", dest=\"report_path\",\n\t\t\t\t\t\trequired=True, help=\"directory of report file\")\n\n\toptions = parser.parse_args()\n\tprint options\n\treturn options","def readArgs():\n parser = argparse.ArgumentParser(description=\n \"\"\"Debug script. This program is used in order to generate a summary\n statistics for the csv files generated by the annotation_parser. Things\n like the average amount of overlap of each window and the average deviation.\n \"\"\")\n\n parser.add_argument('-f', '--csv-dir', metavar='',\n dest='csv_dir',\n action='store', default=os.path.dirname(os.path.abspath(__file__)),\n help='Specify the csv directory.')\n parser.add_argument('-d', '--deviation', metavar='',\n dest='deviation', action='store',\n default=50,\n help='percentage set point from which evaluate the deviation from.')\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Hyper parameter\")\n parser.add_argument(\n \"--model\", help=\"Model to use\", default=\"DenseNet169\", type=str)\n parser.add_argument(\n \"--optimizer\", help=\"which optimizer to use\", default=\"Adam\", type=str)\n parser.add_argument(\n \"--lr\", help=\"learning rate\", default=2e-5, type=float)\n\n return parser.parse_args()","def __parse_cmd_args():\n parser = argparse.ArgumentParser(description='Python Image Downloader.')\n parser.add_argument(\"-f\", \"--file\",\n help=\"Where the URL file is located.\")\n parser.add_argument(\"-d\", \"--dir\",\n help=\"Where the downloaded files are to be stored.\")\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"--thoughtspot_host\", required=True,\n help=\"domain or ip. E.g. http://1.1.1.1\")\n parser.add_argument(\"-u\", \"--username\", required=True,\n help=\"username - must have administrative privileges\")\n parser.add_argument(\"-p\", \"--password\", required=True,\n help=\"password - must have administrative privileges\")\n parser.add_argument(\"-d\", \"--delimiter\", default=',',\n help=\"character to seperate values by. Default to comma\")\n parser.add_argument(\"-c\", \"--csv\", action=\"store_true\",\n help=\"create csv file called permissions.csv\")\n parser.add_argument(\"-s\", \"--share\", action=\"store_true\",\n help=\"output usable format for share api\")\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"img\", type=argparse.FileType(\"r\"),\n help=\"The image file to test\")\n\n encoders = [\"sse2\", \"sse4.1\", \"avx2\"]\n parser.add_argument(\"--encoder\", dest=\"encoder\", default=\"avx2\",\n choices=encoders, help=\"select encoder variant\")\n\n testquant = [str(x) for x in range (0, 101, 10)]\n testqual = [\"-fastest\", \"-fast\", \"-medium\", \"-thorough\", \"-exhaustive\"]\n qualities = testqual + testquant\n parser.add_argument(\"--test-quality\", dest=\"quality\", default=\"medium\",\n choices=qualities, help=\"select compression quality\")\n\n parser.add_argument(\"--no-startup\", dest=\"noStartup\", default=False,\n action=\"store_true\", help=\"Exclude init\")\n\n args = parser.parse_args()\n\n return args","def handleCmdLine(self):\n description = \"Nagios monitoring script to check for open ports\\n\"\n usage = (\"%prog <options>\\n\")\n parser = OptionParser(usage=usage, description=description)\n\n parser.add_option(\"-c\", \"--config\",\n type=\"string\",\n help=\"path to open ports configuration file\")\n parser.add_option(\"-l\", \"--list\",\n type=\"string\",\n help=\"supply list of allowed ports seperated by comma.\")\n\n (self.options, args) = parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Run NCF..\")\n parser.add_argument(\n \"--config_file\",\n nargs=\"?\",\n type=str,\n default=\"../configs/ncf_default.json\",\n help=\"Specify the config file name. Only accept a file from ../configs/\",\n )\n # If the following settings are specified with command line,\n # These settings will used to update the parameters received from the config file.\n parser.add_argument(\n \"--dataset\",\n nargs=\"?\",\n type=str,\n help=\"Options are: tafeng, dunnhunmby and instacart\",\n )\n parser.add_argument(\n \"--data_split\",\n nargs=\"?\",\n type=str,\n help=\"Options are: leave_one_out and temporal\",\n )\n parser.add_argument(\n \"--root_dir\", nargs=\"?\", type=str, help=\"working directory\",\n )\n parser.add_argument(\n \"--emb_dim\", nargs=\"?\", type=int, help=\"Dimension of the embedding.\"\n )\n parser.add_argument(\"--lr\", nargs=\"?\", type=float, help=\"Intial learning rate.\")\n parser.add_argument(\"--max_epoch\", nargs=\"?\", type=int, help=\"Number of max epoch.\")\n parser.add_argument(\n \"--batch_size\", nargs=\"?\", type=int, help=\"Batch size for training.\"\n )\n parser.add_argument(\"--optimizer\", nargs=\"?\", type=str, help=\"OPTI\")\n parser.add_argument(\"--activator\", nargs=\"?\", type=str, help=\"activator\")\n parser.add_argument(\"--alpha\", nargs=\"?\", type=float, help=\"ALPHA\")\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(description='Scraper')\n parser.add_argument('--prefix', help='Prefix for saving files', default=\"\")\n parser.add_argument('--path', help='Dir path', default=\"\")\n parser.add_argument('--urls_path', help='Url path', default=False)\n parser.add_argument('--url', help='Url', default=False)\n parser.add_argument('--disney', dest='disney', action='store_true', help=\"Choose all disney movies\")\n parser.add_argument('--ngram', help='Max ngram', default=2)\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=\"Re-ID feature extractor\")\n parser.add_argument(\n \"--model\",\n default=\"resources/networks/mars-small128.ckpt-68577\",\n help=\"Path to checkpoint file\")\n parser.add_argument(\n \"--loss_mode\", default=\"cosine\", help=\"Network loss training mode\")\n parser.add_argument(\n \"--mot_dir\", help=\"Path to MOTChallenge directory (train or test)\",\n required=True)\n parser.add_argument(\n \"--detection_dir\", help=\"Path to custom detections. Defaults to \"\n \"standard MOT detections Directory structure should be the default \"\n \"MOTChallenge structure: [sequence]/det/det.txt\", default=None)\n parser.add_argument(\n \"--output_dir\", help=\"Output directory. Will be created if it does not\"\n \" exist.\", default=\"detections\")\n return parser.parse_args()","def parse_args():\n global flag_num_classes, flag_num_instances\n\n try:\n optlist, args = getopt.getopt(sys.argv[1:], \"dc:I:\")\n except getopt.GetoptError as err:\n # unrecognized option\n usage(str(err))\n\n if args:\n usage(\"uknown extra args\")\n for opt, arg in optlist:\n if opt == \"-d\":\n u.increment_verbosity()\n elif opt == \"-c\":\n flag_num_classes = int(arg)\n elif opt == \"-I\":\n flag_num_instances = int(arg)","def parse_args():\n sentinel_dict = {}\n\n def _preprocess_sysargv(argv):\n inputs = []\n for arg in argv[1:]:\n # handles case where values contain --, otherwise they will\n # be interpreted as arguments.\n if '--,' in arg or ',--' in arg or arg == '--':\n sentinel = uuid4().hex\n key = '%s' % sentinel\n sentinel_dict[key] = arg\n inputs.append(sentinel)\n else:\n inputs.append(arg)\n return inputs\n\n def _postprocess_sysargv(v):\n if v in sentinel_dict:\n return sentinel_dict.get(v)\n else:\n return v\n\n #----- read input arguments\n for i, arg in enumerate(sys.argv):\n if (arg[0] == '-') and arg[1].isdigit(): sys.argv[i] = ' ' + arg\n parser = argparse.ArgumentParser()\n\n parser.add_argument('-u', action='store_true', dest='helpmenu',help='extended HELP MENU with examples')\n parser.add_argument('-i','--infile',action='store', dest='infile',help='name of file with SAC or mseed file(s)')\n parser.add_argument('-g','--gain',action='store', dest='sensitivity',help='Stage 0 sensitivity')\n parser.add_argument('-N','--net', action='store', dest='network',help='network')\n parser.add_argument('-S','--sta', action='store', dest='station',help='station')\n parser.add_argument('-C','--cha', action='store', dest='chantype',help='chantype')\n parser.add_argument('-s','--start', action='store', dest='startstring',help='start time YYYY-MM-DDTHH:MM:SS')\n parser.add_argument('-e','--end', action='store', dest='endstring',help='end time YYYY-MM-DDTHH:MM:SS')\n parser.add_argument('-d','--duration', action='store', dest='durationinhours',help='duration in hours')\n parser.add_argument('-dc','--dc','--datacenter', action='store', dest='datacenter',default='IRIS',help='FDSN data center (e.g. IRIS, SCEDC, NCEDC)')\n parser.add_argument('-p','--plot',action='store_true',dest='iplot',help='make plots of each hourly trace (NOTE: can be slow)')\n\n helpextended = parser.parse_args(_preprocess_sysargv(sys.argv)).helpmenu\n if ( helpextended is True ):\n print ('')\n print ('portable_pip_squeak: assess a station either using local data or to be downloaded')\n print ('')\n print ('Usage: portable_pip_squeak.py [options]')\n print ('')\n print ('EXAMPLES:')\n print ('portable_pip_squeak.py --infile my_SAC_files.txt')\n print ('portable_pip_squeak.py -N UW -S TKEY -C HH -s 2018-01-01T00:00:00 -d 2 -p')\n print ('portable_pip_squeak.py -N CI -S LEO -C HN -s 2020-01-01T00:00:00 -d 24 -dc SCEDC')\n print ('')\n print ('Inputs if supplying your own data:')\n print (' -i, --infile Name of text file with SAC/mseed file(s) of 3 (Z,N,E) traces.')\n print (' -g, --gain Gain or Stage 0 sensitivity')\n print (' ')\n print ('Inputs if downloading data:')\n print (' -s, --starttime Trace start time (YYYY-MM-DD,HH:MM:SS)')\n print ('')\n print (' One of these:')\n print (' -e, --endtime Trace end time (YYYY-MM-DD,HH:MM:SS)')\n print (' -d, --duration Duration in hours from starttime')\n print (' Note: if duration is neg, starttime becomes endtime')\n print (' N, S, C and a datacenter if other than IRIS')\n print (' -N, --net Network code')\n print (' -S, --sta Station code')\n print (' -C, --cha Channel type, e.g. EN or HH')\n print (' -dc, --datacenter Name of FDSN data center if not IRIS, e.g. SCEDC, NCEDC')\n print (' ')\n print ('Optional flags:')\n print ('-P, --plot Flag to make a figure for each hour. Note: can be slow.')\n print ('-u Print this extended help menu')\n print ('')\n\n\n return parser.parse_args(_preprocess_sysargv(sys.argv))","def parse_command_line_args(args=None):\n description = 'CodaNorm arguments that override default settings'\n parser = argparse.ArgumentParser(description=description)\n \n # argument on which channel to calc\n parser.add_argument(\"-c\", \"--channel\", help=\"Channel to use (N, E, Z).\", \n choices=CHANNELS, nargs='+')\n \n # add option to calc with another coda window length\n parser.add_argument(\"--sd\", type=int, default=0,\n help=\"Specify length of Coda-window (in seconds)\")\n \n # maybe we want to plot anyway\n parser.add_argument('--plot', help='Plot results', action='store_true')\n \n # change station\n parser.add_argument(\"--station\", default=None,\n help=\"Specify station to use\")\n \n # verbose mode\n parser.add_argument(\"-v\", \"--verbose\", help=\"output verbosity\", \n action=\"store_true\")\n \n args = parser.parse_args(args)\n \n return args","def command_line_arguments():\n\n try:\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\n\n # Add required arguments.\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\n\n # Parse the arguments\n args = parser.parse_args()\n\n return args\n\n except Exception as err:\n print(err)\n return","def parse_args(args=None):\n\t\treturn _get_args_parser().parse_args(args)","def get_args():\n parser = argparse.ArgumentParser(description=\"Arguments for data exploration\")\n parser.add_argument(\"--tokenize\",\n dest=\"tokenize\",\n action=\"store_true\",\n help=\"Tokenize by words and sentences, counting averages/sd for each.\")\n return parser","def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments","def parse_args():\n \n parser = argparse.ArgumentParser(description='COVID-19 Detection through Cough')\n parser.add_argument('--run', type=str, default=RUN_NAME, help='run name')\n parser.add_argument('--dataset', type=str, default=DATASET, help='dataset name for call W&B api')\n parser.add_argument('--model', type=str, default=MODEL, help='init model')\n parser.add_argument('--weight', type=str, default=None, help='path to pretrained weight')\n parser.add_argument('--epoch', type=int, default=EPOCH, help='number of epoch')\n parser.add_argument('--size', type=int, default=INPUT_SIZE, help='input size')\n parser.add_argument('--lr', type=float, default=LR, help='learning rate')\n parser.add_argument('--batch_size', type=int, default=BATCH_SIZE, help='size of each batch')\n parser.add_argument('--num_worker', type=int, default=NUM_WORKER, help='how many subprocesses to use for data loading. (default = 0)')\n \n args = parser.parse_args()\n return args","def parse_arguments(raw_args=sys.argv[1:]):\n parser = optparse.OptionParser(\n usage=\"usage: %prog [OPTIONS] DOMAIN_NAME DOMAIN_CONFIG_FILE\",\n description=\"A tool for provisioning a Khan Academy CloudSearch \"\n \"domain.\")\n\n parser.add_option(\"-v\", \"--verbose\", action=\"store_true\", default=False,\n help=\"If specified, DEBUG messages will be printed and more \"\n \"information will be printed with each log message.\")\n\n parser.add_option(\"--leave-temp-dir\", action=\"store_true\", default=False,\n help=\"If specified, the created temporary directory will not be \"\n \"deleted when the script exits.\")\n\n parser.add_option(\"-n\", \"--dry-run\", action=\"store_true\", default=False,\n help=\"If specified, no commands will actually be executed.\")\n\n parser.add_option(\"--no-reindex\", action=\"store_true\", default=False,\n help=\"If specified, will only update the config, without reindexing.\")\n\n options, args = parser.parse_args(raw_args)\n\n if len(args) != 2:\n parser.error(\"You must specify the name of the domain and a file \"\n \"containing the domain configuration.\")\n\n return (options, args[0], args[1])","def command_line_args(parser):\n AbyssAssembler.command_line_args(parser)\n SpadesAssembler.command_line_args(parser)\n TrinityAssembler.command_line_args(parser)\n VelvetAssembler.command_line_args(parser)","def parse_args(args=None):\n return AP.parse_args(args=args)","def parse_args():\n parser = argparse.ArgumentParser(description='Extract left-turn speed data CSV files from Excel')\n parser.add_argument('veh_conflict_data', type=str, help='Excel file with all veh conflicts data')\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()","def parse_command_line_arguments():\n\n description, epilog = __doc__.split(\"\\n\\n\", 1)\n\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawDescriptionHelpFormatter,\n description=description,\n epilog=epilog)\n\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\n help='Minimum frequency')\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\n default=\"./.tpass\",\n help='File with Twitter credentials (username and password, separated by a space)')\n\n args = parser.parse_args()\n \n return args","def _parser_options():\n #We have two options: get some of the details from the config file,\n import argparse\n from pydft import base\n pdescr = \"Numerical DFT code.\"\n parser = argparse.ArgumentParser(parents=[base.bparser], description=pdescr)\n for arg, options in script_options.items():\n parser.add_argument(arg, **options)\n \n args = base.exhandler(examples, parser)\n if args is None:\n return\n\n return args # pragma: no cover","def _parse_args():\n parser = argparse.ArgumentParser(description='main.py')\n \n # General system running and configuration options\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\n\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\n \n # Some common arguments for your convenience\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\n parser.add_argument('--lr', type=float, default=.001)\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\n # 65 is all you need for GeoQuery\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\n\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\n # 50-200 might be a good range to start with for embedding and LSTM sizes\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--zarr_dir',\n type=str,\n help='path to directory of zarr files',\n )\n parser.add_argument(\n '--tiff_dir',\n type=str,\n help='path to directory of tiff files',\n )\n parser.add_argument(\n '--output_dir',\n type=str,\n help='path to directory for writing',\n )\n parser.add_argument(\n '--config_path',\n type=str,\n default=None,\n help='path to yaml preprocess config file',\n )\n \n args = parser.parse_args()\n return args","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--obs_len\",\n default=20,\n type=int,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--data_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--feature_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the computed features are saved\",\n )\n parser.add_argument(\"--mode\",\n required=True,\n type=str,\n help=\"train/val/test/compute_all/lanes_only\")\n parser.add_argument(\n \"--sequence_num\",\n default=-1,\n type=int,\n help=\"Specify a specific sequence to visualize.\",\n )\n parser.add_argument(\n \"--batch_start\",\n default=0,\n type=int,\n help=\"Specify the starting row of features to visualize.\",\n )\n parser.add_argument(\n \"--batch_end\",\n default=-1,\n type=int,\n help=\"Specify the last row to visualize, -1 to visualize till end.\",\n )\n parser.add_argument(\n \"--single_figure\",\n default=False,\n action=\"store_true\",\n help=\"Plot all candidates for a scenein one figure.\",\n )\n return parser.parse_args()","def parse_args():\n import argparse\n\n parser = argparse.ArgumentParser(description=\"Pilot kodi\")\n parser.add_argument(\"--server\",\"-s\",metavar=\"SERVER\",required=True,help=\"Server to connect to\")\n parser.add_argument(\"--port\",\"-p\",metavar=\"PORT\",default=8080,type=int,help=\"Port of the server\")\n parser.add_argument(\"--get-audio\",action=\"store_true\",help=\"Get audio\")\n parser.add_argument(\"--switch-audio\",action=\"store_true\",help=\"Switch Audio\")\n parser.add_argument(\"--valid-audios\",metavar=\"SUBTITLE\",default=[\"fre\",\"eng\"],type=lambda p:p.split(\",\"),help=\"Valid audios\")\n parser.add_argument(\"--get-subtitle\",action=\"store_true\",help=\"Get subtitle\")\n parser.add_argument(\"--toggle-subtitle\",action=\"store_true\",help=\"Toggle subtitles\")\n parser.add_argument(\"--switch-subtitles\",action=\"store_true\",help=\"Switch subtitles\")\n parser.add_argument(\"--valid-subtitles\",metavar=\"SUBTITLE\",default=[\"fre\"],type=lambda p:p.split(\",\"),help=\"Valid subtitles\")\n\n return parser.parse_args()","def _parse(self, args):\r\n\r\n ordered = []\r\n opt_full = dict()\r\n opt_abbrev = dict()\r\n\r\n args = args + [''] # Avoid out of range\r\n i = 0\r\n\r\n while i < len(args) - 1:\r\n arg = args[i]\r\n arg_next = args[i+1]\r\n if arg.startswith('--'):\r\n if arg_next.startswith('-'):\r\n raise ValueError('{} lacks value'.format(arg))\r\n else:\r\n opt_full[arg[2:]] = arg_next\r\n i += 2\r\n elif arg.startswith('-'):\r\n if arg_next.startswith('-'):\r\n raise ValueError('{} lacks value'.format(arg))\r\n else:\r\n opt_abbrev[arg[1:]] = arg_next\r\n i += 2\r\n else:\r\n ordered.append(arg)\r\n i += 1\r\n \r\n return ordered, opt_full, opt_abbrev","def parse_args():\r\n parser = argparse.ArgumentParser(description=\"Available Options\")\r\n\r\n parser.add_argument('-i'\r\n ,'--input_path'\r\n ,dest='input_path'\r\n ,type=is_valid_path\r\n ,required=True\r\n ,help = \"Enter the path of the image file to process\")\r\n\r\n args = vars(parser.parse_args())\r\n\r\n #To Display The Command Line Arguments\r\n print(\"## Command Arguments #################################################\")\r\n print(\"\\n\".join(\"{}:{}\".format(i,j) for i,j in args.items()))\r\n print(\"######################################################################\")\r\n\r\n return args","def parse_arguments(self):\n \n for arg in sys.argv[1:]:\n (key, sep, value) = arg.partition(\"=\")\n if sep != \"=\":\n raise ProcessorError(\"Illegal argument '%s'\" % arg)\n self.update_data(key, value)","def parse_command_line_arguments():\n parser = argparse.ArgumentParser()\n\n # Positional args\n parser.add_argument('data_directory', action=\"store\")\n\n # Optional args\n parser.add_argument('--save_dir', action='store',\n dest='save_dir',\n help='Load categories names from given file',\n default=\"checkpoint.pth\")\n\n parser.add_argument('--gpu', action='store_true',\n dest='device',\n help='Device of prediction processing',\n default=False)\n\n parser.add_argument('--arch', action='store',\n dest='arch',\n help='Name of pre-trained network used for training',\n default=\"vgg11\")\n\n parser.add_argument('--learning_rate', action='store',\n dest='learning_rate',\n help='value of training learning rate',\n default=0.001)\n\n parser.add_argument('--hidden_units', action='store',\n dest='hidden_units',\n help='Number of units in the fully-connected hidden '\n 'layer of the neural netwrork',\n default=512)\n\n parser.add_argument('--epochs', action='store',\n dest='epochs',\n help='Number of training epochs',\n default=5)\n\n # Parse all args\n results = parser.parse_args()\n\n return results","def parse_command_line_arguments():\n parser = argparse.ArgumentParser(\n description=\"Convert dependency files into list of GitHub links.\",\n epilog=\"For help with this program, contact John Speed at jmeyers@iqt.org.\",\n )\n parser.add_argument(\n \"--python\",\n default=False, # default value is False\n help=\"Convert requirements.txt file into GitHub links.\",\n )\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('n_iter',\n help='number of iteration',\n type=int)\n parser.add_argument('n_processes',\n help='number of processes',\n type=int)\n parser.add_argument('method',\n help='mutual exclusion method')\n parser.add_argument('duration',\n help='Duration of each process',\n type=float)\n return parser.parse_args()","def parseArguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('--output_folder',\n help='Path of the folder where output files should be written.')\n parser.add_argument('--partition_id',\n help='ID of the computer partition to collect data from.')\n parser.add_argument('--collector_db',\n help='The path of slapos collect database.')\n\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # Optional Argument\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\n return parser.parse_args()","def _parse_args(self, argv):\n\n opts = optparse.OptionParser()\n\n opts.add_option(\"--data-path\",\n default=\"nyt-ingredients-snapshot-2015.csv\",\n help=\"(%default)\")\n\n (options, args) = opts.parse_args(argv)\n return options","def parse_args():\n parser = MyParser(description='Data processing and analytics library \\\n for OpenStack Browbeat perf data')\n\n parser.add_argument('-s', '--summary', dest=\"days\", type=int, default=-1,\n help='-s N summary of last N days of results')\n\n parser.add_argument('--summary-uuid', dest=\"summary_uuid\", type=str,\n default=None,\n help='--summary-uuid UUID summary of a specific uuid')\n\n parser.add_argument('--short-summary', dest=\"short_days\", type=int,\n default=-1,\n help='--short-summary N gives \\\n summary of last N days of results but uses cockroach \\\n db so only provides with basic summary')\n\n parser.add_argument('--upload-timesummary', dest=\"timeseries_uuid\",\n type=str, default=None,\n help='--upload-timesummary UUID \\\n uploads the features computed from data obtained from\\\n graphite. ')\n\n parser.add_argument('--upload-logsummary', dest=\"loggin_uuid\",\n type=str, default=None,\n help='--upload-logsummary UUID \\\n uploads the log summary to crdb \\\n currently just summarizes over entire timeperiod. ')\n\n parser.add_argument('-u', '--update-db', dest='update', type=bool,\n default=False,\n help='-u True pushes data to cockroach db')\n\n parser.add_argument('--update-clf', dest=\"clf_days\", type=int,\n default=-1,\n help='--update-clf 60 will update all classifiers \\\n listed in config file under classifier_lists \\\n using data from last 60 days')\n\n parser.add_argument('--test-clf', dest=\"test_days\", type=int,\n default=-1,\n help='--test-clf 60 will train all classifiers \\\n listed in config file under classifier_lists \\\n using data from last 60 days and then test it \\\n and display metrics')\n\n parser.add_argument('-v', '--osp-version', dest='version', type=str,\n default=None,\n help='-v 11-tripleo only returns hits for that \\\n OpenStack version, \\\n only supported by summary right now')\n\n parser.add_argument('-c', '--config', dest='config', type=str,\n default=pkg_resources.resource_filename('bml',\n \"config.yml\"),\n help='-c <config file path> use custom config file')\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=\"dem process\")\n parser.add_argument(\"--data_dir\", type=str, default=\"/home/dataset/DEM_data/\",\n help=\"path where the dataset is saved\")\n args_opt = parser.parse_args()\n return args_opt","def _parse_args(self):\n parser = argparse.ArgumentParser()\n _, args = parser.parse_known_args()\n self.args = [a for a in args if a != '']","def read_args(self):\n parser = argparse.ArgumentParser()\n parser.add_argument('--algorithm', '-a', default='onelayer',\n choices=['onelayer', 'randomforest', 'sos'],\n help='which algorithm to run')\n parser.add_argument('--format', '-f', default='pcap',\n choices=['netflow', 'pcap'],\n help='which format are the files to process in')\n parser.add_argument('--operation', '-o', default='eval',\n choices=['eval', 'train', 'test'],\n help='which operation to run')\n parser.add_argument('--sos_model', '-s', default='networkml/trained_models/sos/SoSmodel',\n help='path to SoSmodel')\n parser.add_argument('--trained_model', '-m', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\n help='path to the trained model file')\n parser.add_argument('--path', '-p', default='/pcaps',\n help='path to file or directory of files to process')\n parser.add_argument('--save', '-w', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\n help='path to save the trained model, if training')\n\n self.args = parser.parse_args()\n return","def parse_commandline():\n parser = optparse.OptionParser(usage = __doc__,version=git_version.verbose_msg)\n\n parser.add_option(\"-t\", \"--timeFile\",help=\"Text file with central times.\",default = 'centralTimes.txt')\n\tparser.add_option(\"-c\", \"--channel\",help=\"IFO channel.\",default = 'L1:GDS-CALIB_STRAIN')\n\tparser.add_option(\"-w\", \"--workdirectory\",help=\"Working directory.\",default = '.')\n\tparser.add_option(\"-s\", \"--sourceDir\",help=\"Name of source directory.\",default = 'source')\n\n opts, args = parser.parse_args()\n return opts","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()","def parse_command_line() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'pet_database',\n type=str,\n help='path to pet database'\n )\n parser.add_argument(\n '--image_dir',\n default='data/images'\n )\n parser.add_argument(\n '--log',\n default=None,\n help='log file path'\n )\n\n args = parser.parse_args()\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\n return args","def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser(prog='scoring')\n parser.add_argument(\"pdb_list\", help=\"list of PDB structures\")\n script_args = parser.parse_args()\n return script_args","def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n def getValueOfArgument(): return next(iterator)\n self.parseArgument(argument[2:], getValueOfArgument)","def parse_args():\n parser = argparse.ArgumentParser(description=\"Hyper parameter\")\n parser.add_argument(\n \"--model\", help=\"Model to use\", default=\"All\", type=str)\n return parser.parse_args()","def parse_args():\n parser = ArgumentParser(\n description=\"This is a script for auto apply ipex optimization.\"\n \"\\n################################# Basic usage ############################# \\n\"\n \"\\n 1. Apply ipex optimization with fp32 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\n\"\n \"\\n 2. Apply ipex optimization with bf16 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\n\",\n formatter_class=RawTextHelpFormatter,\n )\n\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\n\n # positional\n parser.add_argument(\n \"program\",\n type=str,\n help=\"The full path to the proram/script to be launched. \"\n \"followed by all the arguments for the script\",\n )\n # rest from the training program\n parser.add_argument(\"program_args\", nargs=REMAINDER)\n return parser.parse_args()","def ParseCommandLineArgs(argv):\n global VERBOSE, COMPILE_MODE, RUN_MODE, TMP_PREFIX\n global CFG, APPEND, SHOW_CONSOLE, CHECK_EXCLUDES, CONCURRENCY\n try:\n opts, args = getopt.getopt(argv[1:], '',\n ['verbose',\n 'show_console',\n 'append=',\n 'append_file=',\n 'config=',\n 'exclude=',\n 'check_excludes',\n 'tmp=',\n 'concurrency='])\n except getopt.GetoptError as err:\n Print(str(err)) # will print something like 'option -a not recognized'\n sys.exit(-1)\n\n for o, a in opts:\n # strip the leading '--'\n o = o[2:]\n if o == 'verbose':\n VERBOSE = 1\n elif o == 'show_console':\n SHOW_CONSOLE = 1\n elif o == 'check_excludes':\n CHECK_EXCLUDES = 1\n elif o == 'tmp':\n TMP_PREFIX = a\n elif o == 'exclude':\n # Parsing of exclude files must happen after we know the current config\n EXCLUDE_FILES.append(a)\n elif o == 'append':\n tag, value = a.split(\":\", 1)\n APPEND.append((tag, value))\n elif o == 'append_file':\n APPEND_FILES.append(a)\n elif o == 'config':\n CFG = a\n elif o == 'concurrency':\n CONCURRENCY = int(a)\n else:\n Print('ERROR: bad commandline arg: %s' % o)\n sys.exit(-1)\n # return the unprocessed options, i.e. the command\n return args","def _parse_args():\n parser = optparse.OptionParser(usage=\"%prog imagefile+number.suffix\", description=\"Opens up a sequence of pictures in a web browser.\")\n\n return parser.parse_args()"],"string":"[\n \"def parse_arguments(args):\",\n \"def parse_command_line():\\r\\n\\r\\n parser = argparse.ArgumentParser(description='User args')\\r\\n parser.add_argument(\\\"--action\\\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\\\"Choose action.\\\")\\r\\n parser.add_argument(\\\"--model\\\", choices=['vgg', 'unet', 'fpn'], required=True, help=\\\"Choose model.\\\")\\r\\n parser.add_argument(\\\"--dataset\\\", choices=['full', 'small'], required=True, help=\\\"Choose dataset.\\\")\\r\\n\\r\\n return parser.parse_args()\",\n \"def _parse_args():\\n args = sys.argv[1:]\\n cmd_parser = argparse.ArgumentParser()\\n cmd_parser.add_argument(\\n '--produce-sub',\\n dest='produce_sub',\\n help='Produce submision file',\\n default=False,\\n action='store_true',\\n )\\n cmd_parser.add_argument(\\n '--search-cv',\\n dest='search_cv',\\n help='Perform Search of parameters',\\n default=False,\\n action='store_true',\\n )\\n cmd_opts = cmd_parser.parse_args(args=args)\\n return cmd_opts\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\\\")\\n parser.add_argument(\\\"--visualization\\\", \\\"-v\\\", action=\\\"store_true\\\", help=\\\"if generated clouds should be visualized\\\")\\n parser.add_argument(\\\"--directory\\\", \\\"-d\\\",\\n help=\\\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\\\")\\n args = parser.parse_args()\\n return args.visualization, args.directory\",\n \"def parse_command_line(self, argv):\\n from optparse import OptionParser\\n usage = \\\"usage: %prog [options]\\\"\\n parser = OptionParser(usage)\\n\\n (options, args) = parser.parse_args(argv)\",\n \"def parse_command_line_arguments(argv):\\n print(\\\"reading command line arguments in...\\\")\\n\\n parser = argparse.ArgumentParser(description='Description of your program')\\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\\n args = parser.parse_args()\\n\\n return args.input, args.predicting, args.scoring, args.scale\",\n \"def __parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-f', '--force', action=\\\"store_true\\\", default=False,\\n help='overwrite existing database files during import')\\n parser.add_argument('-e', '--extension', action=\\\"store\\\", default='txt',\\n help='specify file extension. default is \\\"txt\\\"')\\n parser.add_argument('-d', '--delimiter', action=\\\"store\\\", default='\\\\t',\\n help='specify column delimiter. default is tab (\\\\\\\\t)')\\n parser.add_argument('-m', '--mark', action=\\\"store\\\", default='.',\\n help='specify decimal mark for numeric data. default is'\\n ' dot (.)')\\n parser.add_argument('-o', '--outformat', action=\\\"store\\\", default='npz',\\n help='specify output database format. default is \\\"npz\\\"'\\n ' for numpy database. use \\\"mat\\\" for matlab '\\n ' database format.')\\n parser.add_argument('-r', '--recursive', action=\\\"store_true\\\", default=False,\\n help='recursively walk through all sub-directories of'\\n ' current working directory')\\n parser.add_argument('-p', '--pcs', action=\\\"store_true\\\", default=True,\\n help='indicate if files are pcs files.')\\n parser.add_argument('-c', '--colheadlines', action=\\\"store\\\", default='1',\\n help='number of lines spanned by the column headers')\\n args = parser.parse_args()\\n return args\",\n \"def _parse_args():\\n parser = optparse.OptionParser(usage=\\\"\\\", description=\\\"\\\")\\n parser.add_option(\\\"-o\\\", dest=\\\"outfile\\\", default=None, help=\\\"File to write to\\\")\\n parser.add_option(\\\"-w\\\", dest=\\\"write_format\\\", default=\\\"pidgin\\\", help=\\\"Write format. [default: %default]\\\")\\n parser.add_option(\\\"-r\\\", dest=\\\"read_format\\\", default=\\\"adium\\\", help=\\\"Read format. [default: %default]\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = default_argument_parser()\\n parser.add_argument(\\\"--label-map\\\",\\n dest=\\\"label_map\\\",\\n type=pathlib.Path,\\n help=\\\"Label map in YAML format which maps from category \\\"\\n \\\"ID to name.\\\")\\n parser.add_argument(\\\"--train-csv\\\",\\n dest=\\\"train_csv\\\",\\n required=True,\\n type=pathlib.Path,\\n help=\\\"Path to training data CSV file.\\\")\\n parser.add_argument(\\\"--valid-csv\\\",\\n dest=\\\"valid_csv\\\",\\n required=False,\\n type=pathlib.Path,\\n help=\\\"Optional path to validation data CSV file.\\\")\\n parser.add_argument(\\n \\\"--image-width\\\",\\n type=int,\\n help=\\\"Image width (optional, used to speed up dataset processing).\\\")\\n parser.add_argument(\\n \\\"--image-height\\\",\\n type=int,\\n help=\\\"Image height (optional, used to speed up dataset processing).\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = OptionParser()\\n parser.add_option('--data-file', '-f', default='train_data.hdf5',\\n help=\\\"The path to the data file\\\")\\n parser.add_option('--runs-per-epoch', '-r', type='int',\\n help=\\\"The number of runs per epoch (train samples count)\\\")\\n parser.add_option('--avg-window-size', '-w', default='1', type='int',\\n help=\\\"The window size for moving average\\\")\\n\\n (options, args) = parser.parse_args()\\n return options\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Bandits algorithms on a click-through \\\"\\n \\\"rate dataset.\\\")\\n parser.add_argument('--plot', action='store_true')\\n return parser.parse_args()\",\n \"def parse_options():\\n global parser\\n parser.add_option(\\\"-r\\\", \\\"--regions\\\", dest=\\\"input_brain_regions\\\",\\n help=\\\"Input file for brain region data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-g\\\", \\\"--gray\\\", dest=\\\"input_gray_levels\\\",\\n help=\\\"Input file for gray level data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-n\\\", \\\"--nissl\\\", dest=\\\"input_nissl\\\",\\n help=\\\"Input file for nissl data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-o\\\", \\\"--output\\\", dest=\\\"output_folder_path\\\",\\n help=\\\"Output folder for extracted data files\\\",\\n action=\\\"store\\\", type='string')\\n\\n return parser.parse_args()\",\n \"def _parse_command_line_arguments():\\n parser = ArgumentParser(\\n description=(\\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\\n ),\\n )\\n parser.add_argument(\\n 'ts-file',\\n type=str,\\n help=(\\n 'A file containing the TS sky map'\\n ),\\n )\\n parser.add_argument('--skiprows',\\n type=int,\\n help='number of rows to skip at the top (default 0)',\\n required=False)\\n parser.set_defaults(skiprows=0)\\n arguments = vars(parser.parse_args())\\n return arguments\",\n \"def parse_command_line():\\n\\n parser=OptionParser(usage=\\\"%prog [options] \\\",\\n description=\\\" updates tracker\\\" )\\n parser.add_option(\\\"-c\\\", \\\"--candidate\\\", action=\\\"store\\\", type=\\\"string\\\",\\n dest=\\\"candidate\\\", default=\\\"\\\", help=\\\"candidate name\\\")\\n parser.add_option(\\\"-u\\\", \\\"--username\\\", action=\\\"store\\\", type=\\\"string\\\",\\n dest=\\\"username\\\", default=\\\"gzhou\\\",\\n help=\\\"username\\\")\\n parser.add_option(\\\"-p\\\",\\\"--password\\\", action=\\\"store\\\",\\n dest=\\\"password\\\", default=\\\"egghead\\\", help=\\\"password\\\")\\n parser.add_option(\\\"-i\\\",\\\"--input\\\", action=\\\"store\\\",\\n dest=\\\"input\\\", default=\\\"tracker_temp.txt\\\", help=\\\"Input file\\\") \\n parser.add_option(\\\"-l\\\",\\\"--upload\\\", action=\\\"store\\\",\\n dest=\\\"upload\\\", default=None, help=\\\"upload file\\\") \\n parser.add_option(\\\"-d\\\",\\\"--description\\\", action=\\\"store\\\",\\n dest=\\\"description\\\", default=None, help=\\\"descirption\\\") \\n (options, args)=parser.parse_args()\\n\\n return options, args\",\n \"def parse_cmdline():\\n\\tparser = ArgumentParser(prog=\\\"FastP_QC.py\\\", description=\\\"\\\"\\\"Script collects stats from fastp jsons.\\\"\\\"\\\")\\n\\tparser.add_argument(\\\"-r1\\\", \\\"--r1_stats\\\", dest=\\\"r1_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r1 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-r2\\\", \\\"--r2_stats\\\", dest=\\\"r2_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r2 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-n\\\", \\\"--name\\\", dest=\\\"name\\\", action=\\\"store\\\", required=True, help=\\\"Sample name\\\")\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def __parse_args(self):\\n for argument in self.args:\\n source_arg = re.match(\\\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n input_arg = re.match(\\\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n stats_arg = re.match(\\\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n help_arg = re.match(\\\"^--help$\\\", argument)\\n vars_arg = re.match(\\\"^--vars$\\\", argument)\\n insts_arg = re.match(\\\"^--insts$\\\", argument)\\n if source_arg:\\n self.sourceFile = source_arg.group(2)\\n self.passedArgs.append(\\\"source\\\")\\n elif input_arg:\\n self.inputFile = input_arg.group(2)\\n self.passedArgs.append(\\\"input\\\")\\n elif help_arg:\\n print(\\\"napoveda\\\")\\n sys.exit(0)\\n elif stats_arg:\\n self.statsFile = stats_arg.group(2)\\n self.passedArgs.append(\\\"stats\\\")\\n elif vars_arg:\\n self.passedArgs.append(\\\"vars\\\")\\n if self.first_stat_arg is None:\\n self.first_stat_arg = \\\"vars\\\"\\n elif insts_arg:\\n self.passedArgs.append(\\\"insts\\\")\\n if self.first_stat_arg is None:\\n self.first_stat_arg = \\\"insts\\\"\\n else:\\n raise ArgError(\\\"Unknown argument or format of the argument! (\\\" + argument + \\\")\\\")\",\n \"def handle_cmdline_args():\\n\\n parser = argparse.ArgumentParser(\\n description='Generate synthetic data from a specification in a json '\\n 'file using the \\\"synth-method\\\" described in the json file. ')\\n\\n parser.add_argument(\\n '-i', dest='infile', required=True,\\n help='The input json file. Must contain a \\\"synth-method\\\" property')\\n\\n parser.add_argument(\\n '-o', dest='outfile_prefix', required=True, help='The prefix of the output paths (data json and csv), relative to the QUIPP-pipeline root directory')\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_cmdline_args():\\n parser = argparse.ArgumentParser(description=\\\"Guesses the functional element for host.\\\")\\n ##\\n ## Internal options\\n ##\\n parser.add_argument(\\\"--json\\\", dest=\\\"json\\\", action='store_true', help=\\\"output in JSON\\\")\\n\\n ##\\n ## PuppetDB options\\n ##\\n pdbconf = PdbConfig()\\n pdbconf.add_standard_args(parser)\\n\\n parser.add_argument(\\\"host\\\", metavar=\\\"HOST\\\",\\n help=\\\"hostnames to query for FE\\\")\\n\\n return parser.parse_args()\",\n \"def parseArgs():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dataset', default='fsod', help='training dataset') # use fsod dataset for default\\n parser.add_argument('--cfg', dest='cfg_file', required=True, help='optional config file')\\n parser.add_argument('--load_ckpt', help='path to load checkpoint')\\n parser.add_argument('--load_detectron', help='path to load detectron weight pickle file')\\n parser.add_argument('--output_dir', help='output directory to save the testing results.')\\n parser.add_argument('--range', help='[start, end)', type=int, nargs=2)\\n parser.add_argument('--visualize', dest='visualize', help='output images of detection', action='store_true')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"CUDAPOA Python API sample program.\\\")\\n parser.add_argument('-m',\\n help=\\\"Run MSA generation. By default consensusis generated.\\\",\\n action='store_true')\\n parser.add_argument('-p',\\n help=\\\"Print output MSA or consensus for each POA group.\\\",\\n action='store_true')\\n parser.add_argument('-l',\\n help=\\\"Use long or short read sample data.\\\",\\n action='store_true')\\n return parser.parse_args()\",\n \"def parse_args(self, args):\\n (options, args) = optparse.OptionParser.parse_args(self, args)\\n return options\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"SLOWFAST for AVA Dataset\\\")\\n parser.add_argument(\\\"--pipeline\\\", type=str,\\n default=\\\"../data/config/slowfast.pipeline\\\", help=\\\"SDK infer pipeline\\\")\\n parser.add_argument(\\\"--data_dir\\\", type=str, default=\\\"../data/input\\\",\\n help=\\\"Dataset contain frames and ava_annotations\\\")\\n args_opt = parser.parse_args()\\n return args_opt\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n help_str = \\\\\\n 'The collection folder to sort files into. ' \\\\\\n 'If the folder does not exist, it will be created along with the ' \\\\\\n 'necessary contents.'\\n parser.add_argument('-c', '--collection', help=help_str)\\n\\n help_str = \\\\\\n 'The source folder to import files from. Has to exist and ' \\\\\\n 'has to be a folder.'\\n parser.add_argument('-s', '--source', help=help_str, required=False)\\n\\n help_str = \\\\\\n 'View the gallery in random order auto skpping after the' \\\\\\n 'given amount of seconds'\\n parser.add_argument('-v', '--view', help=help_str, required=False)\\n\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # All reference encoders\\n parser.add_argument(\\\"--step\\\", dest=\\\"step\\\", default=\\\"10\\\", type=int, help=\\\"step size\\\")\\n parser.add_argument(\\\"--repeats\\\", dest=\\\"repeats\\\", type=int, default=1, help=\\\"repeats\\\")\\n\\n parser.add_argument(dest=\\\"image\\\", default=None,\\n help=\\\"select the test image to run\\\")\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input_path\\\", required=True)\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\", required=True)\\n return parser.parse_args()\",\n \"def _parse_args():\\n usage = \\\"usage: %prog [options] arg1 arg2\\\"\\n parser = optparse.OptionParser()\\n parser.add_option(\\n '--platform', dest='platform', default=\\\"\\\", type = \\\"string\\\",\\n help='platform name: UC 360 baidu etc.')\\n parser.add_option(\\n '--workspace', dest='workspace', default=\\\"./\\\", type = \\\"string\\\",\\n help='project directory.')\\n parser.add_option(\\n '--project', dest='projectDir', default=\\\"./destProject\\\", type = \\\"string\\\",\\n help='project directory.')\\n # parser.add_option(\\n # \\\"-t\\\", dest=\\\"test\\\", action=\\\"store_const\\\", const=lambda:_test, default=_test2, help=\\\"////////////\\\"\\n # )\\n options, args = parser.parse_args()\\n # positional arguments are ignored\\n return options, args\",\n \"def _parseArgs():\\n # HINT: If you consider adding an option,\\n # please consider adding a config file option first.\\n parser = ArgumentParser(description=STRING_USAGE_DESCRIPTION,\\n epilog=STRING_USAGE_EPILOG)\\n parser.add_argument('--version', action='version',\\n version='%(prog)s (' + VERSIONSTRING + ')')\\n parser.add_argument('-c', '--configfile', action='store',\\n dest='configfile',\\n default=DEFAULT_CONFIGFILE,\\n help=STRING_USAGE_CONFIGFILE)\\n parser.add_argument('-e', '--editconfig', action='store_true',\\n dest='invoke_editconfig',\\n default=False,\\n help=STRING_USAGE_EDITCONFIG)\\n parser.add_argument('--defaultconfig', action='store_true',\\n dest='invoke_defaultconfig',\\n default=False,\\n help=STRING_USAGE_DEFAULTCONFIG)\\n parser.add_argument('--printconfig', action='store_true',\\n dest='invoke_printconfig',\\n default=False,\\n help=STRING_USAGE_PRINTCONFIG)\\n _addOverwriteBool(parser, 'gui', 'gui', 'enable')\\n parser.add_argument('-s', '--sources', section='wesen',\\n dest='sources',\\n action=_OverwriteConfigAction)\\n parser.add_argument('-r', '--resume',\\n dest='resume', action='store_true',\\n default=False, help=STRING_USAGE_RESUME)\\n return parser.parse_known_args()\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\")\\n #parser.add_argument(\\\"args\\\", metavar=\\\"N\\\", type=str, nargs=\\\"*\\\", help=\\\"Positional arguments.\\\")\\n #parser.add_argument(\\\"\\\", dest=\\\"\\\", type=\\\"\\\", default=, help=)\\n #parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version=\\\"<the version>\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--input-model\\\", help=\\\"Path to read input model from\\\")\\n options = parser.parse_args()\\n return options\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='Disk metric sender')\\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\\n\\n return parser.parse_args()\",\n \"def parse_cmd_arguments():\\n parser = argparse.ArgumentParser(description='Process some integers.')\\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\\n parser.add_argument('-o', '--output', required=True,\\n help='ouput JSON file')\\n parser.add_argument('-d', '--debug', required=False,\\n help='log level. Can be 0-3. Defaults to 0')\\n\\n return parser.parse_args()\",\n \"def parse_cmdline(args):\\n usage = \\\"usage: %prog [options] <name> <snpfile> <human asm build No> \\\" +\\\\\\n \\\"<database>\\\"\\n parser = OptionParser(usage)\\n parser.add_option(\\\"-v\\\", \\\"--verbose\\\", dest=\\\"verbose\\\",\\n action=\\\"store_true\\\", default=False,\\n help=\\\"Give verbose output\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n\\tparser = argparse.ArgumentParser(description='Show video statistics.')\\n\\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\\n\\t default='views',\\n\\t help='sort by the specified field. Options are views, likes and dislikes.')\\n\\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\\n\\tparser.add_argument('--csv', action='store_true', default=False,\\n\\t help='output the data in CSV format.')\\n\\tparser.add_argument('--table', action='store_true', default=False,\\n\\t help='output the data in an ascii table.')\\n\\tparser.add_argument('--workers', type=int, default=8,\\n\\t help='number of workers to use, 8 by default.')\\n\\treturn parser.parse_args()\",\n \"def parse_cli():\\n parser = OptionParser()\\n return parser.parse_args()\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\\n default='/tmp')\\n return ap.parse_args()\",\n \"def parseArgs():\\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\\n parser.add_argument('config', help='configuration file')\\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\\n parser.add_argument('-u', help='update database', action='store_true')\\n args = parser.parse_args()\\n return args.config, args.d, args.u\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"generate training data of apks\\\")\\n parser.add_argument(\\\"-i\\\", action=\\\"store\\\", dest=\\\"input_file\\\",\\n required=True, help=\\\"input json file to predict\\\")\\n parser.add_argument(\\\"-o\\\", action=\\\"store\\\", dest=\\\"output_file\\\",\\n required=True, help=\\\"file path to store predicted data\\\")\\n parser.add_argument(\\\"-server\\\", action=\\\"store\\\", dest=\\\"server_url\\\", default=\\\"http://localhost:5745\\\",\\n required=False, help=\\\"url of nice2predict server\\\")\\n options = parser.parse_args()\\n print options\\n return options\",\n \"def _parse_args(argv):\\n parser = make_parser()\\n args = parser.parse_args(argv)\\n LOGGER.setLevel(to_log_level(args.loglevel))\\n\\n if not args.inputs:\\n if args.list:\\n tlist = \\\", \\\".join(API.list_types())\\n _exit_with_output(\\\"Supported config types: \\\" + tlist)\\n elif args.env:\\n cnf = os.environ.copy()\\n _output_result(cnf, args.output, args.otype or \\\"json\\\", None, None)\\n sys.exit(0)\\n else:\\n parser.print_usage()\\n sys.exit(1)\\n\\n if args.validate and args.schema is None:\\n _exit_with_output(\\\"--validate option requires --scheme option\\\", 1)\\n\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\\n parser.add_argument('--prepare', action='store_true',\\n help='create the directories, prepare the vocabulary and embeddings')\\n parser.add_argument('--train', action='store_true',\\n help='train the model')\\n parser.add_argument('--generate', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gentest', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gpu', type=str, default='0',\\n help='specify gpu device')\\n\\n train_settings = parser.add_argument_group('train settings')\\n train_settings.add_argument('--optim', default='Adam',\\n help='optimizer type')\\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\\n help='learning rate')\\n train_settings.add_argument('--weight_decay', type=float, default=0,\\n help='weight decay')\\n train_settings.add_argument('--dropout', type=float, default=0,\\n help='dropout keep rate')\\n train_settings.add_argument('--batch_size', type=int, default=128,\\n help='train batch size')\\n train_settings.add_argument('--epochs', type=int, default=10,\\n help='train epochs')\\n\\n model_settings = parser.add_argument_group('model settings')\\n model_settings.add_argument('--embed_size', type=int, default=128,\\n help='size of the embeddings')\\n model_settings.add_argument('--hidden_size', type=int, default=256,\\n help='size of LSTM hidden units')\\n model_settings.add_argument('--max_seq_len', type=int, default=50,\\n help='max passage num in one sample')\\n model_settings.add_argument('--max_gen_len', type=int, default=50,\\n help='max length of passage')\\n\\n path_settings = parser.add_argument_group('path settings')\\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\\n help='the dir to save vocabulary')\\n path_settings.add_argument('--model_dir', default='../data/models/',\\n help='the dir to store models')\\n path_settings.add_argument('--result_dir', default='../data/results/',\\n help='the dir to output the results')\\n path_settings.add_argument('--summary_dir', default='../data/summary/',\\n help='the dir to write tensorboard summary')\\n path_settings.add_argument('--log_path',\\n help='path of the log file. If not set, logs are printed to console')\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = ArgumentParser()\\n\\n # For development/testing\\n parser.add_argument(\\\"--dev\\\", help=\\\"run the code of the developers tag\\\")\\n\\n return parser.parse_args()\",\n \"def parse_arguments(self,parser):\\r\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter\\n )\\n parser.add_argument(\\n '-i', '--infile', type=is_valid_file, action=FullPaths,\\n metavar='FILE', required=True, help='''Settings file'''\\n )\\n parser.add_argument(\\n '-d', '--ddc_file', type=is_valid_file, action=FullPaths,\\n metavar='FILE', default='ddc2_nios2_sw.elf',\\n help='''DDC2 download file'''\\n )\\n parser.add_argument(\\n '-t', '--time', type=int, metavar='INT', default=5,\\n help='''Number of seconds to run DDC2'''\\n )\\n parser.add_argument(\\n '-o', '--outfile', type=str, default='./data/test/test',\\n metavar='FILE', required=False,\\n help='''Output location of data (no need to include file extension)'''\\n )\\n parser.add_argument(\\n '--live', action='store_true', default=False,\\n help='''Live visualisation'''\\n )\\n parser.add_argument(\\n '-v', '--verbose', action='store_true', default=False,\\n help='''Verbose'''\\n )\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--version',\\n metavar=\\\"<str>\\\",\\n help=\\\"Input data version number\\\",\\n type=str,\\n required=True\\n )\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=_program_description)\\n parser.add_argument('input_file', help=_input_file_description)\\n #parser.add_argument('-v', '--verbose', action='store_true', \\n # default=False, help='show progress')\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = ArgumentParser()\\n parser.add_argument('-t', '--timer', action='store_true', \\\\\\n help='Time the first random generation')\\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\\n return parser.parse_args()\",\n \"def parseArguments():\\n # Create argument parser\\n parser = argparse.ArgumentParser()\\n\\n # Optional arguments\\n parser.add_argument(\\\"-t\\\", \\\"--test\\\", help=\\\"Optionally test algorithm on subsample of the data. Set to 1 for testing\\\", type=int, default=0)\\n\\n parser.add_argument(\\\"--cores\\\", help=\\\"Optimized code for a server with a lot of RAM, set to the number of available cores\\\", type=int, default=40)\\n\\n\\n # Print version\\n parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version='%(prog)s - Version 2.0') #version 1.0 is for the observations in June 2018\\n #version 1.1 contains the optimizations made after the june observations (mainly the switch to stackmags)\\n #version 1.2 changed sim class to NOT include the list of failed candidates (not qsos)\\n #... copied changes made to crossval version\\n #version 1.5 added check for duplicate quasars and remove them\\n #version 1.6 new simulated quasars (december)\\n ##-------------------\\n #version 2.0: combined training of classifier and regressor, streamlined input\\n #version 2.1: Tryied to updates excluded area to a little more than stripe 82 but decided not to keep it, so no change\\n\\n # Parse arguments\\n args = parser.parse_args()\\n\\n return args\",\n \"def Args(parser):\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Parse flags to configure the json parsing')\\n parser.add_argument(\\\"-f\\\", \\\"--format\\\", help=\\\"output format: (csv|tsv|json)\\\", choices=[\\\"csv\\\", \\\"tsv\\\", \\\"json\\\"],\\n default=\\\"tsv\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--parallelized\\\", help=\\\"save output in parallelized or single file format\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"-i\\\", \\\"--input\\\", help=\\\"folder where input documents are\\\", default=\\\"data\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--output\\\", help=\\\"folder where output documents are\\\", default=\\\"cleaned\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--documentformat\\\", help=\\\"combine all features into a single text per post\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"-pa\\\", \\\"--partitions\\\", help=\\\"number of spark partitions\\\",\\n default=1)\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n\\tparser = argparse.ArgumentParser(description=\\\"comparing proguard-generated and predict mappings\\\")\\n\\tparser.add_argument(\\\"--proguard\\\", action=\\\"store\\\", dest=\\\"proguard_mappings_dir\\\",\\n\\t\\t\\t\\t\\t\\trequired=True, help=\\\"directory of proguard-generated mappings file\\\")\\n\\tparser.add_argument(\\\"--predict\\\", action=\\\"store\\\", dest=\\\"predict_mappings_dir\\\",\\n\\t\\t\\t\\t\\t\\trequired=True, help=\\\"directory of predict mappings file\\\")\\n\\tparser.add_argument(\\\"-o\\\", action=\\\"store\\\", dest=\\\"report_path\\\",\\n\\t\\t\\t\\t\\t\\trequired=True, help=\\\"directory of report file\\\")\\n\\n\\toptions = parser.parse_args()\\n\\tprint options\\n\\treturn options\",\n \"def readArgs():\\n parser = argparse.ArgumentParser(description=\\n \\\"\\\"\\\"Debug script. This program is used in order to generate a summary\\n statistics for the csv files generated by the annotation_parser. Things\\n like the average amount of overlap of each window and the average deviation.\\n \\\"\\\"\\\")\\n\\n parser.add_argument('-f', '--csv-dir', metavar='',\\n dest='csv_dir',\\n action='store', default=os.path.dirname(os.path.abspath(__file__)),\\n help='Specify the csv directory.')\\n parser.add_argument('-d', '--deviation', metavar='',\\n dest='deviation', action='store',\\n default=50,\\n help='percentage set point from which evaluate the deviation from.')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Hyper parameter\\\")\\n parser.add_argument(\\n \\\"--model\\\", help=\\\"Model to use\\\", default=\\\"DenseNet169\\\", type=str)\\n parser.add_argument(\\n \\\"--optimizer\\\", help=\\\"which optimizer to use\\\", default=\\\"Adam\\\", type=str)\\n parser.add_argument(\\n \\\"--lr\\\", help=\\\"learning rate\\\", default=2e-5, type=float)\\n\\n return parser.parse_args()\",\n \"def __parse_cmd_args():\\n parser = argparse.ArgumentParser(description='Python Image Downloader.')\\n parser.add_argument(\\\"-f\\\", \\\"--file\\\",\\n help=\\\"Where the URL file is located.\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--dir\\\",\\n help=\\\"Where the downloaded files are to be stored.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-t\\\", \\\"--thoughtspot_host\\\", required=True,\\n help=\\\"domain or ip. E.g. http://1.1.1.1\\\")\\n parser.add_argument(\\\"-u\\\", \\\"--username\\\", required=True,\\n help=\\\"username - must have administrative privileges\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--password\\\", required=True,\\n help=\\\"password - must have administrative privileges\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--delimiter\\\", default=',',\\n help=\\\"character to seperate values by. Default to comma\\\")\\n parser.add_argument(\\\"-c\\\", \\\"--csv\\\", action=\\\"store_true\\\",\\n help=\\\"create csv file called permissions.csv\\\")\\n parser.add_argument(\\\"-s\\\", \\\"--share\\\", action=\\\"store_true\\\",\\n help=\\\"output usable format for share api\\\")\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\\"img\\\", type=argparse.FileType(\\\"r\\\"),\\n help=\\\"The image file to test\\\")\\n\\n encoders = [\\\"sse2\\\", \\\"sse4.1\\\", \\\"avx2\\\"]\\n parser.add_argument(\\\"--encoder\\\", dest=\\\"encoder\\\", default=\\\"avx2\\\",\\n choices=encoders, help=\\\"select encoder variant\\\")\\n\\n testquant = [str(x) for x in range (0, 101, 10)]\\n testqual = [\\\"-fastest\\\", \\\"-fast\\\", \\\"-medium\\\", \\\"-thorough\\\", \\\"-exhaustive\\\"]\\n qualities = testqual + testquant\\n parser.add_argument(\\\"--test-quality\\\", dest=\\\"quality\\\", default=\\\"medium\\\",\\n choices=qualities, help=\\\"select compression quality\\\")\\n\\n parser.add_argument(\\\"--no-startup\\\", dest=\\\"noStartup\\\", default=False,\\n action=\\\"store_true\\\", help=\\\"Exclude init\\\")\\n\\n args = parser.parse_args()\\n\\n return args\",\n \"def handleCmdLine(self):\\n description = \\\"Nagios monitoring script to check for open ports\\\\n\\\"\\n usage = (\\\"%prog <options>\\\\n\\\")\\n parser = OptionParser(usage=usage, description=description)\\n\\n parser.add_option(\\\"-c\\\", \\\"--config\\\",\\n type=\\\"string\\\",\\n help=\\\"path to open ports configuration file\\\")\\n parser.add_option(\\\"-l\\\", \\\"--list\\\",\\n type=\\\"string\\\",\\n help=\\\"supply list of allowed ports seperated by comma.\\\")\\n\\n (self.options, args) = parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Run NCF..\\\")\\n parser.add_argument(\\n \\\"--config_file\\\",\\n nargs=\\\"?\\\",\\n type=str,\\n default=\\\"../configs/ncf_default.json\\\",\\n help=\\\"Specify the config file name. Only accept a file from ../configs/\\\",\\n )\\n # If the following settings are specified with command line,\\n # These settings will used to update the parameters received from the config file.\\n parser.add_argument(\\n \\\"--dataset\\\",\\n nargs=\\\"?\\\",\\n type=str,\\n help=\\\"Options are: tafeng, dunnhunmby and instacart\\\",\\n )\\n parser.add_argument(\\n \\\"--data_split\\\",\\n nargs=\\\"?\\\",\\n type=str,\\n help=\\\"Options are: leave_one_out and temporal\\\",\\n )\\n parser.add_argument(\\n \\\"--root_dir\\\", nargs=\\\"?\\\", type=str, help=\\\"working directory\\\",\\n )\\n parser.add_argument(\\n \\\"--emb_dim\\\", nargs=\\\"?\\\", type=int, help=\\\"Dimension of the embedding.\\\"\\n )\\n parser.add_argument(\\\"--lr\\\", nargs=\\\"?\\\", type=float, help=\\\"Intial learning rate.\\\")\\n parser.add_argument(\\\"--max_epoch\\\", nargs=\\\"?\\\", type=int, help=\\\"Number of max epoch.\\\")\\n parser.add_argument(\\n \\\"--batch_size\\\", nargs=\\\"?\\\", type=int, help=\\\"Batch size for training.\\\"\\n )\\n parser.add_argument(\\\"--optimizer\\\", nargs=\\\"?\\\", type=str, help=\\\"OPTI\\\")\\n parser.add_argument(\\\"--activator\\\", nargs=\\\"?\\\", type=str, help=\\\"activator\\\")\\n parser.add_argument(\\\"--alpha\\\", nargs=\\\"?\\\", type=float, help=\\\"ALPHA\\\")\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description='Scraper')\\n parser.add_argument('--prefix', help='Prefix for saving files', default=\\\"\\\")\\n parser.add_argument('--path', help='Dir path', default=\\\"\\\")\\n parser.add_argument('--urls_path', help='Url path', default=False)\\n parser.add_argument('--url', help='Url', default=False)\\n parser.add_argument('--disney', dest='disney', action='store_true', help=\\\"Choose all disney movies\\\")\\n parser.add_argument('--ngram', help='Max ngram', default=2)\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Re-ID feature extractor\\\")\\n parser.add_argument(\\n \\\"--model\\\",\\n default=\\\"resources/networks/mars-small128.ckpt-68577\\\",\\n help=\\\"Path to checkpoint file\\\")\\n parser.add_argument(\\n \\\"--loss_mode\\\", default=\\\"cosine\\\", help=\\\"Network loss training mode\\\")\\n parser.add_argument(\\n \\\"--mot_dir\\\", help=\\\"Path to MOTChallenge directory (train or test)\\\",\\n required=True)\\n parser.add_argument(\\n \\\"--detection_dir\\\", help=\\\"Path to custom detections. Defaults to \\\"\\n \\\"standard MOT detections Directory structure should be the default \\\"\\n \\\"MOTChallenge structure: [sequence]/det/det.txt\\\", default=None)\\n parser.add_argument(\\n \\\"--output_dir\\\", help=\\\"Output directory. Will be created if it does not\\\"\\n \\\" exist.\\\", default=\\\"detections\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n global flag_num_classes, flag_num_instances\\n\\n try:\\n optlist, args = getopt.getopt(sys.argv[1:], \\\"dc:I:\\\")\\n except getopt.GetoptError as err:\\n # unrecognized option\\n usage(str(err))\\n\\n if args:\\n usage(\\\"uknown extra args\\\")\\n for opt, arg in optlist:\\n if opt == \\\"-d\\\":\\n u.increment_verbosity()\\n elif opt == \\\"-c\\\":\\n flag_num_classes = int(arg)\\n elif opt == \\\"-I\\\":\\n flag_num_instances = int(arg)\",\n \"def parse_args():\\n sentinel_dict = {}\\n\\n def _preprocess_sysargv(argv):\\n inputs = []\\n for arg in argv[1:]:\\n # handles case where values contain --, otherwise they will\\n # be interpreted as arguments.\\n if '--,' in arg or ',--' in arg or arg == '--':\\n sentinel = uuid4().hex\\n key = '%s' % sentinel\\n sentinel_dict[key] = arg\\n inputs.append(sentinel)\\n else:\\n inputs.append(arg)\\n return inputs\\n\\n def _postprocess_sysargv(v):\\n if v in sentinel_dict:\\n return sentinel_dict.get(v)\\n else:\\n return v\\n\\n #----- read input arguments\\n for i, arg in enumerate(sys.argv):\\n if (arg[0] == '-') and arg[1].isdigit(): sys.argv[i] = ' ' + arg\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('-u', action='store_true', dest='helpmenu',help='extended HELP MENU with examples')\\n parser.add_argument('-i','--infile',action='store', dest='infile',help='name of file with SAC or mseed file(s)')\\n parser.add_argument('-g','--gain',action='store', dest='sensitivity',help='Stage 0 sensitivity')\\n parser.add_argument('-N','--net', action='store', dest='network',help='network')\\n parser.add_argument('-S','--sta', action='store', dest='station',help='station')\\n parser.add_argument('-C','--cha', action='store', dest='chantype',help='chantype')\\n parser.add_argument('-s','--start', action='store', dest='startstring',help='start time YYYY-MM-DDTHH:MM:SS')\\n parser.add_argument('-e','--end', action='store', dest='endstring',help='end time YYYY-MM-DDTHH:MM:SS')\\n parser.add_argument('-d','--duration', action='store', dest='durationinhours',help='duration in hours')\\n parser.add_argument('-dc','--dc','--datacenter', action='store', dest='datacenter',default='IRIS',help='FDSN data center (e.g. IRIS, SCEDC, NCEDC)')\\n parser.add_argument('-p','--plot',action='store_true',dest='iplot',help='make plots of each hourly trace (NOTE: can be slow)')\\n\\n helpextended = parser.parse_args(_preprocess_sysargv(sys.argv)).helpmenu\\n if ( helpextended is True ):\\n print ('')\\n print ('portable_pip_squeak: assess a station either using local data or to be downloaded')\\n print ('')\\n print ('Usage: portable_pip_squeak.py [options]')\\n print ('')\\n print ('EXAMPLES:')\\n print ('portable_pip_squeak.py --infile my_SAC_files.txt')\\n print ('portable_pip_squeak.py -N UW -S TKEY -C HH -s 2018-01-01T00:00:00 -d 2 -p')\\n print ('portable_pip_squeak.py -N CI -S LEO -C HN -s 2020-01-01T00:00:00 -d 24 -dc SCEDC')\\n print ('')\\n print ('Inputs if supplying your own data:')\\n print (' -i, --infile Name of text file with SAC/mseed file(s) of 3 (Z,N,E) traces.')\\n print (' -g, --gain Gain or Stage 0 sensitivity')\\n print (' ')\\n print ('Inputs if downloading data:')\\n print (' -s, --starttime Trace start time (YYYY-MM-DD,HH:MM:SS)')\\n print ('')\\n print (' One of these:')\\n print (' -e, --endtime Trace end time (YYYY-MM-DD,HH:MM:SS)')\\n print (' -d, --duration Duration in hours from starttime')\\n print (' Note: if duration is neg, starttime becomes endtime')\\n print (' N, S, C and a datacenter if other than IRIS')\\n print (' -N, --net Network code')\\n print (' -S, --sta Station code')\\n print (' -C, --cha Channel type, e.g. EN or HH')\\n print (' -dc, --datacenter Name of FDSN data center if not IRIS, e.g. SCEDC, NCEDC')\\n print (' ')\\n print ('Optional flags:')\\n print ('-P, --plot Flag to make a figure for each hour. Note: can be slow.')\\n print ('-u Print this extended help menu')\\n print ('')\\n\\n\\n return parser.parse_args(_preprocess_sysargv(sys.argv))\",\n \"def parse_command_line_args(args=None):\\n description = 'CodaNorm arguments that override default settings'\\n parser = argparse.ArgumentParser(description=description)\\n \\n # argument on which channel to calc\\n parser.add_argument(\\\"-c\\\", \\\"--channel\\\", help=\\\"Channel to use (N, E, Z).\\\", \\n choices=CHANNELS, nargs='+')\\n \\n # add option to calc with another coda window length\\n parser.add_argument(\\\"--sd\\\", type=int, default=0,\\n help=\\\"Specify length of Coda-window (in seconds)\\\")\\n \\n # maybe we want to plot anyway\\n parser.add_argument('--plot', help='Plot results', action='store_true')\\n \\n # change station\\n parser.add_argument(\\\"--station\\\", default=None,\\n help=\\\"Specify station to use\\\")\\n \\n # verbose mode\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", help=\\\"output verbosity\\\", \\n action=\\\"store_true\\\")\\n \\n args = parser.parse_args(args)\\n \\n return args\",\n \"def command_line_arguments():\\n\\n try:\\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\\n\\n # Add required arguments.\\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\\n\\n # Parse the arguments\\n args = parser.parse_args()\\n\\n return args\\n\\n except Exception as err:\\n print(err)\\n return\",\n \"def parse_args(args=None):\\n\\t\\treturn _get_args_parser().parse_args(args)\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=\\\"Arguments for data exploration\\\")\\n parser.add_argument(\\\"--tokenize\\\",\\n dest=\\\"tokenize\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Tokenize by words and sentences, counting averages/sd for each.\\\")\\n return parser\",\n \"def process_command_line_arguments() -> Namespace:\\n\\n parser = build_parser()\\n arguments = parser.parse_args()\\n\\n return arguments\",\n \"def parse_args():\\n \\n parser = argparse.ArgumentParser(description='COVID-19 Detection through Cough')\\n parser.add_argument('--run', type=str, default=RUN_NAME, help='run name')\\n parser.add_argument('--dataset', type=str, default=DATASET, help='dataset name for call W&B api')\\n parser.add_argument('--model', type=str, default=MODEL, help='init model')\\n parser.add_argument('--weight', type=str, default=None, help='path to pretrained weight')\\n parser.add_argument('--epoch', type=int, default=EPOCH, help='number of epoch')\\n parser.add_argument('--size', type=int, default=INPUT_SIZE, help='input size')\\n parser.add_argument('--lr', type=float, default=LR, help='learning rate')\\n parser.add_argument('--batch_size', type=int, default=BATCH_SIZE, help='size of each batch')\\n parser.add_argument('--num_worker', type=int, default=NUM_WORKER, help='how many subprocesses to use for data loading. (default = 0)')\\n \\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments(raw_args=sys.argv[1:]):\\n parser = optparse.OptionParser(\\n usage=\\\"usage: %prog [OPTIONS] DOMAIN_NAME DOMAIN_CONFIG_FILE\\\",\\n description=\\\"A tool for provisioning a Khan Academy CloudSearch \\\"\\n \\\"domain.\\\")\\n\\n parser.add_option(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, DEBUG messages will be printed and more \\\"\\n \\\"information will be printed with each log message.\\\")\\n\\n parser.add_option(\\\"--leave-temp-dir\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, the created temporary directory will not be \\\"\\n \\\"deleted when the script exits.\\\")\\n\\n parser.add_option(\\\"-n\\\", \\\"--dry-run\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, no commands will actually be executed.\\\")\\n\\n parser.add_option(\\\"--no-reindex\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, will only update the config, without reindexing.\\\")\\n\\n options, args = parser.parse_args(raw_args)\\n\\n if len(args) != 2:\\n parser.error(\\\"You must specify the name of the domain and a file \\\"\\n \\\"containing the domain configuration.\\\")\\n\\n return (options, args[0], args[1])\",\n \"def command_line_args(parser):\\n AbyssAssembler.command_line_args(parser)\\n SpadesAssembler.command_line_args(parser)\\n TrinityAssembler.command_line_args(parser)\\n VelvetAssembler.command_line_args(parser)\",\n \"def parse_args(args=None):\\n return AP.parse_args(args=args)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Extract left-turn speed data CSV files from Excel')\\n parser.add_argument('veh_conflict_data', type=str, help='Excel file with all veh conflicts data')\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\\n metavar='<application_name>')\\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\\n metavar='<fetch_interval in seconds>')\\n return parser.parse_args()\",\n \"def parse_command_line_arguments():\\n\\n description, epilog = __doc__.split(\\\"\\\\n\\\\n\\\", 1)\\n\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n description=description,\\n epilog=epilog)\\n\\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\\n help='Minimum frequency')\\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\\n default=\\\"./.tpass\\\",\\n help='File with Twitter credentials (username and password, separated by a space)')\\n\\n args = parser.parse_args()\\n \\n return args\",\n \"def _parser_options():\\n #We have two options: get some of the details from the config file,\\n import argparse\\n from pydft import base\\n pdescr = \\\"Numerical DFT code.\\\"\\n parser = argparse.ArgumentParser(parents=[base.bparser], description=pdescr)\\n for arg, options in script_options.items():\\n parser.add_argument(arg, **options)\\n \\n args = base.exhandler(examples, parser)\\n if args is None:\\n return\\n\\n return args # pragma: no cover\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='main.py')\\n \\n # General system running and configuration options\\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\\n\\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\\n \\n # Some common arguments for your convenience\\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\\n parser.add_argument('--lr', type=float, default=.001)\\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\\n # 65 is all you need for GeoQuery\\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\\n\\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\\n # 50-200 might be a good range to start with for embedding and LSTM sizes\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--zarr_dir',\\n type=str,\\n help='path to directory of zarr files',\\n )\\n parser.add_argument(\\n '--tiff_dir',\\n type=str,\\n help='path to directory of tiff files',\\n )\\n parser.add_argument(\\n '--output_dir',\\n type=str,\\n help='path to directory for writing',\\n )\\n parser.add_argument(\\n '--config_path',\\n type=str,\\n default=None,\\n help='path to yaml preprocess config file',\\n )\\n \\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--obs_len\\\",\\n default=20,\\n type=int,\\n help=\\\"Directory where the sequences (csv files) are saved\\\",\\n )\\n parser.add_argument(\\n \\\"--data_dir\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"Directory where the sequences (csv files) are saved\\\",\\n )\\n parser.add_argument(\\n \\\"--feature_dir\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"Directory where the computed features are saved\\\",\\n )\\n parser.add_argument(\\\"--mode\\\",\\n required=True,\\n type=str,\\n help=\\\"train/val/test/compute_all/lanes_only\\\")\\n parser.add_argument(\\n \\\"--sequence_num\\\",\\n default=-1,\\n type=int,\\n help=\\\"Specify a specific sequence to visualize.\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_start\\\",\\n default=0,\\n type=int,\\n help=\\\"Specify the starting row of features to visualize.\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_end\\\",\\n default=-1,\\n type=int,\\n help=\\\"Specify the last row to visualize, -1 to visualize till end.\\\",\\n )\\n parser.add_argument(\\n \\\"--single_figure\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"Plot all candidates for a scenein one figure.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse_args():\\n import argparse\\n\\n parser = argparse.ArgumentParser(description=\\\"Pilot kodi\\\")\\n parser.add_argument(\\\"--server\\\",\\\"-s\\\",metavar=\\\"SERVER\\\",required=True,help=\\\"Server to connect to\\\")\\n parser.add_argument(\\\"--port\\\",\\\"-p\\\",metavar=\\\"PORT\\\",default=8080,type=int,help=\\\"Port of the server\\\")\\n parser.add_argument(\\\"--get-audio\\\",action=\\\"store_true\\\",help=\\\"Get audio\\\")\\n parser.add_argument(\\\"--switch-audio\\\",action=\\\"store_true\\\",help=\\\"Switch Audio\\\")\\n parser.add_argument(\\\"--valid-audios\\\",metavar=\\\"SUBTITLE\\\",default=[\\\"fre\\\",\\\"eng\\\"],type=lambda p:p.split(\\\",\\\"),help=\\\"Valid audios\\\")\\n parser.add_argument(\\\"--get-subtitle\\\",action=\\\"store_true\\\",help=\\\"Get subtitle\\\")\\n parser.add_argument(\\\"--toggle-subtitle\\\",action=\\\"store_true\\\",help=\\\"Toggle subtitles\\\")\\n parser.add_argument(\\\"--switch-subtitles\\\",action=\\\"store_true\\\",help=\\\"Switch subtitles\\\")\\n parser.add_argument(\\\"--valid-subtitles\\\",metavar=\\\"SUBTITLE\\\",default=[\\\"fre\\\"],type=lambda p:p.split(\\\",\\\"),help=\\\"Valid subtitles\\\")\\n\\n return parser.parse_args()\",\n \"def _parse(self, args):\\r\\n\\r\\n ordered = []\\r\\n opt_full = dict()\\r\\n opt_abbrev = dict()\\r\\n\\r\\n args = args + [''] # Avoid out of range\\r\\n i = 0\\r\\n\\r\\n while i < len(args) - 1:\\r\\n arg = args[i]\\r\\n arg_next = args[i+1]\\r\\n if arg.startswith('--'):\\r\\n if arg_next.startswith('-'):\\r\\n raise ValueError('{} lacks value'.format(arg))\\r\\n else:\\r\\n opt_full[arg[2:]] = arg_next\\r\\n i += 2\\r\\n elif arg.startswith('-'):\\r\\n if arg_next.startswith('-'):\\r\\n raise ValueError('{} lacks value'.format(arg))\\r\\n else:\\r\\n opt_abbrev[arg[1:]] = arg_next\\r\\n i += 2\\r\\n else:\\r\\n ordered.append(arg)\\r\\n i += 1\\r\\n \\r\\n return ordered, opt_full, opt_abbrev\",\n \"def parse_args():\\r\\n parser = argparse.ArgumentParser(description=\\\"Available Options\\\")\\r\\n\\r\\n parser.add_argument('-i'\\r\\n ,'--input_path'\\r\\n ,dest='input_path'\\r\\n ,type=is_valid_path\\r\\n ,required=True\\r\\n ,help = \\\"Enter the path of the image file to process\\\")\\r\\n\\r\\n args = vars(parser.parse_args())\\r\\n\\r\\n #To Display The Command Line Arguments\\r\\n print(\\\"## Command Arguments #################################################\\\")\\r\\n print(\\\"\\\\n\\\".join(\\\"{}:{}\\\".format(i,j) for i,j in args.items()))\\r\\n print(\\\"######################################################################\\\")\\r\\n\\r\\n return args\",\n \"def parse_arguments(self):\\n \\n for arg in sys.argv[1:]:\\n (key, sep, value) = arg.partition(\\\"=\\\")\\n if sep != \\\"=\\\":\\n raise ProcessorError(\\\"Illegal argument '%s'\\\" % arg)\\n self.update_data(key, value)\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser()\\n\\n # Positional args\\n parser.add_argument('data_directory', action=\\\"store\\\")\\n\\n # Optional args\\n parser.add_argument('--save_dir', action='store',\\n dest='save_dir',\\n help='Load categories names from given file',\\n default=\\\"checkpoint.pth\\\")\\n\\n parser.add_argument('--gpu', action='store_true',\\n dest='device',\\n help='Device of prediction processing',\\n default=False)\\n\\n parser.add_argument('--arch', action='store',\\n dest='arch',\\n help='Name of pre-trained network used for training',\\n default=\\\"vgg11\\\")\\n\\n parser.add_argument('--learning_rate', action='store',\\n dest='learning_rate',\\n help='value of training learning rate',\\n default=0.001)\\n\\n parser.add_argument('--hidden_units', action='store',\\n dest='hidden_units',\\n help='Number of units in the fully-connected hidden '\\n 'layer of the neural netwrork',\\n default=512)\\n\\n parser.add_argument('--epochs', action='store',\\n dest='epochs',\\n help='Number of training epochs',\\n default=5)\\n\\n # Parse all args\\n results = parser.parse_args()\\n\\n return results\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser(\\n description=\\\"Convert dependency files into list of GitHub links.\\\",\\n epilog=\\\"For help with this program, contact John Speed at jmeyers@iqt.org.\\\",\\n )\\n parser.add_argument(\\n \\\"--python\\\",\\n default=False, # default value is False\\n help=\\\"Convert requirements.txt file into GitHub links.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('n_iter',\\n help='number of iteration',\\n type=int)\\n parser.add_argument('n_processes',\\n help='number of processes',\\n type=int)\\n parser.add_argument('method',\\n help='mutual exclusion method')\\n parser.add_argument('duration',\\n help='Duration of each process',\\n type=float)\\n return parser.parse_args()\",\n \"def parseArguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--output_folder',\\n help='Path of the folder where output files should be written.')\\n parser.add_argument('--partition_id',\\n help='ID of the computer partition to collect data from.')\\n parser.add_argument('--collector_db',\\n help='The path of slapos collect database.')\\n\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # Optional Argument\\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\\n return parser.parse_args()\",\n \"def _parse_args(self, argv):\\n\\n opts = optparse.OptionParser()\\n\\n opts.add_option(\\\"--data-path\\\",\\n default=\\\"nyt-ingredients-snapshot-2015.csv\\\",\\n help=\\\"(%default)\\\")\\n\\n (options, args) = opts.parse_args(argv)\\n return options\",\n \"def parse_args():\\n parser = MyParser(description='Data processing and analytics library \\\\\\n for OpenStack Browbeat perf data')\\n\\n parser.add_argument('-s', '--summary', dest=\\\"days\\\", type=int, default=-1,\\n help='-s N summary of last N days of results')\\n\\n parser.add_argument('--summary-uuid', dest=\\\"summary_uuid\\\", type=str,\\n default=None,\\n help='--summary-uuid UUID summary of a specific uuid')\\n\\n parser.add_argument('--short-summary', dest=\\\"short_days\\\", type=int,\\n default=-1,\\n help='--short-summary N gives \\\\\\n summary of last N days of results but uses cockroach \\\\\\n db so only provides with basic summary')\\n\\n parser.add_argument('--upload-timesummary', dest=\\\"timeseries_uuid\\\",\\n type=str, default=None,\\n help='--upload-timesummary UUID \\\\\\n uploads the features computed from data obtained from\\\\\\n graphite. ')\\n\\n parser.add_argument('--upload-logsummary', dest=\\\"loggin_uuid\\\",\\n type=str, default=None,\\n help='--upload-logsummary UUID \\\\\\n uploads the log summary to crdb \\\\\\n currently just summarizes over entire timeperiod. ')\\n\\n parser.add_argument('-u', '--update-db', dest='update', type=bool,\\n default=False,\\n help='-u True pushes data to cockroach db')\\n\\n parser.add_argument('--update-clf', dest=\\\"clf_days\\\", type=int,\\n default=-1,\\n help='--update-clf 60 will update all classifiers \\\\\\n listed in config file under classifier_lists \\\\\\n using data from last 60 days')\\n\\n parser.add_argument('--test-clf', dest=\\\"test_days\\\", type=int,\\n default=-1,\\n help='--test-clf 60 will train all classifiers \\\\\\n listed in config file under classifier_lists \\\\\\n using data from last 60 days and then test it \\\\\\n and display metrics')\\n\\n parser.add_argument('-v', '--osp-version', dest='version', type=str,\\n default=None,\\n help='-v 11-tripleo only returns hits for that \\\\\\n OpenStack version, \\\\\\n only supported by summary right now')\\n\\n parser.add_argument('-c', '--config', dest='config', type=str,\\n default=pkg_resources.resource_filename('bml',\\n \\\"config.yml\\\"),\\n help='-c <config file path> use custom config file')\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"dem process\\\")\\n parser.add_argument(\\\"--data_dir\\\", type=str, default=\\\"/home/dataset/DEM_data/\\\",\\n help=\\\"path where the dataset is saved\\\")\\n args_opt = parser.parse_args()\\n return args_opt\",\n \"def _parse_args(self):\\n parser = argparse.ArgumentParser()\\n _, args = parser.parse_known_args()\\n self.args = [a for a in args if a != '']\",\n \"def read_args(self):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--algorithm', '-a', default='onelayer',\\n choices=['onelayer', 'randomforest', 'sos'],\\n help='which algorithm to run')\\n parser.add_argument('--format', '-f', default='pcap',\\n choices=['netflow', 'pcap'],\\n help='which format are the files to process in')\\n parser.add_argument('--operation', '-o', default='eval',\\n choices=['eval', 'train', 'test'],\\n help='which operation to run')\\n parser.add_argument('--sos_model', '-s', default='networkml/trained_models/sos/SoSmodel',\\n help='path to SoSmodel')\\n parser.add_argument('--trained_model', '-m', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\\n help='path to the trained model file')\\n parser.add_argument('--path', '-p', default='/pcaps',\\n help='path to file or directory of files to process')\\n parser.add_argument('--save', '-w', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\\n help='path to save the trained model, if training')\\n\\n self.args = parser.parse_args()\\n return\",\n \"def parse_commandline():\\n parser = optparse.OptionParser(usage = __doc__,version=git_version.verbose_msg)\\n\\n parser.add_option(\\\"-t\\\", \\\"--timeFile\\\",help=\\\"Text file with central times.\\\",default = 'centralTimes.txt')\\n\\tparser.add_option(\\\"-c\\\", \\\"--channel\\\",help=\\\"IFO channel.\\\",default = 'L1:GDS-CALIB_STRAIN')\\n\\tparser.add_option(\\\"-w\\\", \\\"--workdirectory\\\",help=\\\"Working directory.\\\",default = '.')\\n\\tparser.add_option(\\\"-s\\\", \\\"--sourceDir\\\",help=\\\"Name of source directory.\\\",default = 'source')\\n\\n opts, args = parser.parse_args()\\n return opts\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\\n parser.add_argument('-r', '--resources_dir', type=unicode)\\n parser.add_argument('-t', '--total_docs', type=int)\\n parser.add_argument('-m', '--mapping', type=unicode,\\n help='File with the yago to lkif mapping')\\n\\n return parser.parse_args()\",\n \"def parse_command_line() -> argparse.Namespace:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'pet_database',\\n type=str,\\n help='path to pet database'\\n )\\n parser.add_argument(\\n '--image_dir',\\n default='data/images'\\n )\\n parser.add_argument(\\n '--log',\\n default=None,\\n help='log file path'\\n )\\n\\n args = parser.parse_args()\\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\\n return args\",\n \"def parse_args():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'config',\\n help='Config file')\\n parser.add_argument(\\n '--quiet',\\n '-q',\\n action='store_true',\\n help='do not print to console'\\n )\\n parser.add_argument(\\n '--password',\\n '-p',\\n action='store_true',\\n help='Set password in keyring.'\\n )\\n parser.add_argument(\\n '--update',\\n '-u',\\n action='store_true',\\n help='Only add transactions after last date in database.'\\n )\\n parser.add_argument(\\n '--mark_seen',\\n '-m',\\n action='store_true',\\n help='Mark fetched emails as seen.'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(prog='scoring')\\n parser.add_argument(\\\"pdb_list\\\", help=\\\"list of PDB structures\\\")\\n script_args = parser.parse_args()\\n return script_args\",\n \"def parseArguments(self):\\n iterator = iter(sys.argv[1:]) # Skip file name\\n for argument in iterator:\\n if len(argument) < 2 or argument[:2] != '--':\\n self.error('syntax error \\\"{}\\\"'.format(argument))\\n else:\\n def getValueOfArgument(): return next(iterator)\\n self.parseArgument(argument[2:], getValueOfArgument)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Hyper parameter\\\")\\n parser.add_argument(\\n \\\"--model\\\", help=\\\"Model to use\\\", default=\\\"All\\\", type=str)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=\\\"This is a script for auto apply ipex optimization.\\\"\\n \\\"\\\\n################################# Basic usage ############################# \\\\n\\\"\\n \\\"\\\\n 1. Apply ipex optimization with fp32 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\\\n\\\"\\n \\\"\\\\n 2. Apply ipex optimization with bf16 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\\\n\\\",\\n formatter_class=RawTextHelpFormatter,\\n )\\n\\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\\n\\n # positional\\n parser.add_argument(\\n \\\"program\\\",\\n type=str,\\n help=\\\"The full path to the proram/script to be launched. \\\"\\n \\\"followed by all the arguments for the script\\\",\\n )\\n # rest from the training program\\n parser.add_argument(\\\"program_args\\\", nargs=REMAINDER)\\n return parser.parse_args()\",\n \"def ParseCommandLineArgs(argv):\\n global VERBOSE, COMPILE_MODE, RUN_MODE, TMP_PREFIX\\n global CFG, APPEND, SHOW_CONSOLE, CHECK_EXCLUDES, CONCURRENCY\\n try:\\n opts, args = getopt.getopt(argv[1:], '',\\n ['verbose',\\n 'show_console',\\n 'append=',\\n 'append_file=',\\n 'config=',\\n 'exclude=',\\n 'check_excludes',\\n 'tmp=',\\n 'concurrency='])\\n except getopt.GetoptError as err:\\n Print(str(err)) # will print something like 'option -a not recognized'\\n sys.exit(-1)\\n\\n for o, a in opts:\\n # strip the leading '--'\\n o = o[2:]\\n if o == 'verbose':\\n VERBOSE = 1\\n elif o == 'show_console':\\n SHOW_CONSOLE = 1\\n elif o == 'check_excludes':\\n CHECK_EXCLUDES = 1\\n elif o == 'tmp':\\n TMP_PREFIX = a\\n elif o == 'exclude':\\n # Parsing of exclude files must happen after we know the current config\\n EXCLUDE_FILES.append(a)\\n elif o == 'append':\\n tag, value = a.split(\\\":\\\", 1)\\n APPEND.append((tag, value))\\n elif o == 'append_file':\\n APPEND_FILES.append(a)\\n elif o == 'config':\\n CFG = a\\n elif o == 'concurrency':\\n CONCURRENCY = int(a)\\n else:\\n Print('ERROR: bad commandline arg: %s' % o)\\n sys.exit(-1)\\n # return the unprocessed options, i.e. the command\\n return args\",\n \"def _parse_args():\\n parser = optparse.OptionParser(usage=\\\"%prog imagefile+number.suffix\\\", description=\\\"Opens up a sequence of pictures in a web browser.\\\")\\n\\n return parser.parse_args()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80873114","0.7811934","0.77932054","0.77715003","0.77535075","0.76733726","0.7649569","0.7641751","0.7631887","0.75946397","0.7534283","0.7530792","0.7495356","0.7490417","0.7487174","0.74836403","0.7483276","0.7483084","0.7479624","0.7477241","0.7473857","0.7455566","0.74502933","0.74417514","0.7436219","0.7420309","0.7419267","0.74192107","0.74085796","0.74022704","0.739895","0.7386763","0.7379832","0.7378474","0.7375781","0.73714375","0.73609096","0.7343819","0.73433983","0.73382115","0.73285615","0.732669","0.73163897","0.73146033","0.7307629","0.73039645","0.72993135","0.7293872","0.7293291","0.7292875","0.7292084","0.72908825","0.72888505","0.72872037","0.7280672","0.7279105","0.72726196","0.727257","0.7271365","0.7267821","0.72652453","0.7261676","0.7259688","0.7257386","0.72570825","0.7256473","0.7255656","0.72499573","0.72495043","0.7246821","0.72420156","0.72382677","0.7237524","0.7234109","0.72339314","0.7232878","0.72311044","0.7230297","0.7229351","0.7229339","0.7221109","0.7220599","0.7217785","0.7212347","0.7210987","0.72048175","0.7202752","0.7202076","0.7201756","0.7198374","0.719779","0.7197192","0.71958303","0.7195128","0.7189069","0.71874726","0.71856844","0.71835285","0.7183095","0.7183046","0.718135"],"string":"[\n \"0.80873114\",\n \"0.7811934\",\n \"0.77932054\",\n \"0.77715003\",\n \"0.77535075\",\n \"0.76733726\",\n \"0.7649569\",\n \"0.7641751\",\n \"0.7631887\",\n \"0.75946397\",\n \"0.7534283\",\n \"0.7530792\",\n \"0.7495356\",\n \"0.7490417\",\n \"0.7487174\",\n \"0.74836403\",\n \"0.7483276\",\n \"0.7483084\",\n \"0.7479624\",\n \"0.7477241\",\n \"0.7473857\",\n \"0.7455566\",\n \"0.74502933\",\n \"0.74417514\",\n \"0.7436219\",\n \"0.7420309\",\n \"0.7419267\",\n \"0.74192107\",\n \"0.74085796\",\n \"0.74022704\",\n \"0.739895\",\n \"0.7386763\",\n \"0.7379832\",\n \"0.7378474\",\n \"0.7375781\",\n \"0.73714375\",\n \"0.73609096\",\n \"0.7343819\",\n \"0.73433983\",\n \"0.73382115\",\n \"0.73285615\",\n \"0.732669\",\n \"0.73163897\",\n \"0.73146033\",\n \"0.7307629\",\n \"0.73039645\",\n \"0.72993135\",\n \"0.7293872\",\n \"0.7293291\",\n \"0.7292875\",\n \"0.7292084\",\n \"0.72908825\",\n \"0.72888505\",\n \"0.72872037\",\n \"0.7280672\",\n \"0.7279105\",\n \"0.72726196\",\n \"0.727257\",\n \"0.7271365\",\n \"0.7267821\",\n \"0.72652453\",\n \"0.7261676\",\n \"0.7259688\",\n \"0.7257386\",\n \"0.72570825\",\n \"0.7256473\",\n \"0.7255656\",\n \"0.72499573\",\n \"0.72495043\",\n \"0.7246821\",\n \"0.72420156\",\n \"0.72382677\",\n \"0.7237524\",\n \"0.7234109\",\n \"0.72339314\",\n \"0.7232878\",\n \"0.72311044\",\n \"0.7230297\",\n \"0.7229351\",\n \"0.7229339\",\n \"0.7221109\",\n \"0.7220599\",\n \"0.7217785\",\n \"0.7212347\",\n \"0.7210987\",\n \"0.72048175\",\n \"0.7202752\",\n \"0.7202076\",\n \"0.7201756\",\n \"0.7198374\",\n \"0.719779\",\n \"0.7197192\",\n \"0.71958303\",\n \"0.7195128\",\n \"0.7189069\",\n \"0.71874726\",\n \"0.71856844\",\n \"0.71835285\",\n \"0.7183095\",\n \"0.7183046\",\n \"0.718135\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81397,"cells":{"query":{"kind":"string","value":"distinguishes one vs. many unified input csv files and either sets the single csv as input, or merges all csvs and sets the merged csv as input."},"document":{"kind":"string","value":"def set_input_csv(self):\n if len(self[\"input_csv\"]) > 1:\n raise Exception(\"You must only specify *one* unified CSV file!\")\n self.csv_path = self[\"input_csv\"][0]\n print(\"Using input file\", self.csv_path)"},"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 import_directory_csv(d_in, d_out, target_column, merge_columns):\n\n INPUT_FILES = grab_files(\"*.csv\", d_in)\n\n if not INPUT_FILES:\n logger.warning(\"No matching CSV files found, exiting\")\n exit(2)\n\n for f_csv in INPUT_FILES:\n f_csv_out = os.path.join(d_out, os.path.basename(f_csv))\n vals = (f_csv, f_csv_out, target_column, merge_columns)\n import_csv(vals)","def process_csv(csv_file=None):\n if csv_file:\n _process_csv_data(csv_file, USER_DATA_MAP)\n else:\n csv_files_list = [os.path.join(DATA_DIR, f) for f in os.listdir(DATA_DIR) if f.endswith('.csv')]\n for fl in csv_files_list:\n _process_csv_data(fl, USER_DATA_MAP)\n return USER_DATA_MAP","def sync_csv(arg):\n files = os.listdir(arg.input_dir)\n file_map = dict()\n for f in files:\n label = os.path.splitext(f)[0].split('_')\n if len(label) < 2:\n continue\n if file_map.get(label[0], None) is None:\n file_map[label[0]] = dict()\n if label[1] == 'grid':\n file_map[label[0]]['grid'] = f\n else:\n if file_map[label[0]].get('data', None) is None:\n file_map[label[0]]['data'] = dict()\n if file_map[label[0]]['data'].get(label[1], None) is None:\n file_map[label[0]]['data'][label[1]] = []\n file_map[label[0]]['data'][label[1]].append(f)\n tar_name = 't{}'.format(datetime.now().strftime('%Y%m%d'))\n tar_path = os.path.join(arg.output_dir, 'tar', tar_name)\n if not os.path.exists(tar_path):\n os.mkdir(tar_path)\n i = 0\n n = len(file_map)\n for city, v in file_map.items():\n i = i + 1\n print('------ handle city [{}/{}]: {} -------'.format(i, n, city))\n city_csv_path = os.path.join(arg.output_dir, 'csv', city)\n city_sql_path = os.path.join(arg.output_dir, 'sql', city)\n if not os.path.exists(city_csv_path):\n os.mkdir(city_csv_path)\n if not os.path.exists(city_sql_path):\n os.mkdir(city_sql_path)\n grid = v.get('grid', None)\n if grid:\n grid = os.path.splitext(grid)[0]\n print('** handling grid ...')\n tar_sql = os.path.join(tar_path, '{}.sql.gz'.format(grid))\n if os.path.exists(tar_sql):\n print('****** {} exist!'.format(tar_sql))\n else:\n shutil.copyfile(os.path.join(arg.input_dir, '{}.csv'.format(grid)),\n os.path.join(city_csv_path, '{}.csv'.format(grid)))\n trans_grid(city, city_csv_path, city_sql_path)\n print('****** GZIP grid sql')\n with open(os.path.join(city_sql_path, '{}.sql'.format(grid))) as fi, gzip.open(\n os.path.join(tar_path, '{}.sql.gz'.format(grid)), 'wb') as fo:\n fo.write(fi.read().encode())\n data = v.get('data', None)\n if data:\n print('** handling data ...')\n for week, data_files in data.items():\n print('**** week: {}'.format(week))\n tar_detail = os.path.join(tar_path, '{}_{}_detail.sql.tar.gz'.format(city, week))\n if os.path.exists(tar_detail):\n print('****** {} exist!'.format(tar_detail))\n else:\n for data_file in data_files:\n shutil.copyfile(os.path.join(arg.input_dir, data_file), os.path.join(city_csv_path, data_file))\n create_detail(city, week, 30000, city_csv_path, city_sql_path)\n print('****** TAR detail sql')\n with tarfile.open(tar_detail, 'w:gz') as f:\n for city_week_detail in os.listdir(city_sql_path):\n if city_week_detail.startswith('{}_{}_detail'.format(city, week)):\n f.add(os.path.join(city_sql_path, city_week_detail), arcname=city_week_detail)\n print('****** remove csv and sql file...')\n for data_file in data_files:\n os.remove(os.path.join(city_csv_path, data_file))\n sql_files = os.path.join(city_sql_path, '{}_{}_detail*sql'.format(city, week))\n for sql_file in glob.glob(sql_files):\n os.remove(sql_file)","def concat_vsource_sink_csv(csv_fn1,csv_fn2,merged_source_sink_in,\n csv_type,csv_merged,freq='infer',how='left'):\n # merged_source_sink_in: the merged source_sink.in or source_sink.yaml file \n # where the data sources are from csv_fn1, csv_fn2. \n if merged_source_sink_in.endswith('yaml'):\n df_sources,df_sinks = read_source_sink_yaml(merged_source_sink_in)\n elif merged_source_sink_in.endswith('in'):\n df_sources,df_sinks = read_source_sink_in(merged_source_sink_in)\n else:\n raise NotImplementedError(\n 'merged_source_sink_in can either be .yaml or .in file')\n if csv_type == 'sources':\n sites = df_sources.index\n elif csv_type == 'sink':\n sites = df_sinks.index\n else:\n raise NotImplementedError('csv_type can either be sources or sinks')\n th1 = read_source_sink_csv(csv_fn1)\n th2 = read_source_sink_csv(csv_fn2)\n if freq=='infer':\n if th1.index.freq!=th2.index.freq:\n print(\"th1 and th2 has different frequency\")\n else:\n th1 = th1.asfreq(freq)\n th2 = th2.asfreq(freq)\n th_merged = th1.join(th2,how=how,rsuffix='r').drop(columns=['datetimer'])\n th_merged = th_merged.fillna(-9999.0)\n cols = np.append(['datetime'],sites)\n th_merged = th_merged[cols] #rearrange the array to have the same order as defined in merged_source_sink_in\n th_merged['datetime'] = np.datetime_as_string(th_merged.index.values,'h')\n write_source_sink_csv(th_merged,csv_merged)","def loadCSV(input_file):","async def collate_similar_data(input_csv_file_path, output_csv_file_path):\n if not input_csv_file_path or not output_csv_file_path:\n return\n with open(output_csv_file_path, 'w') as file_object:\n csv_writer = csv.writer(file_object, delimiter=',')\n csv_writer.writerow(\n ('Account ID', 'First Name', 'Created On', 'Status',\n 'Status Set On'))\n for csv_row in read_csv_file(input_csv_file_path):\n account_status = (await fetch_account_status(csv_row[0]))\n csv_writer.writerow(csv_row + (\n account_status.get('status', ''),\n datetime.datetime.strftime(\n datetime.datetime.strptime(\n account_status.get('created_on'), '%Y-%m-%d'),\n '%Y-%m-%d') if account_status.get('created_on') else ''))","def merge(path_to_mf_lf_1, path_to_mf_lf_2, path_to_mf_hf_1, path_to_mf_hf_2, path_to_sf,\n path_to_mf_lf, path_to_mf_hf, path_to_sf_copy):\n mf_lf = merge_one_case(pd.read_csv(path_to_mf_lf_1, index_col=0), pd.read_csv(path_to_mf_lf_2, index_col=0))\n mf_hf = merge_one_case(pd.read_csv(path_to_mf_hf_1, index_col=0), pd.read_csv(path_to_mf_hf_2, index_col=0))\n sf = pd.read_csv(path_to_sf, index_col=0) # only bypassed\n mf_lf.to_csv(path_to_mf_lf, index=True, header=True)\n mf_hf.to_csv(path_to_mf_hf, index=True, header=True)\n sf.to_csv(path_to_sf_copy, index=True, header=True)","def process_file_import(self):\r\n directory_csv = [file for file in os.listdir() if file.endswith(\".csv\")]\r\n self.print_options(directory_csv,2)\r\n\r\n \"\"\"\r\n Asks for user input. Then imports csv file based on user's input.\r\n \"\"\"\r\n n = (input(\"Which csv would you like to import? Please input the corresponding integer:\"))\r\n\r\n try:\r\n n = int(n)\r\n except:\r\n pass\r\n\r\n if isinstance(n, int) is True and n <= len(directory_csv):\r\n self.population.import_csv(directory_csv[int(n)-1])\r\n print(self.population)\r\n self.file_import()\r\n elif n == 'q':\r\n quit()\r\n elif n == 'b':\r\n self.menu_page()\r\n else:\r\n raise InputError(\"\\nPlease input a valid digit, 'q' or 'b'\")","def merge(parent_folder):\n parent_folder = Path(parent_folder)\n\n address_csv_files = sorted(parent_folder.glob('*_step_*.csv'))\n\n frames = []\n\n #: read all csv's delimiter='|', quoting=csv.QUOTE_MINIMAL\n for address_csv_file in address_csv_files:\n temp = pd.read_csv(\n address_csv_file, sep='|', encoding='utf-8', names=['type', 'id', 'county', 'senate', 'house', 'census']\n )\n\n frames.append(temp)\n\n #: merge all csv's\n merged = pd.concat(frames)\n merged.to_csv(parent_folder / 'all.csv', sep='|', header=False, index=False, encoding='utf-8')","def from_csv(self):\n timestamp_logname = \"from_csv_\" + datetime.today().strftime('%Y_%m_%d_%H_%M_%S')\n csv_files = [f for f in self.args.files if f.endswith('.csv')]\n if not csv_files:\n self.logger.error(\"No CSV files found.\")\n return False\n\n # Create an instance of the Ingestor class with common options set.\n ingestor = Ingestor(**self.options)\n\n # Ingest from each CSV file.\n for csv_file in csv_files:\n data_groups = Ingestor.process_csv(csv_file)\n for mask, routes, deployment_number in data_groups:\n ingestor.load_queue(mask, routes, deployment_number)\n ingestor.ingest_from_queue()\n\n # Write out any failed ingestions from the entire batch to a new CSV file.\n if ingestor.failed_ingestions:\n ingestor.write_failures_to_csv(timestamp_logname)\n\n self.logger.info('')\n self.logger.info(\"Ingestion completed.\")\n return True","def merge_csv_initial(output_filename, path):\n\n prefix = ['ParticipantID',\n 'igtb.datatime',\n 'igtb.timezone']\n\n names = ['irb',\n 'itp',\n 'ocb',\n 'inter.deviance',\n 'org.deviance',\n 'shipley.abs',\n 'shipley.vocab',\n 'neuroticism',\n 'conscientiousness',\n 'extraversion',\n 'agreeableness',\n 'openness',\n 'pos.affect',\n 'neg.affect',\n 'stai.trait',\n 'audit',\n 'gats.quantity',\n 'ipaq',\n 'psqi',\n 'gats.status']\n\n\n \n\n #b = np.loadtxt(path + names[0] + '.csv', delimiter=\",\", skiprows=1, usecols=(0, 1, 2), dtype=object)\n #a = np.array(b, dtype=object)\n\n for i,n in enumerate(names):\n file = path + n + '.csv'\n if(i==0):\n df = pd.read_csv(file, sep=',', index_col=0,usecols=[0,1,2,3]) \n df_all = df\n else:\n df = pd.read_csv(file, sep=',', index_col=0,usecols=[0,3]) \n df_all=pd.concat([df_all,df],axis=1)\n \n df_all=df_all.reset_index() \n a = df_all.as_matrix()\n\n # column_format = '%20s %10s %10s %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f'\n # column_format = '%20s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s'\n column_format = '%20s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s'\n names_string = ','.join(prefix + names)\n\n print(a.shape)\n\n np.savetxt(output_filename, a, delimiter=\",\", fmt=column_format, comments='', header=names_string)\n\n return output_filename","def combine_files(file_name):\n\n\tif file_name == \"train\":\n\n\t\tif os.path.isfile(\"./Data/Level1_model_files/Train/all_level1_train.csv\"):\n\t\t\tos.remove(\"./Data/Level1_model_files/Train/all_level1_train.csv\")\n\n\t\tlist_files = glob(\"./Data/Level1_model_files/Train/*.csv*\")\n\t\tlist_df = []\n\t\tfor f in list_files :\n\t\t\tlist_df.append(pd.read_csv(f))\n\n\t\tfor i in range(1,len(list_df)):\n\t\t\tlist_df[i] = list_df[i].drop([\"Response\", \"Id\"],1)\n\n\t\t# Concat\n\t\tdf_out = pd.concat(list_df, axis=1)\n\t\t# Order columns\n\t\tlist_col = df_out.columns.values.tolist()\n\t\tlist_col = sorted(list_col)\n\t\tlist_col.remove(\"Response\")\n\t\tlist_col.remove(\"Id\")\n\t\tlist_col = [\"Id\"] + list_col + [\"Response\"]\n\t\tdf_out = df_out[list_col]\n\t\tdf_out.to_csv(\"./Data/Level1_model_files/Train/all_level1_train.csv\", index = False)\n\n\telif file_name == \"test\":\n\n\t\tif os.path.isfile(\"./Data/Level1_model_files/Test/all_level1_test.csv\"):\n\t\t\tos.remove(\"./Data/Level1_model_files/Test/all_level1_test.csv\")\n\n\t\tlist_files = glob(\"./Data/Level1_model_files/Test/*.csv*\")\n\t\tlist_df = []\n\t\tfor f in list_files :\n\t\t\tlist_df.append(pd.read_csv(f))\n\n\t\tfor i in range(1,len(list_df)):\n\t\t\tlist_df[i] = list_df[i].drop(\"Id\",1)\n\n\t\t# Concat\n\t\tdf_out = pd.concat(list_df, axis=1)\n\t\t# Order columns\n\t\tlist_col = df_out.columns.values.tolist()\n\t\tlist_col = sorted(list_col)\n\t\tlist_col.remove(\"Id\")\n\t\tlist_col = [\"Id\"] + list_col \n\t\tdf_out = df_out[list_col]\n\t\tdf_out.to_csv(\"./Data/Level1_model_files/Test/all_level1_test.csv\", index = False)","def main():\n location = os.getcwd()\n header = \"Date,Time,Voltage,Current,Isolation,Range,SoC,Distance,Fan rpm,Fan Torque,Hyd. Pump rpm,Hyd. Pump Torque,SW Pump rpm,SW Pump Torque,Nozzle,Sidebrushes,WideSweepBrush,TempIGBT-Fan,Fan motor temp, Traction rpm, Traction torque,BMS1 Volts, BMS2 Volts\"\n header = header+\"\\n\"\n\n of =\"outFile.csv\"\n outFile = open(of, \"w\")\n outFile.write(header)\n\n for file in os.listdir(location ):\n try:\n if file.endswith(\".csv\") and not(file.startswith(\"outFile\")):\n print(\"...reading {}\".format(file))\n fcsv = csv.reader(open(file, newline=''), delimiter=' ', quotechar='|') \n for row in fcsv:\n line = ', '.join(row)\n if line[:4] == \"Date\":\n d = line[5:13]\n dd = d[6:9]+\"/\"+d[4:6]+\"/\"+d[:4]\n next\n elif line[12] == \"*\" or line[0] == \"*\":\n next\n elif line[0] == \"T\":\n next\n else:\n L = dd + \",\" + line + \"\\n\"\n outFile.write(L)\n except Exception as e:\n raise e\n print(\"No CSV files in here!\")\n\n try: \n print(\"\\nAll files have been merged into: {}\".format(of))\n outFile.close()\n \n except Exception as ee:\n raise ee","def seed_from_csv_diff(original_file_path, new_file_path, model, **kwargs):\n\n original_diff_set = set()\n new_diff_set = set()\n new_file = open(new_file_path, 'r')\n headers = new_file.readline().replace('\\n', '').split(',')\n new_reader = model.update_set_filter(csv.reader(new_file), headers)\n\n original_file = open(original_file_path, 'r')\n original_reader = csv.reader(original_file)\n next(original_reader, None)\n logger.debug(\" * Beginning CSV diff process.\")\n\n for row in new_reader:\n new_diff_set.add(json.dumps(row))\n\n for row in original_reader:\n original_diff_set.add(json.dumps(row))\n\n diff = new_diff_set - original_diff_set\n temp_file_path = os.path.join(settings.MEDIA_TEMP_ROOT, str(\n 'set_diff' + str(random.randint(1, 10000000))) + '.mock' if settings.TESTING else '.csv')\n with open(temp_file_path, 'w') as temp_file:\n writer = csv.writer(temp_file, delimiter=',')\n writer.writerow(headers)\n for row in diff:\n writer.writerow(json.loads(row))\n\n diff_gen = from_csv_file_to_gen(temp_file_path, kwargs['update'])\n logger.debug(\" * Csv diff completed, beginning batch upsert.\")\n batch_upsert_from_gen(model, diff_gen, settings.BATCH_SIZE, **kwargs)\n if os.path.isfile(temp_file_path):\n os.remove(temp_file_path)\n if 'callback' in kwargs and kwargs['callback']:\n kwargs['callback']()","def merge_csv_daily(output_filename, path):\n\n # import csv files from folder\n allFiles = glob.glob(path + \"*.csv\")\n\n with open(output_filename, 'wb+') as outfile:\n for i, fname in enumerate(allFiles):\n with open(fname, 'rb') as infile:\n if i != 0:\n infile.readline() # Throw away header on all but first file\n # Block copy rest of file from input to output without parsing\n shutil.copyfileobj(infile, outfile)\n # print(fname + \" has been imported.\")\n\n # adding MissingObs column back:\n df = pd.read_csv(output_filename, header=0, sep=',', index_col=[0,1], parse_dates=False)\n df.insert(loc=3, column='MissingObs', value=np.zeros((df.shape[0], )))\n df.to_csv(output_filename, sep=',')\n\n return output_filename","def initial_csv_wrangling(csv_file):\n df = pd.read_csv(csv_file)\n df = df.fillna('')\n columns = list(df.columns)\n\n # check that \"url\" column exists (required)\n if 'url' not in columns:\n raise Exception('Input csv file requires a \"url\" column, which does not seem to exist. Exiting.')\n\n # check if \"pos_concepts\" column exists and parse accordingly (not required)\n if 'pos_concepts' in columns:\n print('Found \"pos_concepts\" column. Values will be split by pipe/vertical bar \"|\" into a python list.')\n df['pos_concepts'] = df['pos_concepts'].map(lambda x: list(set(x.split('|'))))\n\n # check if \"neg_concepts\" column exists and parse accordingly (not required)\n if \"neg_concepts\" in columns:\n print('Found \"neg_concepts\" column. Values will be split by pipe/vertical bar \"|\" into a python list.')\n df['neg_concepts'] = df['neg_concepts'].map(lambda x: list(set(x.split('|'))))\n\n # check if \"metadata\" column exists and load accordingly (not required)\n if \"metadata\" in columns:\n print('Found \"metadata\" column. Attempting to ingest.')\n try:\n df['metadata'] = df['metadata'].replace('','{}').map(json.loads)\n except:\n raise Exception('Value in \"metadata\" column does not seem to be a properly JSON formatted str.')\n\n return df","def merge_data(csv_files, delimiter = ',', parse_dates = ['Date']):\n \n for csv in csv_files:\n \n # date formats in source data is slightly different (/2019 vs. /19), \n # TODO: check for better method to catch this error\n \n \n try:\n df_new = pd.read_csv(csv, parse_dates=parse_dates,\n date_parser=lambda x: pd.datetime.strptime(str(x), '%d/%m/%Y'), delimiter=delimiter)\n \n except:\n df_new = pd.read_csv(csv, parse_dates=parse_dates,\n date_parser=lambda x: pd.datetime.strptime(str(x), '%d/%m/%y'), delimiter=delimiter)\n \n \n\n \n df_new['season'] = df_new.Date.max().year # add season column, defined as the year of the last matchday\n df_new['first_match_day'] = False \n df_new.loc[0:9, 'first_match_day'] = True # declare first 10 games as first match day\n df_new['matchDay'] = 0\n \n try:\n df = df.append(df_new,sort=False)\n except:\n df = df_new\n \n return df","def intersect_csv_and_shapefiles(in_csv_filename, geodata1, geodata2,\n ancillary_path, out_csv_filename, from_gbif):\n pth, basefname = os.path.split(out_csv_filename)\n logbasename, _ = os.path.splitext(basefname)\n logfname = os.path.join(pth, '{}.log'.format(logbasename))\n logger = get_logger(logbasename, logfname)\n bf = BisonFiller(log=logger)\n # Pass 4 of CSV transform, final step, point-in-polygon intersection\n bf.update_point_in_polygons(\n geodata1, geodata2, ancillary_path, in_csv_filename, out_csv_filename,\n from_gbif=from_gbif)\n # Do intersection here\n sleep(randint(0, 10))\n print(' - {}'.format(out_csv_filename))","def check_for_csv(inp_dict):\n if inp_dict[\".csv\"]:\n for path in inp_dict[\".csv\"]:\n csv_path = convert_csv(path)\n inp_dict[\".xls\"].append(csv_path)\n inp_dict[\"del\"].append(csv_path)\n inp_dict[\"out\"].append(csv_path)\n inp_dict[\".csv\"] = []\n return inp_dict","def merge_files(self, infnames, outfname, csv_header=True):\n assert outfname not in infnames\n start = time.time()\n\n header = ''\n with open(outfname, 'w') as outfile:\n if csv_header: # if not <csv_header>, we'll just end up with a zero-length file\n for fname in infnames:\n if not os.path.exists(fname) or os.stat(fname).st_size == 0:\n continue\n with open(fname) as headfile:\n reader = csv.DictReader(headfile)\n writer = csv.DictWriter(outfile, reader.fieldnames)\n writer.writeheader()\n header = ','.join(reader.fieldnames)\n break\n\n cmd = 'cat ' + ' '.join(infnames) + ' | grep -v \\'^' + header + '$\\' | sort | uniq >>' + outfname\n check_call(cmd, shell=True)\n\n if not self.args.no_clean:\n for infname in infnames:\n os.remove(infname)\n\n print ' time to merge csv files: %.3f' % (time.time()-start)","def step_parallel(in_csv_filename, terrestrial_data, marine_data, ancillary_path,\n out_csv_filename, from_gbif=True):\n csv_filename_pairs, header = get_chunk_files(\n in_csv_filename, out_csv_filename=out_csv_filename)\n\n# in_csv_fn, out_csv_fn = csv_filename_pairs[0]\n# intersect_csv_and_shapefiles(in_csv_fn, terrestrial_data,\n# marine_data, ancillary_path, out_csv_fn, False)\n\n with ProcessPoolExecutor() as executor:\n for in_csv_fn, out_csv_fn in csv_filename_pairs:\n executor.submit(\n intersect_csv_and_shapefiles, in_csv_fn, terrestrial_data,\n marine_data, ancillary_path, out_csv_fn, from_gbif)\n\n try:\n outf = open(out_csv_filename, 'w', encoding='utf-8')\n outf.write('{}'.format(header))\n smfile_linecount = 0\n for _, small_csv_fn in csv_filename_pairs:\n curr_linecount = get_line_count(small_csv_fn) - 1\n print('Appending {} records from {}'.format(\n curr_linecount, small_csv_fn))\n # Do not count header\n smfile_linecount += (curr_linecount)\n lineno = 0\n try:\n for line in open(small_csv_fn, 'r', encoding='utf-8'):\n # Skip header in each file\n if lineno == 0:\n pass\n else:\n outf.write('{}'.format(line))\n lineno += 1\n except Exception as inner_err:\n print('Failed to write {} to merged file; {}'.format(small_csv_fn, inner_err))\n except Exception as outer_err:\n print('Failed to write to {}; {}'.format(out_csv_filename, outer_err))\n finally:\n outf.close()\n\n lgfile_linecount = get_line_count(out_csv_filename) - 1\n print('Total {} of {} records written to {}'.format(\n lgfile_linecount, smfile_linecount, out_csv_filename))","def test_reading_with_multiple_files(self):\n self.prepare()\n self.session.execute(\"\"\"\n CREATE TABLE testmultifiles (\n a int,\n b int,\n c float,\n PRIMARY KEY (a, b)\n )\"\"\")\n\n num_rows_per_file = 100\n num_files = 10\n tempfiles = []\n\n for i in range(num_files):\n tempfiles.append(self.get_temp_file(prefix='testreadmult{}'.format(i), suffix='.csv'))\n\n for i in range(num_files):\n with open(tempfiles[i].name, 'w') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=['a', 'b', 'c'])\n for k in range(num_rows_per_file):\n writer.writerow({'a': i, 'b': k, 'c': 2.0})\n\n def import_and_check(temp_files_str):\n self.session.execute(\"TRUNCATE testmultifiles\")\n\n logger.debug(\"Importing csv files {}\".format(temp_files_str))\n self.run_cqlsh(cmds=\"COPY ks.testmultifiles FROM '{}'\".format(temp_files_str))\n\n assert [[num_rows_per_file * len(tempfiles)]] == rows_to_list(self.session.execute(\"SELECT COUNT(*) FROM testmultifiles\"))\n\n import_and_check(','.join([tempfile.name for tempfile in tempfiles]))\n import_and_check(os.path.join(gettempdir(), 'testreadmult*.csv'))\n import_and_check(','.join([os.path.join(gettempdir(), 'testreadmult[0-4]*.csv'),\n os.path.join(gettempdir(), 'testreadmult[5-9]*.csv')]))","def main():\n\n # Ensure the output directory exists\n if not os.path.exists(OUTPUT_DIR):\n os.makedirs(OUTPUT_DIR)\n\n process_csv()","def main():\n master_csv = open(\"master.csv\", \"w\")\n master_csv.write(\"lat, lon, year, month, day, T_max, T_min, PrecipMM, T_ave, PrecipCM, RelHum\\n\")\n MoLS_comp_csv = open(\"MoLS_comp.csv\", \"w\")\n lat_lon_csv = open(\"lat_lon.csv\", \"w\")\n\n for csvFilename in os.listdir('.'):\n\n if not csvFilename.endswith('.csv') or csvFilename == \"master.csv\" or csvFilename == \"MoLS_comp.csv\" or csvFilename == \"lat_lon.csv\":\n continue # skip non-csv files\n\n csvFileObj = open(csvFilename)\n readerObj = csv.reader(csvFileObj)\n print(\"Currently parsing \" + str(csvFilename))\n for row in readerObj:\n if readerObj.line_num <= 8 :\n continue\n\n year = int(row[0])\n vp = float(row[8]) / 1000.0\n month, day = get_month(int(row[1]))\n T_ave = (float(row[6]) + float(row[7])) / 2\n PrecipCM = float(row[3]) / 10\n svp = .611 * math.e ** (5321 * ((1 / 273.0) - (1 / (T_ave + 273.15))))\n rh_ave = round((vp / svp) * 100, 2)\n\n # print([[csvFilename], , row[0], row[1], row[3], row[6], row[7], row[8]])\n # print(readerObj.line_num)\n # print([csvFilename.split(\"_\")[0], csvFilename.split(\"_\")[1].split(\".csv\")[0], row[0], row[1], row[3],\n # row[6], row[7], row[8]])\n\n master_csv.write(str(csvFilename.split(\"_\")[0]) + \",\" + str(csvFilename.split(\"_\")[1].split(\".csv\")[0]) +\n \",\" + str(year) + \",\" + str(month) + \",\" + str(day) + \",\" + str(row[6]) + \",\" + str(row[7])\n + \",\" + str(row[3]) + \",\" + str(T_ave) + \",\" + str(PrecipCM) + \",\" + str(rh_ave) + \"\\n\")\n MoLS_comp_csv.write(str(year) + \",\" + str(month) + \",\" + str(day) + \",\" + str(row[6]) + \",\" + str(row[7])\n + \",\" + str(row[3]) + \",\" + str(T_ave) + \",\" + str(PrecipCM) + \",\" + str(rh_ave) + \"\\n\")\n lat_lon_csv.write(str(csvFilename.split(\"_\")[0]) + \",\" + str(csvFilename.split(\"_\")[1].split(\".csv\")[0]) + \"\\n\")\n\n master_csv.close()\n MoLS_comp_csv.close()\n lat_lon_csv.close()","def merge_cat(UT):\n csv_path = Path(\"./catalog\"+UT+\".csv\")\n if csv_path.exists() != 1:\n Popen('rm -rf merged'+UT+'.log', shell=True)\n Popen('touch merged'+UT+'.log', shell=True)\n all_files = glob.glob(\"./results/20*/\"+UT+\"/*\")\n print('merging table: {} (1/{})'.format(all_files[0],len(all_files)))\n tab = pd.read_csv(all_files[0])\n cat = tab.copy()\n merged = open('merged'+UT+'.log','a+')\n merged.write(all_files[0]+'\\n')\n try:\n for i, file in enumerate(all_files[1:]):\n print('merging table: {} ({}/{})'.format(file,i+2,len(all_files)))\n tab = pd.read_csv(file)\n cat = pd.merge(cat, tab, how='outer')\n merged.write(file+'\\n')\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\n merged.close()\n except:\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\n merged.close()\n else:\n cat = pd.read_csv('catalog'+UT+'.csv')\n all_files = glob.glob(\"./results/20*/\"+UT+\"/*\")\n merged = list(pd.read_table('merged'+UT+'.log', header=None).values)\n merged = [i[0] for i in merged]\n if set(all_files) == set(merged):\n print('GOOD NEWS: No new table is needed to be merged.')\n else:\n non_processed = list(set(all_files) - set(merged))\n merged = open('merged'+UT+'.log','a+')\n try:\n for i, new_img in enumerate(non_processed):\n print('merging table: {} ({}/{})'.format(new_img,i+1,len(non_processed)))\n tab = pd.read_csv(new_img)\n cat = pd.merge(cat, tab, how='outer')\n merged.write(new_img+'\\n')\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\n merged.close()\n except:\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\n merged.close()\n cat = pd.read_csv('catalog'+UT+'.csv')\n m = Table(cat.values, names=cat.columns)\n hdu = fits.table_to_hdu(m)\n hdulist = fits.HDUList([fits.PrimaryHDU(), hdu])\n hdulist.writeto('catalog'+UT+'.fits', overwrite=True)","def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n self.input_data.append(row)","def process_csv_data(file_for_processing: FileForProcessing):\n \n if file_for_processing.file_to_process.os_type == ANDROID_API:\n # Do fixes for Android\n if file_for_processing.data_type == ANDROID_LOG_FILE:\n file_for_processing.file_contents = fix_app_log_file(\n file_for_processing.file_contents, file_for_processing.file_to_process.s3_file_path\n )\n \n header, csv_rows_list = csv_to_list(file_for_processing.file_contents)\n if file_for_processing.data_type != ACCELEROMETER:\n # If the data is not accelerometer data, convert the generator to a list.\n # For accelerometer data, the data is massive and so we don't want it all\n # in memory at once.\n csv_rows_list = list(csv_rows_list)\n \n if file_for_processing.data_type == CALL_LOG:\n header = fix_call_log_csv(header, csv_rows_list)\n if file_for_processing.data_type == WIFI:\n header = fix_wifi_csv(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\n else:\n # Do fixes for iOS\n header, csv_rows_list = csv_to_list(file_for_processing.file_contents)\n \n if file_for_processing.data_type != ACCELEROMETER:\n csv_rows_list = list(csv_rows_list)\n \n # Memory saving measure: this data is now stored in its entirety in csv_rows_list\n file_for_processing.clear_file_content()\n \n # Do these fixes for data whether from Android or iOS\n if file_for_processing.data_type == IDENTIFIERS:\n header = fix_identifier_csv(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\n if file_for_processing.data_type == SURVEY_TIMINGS:\n header = fix_survey_timings(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\n \n header = b\",\".join([column_name.strip() for column_name in header.split(b\",\")])\n if csv_rows_list:\n return (\n # return item 1: the data as a defaultdict\n binify_csv_rows(\n csv_rows_list,\n file_for_processing.file_to_process.study.object_id,\n file_for_processing.file_to_process.participant.patient_id,\n file_for_processing.data_type,\n header\n ),\n # return item 2: the tuple that we use as a key for the defaultdict\n (\n file_for_processing.file_to_process.study.object_id,\n file_for_processing.file_to_process.participant.patient_id,\n file_for_processing.data_type,\n header\n )\n )\n else:\n return None, None","def pre_process_books(csv, outputname):\n df = pd.read_csv(csv, error_bad_lines=False, encoding = \"ISO-8859-1\")\n df.to_csv(outputname, index=False)","def process(self, filename=None):\n if not filename:\n filename = self.input_csv\n\n if filename.endswith('.csv'):\n\n with open(filename) as _file:\n reader = csv.reader(_file)\n data = list(reader)\n\n self.save(self.format(self.purify(data)))\n return\n\n raise TypeError(\n \"Excepting csv filetype got %s \\\n filetype instead.\" % (filename.split('.', 1)[1])\n )","def import_csv(item):\n (f_csv, f_csv_out, target_column, merge_columns) = item\n has_checked_keys = False\n\n if not merge_columns:\n raise ValueError(\"merge_columns must not be empty\")\n\n with open(f_csv_out, \"w\") as FOUT:\n CSV_HANDLE = None\n total_rows = 0\n\n for row in csv_iterator(f_csv):\n\n output = {\"_ref\": next(_ref_counter)}\n\n if not has_checked_keys:\n for key in merge_columns:\n if key not in row.keys():\n msg = \"Column **{}** not in csv file {}\"\n raise KeyError(msg.format(key, f_csv))\n has_checked_keys = True\n\n if target_column in row.keys():\n msg = \"Generated column **{}** already in csv file {}\"\n raise KeyError(msg.format(target_column, f_csv))\n\n text = []\n for key in merge_columns:\n val = row[key].strip()\n if not val:\n continue\n if val[-1] not in \".?!,\":\n val += \".\"\n text.append(val)\n\n output[target_column] = \"\\n\".join(text).strip()\n\n if CSV_HANDLE is None:\n CSV_HANDLE = csv.DictWriter(FOUT, sorted(output.keys()))\n CSV_HANDLE.writeheader()\n\n CSV_HANDLE.writerow(output)\n total_rows += 1\n\n logger.info(\"Imported {}, {} entries\".format(f_csv, total_rows))","def pre_process_multispace(filepath, delimiter=\" \"):\n newpath = filepath+\".rev.csv\"\n with open(filepath, \"r\") as src_csv_file:\n with open(newpath, \"w\") as dst_csv_file:\n for src_line in src_csv_file:\n dst_csv_file.write(delimiter.join(src_line.split())+\"\\n\")","def managecsv(data):\n\n checkfolderdata()\n if not datafileexist(data[7]):\n createcsv(data[7])\n managecsv(data)\n else:\n addcsv(data, data[7])","def import_input_set(name, csv_fn, my_session):\n input_set = InputSet(name=name)\n n_added_input = 0\n with open(csv_fn, 'r') as csv_fh:\n for ln in csv_fh:\n ln = ln.rstrip()\n if len(ln) == 0:\n continue\n toks = ln.split(',')\n if len(toks) != 9:\n raise ValueError('Line did not have 9 tokens: \"%s\"' % ln)\n toks = list(map(lambda x: None if x == 'NA' else x, toks))\n acc_r, acc_s, url_1, url_2, url_3, checksum_1, checksum_2, checksum_3, retrieval_method = toks\n input = Input(acc_r=acc_r, acc_s=acc_s, url_1=url_1, url_2=url_2, url_3=url_3,\n checksum_1=checksum_1, checksum_2=checksum_2, checksum_3=checksum_3,\n retrieval_method=retrieval_method)\n my_session.add(input)\n input_set.inputs.append(input)\n n_added_input += 1\n log.info('Imported %d items from input set' % len(input_set.inputs), 'input.py')\n my_session.add(input_set)\n my_session.commit()\n return input_set.id, n_added_input","def clean_file(csv_file):\n my_list = []\n with open(csv_file, newline='') as csvfile:\n file_reader = csv.reader(csvfile, delimiter=',', quotechar=\" \")\n for row in file_reader:\n my_list.append(row)\n\n \"\"\"\n > Part Two\n Input: Nested list csv_table and a string file_name\n Action: Write fields in csv_table into a comma-separated CSV file with the name file_name\n Mutates output: Yes\n \"\"\"\n with open(csv_file, 'w', newline='') as csvfile:\n my_csv_writer = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_NONE)\n for row in my_list:\n row2 = []\n for item in row:\n a = item.lstrip('\"')\n b = a.rstrip('\"')\n row2.append(b)\n my_csv_writer.writerow(row2)","def collate(\n batch,\n config,\n plate,\n base_directory=\"../..\",\n column=None,\n munge=False,\n csv_dir=\"analysis\",\n aws_remote=None,\n aggregate_only=False,\n tmp_dir=\"/tmp\",\n overwrite=False,\n add_image_features=True,\n image_feature_categories=[\"Granularity\", \"Texture\", \"ImageQuality\", \"Threshold\"],\n printtoscreen=True,\n):\n\n from pycytominer.cyto_utils.cells import SingleCells\n\n # Set up directories (these need to be abspaths to keep from confusing makedirs later)\n input_dir = pathlib.Path(f\"{base_directory}/analysis/{batch}/{plate}/{csv_dir}\")\n backend_dir = pathlib.Path(f\"{base_directory}/backend/{batch}/{plate}\")\n cache_backend_dir = pathlib.Path(f\"{tmp_dir}/backend/{batch}/{plate}\")\n\n aggregated_file = pathlib.Path(f\"{backend_dir}/{plate}.csv\")\n backend_file = pathlib.Path(f\"{backend_dir}/{plate}.sqlite\")\n cache_backend_file = pathlib.Path(f\"{cache_backend_dir}/{plate}.sqlite\")\n\n if not aggregate_only:\n if os.path.exists(cache_backend_file):\n if not overwrite:\n sys.exit(\n f\"An SQLite file for {plate} already exists at {cache_backend_file} and overwrite is set to False. Terminating.\"\n )\n else:\n os.remove(cache_backend_file)\n\n for eachdir in [input_dir, backend_dir, cache_backend_dir]:\n if not os.path.exists(eachdir):\n os.makedirs(eachdir, exist_ok=True)\n\n if aws_remote:\n remote_input_dir = f\"{aws_remote}/analysis/{batch}/{plate}/{csv_dir}\"\n\n remote_backend_file = f\"{aws_remote}/backend/{batch}/{plate}/{plate}.sqlite\"\n\n remote_aggregated_file = f\"{aws_remote}/backend/{batch}/{plate}/{plate}.csv\"\n\n sync_cmd = f\"aws s3 sync --exclude * --include */Cells.csv --include */Nuclei.csv --include */Cytoplasm.csv --include */Image.csv {remote_input_dir} {input_dir}\"\n if printtoscreen:\n print(f\"Downloading CSVs from {remote_input_dir} to {input_dir}\")\n run_check_errors(sync_cmd)\n\n if printtoscreen:\n print(f\"Ingesting {input_dir}\")\n # Run cytominer-database ingest\n if munge:\n cytominer_database.munge.munge(config_path=config, source=input_dir)\n\n cytominer_database.ingest.seed(\n source=input_dir,\n target=f\"sqlite:///{cache_backend_file}\",\n config_file=config,\n )\n\n # Create a sqlite3 connection\n with sqlite3.connect(cache_backend_file, isolation_level=None) as connection:\n cursor = connection.cursor()\n if column:\n if print:\n print(f\"Adding a Metadata_Plate column based on column {column}\")\n cursor.execute(\"ALTER TABLE Image ADD COLUMN Metadata_Plate TEXT;\")\n cursor.execute(f\"UPDATE image SET Metadata_Plate ={column};\")\n\n if printtoscreen:\n print(f\"Indexing database {cache_backend_file}\")\n cursor.execute(\n \"CREATE INDEX IF NOT EXISTS table_image_idx ON Image(TableNumber, ImageNumber);\"\n )\n for eachcompartment in [\"Cells\", \"Cytoplasm\", \"Nuclei\"]:\n cursor.execute(\n f\"\"\"CREATE INDEX IF NOT EXISTS table_image_object_{eachcompartment.lower()}_idx \n ON {eachcompartment}(TableNumber, ImageNumber, ObjectNumber);\"\"\"\n )\n cursor.execute(\n \"CREATE INDEX IF NOT EXISTS plate_well_image_idx ON Image(Metadata_Plate, Metadata_Well);\"\n )\n cursor.close()\n connection.close()\n\n if aws_remote:\n if printtoscreen:\n print(f\"Uploading {cache_backend_file} to {remote_backend_file}\")\n cp_cmd = [\"aws\", \"s3\", \"cp\", cache_backend_file, remote_backend_file]\n run_check_errors(cp_cmd)\n\n if printtoscreen:\n print(\n f\"Removing analysis files from {input_dir} and {cache_backend_dir}\"\n )\n import shutil\n\n shutil.rmtree(input_dir)\n\n if printtoscreen:\n print(f\"Renaming {cache_backend_file} to {backend_file}\")\n os.rename(cache_backend_file, backend_file)\n\n if printtoscreen:\n print(f\"Aggregating sqlite:///{backend_file}\")\n\n if aggregate_only and aws_remote:\n remote_backend_file = f\"{aws_remote}/backend/{batch}/{plate}/{plate}.sqlite\"\n\n remote_aggregated_file = f\"{aws_remote}/backend/{batch}/{plate}/{plate}.csv\"\n\n cp_cmd = [\"aws\", \"s3\", \"cp\", remote_backend_file, backend_file]\n if printtoscreen:\n print(\n f\"Downloading SQLite files from {remote_backend_file} to {backend_file}\"\n )\n run_check_errors(cp_cmd)\n\n if not os.path.exists(backend_file):\n sys.exit(f\"{backend_file} does not exist. Exiting.\")\n\n if add_image_features:\n pass\n else:\n image_feature_categories = None # defensive but not sure what will happen if we give a list but set to False\n\n database = SingleCells(\n f\"sqlite:///{backend_file}\",\n aggregation_operation=\"mean\",\n add_image_features=add_image_features,\n image_feature_categories=image_feature_categories,\n )\n database.aggregate_profiles(output_file=aggregated_file)\n\n if aws_remote:\n if printtoscreen:\n print(f\"Uploading {aggregated_file} to {remote_aggregated_file}\")\n csv_cp_cmd = [\"aws\", \"s3\", \"cp\", aggregated_file, remote_aggregated_file]\n run_check_errors(csv_cp_cmd)\n\n if printtoscreen:\n print(f\"Removing backend files from {backend_dir}\")\n import shutil\n\n shutil.rmtree(backend_dir)","def annotation_csv_consolidator(filenames, sessions=[], subjects=[], sensors=[]):\n \n single_sess_annotats = []\n c = 0\n for filename in filenames:\n single_sess_annotat = annotation_csv_importer(filename)\n if np.iterable(sessions) and len(sessions) == len(filenames):\n single_sess_index = [sessions[c],]*single_sess_annotat.shape[0]\n single_sess_annotat['session'] = single_sess_index\n if np.iterable(subjects) and len(subjects) == len(filenames):\n single_subj_index = [subjects[c],]*single_sess_annotat.shape[0]\n single_sess_annotat['subject'] = single_subj_index\n if np.iterable(sensors) and len(sensors) == len(filenames):\n single_sensor_index = [sensors[c],]*single_sess_annotat.shape[0]\n single_sess_annotat['sensor'] = single_sensor_index\n c += 1\n single_sess_annotats.append(single_sess_annotat)\n consolidate_annotation_data = pd.concat(single_sess_annotats)\n # consolidate_annotation_data = consolidate_annotation_data.reset_index(drop=False)\n # consolidate_annotation_data = consolidate_annotation_data.rename(columns={\"index\":\"index per sensor\"})\n return consolidate_annotation_data","def process_csv():\n csv_rows = []\n fieldnames = ['site',\n 'latitude',\n 'longitude',\n 'city',\n 'region_code',\n 'country_code',\n 'continent_code',\n 'min_ip_hex',\n 'max_ip_hex',\n 'transit_provider',\n 'min_ip',\n 'max_ip',\n 'ip_prefix',\n 'min_ipv6_hex',\n 'max_ipv6_hex',\n 'min_ipv6',\n 'max_ipv6',\n 'ipv6_prefix']\n\n location_map = build_location_map()\n\n # Read in the CSV file and augment the columns\n with open(INPUT_FILE, 'rb') as csvfile:\n reader = csv.DictReader(csvfile)\n\n for row in reader:\n csv_rows.append(process_row(row, location_map))\n\n # Write the new CSV file with new columns\n with open(OUTPUT_FILE, 'w') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n writer.writeheader()\n for row in csv_rows:\n writer.writerow(row)\n\n print(\"MLab Sites CSV generated at {0}\".format(OUTPUT_FILE))","def merge_csv_files(filelist):\n data = tables.DictList()\n for file_name in filelist:\n reader = csv.DictReader(open(file_name))\n data += list(reader)\n\n return data","def import_from_csv(self) -> None:\n logging.info('import_from_csv')\n if self.target_table and str(self.target_table).lower() in [\"issue\", \"version\"]:\n if self.file_path and exists(self.file_path):\n # Read CSV file\n csv_data = pd.read_csv(self.file_path).to_dict('records')\n\n # Import Version\n if str(self.target_table).capitalize() == \"Version\":\n # Overwrite option\n if self.overwrite:\n self.session.query(Version).delete()\n click.echo('Overwrite Version table')\n\n for version in csv_data:\n if all(item in list(version.keys()) for item in ['tag', 'start_date', 'end_date']):\n newVersion=Version(\n project_id=version['project_id'],\n name=version[\"name\"], \n tag=version[\"tag\"], \n start_date=datetime.strptime(version[\"start_date\"], '%Y-%m-%d %H:%M:%S.%f'), \n end_date=datetime.strptime(version[\"end_date\"], '%Y-%m-%d %H:%M:%S.%f'), \n )\n \n try:\n self.session.add(newVersion)\n compute_version_metrics(self.session, self.configuration.current_branch, newVersion.project_id)\n click.echo('Importing ' + str(len(csv_data)) + ' version(s) on database')\n except Exception:\n logging.error(Exception)\n else:\n logging.error(\"CSV file no contain minimal mandatory fields\")\n sys.exit('CSV file no contain minimal mandatory fields')\n\n # Import Issue\n if str(self.target_table).capitalize() == \"Issue\":\n # Overwrite option\n if self.overwrite:\n self.session.query(Issue).delete()\n click.echo('Overwrite Issue table')\n\n for issue in csv_data:\n if all(item in list(issue.keys()) for item in ['number', 'created_at', 'updated_at']):\n newIssue=Issue(\n project_id=issue['project_id'],\n number=issue[\"number\"],\n title=issue[\"title\"],\n created_at=datetime.strptime(issue[\"created_at\"], '%Y-%m-%d %H:%M:%S.%f'),\n updated_at=datetime.strptime(issue[\"updated_at\"], '%Y-%m-%d %H:%M:%S.%f'))\n\n try:\n self.session.add(newIssue)\n click.echo('Importing ' + str(len(csv_data)) + ' issue(s) on database')\n except Exception:\n logging.error(Exception)\n else:\n logging.error(\"CSV file no contain minimal mandatory fields\")\n sys.exit('CSV file no contain minimal mandatory fields') \n\n self.session.commit()\n else:\n logging.error('File not found')\n sys.exit('File not found')\n else:\n logging.error('Target table not found')\n sys.exit('Target table not found')","def _enumerate_csv(self, csv_input):\n csv_file = open(csv_input, 'rb') \n csv_reader = csv.reader(csv_file)\n next(csv_reader, None)\n for row in reader:\n yield row","def read_csv(self, path):\n for file in os.listdir(path):\n if file[-4:] == \".csv\":\n name = file[:-4]\n table_index_header = cfg.get_list(\"table_index_header\", name)\n filename = os.path.join(path, file)\n self.input_data[name] = pd.read_csv(\n filename,\n index_col=list(range(int(table_index_header[0]))),\n header=list(range(int(table_index_header[1]))),\n squeeze=(\"series\" not in name),\n )\n self.check_input_data(warning=False)\n self.add_meta_data()\n return self","def _process_csv_data(csv_file, user_data_map):\n with open(csv_file, 'r') as csvfile:\n rows = csv.reader(csvfile)\n for row in rows:\n if len(row) < 2:\n print('The CSV file is not in expected format.')\n raise Exception\n user_data_map[row[1].lower()] = row[0]","def load_from_csv(self):\n\n self._logger.info('Reading data coming from CSV files')\n\n sta = self.stations\n\n if sta != None:\n msta = \", \".join(sta)\n self._logger.debug('Using only stations {0}'.format(msta))\n\n # load the data\n v = list(self.variables)\n v.append('metadata')\n for i in v:\n if i in self.dataConfig:\n\n self._logger.debug('Reading %s...' % self.dataConfig[i])\n if i == 'metadata':\n dp_final = pd.read_csv(self.dataConfig[i],\n index_col='primary_id')\n #Ensure all stations are all caps.\n dp_final.index = [s.upper() for s in dp_final.index]\n\n elif self.dataConfig[i]:\n dp_full = pd.read_csv(self.dataConfig[i],\n index_col='date_time',\n parse_dates=[0])\n dp_full.columns = [s.upper() for s in dp_full.columns]\n\n if sta is not None:\n\n data_sta = dp_full.columns.str.upper()\n\n # Grab IDs from user list thats also in Data\n self.stations = [s for s in data_sta if s in sta]\n dp = dp_full[dp_full.columns[(data_sta).isin(sta)]]\n\n else:\n dp = dp_full\n\n # Only get the desired dates\n dp_final = dp[self.start_date:self.end_date]\n\n if dp_final.empty:\n raise Exception(\"No CSV data found for {0}\"\n \"\".format(i))\n\n setattr(self, i, dp_final)","def _reformat_csv(self, csv):\n\n # avoid using extra backslashes because sed uses them as delimiter\n date = csv[-19:-9].replace('/', '-')\n cmds = [f'cut -d , -f 1 --complement <{csv} >{csv}.new',\n f'mv {csv}.new {csv}',\n f'sed -i \"1d\" {csv}',\n f'sed -i \"s/AS//g\" {csv}',\n f'sed -i \"s/,/\\t/g\" {csv}',\n f'sed -i \"s/$/\\t{date}/\" {csv}']\n\n utils.run_cmds(cmds)","def get_files(self):\n\n # Grab master data - use existing header, remove unhappy columns\n\n self.df_mas_lab_data = pd.read_csv(\n self.master_csv, dtype=str, usecols=self.columns\n )\n\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\n # Physician Office\n facility_type_keep_list = [\"Independent\", \"Hospital\", \"Physician Office\"]\n self.df_mas_lab_data = self.df_mas_lab_data[\n self.df_mas_lab_data[\"FACILITY_TYPE\"].isin(facility_type_keep_list)\n ]\n\n # Make everything a string and remove trailing and leading whitespaces\n self.df_mas_lab_data = self.df_mas_lab_data.astype(str)\n self.df_mas_lab_data = self.df_mas_lab_data.applymap(\n lambda x: x.strip() if isinstance(x, str) else x\n )\n\n print_banner(\"Computing all the Data\")\n print(f\"{len(self.df_mas_lab_data)} original master CLIA labs...\")\n\n # Grab other inputed files to make new data file to compare with\n self.df_new_lab_data = pd.concat(\n [\n pd.read_csv(file, names=self.columns, header=None, dtype=str, usecols=self.columns)\n for file in self.new_files\n ]\n )\n\n # Probably not needed for the new data but just in case:\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\n # Physician Office\n self.df_new_lab_data = self.df_new_lab_data[\n self.df_new_lab_data[\"FACILITY_TYPE\"].isin(facility_type_keep_list)\n ]\n\n # Make everything a string and remove trailing and leading whitespaces\n self.df_new_lab_data = self.df_new_lab_data.astype(str)\n self.df_new_lab_data = self.df_new_lab_data.applymap(\n lambda x: x.strip() if isinstance(x, str) else x\n )\n\n print(f\"{len(self.df_new_lab_data)} inputted CLIA labs for comparison...\")","def place_types_read_csv(self, csv_input):\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)","def renameCSVColumns(CSVPathOrList,targetDir,renameDict,indepToAdd=None):\n if not isinstance(CSVPathOrList, list):\n CSVPathOrList = [CSVPathOrList]\n if indepToAdd is not None:\n if not isinstance(indepToAdd, list):\n indepToAdd = [indepToAdd]\n if len(CSVPathOrList)!=len(indepToAdd):\n print(\"each data set needs independed variables if you use them\")\n return None\n outList=[]\n for CSVPath, i in zip(CSVPathOrList,range(len(CSVPathOrList))):\n CSVData = pd.read_csv(CSVPath)\n CSVData=CSVData.rename(columns=renameDict)\n if indepToAdd is not None:\n for myKey, myVal in indepToAdd[i].items():\n CSVData[myKey+\"_indep\"]=myVal\n newPath = os.path.join(targetDir,os.path.split(CSVPath)[1])\n CSVData.to_csv(newPath,index=False)\n outList.append(newPath)\n if len(outList)==1:\n outList=outList[0]\n return outList","def process(fileglob):\n\n filepaths = glob.glob(fileglob)\n\n for filepath in filepaths:\n datum_list = []\n aggregated_data = {'user_id': None, 'n': 0, 'sum': 0, 'min': 0, 'max': 0}\n\n for parsed_row in extract_csv_data(filepath):\n\n if aggregated_data['user_id'] is None:\n aggregated_data['user_id'] = parsed_row['user_id']\n\n if aggregated_data['user_id'] != parsed_row['user_id']:\n # We want earliest 'date' datum first.\n sorted_datum = sorted(datum_list, key=lambda k: k['date'])\n\n for datum in sorted_datum:\n aggregated_data = update_aggregated_data(aggregated_data, datum)\n\n aggregated_data = finalize_aggregated_data(aggregated_data)\n\n # Dump current stack of user info to output file.\n dump_aggregated_data(aggregated_data, output_filepath(filepath))\n\n # Re-initialize\n datum_list = []\n aggregated_data = {'user_id': parsed_row['user_id'], 'n': 0, 'sum': 0, 'min': 0, 'max': 0}\n\n \"\"\"\n We are still on same user_id so just append to datum_list.\n \"\"\"\n datum_list.append(parsed_row)\n\n\n \"\"\"\n At end of csv file, roll-up and dump last chunk of user_data.\n \"\"\"\n\n sorted_datum = sorted(datum_list, key=lambda k: k['date'])\n\n for datum in sorted_datum:\n aggregated_data = update_aggregated_data(aggregated_data, datum)\n\n aggregated_data = finalize_aggregated_data(aggregated_data)\n\n dump_aggregated_data(aggregated_data, output_filepath(filepath))","def parse_csv_files(csv_files, **kwargs):\n\n per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\n slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\n\n for file in csv_files:\n per_file_base_prices = {}\n for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):\n if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token\n per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes\n\n slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size\n # i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]\n\n slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000\n price_diff = (totle_price - exchange_price) / exchange_price\n\n slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))\n per_token_savings[token][trade_size][exchange].append(pct_savings)\n\n\n return per_token_savings, slip_price_diff_splits","def process_file(input_file, output_good, output_bad):\n\t# Lists containing good and bad rows\n\tlist_good = []\n\tlist_bad = []\n\t# Open csv file \n\twith open(input_file, 'r') as f:\n\t\t# Create reader from csv and store header row\n\t\treader = csv.DictReader(f)\n\t\theader = reader.fieldnames\n\t\t# Store useful keys\n\t\tyear = 'productionStartYear'\n\t\turi = 'URI'\n\t\t# Loop through all rows\n\t\tfor row in reader:\n\t\t\t# Discard rows with a URI not from DBpedia\n\t\t\tif not row[uri].startswith('http://dbpedia.org'):\n\t\t\t\tcontinue\n\t\t\t# Extract year from datetime\n\t\t\tyear_value = row[year][:4]\n\t\t\t# Change row datetime value to its year\n\t\t\trow[year] = year_value\n\t\t\t# Check if year actually contains a year\n\t\t\tif not row[year].isdigit():\n\t\t\t\t# Add to list_bad\n\t\t\t\tlist_bad.append(row)\n\t\t\t\tcontinue\n\t\t\t# Check if year falls within expected range\n\t\t\tif int(row[year]) < 1886 or int(row[year]) > 2014:\n\t\t\t\t# Add list to bad\n\t\t\t\tlist_bad.append(row)\n\t\t\t\tcontinue\n\t\t\t# Row is proper, add to list_good\n\t\t\tlist_good.append(row)\n\t\t\n\t\t# Open good ouput file, write the good rows to it\n\t\twith open(output_good, 'w') as csvfile:\n\t\t\twriter = csv.DictWriter(csvfile, delimiter = ',', fieldnames = header)\n\t\t\twriter.writeheader()\n\t\t\tfor item in list_good:\n\t\t\t\twriter.writerow(item)\n\n\t\t# Open bad ouput file, write the nad rows to it\n\t\twith open(output_bad, 'w') as csvfile:\n\t\t\twriter = csv.DictWriter(csvfile, delimiter = ',', fieldnames = header)\n\t\t\twriter.writeheader()\n\t\t\tfor item in list_bad:\n\t\t\t\twriter.writerow(item)","def test_36_bulk_csv_import_dup_header(self, Mock, mock):\r\n empty_file = FakeRequest('Foo,Bar,Foo\\n1,2,3', 200,\r\n {'content-type': 'text/plain'})\r\n Mock.return_value = empty_file\r\n self.register()\r\n self.new_application()\r\n app = db.session.query(App).first()\r\n url = '/app/%s/tasks/import?template=csv' % (app.short_name)\r\n res = self.app.post(url, data={'csv_url': 'http://myfakecsvurl.com',\r\n 'formtype': 'csv'},\r\n follow_redirects=True)\r\n msg = \"The file you uploaded has two headers with the same name\"\r\n assert msg in res.data","def read_csv(self, csv_input):\n # https://stackoverflow.com/a/45063514\n dtypes = {\n 'lat': 'U',\n 'long': 'U'\n }\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\n\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)\n #print('Data read from CSV %s' % csv_input)","def merge(df_list):\n df_final = pd.read_csv(df_list[0])\n for ind, df in enumerate(df_list):\n if ind >= 1:\n temp_df = pd.read_csv(df_list[ind])\n temp_df = temp_df.drop(['lbl'], axis=1)\n df_final = pd.merge(df_final, temp_df, on=['author_id'])\n final_path = os.path.join(os.path.expanduser(\"~/Desktop/Age-Detection\"), \"merged-feature-collection.csv\")\n df_final.to_csv(final_path, sep=',', index=False)\n return final_path","def collect_csv(source_dir, dest_dir):\n source_dir = Path(source_dir)\n dest_dir = Path(dest_dir)\n for csvfile in source_dir.rglob(\"*.csv\"):\n species = normalized_species(csvfile)\n species_dir = dest_dir / species\n species_dir.mkdir(exist_ok=True, parents=True)\n date_time = normalized_datetime(csvfile)\n print(f\"Renaming {csvfile} to {species_dir / (date_time + '.csv')}\")\n csvfile.rename(species_dir / (date_time + \".csv\"))","def execute_processor(self):\n \n # pull in the parameter that has the file names we will process\n filename1 = self.param_dict['file1']\n filename2 = self.param_dict['file2']\n \n ''' these next 2 lines are the ones that I added to create a dummy row '''\n right_dummy = self.create_dummy_row( self.param_dict['dummy_rec_right'])\n left_dummy = self.create_dummy_row( self.param_dict['dummy_rec_left'])\n \n \n \n\n self.open_files(os.path.join(self.entry.working_directory,filename1), os.path.join(self.entry.working_directory,filename2))\n self.process_params()\n key_dict = self.create_key_match()\n file1_rec = self.read_file1(first=True)\n file2_rec = self.read_file2(first=True)\n \n file2_used = False\n \n # call the convenience method to setup the temp_csv file. This will also write the header row by default\n self.setup_csv_temp_writer(self.get_temp_csv_name(), self.get_header(self.file1_reader.fieldnames,self.file2_reader.fieldnames),preserve_order=True)\n \n while file1_rec:\n combined = {k:v for k,v in file1_rec.items()}\n if file2_rec and self.get_key(file2_rec,self.file2_key) == self.get_key(file1_rec,self.file1_key):\n # merge these two bad boys\n combined.update(self.get_values(file2_rec))\n file2_used = True\n ### WRITE ###\n self.write_temp_rec(combined)\n file1_rec = self.read_file1()\n elif file2_rec and self.get_key(file1_rec,self.file1_key) > self.get_key(file2_rec,self.file2_key):\n if not file2_used and left_dummy:\n ''' left side dummy \n now use the already created dummy_row to updated the dictionary '''\n left_dummy.update(self.get_values(file2_rec))\n key_fields = {key_dict[k]:file2_rec[k] for k in self.file2_key.split(\",\")}\n left_dummy.update(key_fields)\n self.write_temp_rec(left_dummy)\n left_dummy = self.create_dummy_row( self.param_dict['dummy_rec_left'])\n \n \n file2_rec = self.read_file2()\n file2_used = False\n \n elif not file2_rec or self.get_key(file1_rec,self.file1_key) < self.get_key(file2_rec,self.file2_key):\n ### WRITE REC WITH NO MATCH ###\n if self.keep_nomatch:\n ''' right side dummy\n now use the already created dummy_row to updated the dictionary '''\n if right_dummy:\n combined.update(self.get_values(right_dummy))\n self.write_temp_rec(combined)\n file1_rec = self.read_file1()\n else:\n raise Exception\n self.close_temp_csv()\n return 0","def main(input_filepath, output_filepath):\n # return processed data and save in the output files\n in_data_y, y_output, in_data = make_data_set(input_filepath)\n in_data_y.to_csv(output_filepath)\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')\n return in_data_y, y_output, in_data","def recalc_csv(input_path, config_file, family_name, source_string, quiet):\n csv_file = getCsvPath(input_path)\n\n if not config_file:\n config_file = getConfigPath(input_path)\n\n # If config.json doesn't exist, it has to be created before.\n if not os.path.exists(config_file):\n configHandler(config_file).resetConfig()\n click.secho('\\n{} didn\\'t exist and has been created'.format(\n config_file), fg='yellow')\n\n if os.path.exists(csv_file) and not quiet:\n confirmation = click.confirm(\n '\\n{} already exists. Do you want to overwrite it?'.format(csv_file))\n if confirmation is True:\n csvHandler(csv_file).recalcCSV(\n config_file=config_file, family_name=family_name, source_string=source_string)\n click.secho('\\n{} created'.format(csv_file), fg='green')\n else:\n # Let's ensure that, if the data.csv file doesn't exist,\n # it is created before recalculation.\n if not os.path.exists(csv_file):\n csvHandler(csv_file).resetCSV(config_file=config_file)\n\n csvHandler(csv_file).recalcCSV(\n config_file=config_file, family_name=family_name, source_string=source_string)\n click.secho('\\n{} created'.format(csv_file), fg='green')","def process_csvs(conn: Connection, basedir: Path) -> None:\n process_files(conn, basedir/\"files.csv\")\n process_notes(conn, basedir/\"notes.csv\")\n process_links(conn, basedir/\"links.csv\")\n process_clusters(conn, basedir/\"clusters.csv\")\n process_bibliography(conn, basedir/\"bibliography.csv\")\n process_citations(conn, basedir/\"citations.csv\")","def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\n with open(attach_path(answer_file_path), 'r') as answer_file:\n csv_file = open(attach_path(input_file_path))\n assert str(read_csv(csv_file)) == answer_file.read().strip()","def process_input_data(input_data_path):\n if os.path.isdir(input_data_path):\n input_data_glob = glob.glob(input_data_path + \"/*.csv\")\n else:\n if is_gcs_path(input_data_path):\n # Download the input to a local\n with tempfile.NamedTemporaryFile() as hf:\n input_data = hf.name\n\n logging.info(\"Copying %s to %s\", input_data_path, input_data)\n input_data_gcs_bucket, input_data_gcs_path = split_gcs_uri(\n input_data_path)\n\n logging.info(\"Download bucket %s object %s.\", input_data_gcs_bucket,\n input_data_gcs_path)\n bucket = storage.Bucket(storage.Client(), input_data_gcs_bucket)\n storage.Blob(input_data_gcs_path, bucket).download_to_filename(\n input_data)\n else:\n input_data = input_data_path\n\n ext = os.path.splitext(input_data)[-1]\n if ext.lower() == '.zip':\n zip_ref = zipfile.ZipFile(input_data, 'r')\n zip_ref.extractall('.')\n zip_ref.close()\n # TODO: Hardcoding the file in the Archive to use is brittle.\n # We should probably just require the input to be a CSV file.:\n csv_file = 'stackoverflow-questions.csv'\n else:\n csv_file = input_data\n\n input_data_glob = glob.glob(csv_file)\n\n return input_data_glob","def mani2():\r\n #open the original file\r\n with open('csvfile1.csv', 'r') as csvfile1:\r\n #read the csv file\r\n csv_reader = csv.reader(csvfile1)\r\n\r\n #open the new csv file \r\n with open('csvfile2.csv', 'w') as csvfile2:\r\n #write to it with another delimeter\r\n csv_writer = csv.writer(csvfile2, delimiter='-')\r\n #loop through the line\r\n for line in csv_reader:\r\n csv_writer.writerow(line)","def prepare_data(\n self,\n csv_file_path='../data/train-orig.csv',\n tiff_folder_path='../data/train/', # for validation: '../data/valid'\n mixup: bool = False,\n for_training=True,\n data_ratio_mixup=2,\n alpha_mixup=0.2,\n # if True, standardization parameters will be computed, if False then apply parameters computed from training data\n ):\n self.data = read_data(\n csv_file_path=csv_file_path,\n tiff_folder_path=tiff_folder_path,\n )\n # Mixup\n if mixup:\n self.mixup_data(data_ratio_produce=data_ratio_mixup, alpha=alpha_mixup)\n\n ### augment, do whatever you want (distinguish between train and validation setting!)","def from_csv(\n cls,\n supply_csv: str,\n requests_csv: str,\n ) -> \"list[TransicationRecord]\":\n results = [None] * cls.SUPPLIER_COUNT\n with open(supply_csv, 'r', encoding='utf8') as s:\n reader = csv.reader(s)\n _header = next(reader)\n for row in reader:\n src_t = SrcType(row[1])\n sid = int(row[0][1:]) - 1\n data = [float(i) for i in row[2:]]\n results[sid] = TransicationRecord(row[0], sid, src_t, data)\n with open(requests_csv, 'r', encoding='utf8') as r:\n reader = csv.reader(r)\n _header = next(reader)\n for row in reader:\n sid = int(row[0][1:]) - 1\n data = [float(i) for i in row[2:]]\n results[sid].requests = np.array(data)\n for r in results:\n r.update_request_state()\n return results","def load_or_new(cls, csv_path, image_files):\n if os.path.exists(csv_path):\n return cls.from_csv(csv_path)\n else:\n return cls.graphical(image_files)","def pre_process_reviews(csv, outputname):\n df = pd.read_csv(csv)\n df = df.drop(\"Unnamed: 0\", axis='columns')\n df.to_csv(outputname, index=False)","def merge_csvs(metrics_csv_dims,metrics_csv_int,region,wk_dir):\n dict_dims = load_and_transpose_csv(metrics_csv_dims)\n dict_int = load_and_transpose_csv(metrics_csv_int)\n dict_dims.update(dict_int.copy())\n fname = os.path.join(wk_dir,region.replace(' ','_') + '_summary.csv')\n fields = [*dict_dims]\n models = ['Metric']+[*dict_dims[fields[0]]]\n\n with open(fname,'w') as f:\n writer = csv.DictWriter(f,fieldnames=models)\n writer.writeheader()\n for field in fields:\n row = {'Metric': field}\n row.update(dict_dims.get(field,{}))\n writer.writerow(row)\n\n data_desc = {\n os.path.basename(fname): {\n 'longname': os.path.basename(fname).split('.')[1].replace('_',' '),\n 'description': 'Parameters and metrics for ' + region + ' region'}}\n\n # add metadata to output.json\n asop.update_output_json('metrics', data_desc, wk_dir)","def merge_csv(csv_files):\n results = dict()\n data_all = list()\n keys = set()\n for filename in csv_files:\n data, row_len = load_csv_to_dict(filename)\n keys |= set(data.keys())\n data_all.append((data, row_len))\n for key in keys:\n values = list()\n for value, row_len in data_all:\n fill = [\"0\"]*row_len\n dt = value[key] if key in value else fill\n values.extend(dt)\n results[key] = values\n return results","def emp_import():\n\twhile True:\n\t\ttry:\n\t\t\tfile_path = input(\"Enter the path of your file or enter 'quit' to go back to menu.\\n File Path: \")\n\t\texcept FileNotFoundError:\n\t\t\tprint(\"File Not Found Error.\")\n\t\t\tcontinue\n\t\tif file_path == \"quit\":\n\t\t\treturn\n\t\telif not os.path.exists(file_path) and not os.path.isfile(file_path):\n\t\t\tprint(\"Invalid Path.\")\n\t\t\tcontinue\n\t\telif file_path.lower().endswith(('.csv')) == False:\n\t\t\tprint(\"Please Choose a CSV File!\")\n\t\t\tcontinue\n\t\telse:\n\t\t\tprint(\"File Found!\")\n\t\t\tbreak\n\tnew_lines = list()\n\tlines = list()\n\twith open(file_path, 'r') as f:\n\t\treader = csv.reader(f)\n\t\tfor row in reader:\n\t\t\tnew_lines.append(row)\n\twith open(\"employees.csv\", 'r') as readFile:\n\t\treader = csv.reader(readFile)\n\t\tnext(reader, None)\n\t\tfor row in reader:\n\t\t\tlines.append(row)\n\tnew_list = new_lines + lines\n\tto_add = set(tuple(row) for row in new_list)\n\twith open('employees.csv', 'w', newline='') as writeFile:\n\t\twriter = csv.writer(writeFile)\n\t\twriter.writerows(to_add)\n\t\tprint(\"Employees Added.\")\n\t\treturn","def _load_single_file(self, table_name, manifest_row, csv_reader,\n temp_filepath):\n # get database interface and it's equivalent manifest row\n sql_interface = self._configure_db_interface(\n manifest_row=manifest_row, temp_filepath=temp_filepath)\n\n sql_manifest_row = sql_interface.get_sql_manifest_row()\n\n cleaner = self._get_cleaner(table_name=table_name,\n manifest_row=manifest_row)\n csv_writer = CSVWriter(meta=self.meta,\n manifest_row=manifest_row,\n filename=temp_filepath)\n\n # clean the file and save the output to a local pipe-delimited file\n # if it doesn't have a 'loaded' status in the database manifest\n if csv_reader.should_file_be_loaded(sql_manifest_row=sql_manifest_row):\n print(\" Cleaning...\")\n meta_only_fields = self._get_meta_only_fields(\n table_name=table_name, data_fields=csv_reader.keys)\n for idx, data_row in enumerate(csv_reader):\n data_row.update(meta_only_fields) # insert other field dict\n clean_data_row = cleaner.clean(data_row, idx)\n if clean_data_row is not None:\n csv_writer.write(clean_data_row)\n\n csv_writer.close()\n\n # write the data to the database\n self._update_database(sql_interface=sql_interface)\n\n if not self._keep_temp_files:\n csv_writer.remove_file()","def perform_process(transformer: transformer_class.Transformer, check_md: dict) -> dict:\n # Process each CSV file into BETYdb\n start_timestamp = datetime.datetime.now()\n files_count = 0\n files_csv = 0\n lines_read = 0\n error_count = 0\n files_loaded = []\n for one_file in check_md['list_files']():\n files_count += 1\n if os.path.splitext(one_file)[1].lower() == '.csv':\n files_csv += 1\n\n # Make sure we can access the file\n if not os.path.exists(one_file):\n msg = \"Unable to access csv file '%s'\" % one_file\n logging.debug(msg)\n return {'code': -1000,\n 'error': msg}\n\n try:\n # Read in the lines from the file\n with open(one_file, 'r') as in_file:\n reader = csv.DictReader(in_file)\n files_loaded.append(one_file)\n for row in reader:\n centroid_lonlat = [row['lon'], row['lat']]\n time_fmt = row['dp_time']\n timestamp = row['timestamp']\n dp_metadata = {\n \"source\": row['source'],\n \"value\": row['value']\n }\n trait = row['trait']\n\n __internal__.create_datapoint_with_dependencies(transformer.args.clowder_url, transformer.args.clowder_key,\n trait, (centroid_lonlat[1], centroid_lonlat[0]), time_fmt,\n time_fmt, dp_metadata, timestamp)\n lines_read += 1\n\n except Exception:\n logging.exception(\"Error reading CSV file '%s'. Continuing processing\", os.path.basename(one_file))\n error_count += 1\n\n if files_csv <= 0:\n logging.info(\"No CSV files were found in the list of files to process\")\n if error_count > 0:\n logging.error(\"Errors were found during processing\")\n return {'code': -1001, 'error': \"Too many errors occurred during processing. Please correct and try again\"}\n\n return {\n 'code': 0,\n configuration.TRANSFORMER_NAME: {\n 'version': configuration.TRANSFORMER_VERSION,\n 'utc_timestamp': datetime.datetime.utcnow().isoformat(),\n 'processing_time': str(datetime.datetime.now() - start_timestamp),\n 'num_files_received': str(files_count),\n 'num_csv_files': str(files_csv),\n 'lines_loaded': str(lines_read),\n 'files_processed': str(files_loaded)\n }\n }","def csvs_scattered_to_grouped(path_dir, inlist, outlist, gcols,\n sort=1, scols=None, catalog=\"\", supersede=False):\n\n filelist=[os.path.join(path_dir,i) for i in inlist]\n n_split=len(outlist)\n\n pdfs=pd.read_csv(filelist[0],usecols=gcols)\n pdfs.drop_duplicates(inplace=True)\n\n print(\"csvs_scattered_to_grouped: Collecting items for group.\\n\")\n for i in range(1,len(filelist)):\n pdfs=pdfs.append(pd.read_csv(filelist[i],usecols=gcols),ignore_index=True)\n pdfs.drop_duplicates(inplace=True)\n\n if sort==1:\n pdfs.sort_values(gcols,inplace=True, ascending=True)\n elif sort==-1:\n pdfs.sort_values(gcols,inplace=True, ascending=False)\n\n aa_ed=np.array_split(pdfs, n_split)\n\n if supersede:\n for i in outlist:\n if os.path.isfile(os.path.join(path_dir,i)):\n os.remove(os.path.join(path_dir,i))\n if os.path.isfile(os.path.join(path_dir,str(catalog))):\n os.remove(os.path.join(path_dir,str(catalog)))\n\n print(\"csvs_scattered_to_grouped: Start processing files:\\n\")\n for i in range(0,len(filelist)):\n fi=pd.read_csv(filelist[i],usecols=scols)\n for j,ja in enumerate(aa_ed):\n wrtj=pd.merge(ja, fi, how='inner', on=gcols)\n append_to_csv(wrtj, os.path.join(path_dir,outlist[j]))\n print('csvs_scattered_to_grouped: '+str(i)+' file(s) finished.')\n\n if catalog:\n for i, d in enumerate(aa_ed):\n d['_@_FILE_']=outlist[i]\n append_to_csv(d, os.path.join(path_dir,str(catalog)))\n print('csvs_scattered_to_grouped: Catalog file created.')","def load(*args):\r\n\r\n #args[0].to_csv(str(PATH.joinpath('./data/{}.csv'.format(args[1]))),index=False)\r\n\r\n try: # it will fail if duplicates\r\n args[0].to_sql('cmf', con=engine, if_exists='append', index=False)\r\n except:\r\n pass","def ingest_file(input, fields, advanced_operators, output, delimiter=',', quotechar='\"'):\n with open(input, 'rb') as csv_file:\n reader = csv.DictReader(csv_file)\n\n with open(output, 'a') as write_csvfile:\n fieldnames = ['acronym', 'title', 'projectUrl',\n 'foundProjectUrl1', 'foundProjectUrl2',\n 'foundProjectUrl3', 'foundProjectUrl4',\n 'foundProjectUrl5', 'foundProjectUrl6',\n 'foundProjectUrl7', 'foundProjectUrl8',\n 'foundProjectUrl9', 'foundProjectUrl10']\n\n writer = csv.DictWriter(write_csvfile, fieldnames=fieldnames)\n writer.writeheader() # this method only available at python 2.7\n\n search_engine = SearchWeb()\n\n # iterate reader\n for row in reader:\n query_string = str(concatenate(row, fields))\n\n response = search_engine.search(query_string, advanced_operators)\n\n projectsUrl = []\n results_size = len(response)\n\n # TODO print with logger\n print \"INFO: RESULT SIZE - %s\" % results_size\n\n for i in range(10):\n if i < results_size:\n projectsUrl.append(response[i]['Url'])\n else:\n projectsUrl.append('')\n\n # TODO print with logger\n print \"INFO: FIRST RESULT - %s\" % projectsUrl[0]\n writer.writerow(dict(acronym=row['acronym'], title=row['title'], projectUrl=row['projectUrl'],\n foundProjectUrl1=projectsUrl[0], foundProjectUrl2=projectsUrl[1],\n foundProjectUrl3=projectsUrl[2], foundProjectUrl4=projectsUrl[3],\n foundProjectUrl5=projectsUrl[4], foundProjectUrl6=projectsUrl[5],\n foundProjectUrl7=projectsUrl[6], foundProjectUrl8=projectsUrl[7],\n foundProjectUrl9=projectsUrl[8], foundProjectUrl10=projectsUrl[9]))","def prepare_csv(self, filename, *args, **kwargs):\n x_possible = getattr(settings, 'IMPORT_CSV_X_FIELDS', ['Lon*', 'x', 'lon*'])\n y_possible = getattr(settings, 'IMPORT_CSV_Y_FIELDS', ['Lat*', 'y', 'lat*'])\n geom_possible = getattr(settings, 'IMPORT_CSV_GEOM_FIELDS',\n ['geom', 'GEOM', 'WKT', 'the_geom', 'THE_GEOM', 'WKB'])\n\n oo = kwargs.get('open_options', [])\n\n oo.append('X_POSSIBLE_NAMES={0}'.format(','.join(x_possible)))\n oo.append('Y_POSSIBLE_NAMES={0}'.format(','.join(y_possible)))\n oo.append('GEOM_POSSIBLE_NAMES={0}'.format(','.join(geom_possible)))\n\n kwargs['open_options'] = oo\n\n return filename, args, kwargs","def init_csv(input_path, config_file, quiet):\n\n if not config_file:\n config_file = getConfigPath(input_path)\n\n if not os.path.exists(config_file) or quiet:\n configHandler(config_file).resetConfig()\n click.secho('\\n{} didn\\'t exist and has been created'.format(\n config_file), fg='green')\n\n csv_file = getCsvPath(input_path)\n if not os.path.exists(csv_file) or quiet:\n confirm_overwrite = True\n else:\n confirm_overwrite = click.confirm(\n '{} already exists. Do you want to overwrite it?'.format(csv_file))\n\n if confirm_overwrite:\n if not os.path.exists(config_file):\n configHandler(config_file).resetConfig()\n csvHandler(csv_file).resetCSV(config_file=config_file)\n click.secho('{} created'.format(csv_file), fg='green')","def cell_map_from_csv(self, source_file: str) -> None:\n if source_file[-4:] == '.csv':\n try:\n self._import_source_data(source_file)\n except Exception:\n print(\"Problem with that CSV file. File extension?\")","def merge_duplicate_psm_rows(\n csv_file_path=None,\n psm_counter=None,\n psm_defining_colnames=None,\n psm_colnames_to_merge_multiple_values={},\n joinchar=\"<|>\",\n overwrite_file=True,\n):\n rows_to_merge_dict = defaultdict(list)\n\n if overwrite_file:\n tmp_file = csv_file_path + \".tmp\"\n os.rename(csv_file_path, tmp_file)\n out_file = csv_file_path\n else:\n tmp_file = csv_file_path\n out_file = csv_file_path.strip(\".csv\") + \"_merged_duplicates.csv\"\n UNode.print_info(\"Merging rows of the same PSM...\", caller=\"postflight\")\n # print('Merging rows of the same PSM...')\n csv_kwargs = {}\n if sys.platform == \"win32\":\n csv_kwargs[\"lineterminator\"] = \"\\n\"\n else:\n csv_kwargs[\"lineterminator\"] = \"\\r\\n\"\n with open(tmp_file, \"r\") as tmp, open(out_file, \"w\", newline=\"\") as out:\n tmp_reader = csv.DictReader(tmp)\n writer = csv.DictWriter(out, fieldnames=tmp_reader.fieldnames, **csv_kwargs)\n writer.writeheader()\n for row in tmp_reader:\n psm = tuple([row[x] for x in psm_defining_colnames if x in row.keys()])\n # each unique combination of these should only have ONE row!\n # i.e. combination of seq+spec+score\n if psm_counter[psm] == 1:\n # no duplicate = no problem, we can just write the row again\n writer.writerow(row)\n elif psm_counter[psm] > 1:\n # we have to collect all rows of this psm, and merge + write\n # them later!\n rows_to_merge_dict[psm].append(row)\n else:\n raise Exception(\"This should never happen.\")\n # finished parsing the old unmerged unified csv\n for rows_to_merge in rows_to_merge_dict.values():\n writer.writerow(\n merge_rowdicts(\n rows_to_merge,\n psm_colnames_to_merge_multiple_values,\n joinchar=joinchar,\n )\n )\n # remove the old unified csv that contains duplicate rows\n if overwrite_file:\n os.remove(tmp_file)\n UNode.print_info(\"Done.\", caller=\"postflight\")\n return out_file","def combine_syllable_csv():\n reading_csv = pd.read_csv(sys.argv[1])\n memory_csv = pd.read_csv(sys.argv[2])\n cookie_csv = pd.read_csv(sys.argv[3])\n merged = reading_csv.merge(memory_csv, on=TRANSCRIPT_ID)\n merged = merged.merge(cookie_csv, on=TRANSCRIPT_ID)\n merged.to_csv('jan27_merged_syllabus.csv', sep=',', header=True, index=False)","def test_37_bulk_csv_import_no_column_names(self, Mock, mock):\r\n empty_file = FakeRequest('Foo,Bar,Baz\\n1,2,3', 200,\r\n {'content-type': 'text/plain'})\r\n Mock.return_value = empty_file\r\n self.register()\r\n self.new_application()\r\n app = db.session.query(App).first()\r\n url = '/app/%s/tasks/import?template=csv' % (app.short_name)\r\n res = self.app.post(url, data={'csv_url': 'http://myfakecsvurl.com',\r\n 'formtype': 'csv'},\r\n follow_redirects=True)\r\n task = db.session.query(Task).first()\r\n assert {u'Bar': u'2', u'Foo': u'1', u'Baz': u'3'} == task.info\r\n assert \"1 Task imported successfully!\" in res.data","def enhance(parent_folder):\n parent_folder = Path(parent_folder).resolve()\n address_csv_files = sorted(parent_folder.glob('*.csv'))\n\n print(f'enhancing {len(address_csv_files)} csv files in {parent_folder}')\n\n data = Path(__file__).parent.parent.parent / 'data'\n workspace = (data / 'enhanced' / GDB_NAME).resolve()\n\n arcpy.env.workspace = str(workspace)\n\n for address_csv in address_csv_files:\n job = enhance_data(address_csv)\n\n prepare_output(job)\n convert_to_csv(job)\n remove_temp_tables(job)","def _check_duplicate_id_csv(self):\n all_csv_ids = []\n self.msg_args = []\n for csv_file_rel in self.filter_files_ext('csv', relpath=True):\n csv_file = os.path.join(self.module_path, csv_file_rel)\n if os.path.basename(csv_file) == 'ir.model.access.csv':\n all_csv_ids.extend(self.get_field_csv(csv_file))\n duplicated_ids_csv = self.get_duplicated_items(all_csv_ids)\n for duplicated_id_csv in duplicated_ids_csv:\n self.msg_args.append((csv_file_rel, duplicated_id_csv))\n if duplicated_ids_csv:\n return False\n return True","def read_csv():","def read_csv_input_file(self,\n file_name: str,\n usecols: list = None,\n names: list = None,\n remove_spurious_urls=False,\n unique_key=None\n ):\n\n # split the extension two time so we can also deal with a double extension bla.csv.zip\n file_base, file_ext = os.path.splitext(file_name)\n file_base2, file_ext2 = os.path.splitext(file_base)\n\n # build the cache file including the cache_directory\n cache_file = Path(CACHE_DIRECTORY) / (file_base2 + \".pkl\")\n\n if os.path.exists(cache_file):\n # add the type so we can recognise it is a data frame\n self.logger.info(\"Reading from cache {}\".format(cache_file))\n df: pd.DataFrame = pd.read_pickle(cache_file)\n df.reset_index(inplace=True)\n elif \".csv\" in (file_ext, file_ext2):\n self.logger.info(\"Reading from file {}\".format(file_name))\n df = pd.read_csv(file_name,\n header=None,\n usecols=usecols,\n names=names\n )\n\n if remove_spurious_urls:\n self.logger.info(\"Removing spurious urls\")\n df = self.remove_spurious_urls(df)\n\n df = self.clip_kvk_range(df, unique_key=unique_key, kvk_range=self.kvk_range_read)\n\n self.logger.info(\"Writing data to cache {}\".format(cache_file))\n df.to_pickle(cache_file)\n else:\n raise AssertionError(\"Can only read h5 or csv files\")\n\n try:\n df.drop(\"index\", axis=0, inplace=True)\n except KeyError:\n self.logger.debug(\"No index to drop\")\n else:\n self.logger.debug(\"Dropped index\")\n\n return df","def read_whole_csv_file(csvfile, numpy_option, **kwargs):\n import csv\n import numpy as np\n import sys\n sys.dont_write_bytecode = True\n # handles forgetting to type .csv\n if len(csvfile.split('.'))==1:\n csvfile = csvfile + '.csv'\n data_file_info = []\n if 'desired_lines' in kwargs:\n lines = kwargs['desired_lines']\n with open(csvfile, 'rb') as csvfile:\n myread = csv.reader(csvfile)\n for index, row in enumerate(myread):\n if index in lines:\n data_file_info.append(row)\n else:\n with open(csvfile, 'rb') as csvfile:\n myread = csv.reader(csvfile)\n for index, row in enumerate(myread):\n data_file_info.append(row)\n\n if 'unnecessary_lines' in kwargs:\n lines = kwargs['unnecessary_lines']\n lines = sorted(lines, reverse=True)\n for line in lines:\n del data_file_info[line]\n\n if numpy_option is True:\n data_file_info = np.array(data_file_info)\n return data_file_info","def read_csv():\n global csvdata\n global CONFIG\n if type(csvdata) == type(None):\n if not os.path.exists(CONFIG[\"csvfile\"]):\n csvdata = pandas.read_csv(CONFIG[\"csvrepo\"],\n na_values=[\"-999999\",\"NOT AVAILABLE\"])\n os.makedirs(CONFIG[\"cachedir\"],exist_ok=True)\n csvdata.to_csv(CONFIG[\"csvfile\"])\n else:\n csvdata = pandas.read_csv(CONFIG[\"csvfile\"])\n return csvdata","def process_header_data(spark, input_dir, output):\n\theader = spark.read \\\n\t\t.option(\"header\", True) \\\n\t\t.option(\"escape\", '\"') \\\n\t\t.option(\"inferSchema\", True) \\\n\t\t.csv(f\"{input_dir}/ams/*/*/ams__header_*__*.csv\") \\\n\t\t.select(*header_cols) \\\n\t\t.where(col('identifier').isNotNull())\n\n\tbill = spark.read \\\n\t\t.option(\"header\", True) \\\n\t\t.option(\"escape\", '\"') \\\n\t\t.option(\"inferSchema\", True) \\\n\t\t.csv(f\"{input_dir}/ams/*/*/ams__billgen_*__*.csv\") \\\n\t\t.select(*bill_cols)\n\n\theader_full = header.join(bill, ['identifier'], how='left')\n\n\theader_full.repartition(1).write.mode('overwrite').format(\"csv\") \\\n\t\t.option(\"header\", True) \\\n\t\t.option(\"escape\", '\"') \\\n\t\t.save(f\"{output}/header/\")","def test_csv_row_bug(script_runner, tmpdir, test_dir):\n csv_file = tmpdir / 'csv_file.csv'\n\n ret = script_runner.run(\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\n print(ret.stdout)\n print(ret.stderr, file=sys.stderr)\n assert ret.success\n\n assert csv_file.exists()\n\n with csv_file.open('r') as fo:\n reader = csv.reader(fo)\n rows = list(reader)\n assert len(rows) == len(test_dir.listdir()) + 1\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\n for i, row in enumerate(rows[1:]):\n assert row[0] and row[1]\n # Test entries except the timestamp and full file path.\n assert row[2:] == [\n 'fooconfigtest.txt',\n 'example output file',\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\n '127.0.0.1',\n ('[+] File test_{0}.txt identified as Foo.\\n'\n '[+] size of inputfile is 23 bytes\\n'\n '[+] operating on inputfile test_{0}.txt').format(i),\n 'http://127.0.0.1',\n ]","def get_concatenated_csv_data(concatenated_filepath, concatenated_filename, device_id, output_create_files_filepath, output_create_files_filename):\n\n # Create the full file name of the concatenated filename.\n concatenated_file = concatenated_filepath + \"/\" + concatenated_filename + \"_concatenated.csv\"\n print(\"Looking for concatenated file name: \", concatenated_file)\n\n # Test if the concatenated file exists and if it does, return it.\n if os.path.isfile(concatenated_file):\n print(\"Concatenated file exists: \", concatenated_file)\n return concatenated_file\n\n # If it does not exist, test if the individual files exist.\n elif not os.path.isfile(concatenated_file):\n print(\"Concatenated file does not exist. Create file: \", concatenated_file)\n file_list = get_data_from_files(concatenated_filepath, concatenated_filename)\n # print(\"File list:\", file_list)\n\n # If the individual files exist, create the concatenated file.\n if len(file_list) > 0:\n print(\"Individual csv files exist. Creating the concatenated file.\")\n concatenated_file = create_concatenated_csvfile(concatenated_filepath, concatenated_filename)\n return concatenated_file\n\n # If the individual files do not exist, get the data from the database, create the files then concatenate them.\n else:\n database_query = \"select * from ship_data_gpggagpsfix where device_id=\" + int(\n device_id) + \" order by date_time;\"\n # print(database_query)\n password = input()\n\n db_connection = MySQLdb.connect(host='localhost', user='ace', passwd=password, db='ace2016', port=3306);\n\n track_df = get_data_from_database(database_query, db_connection)\n track_df = string_to_datetime(track_df)\n\n # Output the data into daily files (as they do not already exist).\n output_daily_files(track_df, output_create_files_filepath, output_create_files_filename)\n\n concatenated_file = create_concatenated_csvfile(concatenated_filepath, concatenated_filename)\n return concatenated_file","def preprocess_files(file_path):\n # checking your current working directory\n cur_dir = os.getcwd()\n\n # Get your current folder and sub folder event data\n data_dir = os.path.join(cur_dir, 'event_data')\n\n # Create a for loop to create a list of files and collect each\n # file_path\n file_path_list = []\n for root, dirs, files in os.walk(data_dir):\n # join the file path and roots with the subdirectories using\n # glob\n file_path_list = glob.glob(os.path.join(root, '*'))\n\n full_data_rows_list = []\n\n # for every file_path in the file path list collect records\n for f in file_path_list:\n\n # reading csv file\n with open(f, 'r', encoding='utf8', newline='') as csvfile:\n\n # creating a csv reader object\n csvreader = csv.reader(csvfile)\n next(csvreader)\n\n # extracting each data row one by one and append it\n for line in csvreader:\n full_data_rows_list.append(line)\n\n csv.register_dialect('myDialect', quoting=csv.QUOTE_ALL,\n skipinitialspace=True)\n\n # create one file with all the records\n with open(file_path, 'w', encoding='utf8',\n newline='') as f:\n writer = csv.writer(f, dialect='myDialect')\n writer.writerow(\n ['artist', 'firstName', 'gender', 'itemInSession',\n 'lastName', 'length', 'level', 'location', 'sessionId',\n 'song', 'userId'])\n for row in full_data_rows_list:\n if row[0] == '':\n continue\n writer.writerow((row[0], row[2], row[3], row[4], row[5],\n row[6], row[7], row[8], row[12], row[13],\n row[16]))","def merge_files():\n # abs path of data folder\n work_folder = os.path.join(CURRENT_FOLDER, \"..\\\\Data\\\\weather_data\\\\KORD\")\n file_list = os.listdir(work_folder)\n with open(os.path.join(work_folder, \"..\\\\merged_history_KORD.csv\"), \"w\") as outfile:\n for line in open(os.path.join(work_folder, file_list[0])):\n outfile.write(line)\n print \"write the first line\"\n for i in range(1, len(file_list)):\n with open(os.path.join(work_folder, file_list[i])) as infile:\n infile.next()\n for line in infile:\n outfile.write(line)","def _init_train_valid(self, csv_path, csv_sep, csv_names):\n # load groundtruth\n # last element following a dot is file's extension\n print('Loading data...') \n if csv_path.split('.')[-1] == 'cache':\n # load cache\n # Assumes that the cache contains a list of all the identities, a dictionary containing metadata about those identities and the number of samples contained in the cache.\n # The dictionary must have the same format as the 'groundtruth_metadata' dictionary that is built below.\n # dati che mi servono: identities, groundtruth_metadata, num_samples\n with open(csv_path, 'rb') as cache_file:\n cache = pickle.load(cache_file)\n self.identities = cache['identities']\n self.groundtruth_metadata = cache['groundtruth_metadata']\n self.num_samples = cache['num_samples']\n else:\n # Assumes for the provided csv the following structure:\n # Path, ID, Gender, Age, x_min(roi_origin_x), y_min(roi_origin_y), width(roi_width), height(roi_height)\n groundtruth = pd.read_csv(csv_path, sep=csv_sep, names=csv_names)\n # for each groundtruth row\n for gt_sample in groundtruth.iterrows():\n identity = gt_sample[1][\"ID\"]\n # this iteration is over all of the elements in groundtruth, so the same id can be encountered multiple times (same id associated to multiple images)\n if identity not in self.identities:\n self.identities.append(identity)\n # load identity's metadata\n id_data = {\n 'age': gt_sample[1][\"Age\"],\n 'roi': {\n 'upper_left_x': gt_sample[1][\"x_min\"],\n 'upper_left_y': gt_sample[1][\"y_min\"],\n 'width': gt_sample[1][\"width\"],\n 'height': gt_sample[1][\"height\"]\n },\n 'path': gt_sample[1][\"Path\"]\n }\n if identity not in self.groundtruth_metadata.keys():\n self.groundtruth_metadata[identity] = {\n 'index': 0,\n 'metadata': []\n }\n # the other elements in the list associated to an identity are metadata \n self.groundtruth_metadata[identity]['metadata'].append(id_data)\n self.num_samples += 1\n # Dump loaded data to cache\n # Split csv path in directory path and filename\n (csv_dir, csv_name) = os.path.split(csv_path)\n # Create a name for cache file with the same name as csv file but different extension\n cache_name = csv_name.split('.')[0]+'.cache'\n # Create a path pointing to the new cache file, locating it in the same directory as the csv file\n cache_path = os.path.join(csv_dir, cache_name)\n # Write relevant data to file\n with open(cache_path, 'wb') as cache_out_file:\n out_dict = {}\n out_dict['identities'] = self.identities\n out_dict['groundtruth_metadata'] = self.groundtruth_metadata\n out_dict['num_samples'] = self.num_samples\n pickle.dump(out_dict, cache_out_file) \n print('Finished loading data!')\n if self.mode == 'training':\n self._shuffle()","def copy_csv_files(data_files_dict):\n # Depending on your local settings, you may need to specify a user and password, e.g.\n # conn = psycopg2.connect(dbname=DBNAME, user=\"postgres\", password=\"password\")\n conn = psycopg2.connect(dbname=DBNAME)\n\n for name, files in data_files_dict.items():\n csv_file = files[0]\n # skip the header; this info is already in the table schema\n next(csv_file)\n if name == \"train\":\n copy_csv_to_train_table(conn, csv_file)\n elif name == \"questions\":\n copy_csv_to_questions_table(conn, csv_file)\n elif name == \"lectures\":\n copy_csv_to_lectures_table(conn, csv_file)\n elif name == \"example_test\":\n copy_csv_to_example_test_table(conn, csv_file)\n elif name == \"example_sample_submission\":\n copy_csv_to_example_sample_submission_table(conn, csv_file)\n\n print(f\"\"\"Successfully loaded CSV file into `{name}` table\n \"\"\")\n\n conn.close()","def reformat_submission_files(self, submission_local_path=None):\n if submission_local_path is not None:\n sub_files = [f for f in listdir(submission_local_path) if isfile(join(submission_local_path, f))]\n for sub_file in sub_files:\n submission_local_file_path = '{}/{}'.format(submission_local_path, sub_file)\n sub_df = pd.read_csv(submission_local_file_path)\n if ('SK_ID_CURR' in sub_df.columns) and (sub_df.shape[0] == 48744):\n sub_df['SK_ID_CURR'] = sub_df['SK_ID_CURR'].astype(int)\n sub_df.to_csv(submission_local_file_path, index=False)\n else:\n os.remove(submission_local_file_path)","def import_csv_dataset():\n import_fields = pd.read_csv('redacted-2020-june-30-wprdc-.csv', header=None).to_numpy()[0, :]\n import_values = pd.read_csv('redacted-2020-june-30-wprdc-.csv').to_numpy()\n import_values = clean_values(import_values)\n return import_fields, import_values","def combine(self, input_file, output_file):\n \n csvOutput = self.csvData.readCsv(input_file)\n \n # Extract csv column names\n columnsNmes = csvOutput[0]\n \n response = []\n \n # Remove first row from csv output (columns names)\n iterCsvOutput = iter(csvOutput)\n next(iterCsvOutput)\n # Get all api data with one call\n apiResponse = self.apiData.getContent(self.apiUrl)\n\n # Iterate over Csv lines\n for item in iterCsvOutput: \n\n # For each CSV line find corresponding account in Api response\n for apiItem in apiResponse['results']:\n\n # I Api response match Csv row combine data\n if str(apiItem['account_id']) == item[0]: \n # Add response form Api\n item.insert(4, apiItem['status'])\n item.insert(5, apiItem['created_on'])\n response.append(item)\n \n # Add row with new column names\n columnsNmes.insert(4, 'Status')\n columnsNmes.insert(5, 'Status Set On')\n response.insert(0, columnsNmes)\n\n # Generate csv output file\n self.csvData.writeCsv(response, output_file)\n \n return 'Given output file has been generated'","def csv_file(input_file):\n\n current_dir = os.getcwd()\n directory_name = current_dir + '\\\\' + 'data' + '\\\\'\n csv_out = directory_name + input_file\n return csv_out","def merge_csv_files(files: List[str], outfile: str):\n\tlogthis.say('Merging files starts.')\n\tdata: pd.DataFrame = pd.DataFrame([], columns=['Label', 'Repo', 'Text'])\n\tnum_files = len(files)\n\tfor index, file in enumerate(files):\n\t\tlogthis.say(f'Merging files {100*(index+1)/num_files:.2f}% {index+1}/{num_files}')\n\t\tdf = pd.read_csv(file, sep=';')\n\t\tdata = pd.concat([df, data])\n\tlogthis.say(f'Write data to {outfile}')\n\tdata.to_csv(outfile, sep=';', index=False)\n\tlogthis.say('Merging files done.')","def main(file1, file2, uniq1=False, uniq2=False, union=False, tab=False, col1=1, col2=1):\n delimiter = \"\\t\" if tab else \",\"\n\n idx1 = col1 - 1\n idx2 = col2 - 1\n\n # Figure out what the mode of operation is.\n show = ISECT\n show = UNIQ1 if uniq1 else show\n show = UNIQ2 if uniq2 else show\n show = UNION if union else show\n\n if not os.path.isfile(file1):\n print(f\"file not found: {file1}\")\n sys.exit(1)\n\n # Get a stream for each file\n stream1 = get_stream(file1)\n stream2 = get_stream(file2)\n\n # Process the file.\n process(stream1=stream1, stream2=stream2, delimiter=delimiter, idx1=idx1, idx2=idx2, show=show)","def run(self):\n lineage_csv_gz = self.input_files_local[0][0]\n output_db = self.output_files_local()[0]\n log.write(f\"input: {lineage_csv_gz} output: {output_db}\")\n\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\n batch_list = {}\n with gzip.open(lineage_csv_gz, \"rt\") as gzf:\n for line in gzf:\n fields = line.rstrip().split(\",\")\n taxid = fields[0]\n species, genus, family = fields[-1:-4:-1]\n batch_list[taxid] = [species, genus, family]\n if len(batch_list) >= BATCH_INSERT_SIZE:\n lineage_dict.batch_inserts(batch_list.items())\n batch_list = {}\n lineage_dict.batch_inserts(batch_list.items())","def csv_to_ins_file(\n csv_filename,\n ins_filename=None,\n only_cols=None,\n only_rows=None,\n marker=\"~\",\n includes_header=True,\n includes_index=True,\n prefix=\"\",\n head_lines_len=0,\n sep=\",\",\n gpname=False,\n):\n # process the csv_filename in case it is a dataframe\n if isinstance(csv_filename, str):\n df = pd.read_csv(csv_filename, index_col=0)\n df.columns = df.columns.map(str.lower)\n df.index = df.index.map(lambda x: str(x).lower())\n else:\n df = csv_filename\n\n # process only_cols\n if only_cols is None:\n only_cols = set(df.columns.map(lambda x: x.lower().strip()).tolist())\n else:\n if isinstance(only_cols, str): # incase it is a single name\n only_cols = [only_cols]\n only_cols = set(only_cols)\n only_cols = {c.lower() if isinstance(c, str) else c for c in only_cols}\n\n if only_rows is None:\n only_rows = set(df.index.map(lambda x: x.lower().strip()).tolist())\n else:\n if isinstance(only_rows, str): # incase it is a single name\n only_rows = [only_rows]\n only_rows = set(only_rows)\n only_rows = {r.lower() if isinstance(r, str) else r for r in only_rows}\n\n # process the row labels, handling duplicates\n rlabels = []\n row_visit = {}\n only_rlabels = []\n for rname_org in df.index:\n rname = str(rname_org).strip().lower()\n if rname in row_visit:\n rsuffix = \"_\" + str(int(row_visit[rname] + 1))\n row_visit[rname] += 1\n else:\n row_visit[rname] = 1\n rsuffix = \"\"\n rlabel = rname + rsuffix\n rlabels.append(rlabel)\n if rname in only_rows or rname_org in only_rows:\n only_rlabels.append(rlabel)\n only_rlabels = set(only_rlabels)\n\n # process the col labels, handling duplicates\n clabels = []\n col_visit = {}\n only_clabels = []\n for cname_org in df.columns:\n cname = str(cname_org).strip().lower()\n if cname in col_visit:\n csuffix = \"_\" + str(int(col_visit[cname] + 1))\n col_visit[cname] += 1\n else:\n col_visit[cname] = 1\n csuffix = \"\"\n clabel = cname + csuffix\n clabels.append(clabel)\n if cname in only_cols or cname_org in only_cols:\n only_clabels.append(clabel)\n only_clabels = set(only_clabels)\n if len(only_clabels) == 0:\n print(\"only_cols:\", only_cols)\n raise Exception(\"csv_to_ins_file(): only_clabels is empty\")\n\n if ins_filename is None:\n if not isinstance(csv_filename, str):\n raise Exception(\"ins_filename is None but csv_filename is not string\")\n ins_filename = csv_filename + \".ins\"\n row_visit, col_visit = {}, {}\n onames = []\n ovals = []\n ognames = []\n only_clabels_len = len(only_clabels)\n clabels_len = len(clabels)\n prefix_is_str = isinstance(prefix, str)\n vals = df.values.copy() # wasteful but way faster\n with open(ins_filename, \"w\") as f:\n f.write(f\"pif {marker}\\n\")\n [f.write(\"l1\\n\") for _ in range(head_lines_len)]\n if includes_header:\n f.write(\"l1\\n\") # skip the row (index) label\n for i, rlabel in enumerate(rlabels): # loop over rows\n f.write(\"l1\")\n if rlabel not in only_rlabels:\n f.write(\"\\n\")\n continue\n c_count = 0\n line = \"\"\n for j, clabel in enumerate(clabels): # loop over columns\n\n if j == 0:\n # if first col and input file has an index need additional spacer\n if includes_index:\n if sep == \",\":\n # f.write(f\" {marker},{marker}\")\n line += f\" {marker},{marker}\"\n else:\n # f.write(\" !dum!\")\n line += \" !dum! \"\n\n if c_count < only_clabels_len:\n if clabel in only_clabels: # and rlabel in only_rlabels:\n oname = \"\"\n # define obs names\n if not prefix_is_str:\n nprefix = prefix[c_count]\n else:\n nprefix = prefix\n if len(nprefix) > 0:\n nname = f\"{nprefix}_usecol:{clabel}\"\n else:\n nname = f\"usecol:{clabel}\"\n oname = f\"{nname}_{rlabel}\"\n onames.append(oname) # append list of obs\n ovals.append(vals[i, j]) # store current obs val\n # defin group name\n if gpname is False or gpname[c_count] is False:\n # keeping consistent behaviour\n ngpname = None # nname\n elif gpname is True or gpname[c_count] is True:\n ngpname = nname # set to base of obs name\n else: # a group name has been specified\n if not isinstance(gpname, str):\n ngpname = gpname[c_count]\n else:\n ngpname = gpname\n ognames.append(ngpname) # add to list of group names\n # start defining string to write in ins\n oname = f\" !{oname}!\"\n line += f\" {oname} \"\n if j < len(clabels) - 1:\n if sep == \",\":\n line += f\" {marker},{marker} \"\n # else:\n # line += \" !dum! \"\n c_count += 1\n elif (\n j < len(clabels) - 1\n ): # this isnt a row-col to observationalize (nice word!)\n if sep == \",\":\n line += f\" {marker},{marker} \"\n else:\n line += \" !dum! \"\n f.write(line + \"\\n\")\n odf = pd.DataFrame(\n {\"obsnme\": onames, \"obsval\": ovals, \"obgnme\": ognames}, index=onames\n ).dropna(\n axis=1\n ) # dropna to keep consistent after adding obgnme\n return odf"],"string":"[\n \"def import_directory_csv(d_in, d_out, target_column, merge_columns):\\n\\n INPUT_FILES = grab_files(\\\"*.csv\\\", d_in)\\n\\n if not INPUT_FILES:\\n logger.warning(\\\"No matching CSV files found, exiting\\\")\\n exit(2)\\n\\n for f_csv in INPUT_FILES:\\n f_csv_out = os.path.join(d_out, os.path.basename(f_csv))\\n vals = (f_csv, f_csv_out, target_column, merge_columns)\\n import_csv(vals)\",\n \"def process_csv(csv_file=None):\\n if csv_file:\\n _process_csv_data(csv_file, USER_DATA_MAP)\\n else:\\n csv_files_list = [os.path.join(DATA_DIR, f) for f in os.listdir(DATA_DIR) if f.endswith('.csv')]\\n for fl in csv_files_list:\\n _process_csv_data(fl, USER_DATA_MAP)\\n return USER_DATA_MAP\",\n \"def sync_csv(arg):\\n files = os.listdir(arg.input_dir)\\n file_map = dict()\\n for f in files:\\n label = os.path.splitext(f)[0].split('_')\\n if len(label) < 2:\\n continue\\n if file_map.get(label[0], None) is None:\\n file_map[label[0]] = dict()\\n if label[1] == 'grid':\\n file_map[label[0]]['grid'] = f\\n else:\\n if file_map[label[0]].get('data', None) is None:\\n file_map[label[0]]['data'] = dict()\\n if file_map[label[0]]['data'].get(label[1], None) is None:\\n file_map[label[0]]['data'][label[1]] = []\\n file_map[label[0]]['data'][label[1]].append(f)\\n tar_name = 't{}'.format(datetime.now().strftime('%Y%m%d'))\\n tar_path = os.path.join(arg.output_dir, 'tar', tar_name)\\n if not os.path.exists(tar_path):\\n os.mkdir(tar_path)\\n i = 0\\n n = len(file_map)\\n for city, v in file_map.items():\\n i = i + 1\\n print('------ handle city [{}/{}]: {} -------'.format(i, n, city))\\n city_csv_path = os.path.join(arg.output_dir, 'csv', city)\\n city_sql_path = os.path.join(arg.output_dir, 'sql', city)\\n if not os.path.exists(city_csv_path):\\n os.mkdir(city_csv_path)\\n if not os.path.exists(city_sql_path):\\n os.mkdir(city_sql_path)\\n grid = v.get('grid', None)\\n if grid:\\n grid = os.path.splitext(grid)[0]\\n print('** handling grid ...')\\n tar_sql = os.path.join(tar_path, '{}.sql.gz'.format(grid))\\n if os.path.exists(tar_sql):\\n print('****** {} exist!'.format(tar_sql))\\n else:\\n shutil.copyfile(os.path.join(arg.input_dir, '{}.csv'.format(grid)),\\n os.path.join(city_csv_path, '{}.csv'.format(grid)))\\n trans_grid(city, city_csv_path, city_sql_path)\\n print('****** GZIP grid sql')\\n with open(os.path.join(city_sql_path, '{}.sql'.format(grid))) as fi, gzip.open(\\n os.path.join(tar_path, '{}.sql.gz'.format(grid)), 'wb') as fo:\\n fo.write(fi.read().encode())\\n data = v.get('data', None)\\n if data:\\n print('** handling data ...')\\n for week, data_files in data.items():\\n print('**** week: {}'.format(week))\\n tar_detail = os.path.join(tar_path, '{}_{}_detail.sql.tar.gz'.format(city, week))\\n if os.path.exists(tar_detail):\\n print('****** {} exist!'.format(tar_detail))\\n else:\\n for data_file in data_files:\\n shutil.copyfile(os.path.join(arg.input_dir, data_file), os.path.join(city_csv_path, data_file))\\n create_detail(city, week, 30000, city_csv_path, city_sql_path)\\n print('****** TAR detail sql')\\n with tarfile.open(tar_detail, 'w:gz') as f:\\n for city_week_detail in os.listdir(city_sql_path):\\n if city_week_detail.startswith('{}_{}_detail'.format(city, week)):\\n f.add(os.path.join(city_sql_path, city_week_detail), arcname=city_week_detail)\\n print('****** remove csv and sql file...')\\n for data_file in data_files:\\n os.remove(os.path.join(city_csv_path, data_file))\\n sql_files = os.path.join(city_sql_path, '{}_{}_detail*sql'.format(city, week))\\n for sql_file in glob.glob(sql_files):\\n os.remove(sql_file)\",\n \"def concat_vsource_sink_csv(csv_fn1,csv_fn2,merged_source_sink_in,\\n csv_type,csv_merged,freq='infer',how='left'):\\n # merged_source_sink_in: the merged source_sink.in or source_sink.yaml file \\n # where the data sources are from csv_fn1, csv_fn2. \\n if merged_source_sink_in.endswith('yaml'):\\n df_sources,df_sinks = read_source_sink_yaml(merged_source_sink_in)\\n elif merged_source_sink_in.endswith('in'):\\n df_sources,df_sinks = read_source_sink_in(merged_source_sink_in)\\n else:\\n raise NotImplementedError(\\n 'merged_source_sink_in can either be .yaml or .in file')\\n if csv_type == 'sources':\\n sites = df_sources.index\\n elif csv_type == 'sink':\\n sites = df_sinks.index\\n else:\\n raise NotImplementedError('csv_type can either be sources or sinks')\\n th1 = read_source_sink_csv(csv_fn1)\\n th2 = read_source_sink_csv(csv_fn2)\\n if freq=='infer':\\n if th1.index.freq!=th2.index.freq:\\n print(\\\"th1 and th2 has different frequency\\\")\\n else:\\n th1 = th1.asfreq(freq)\\n th2 = th2.asfreq(freq)\\n th_merged = th1.join(th2,how=how,rsuffix='r').drop(columns=['datetimer'])\\n th_merged = th_merged.fillna(-9999.0)\\n cols = np.append(['datetime'],sites)\\n th_merged = th_merged[cols] #rearrange the array to have the same order as defined in merged_source_sink_in\\n th_merged['datetime'] = np.datetime_as_string(th_merged.index.values,'h')\\n write_source_sink_csv(th_merged,csv_merged)\",\n \"def loadCSV(input_file):\",\n \"async def collate_similar_data(input_csv_file_path, output_csv_file_path):\\n if not input_csv_file_path or not output_csv_file_path:\\n return\\n with open(output_csv_file_path, 'w') as file_object:\\n csv_writer = csv.writer(file_object, delimiter=',')\\n csv_writer.writerow(\\n ('Account ID', 'First Name', 'Created On', 'Status',\\n 'Status Set On'))\\n for csv_row in read_csv_file(input_csv_file_path):\\n account_status = (await fetch_account_status(csv_row[0]))\\n csv_writer.writerow(csv_row + (\\n account_status.get('status', ''),\\n datetime.datetime.strftime(\\n datetime.datetime.strptime(\\n account_status.get('created_on'), '%Y-%m-%d'),\\n '%Y-%m-%d') if account_status.get('created_on') else ''))\",\n \"def merge(path_to_mf_lf_1, path_to_mf_lf_2, path_to_mf_hf_1, path_to_mf_hf_2, path_to_sf,\\n path_to_mf_lf, path_to_mf_hf, path_to_sf_copy):\\n mf_lf = merge_one_case(pd.read_csv(path_to_mf_lf_1, index_col=0), pd.read_csv(path_to_mf_lf_2, index_col=0))\\n mf_hf = merge_one_case(pd.read_csv(path_to_mf_hf_1, index_col=0), pd.read_csv(path_to_mf_hf_2, index_col=0))\\n sf = pd.read_csv(path_to_sf, index_col=0) # only bypassed\\n mf_lf.to_csv(path_to_mf_lf, index=True, header=True)\\n mf_hf.to_csv(path_to_mf_hf, index=True, header=True)\\n sf.to_csv(path_to_sf_copy, index=True, header=True)\",\n \"def process_file_import(self):\\r\\n directory_csv = [file for file in os.listdir() if file.endswith(\\\".csv\\\")]\\r\\n self.print_options(directory_csv,2)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Asks for user input. Then imports csv file based on user's input.\\r\\n \\\"\\\"\\\"\\r\\n n = (input(\\\"Which csv would you like to import? Please input the corresponding integer:\\\"))\\r\\n\\r\\n try:\\r\\n n = int(n)\\r\\n except:\\r\\n pass\\r\\n\\r\\n if isinstance(n, int) is True and n <= len(directory_csv):\\r\\n self.population.import_csv(directory_csv[int(n)-1])\\r\\n print(self.population)\\r\\n self.file_import()\\r\\n elif n == 'q':\\r\\n quit()\\r\\n elif n == 'b':\\r\\n self.menu_page()\\r\\n else:\\r\\n raise InputError(\\\"\\\\nPlease input a valid digit, 'q' or 'b'\\\")\",\n \"def merge(parent_folder):\\n parent_folder = Path(parent_folder)\\n\\n address_csv_files = sorted(parent_folder.glob('*_step_*.csv'))\\n\\n frames = []\\n\\n #: read all csv's delimiter='|', quoting=csv.QUOTE_MINIMAL\\n for address_csv_file in address_csv_files:\\n temp = pd.read_csv(\\n address_csv_file, sep='|', encoding='utf-8', names=['type', 'id', 'county', 'senate', 'house', 'census']\\n )\\n\\n frames.append(temp)\\n\\n #: merge all csv's\\n merged = pd.concat(frames)\\n merged.to_csv(parent_folder / 'all.csv', sep='|', header=False, index=False, encoding='utf-8')\",\n \"def from_csv(self):\\n timestamp_logname = \\\"from_csv_\\\" + datetime.today().strftime('%Y_%m_%d_%H_%M_%S')\\n csv_files = [f for f in self.args.files if f.endswith('.csv')]\\n if not csv_files:\\n self.logger.error(\\\"No CSV files found.\\\")\\n return False\\n\\n # Create an instance of the Ingestor class with common options set.\\n ingestor = Ingestor(**self.options)\\n\\n # Ingest from each CSV file.\\n for csv_file in csv_files:\\n data_groups = Ingestor.process_csv(csv_file)\\n for mask, routes, deployment_number in data_groups:\\n ingestor.load_queue(mask, routes, deployment_number)\\n ingestor.ingest_from_queue()\\n\\n # Write out any failed ingestions from the entire batch to a new CSV file.\\n if ingestor.failed_ingestions:\\n ingestor.write_failures_to_csv(timestamp_logname)\\n\\n self.logger.info('')\\n self.logger.info(\\\"Ingestion completed.\\\")\\n return True\",\n \"def merge_csv_initial(output_filename, path):\\n\\n prefix = ['ParticipantID',\\n 'igtb.datatime',\\n 'igtb.timezone']\\n\\n names = ['irb',\\n 'itp',\\n 'ocb',\\n 'inter.deviance',\\n 'org.deviance',\\n 'shipley.abs',\\n 'shipley.vocab',\\n 'neuroticism',\\n 'conscientiousness',\\n 'extraversion',\\n 'agreeableness',\\n 'openness',\\n 'pos.affect',\\n 'neg.affect',\\n 'stai.trait',\\n 'audit',\\n 'gats.quantity',\\n 'ipaq',\\n 'psqi',\\n 'gats.status']\\n\\n\\n \\n\\n #b = np.loadtxt(path + names[0] + '.csv', delimiter=\\\",\\\", skiprows=1, usecols=(0, 1, 2), dtype=object)\\n #a = np.array(b, dtype=object)\\n\\n for i,n in enumerate(names):\\n file = path + n + '.csv'\\n if(i==0):\\n df = pd.read_csv(file, sep=',', index_col=0,usecols=[0,1,2,3]) \\n df_all = df\\n else:\\n df = pd.read_csv(file, sep=',', index_col=0,usecols=[0,3]) \\n df_all=pd.concat([df_all,df],axis=1)\\n \\n df_all=df_all.reset_index() \\n a = df_all.as_matrix()\\n\\n # column_format = '%20s %10s %10s %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f'\\n # column_format = '%20s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s'\\n column_format = '%20s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s, %10s'\\n names_string = ','.join(prefix + names)\\n\\n print(a.shape)\\n\\n np.savetxt(output_filename, a, delimiter=\\\",\\\", fmt=column_format, comments='', header=names_string)\\n\\n return output_filename\",\n \"def combine_files(file_name):\\n\\n\\tif file_name == \\\"train\\\":\\n\\n\\t\\tif os.path.isfile(\\\"./Data/Level1_model_files/Train/all_level1_train.csv\\\"):\\n\\t\\t\\tos.remove(\\\"./Data/Level1_model_files/Train/all_level1_train.csv\\\")\\n\\n\\t\\tlist_files = glob(\\\"./Data/Level1_model_files/Train/*.csv*\\\")\\n\\t\\tlist_df = []\\n\\t\\tfor f in list_files :\\n\\t\\t\\tlist_df.append(pd.read_csv(f))\\n\\n\\t\\tfor i in range(1,len(list_df)):\\n\\t\\t\\tlist_df[i] = list_df[i].drop([\\\"Response\\\", \\\"Id\\\"],1)\\n\\n\\t\\t# Concat\\n\\t\\tdf_out = pd.concat(list_df, axis=1)\\n\\t\\t# Order columns\\n\\t\\tlist_col = df_out.columns.values.tolist()\\n\\t\\tlist_col = sorted(list_col)\\n\\t\\tlist_col.remove(\\\"Response\\\")\\n\\t\\tlist_col.remove(\\\"Id\\\")\\n\\t\\tlist_col = [\\\"Id\\\"] + list_col + [\\\"Response\\\"]\\n\\t\\tdf_out = df_out[list_col]\\n\\t\\tdf_out.to_csv(\\\"./Data/Level1_model_files/Train/all_level1_train.csv\\\", index = False)\\n\\n\\telif file_name == \\\"test\\\":\\n\\n\\t\\tif os.path.isfile(\\\"./Data/Level1_model_files/Test/all_level1_test.csv\\\"):\\n\\t\\t\\tos.remove(\\\"./Data/Level1_model_files/Test/all_level1_test.csv\\\")\\n\\n\\t\\tlist_files = glob(\\\"./Data/Level1_model_files/Test/*.csv*\\\")\\n\\t\\tlist_df = []\\n\\t\\tfor f in list_files :\\n\\t\\t\\tlist_df.append(pd.read_csv(f))\\n\\n\\t\\tfor i in range(1,len(list_df)):\\n\\t\\t\\tlist_df[i] = list_df[i].drop(\\\"Id\\\",1)\\n\\n\\t\\t# Concat\\n\\t\\tdf_out = pd.concat(list_df, axis=1)\\n\\t\\t# Order columns\\n\\t\\tlist_col = df_out.columns.values.tolist()\\n\\t\\tlist_col = sorted(list_col)\\n\\t\\tlist_col.remove(\\\"Id\\\")\\n\\t\\tlist_col = [\\\"Id\\\"] + list_col \\n\\t\\tdf_out = df_out[list_col]\\n\\t\\tdf_out.to_csv(\\\"./Data/Level1_model_files/Test/all_level1_test.csv\\\", index = False)\",\n \"def main():\\n location = os.getcwd()\\n header = \\\"Date,Time,Voltage,Current,Isolation,Range,SoC,Distance,Fan rpm,Fan Torque,Hyd. Pump rpm,Hyd. Pump Torque,SW Pump rpm,SW Pump Torque,Nozzle,Sidebrushes,WideSweepBrush,TempIGBT-Fan,Fan motor temp, Traction rpm, Traction torque,BMS1 Volts, BMS2 Volts\\\"\\n header = header+\\\"\\\\n\\\"\\n\\n of =\\\"outFile.csv\\\"\\n outFile = open(of, \\\"w\\\")\\n outFile.write(header)\\n\\n for file in os.listdir(location ):\\n try:\\n if file.endswith(\\\".csv\\\") and not(file.startswith(\\\"outFile\\\")):\\n print(\\\"...reading {}\\\".format(file))\\n fcsv = csv.reader(open(file, newline=''), delimiter=' ', quotechar='|') \\n for row in fcsv:\\n line = ', '.join(row)\\n if line[:4] == \\\"Date\\\":\\n d = line[5:13]\\n dd = d[6:9]+\\\"/\\\"+d[4:6]+\\\"/\\\"+d[:4]\\n next\\n elif line[12] == \\\"*\\\" or line[0] == \\\"*\\\":\\n next\\n elif line[0] == \\\"T\\\":\\n next\\n else:\\n L = dd + \\\",\\\" + line + \\\"\\\\n\\\"\\n outFile.write(L)\\n except Exception as e:\\n raise e\\n print(\\\"No CSV files in here!\\\")\\n\\n try: \\n print(\\\"\\\\nAll files have been merged into: {}\\\".format(of))\\n outFile.close()\\n \\n except Exception as ee:\\n raise ee\",\n \"def seed_from_csv_diff(original_file_path, new_file_path, model, **kwargs):\\n\\n original_diff_set = set()\\n new_diff_set = set()\\n new_file = open(new_file_path, 'r')\\n headers = new_file.readline().replace('\\\\n', '').split(',')\\n new_reader = model.update_set_filter(csv.reader(new_file), headers)\\n\\n original_file = open(original_file_path, 'r')\\n original_reader = csv.reader(original_file)\\n next(original_reader, None)\\n logger.debug(\\\" * Beginning CSV diff process.\\\")\\n\\n for row in new_reader:\\n new_diff_set.add(json.dumps(row))\\n\\n for row in original_reader:\\n original_diff_set.add(json.dumps(row))\\n\\n diff = new_diff_set - original_diff_set\\n temp_file_path = os.path.join(settings.MEDIA_TEMP_ROOT, str(\\n 'set_diff' + str(random.randint(1, 10000000))) + '.mock' if settings.TESTING else '.csv')\\n with open(temp_file_path, 'w') as temp_file:\\n writer = csv.writer(temp_file, delimiter=',')\\n writer.writerow(headers)\\n for row in diff:\\n writer.writerow(json.loads(row))\\n\\n diff_gen = from_csv_file_to_gen(temp_file_path, kwargs['update'])\\n logger.debug(\\\" * Csv diff completed, beginning batch upsert.\\\")\\n batch_upsert_from_gen(model, diff_gen, settings.BATCH_SIZE, **kwargs)\\n if os.path.isfile(temp_file_path):\\n os.remove(temp_file_path)\\n if 'callback' in kwargs and kwargs['callback']:\\n kwargs['callback']()\",\n \"def merge_csv_daily(output_filename, path):\\n\\n # import csv files from folder\\n allFiles = glob.glob(path + \\\"*.csv\\\")\\n\\n with open(output_filename, 'wb+') as outfile:\\n for i, fname in enumerate(allFiles):\\n with open(fname, 'rb') as infile:\\n if i != 0:\\n infile.readline() # Throw away header on all but first file\\n # Block copy rest of file from input to output without parsing\\n shutil.copyfileobj(infile, outfile)\\n # print(fname + \\\" has been imported.\\\")\\n\\n # adding MissingObs column back:\\n df = pd.read_csv(output_filename, header=0, sep=',', index_col=[0,1], parse_dates=False)\\n df.insert(loc=3, column='MissingObs', value=np.zeros((df.shape[0], )))\\n df.to_csv(output_filename, sep=',')\\n\\n return output_filename\",\n \"def initial_csv_wrangling(csv_file):\\n df = pd.read_csv(csv_file)\\n df = df.fillna('')\\n columns = list(df.columns)\\n\\n # check that \\\"url\\\" column exists (required)\\n if 'url' not in columns:\\n raise Exception('Input csv file requires a \\\"url\\\" column, which does not seem to exist. Exiting.')\\n\\n # check if \\\"pos_concepts\\\" column exists and parse accordingly (not required)\\n if 'pos_concepts' in columns:\\n print('Found \\\"pos_concepts\\\" column. Values will be split by pipe/vertical bar \\\"|\\\" into a python list.')\\n df['pos_concepts'] = df['pos_concepts'].map(lambda x: list(set(x.split('|'))))\\n\\n # check if \\\"neg_concepts\\\" column exists and parse accordingly (not required)\\n if \\\"neg_concepts\\\" in columns:\\n print('Found \\\"neg_concepts\\\" column. Values will be split by pipe/vertical bar \\\"|\\\" into a python list.')\\n df['neg_concepts'] = df['neg_concepts'].map(lambda x: list(set(x.split('|'))))\\n\\n # check if \\\"metadata\\\" column exists and load accordingly (not required)\\n if \\\"metadata\\\" in columns:\\n print('Found \\\"metadata\\\" column. Attempting to ingest.')\\n try:\\n df['metadata'] = df['metadata'].replace('','{}').map(json.loads)\\n except:\\n raise Exception('Value in \\\"metadata\\\" column does not seem to be a properly JSON formatted str.')\\n\\n return df\",\n \"def merge_data(csv_files, delimiter = ',', parse_dates = ['Date']):\\n \\n for csv in csv_files:\\n \\n # date formats in source data is slightly different (/2019 vs. /19), \\n # TODO: check for better method to catch this error\\n \\n \\n try:\\n df_new = pd.read_csv(csv, parse_dates=parse_dates,\\n date_parser=lambda x: pd.datetime.strptime(str(x), '%d/%m/%Y'), delimiter=delimiter)\\n \\n except:\\n df_new = pd.read_csv(csv, parse_dates=parse_dates,\\n date_parser=lambda x: pd.datetime.strptime(str(x), '%d/%m/%y'), delimiter=delimiter)\\n \\n \\n\\n \\n df_new['season'] = df_new.Date.max().year # add season column, defined as the year of the last matchday\\n df_new['first_match_day'] = False \\n df_new.loc[0:9, 'first_match_day'] = True # declare first 10 games as first match day\\n df_new['matchDay'] = 0\\n \\n try:\\n df = df.append(df_new,sort=False)\\n except:\\n df = df_new\\n \\n return df\",\n \"def intersect_csv_and_shapefiles(in_csv_filename, geodata1, geodata2,\\n ancillary_path, out_csv_filename, from_gbif):\\n pth, basefname = os.path.split(out_csv_filename)\\n logbasename, _ = os.path.splitext(basefname)\\n logfname = os.path.join(pth, '{}.log'.format(logbasename))\\n logger = get_logger(logbasename, logfname)\\n bf = BisonFiller(log=logger)\\n # Pass 4 of CSV transform, final step, point-in-polygon intersection\\n bf.update_point_in_polygons(\\n geodata1, geodata2, ancillary_path, in_csv_filename, out_csv_filename,\\n from_gbif=from_gbif)\\n # Do intersection here\\n sleep(randint(0, 10))\\n print(' - {}'.format(out_csv_filename))\",\n \"def check_for_csv(inp_dict):\\n if inp_dict[\\\".csv\\\"]:\\n for path in inp_dict[\\\".csv\\\"]:\\n csv_path = convert_csv(path)\\n inp_dict[\\\".xls\\\"].append(csv_path)\\n inp_dict[\\\"del\\\"].append(csv_path)\\n inp_dict[\\\"out\\\"].append(csv_path)\\n inp_dict[\\\".csv\\\"] = []\\n return inp_dict\",\n \"def merge_files(self, infnames, outfname, csv_header=True):\\n assert outfname not in infnames\\n start = time.time()\\n\\n header = ''\\n with open(outfname, 'w') as outfile:\\n if csv_header: # if not <csv_header>, we'll just end up with a zero-length file\\n for fname in infnames:\\n if not os.path.exists(fname) or os.stat(fname).st_size == 0:\\n continue\\n with open(fname) as headfile:\\n reader = csv.DictReader(headfile)\\n writer = csv.DictWriter(outfile, reader.fieldnames)\\n writer.writeheader()\\n header = ','.join(reader.fieldnames)\\n break\\n\\n cmd = 'cat ' + ' '.join(infnames) + ' | grep -v \\\\'^' + header + '$\\\\' | sort | uniq >>' + outfname\\n check_call(cmd, shell=True)\\n\\n if not self.args.no_clean:\\n for infname in infnames:\\n os.remove(infname)\\n\\n print ' time to merge csv files: %.3f' % (time.time()-start)\",\n \"def step_parallel(in_csv_filename, terrestrial_data, marine_data, ancillary_path,\\n out_csv_filename, from_gbif=True):\\n csv_filename_pairs, header = get_chunk_files(\\n in_csv_filename, out_csv_filename=out_csv_filename)\\n\\n# in_csv_fn, out_csv_fn = csv_filename_pairs[0]\\n# intersect_csv_and_shapefiles(in_csv_fn, terrestrial_data,\\n# marine_data, ancillary_path, out_csv_fn, False)\\n\\n with ProcessPoolExecutor() as executor:\\n for in_csv_fn, out_csv_fn in csv_filename_pairs:\\n executor.submit(\\n intersect_csv_and_shapefiles, in_csv_fn, terrestrial_data,\\n marine_data, ancillary_path, out_csv_fn, from_gbif)\\n\\n try:\\n outf = open(out_csv_filename, 'w', encoding='utf-8')\\n outf.write('{}'.format(header))\\n smfile_linecount = 0\\n for _, small_csv_fn in csv_filename_pairs:\\n curr_linecount = get_line_count(small_csv_fn) - 1\\n print('Appending {} records from {}'.format(\\n curr_linecount, small_csv_fn))\\n # Do not count header\\n smfile_linecount += (curr_linecount)\\n lineno = 0\\n try:\\n for line in open(small_csv_fn, 'r', encoding='utf-8'):\\n # Skip header in each file\\n if lineno == 0:\\n pass\\n else:\\n outf.write('{}'.format(line))\\n lineno += 1\\n except Exception as inner_err:\\n print('Failed to write {} to merged file; {}'.format(small_csv_fn, inner_err))\\n except Exception as outer_err:\\n print('Failed to write to {}; {}'.format(out_csv_filename, outer_err))\\n finally:\\n outf.close()\\n\\n lgfile_linecount = get_line_count(out_csv_filename) - 1\\n print('Total {} of {} records written to {}'.format(\\n lgfile_linecount, smfile_linecount, out_csv_filename))\",\n \"def test_reading_with_multiple_files(self):\\n self.prepare()\\n self.session.execute(\\\"\\\"\\\"\\n CREATE TABLE testmultifiles (\\n a int,\\n b int,\\n c float,\\n PRIMARY KEY (a, b)\\n )\\\"\\\"\\\")\\n\\n num_rows_per_file = 100\\n num_files = 10\\n tempfiles = []\\n\\n for i in range(num_files):\\n tempfiles.append(self.get_temp_file(prefix='testreadmult{}'.format(i), suffix='.csv'))\\n\\n for i in range(num_files):\\n with open(tempfiles[i].name, 'w') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=['a', 'b', 'c'])\\n for k in range(num_rows_per_file):\\n writer.writerow({'a': i, 'b': k, 'c': 2.0})\\n\\n def import_and_check(temp_files_str):\\n self.session.execute(\\\"TRUNCATE testmultifiles\\\")\\n\\n logger.debug(\\\"Importing csv files {}\\\".format(temp_files_str))\\n self.run_cqlsh(cmds=\\\"COPY ks.testmultifiles FROM '{}'\\\".format(temp_files_str))\\n\\n assert [[num_rows_per_file * len(tempfiles)]] == rows_to_list(self.session.execute(\\\"SELECT COUNT(*) FROM testmultifiles\\\"))\\n\\n import_and_check(','.join([tempfile.name for tempfile in tempfiles]))\\n import_and_check(os.path.join(gettempdir(), 'testreadmult*.csv'))\\n import_and_check(','.join([os.path.join(gettempdir(), 'testreadmult[0-4]*.csv'),\\n os.path.join(gettempdir(), 'testreadmult[5-9]*.csv')]))\",\n \"def main():\\n\\n # Ensure the output directory exists\\n if not os.path.exists(OUTPUT_DIR):\\n os.makedirs(OUTPUT_DIR)\\n\\n process_csv()\",\n \"def main():\\n master_csv = open(\\\"master.csv\\\", \\\"w\\\")\\n master_csv.write(\\\"lat, lon, year, month, day, T_max, T_min, PrecipMM, T_ave, PrecipCM, RelHum\\\\n\\\")\\n MoLS_comp_csv = open(\\\"MoLS_comp.csv\\\", \\\"w\\\")\\n lat_lon_csv = open(\\\"lat_lon.csv\\\", \\\"w\\\")\\n\\n for csvFilename in os.listdir('.'):\\n\\n if not csvFilename.endswith('.csv') or csvFilename == \\\"master.csv\\\" or csvFilename == \\\"MoLS_comp.csv\\\" or csvFilename == \\\"lat_lon.csv\\\":\\n continue # skip non-csv files\\n\\n csvFileObj = open(csvFilename)\\n readerObj = csv.reader(csvFileObj)\\n print(\\\"Currently parsing \\\" + str(csvFilename))\\n for row in readerObj:\\n if readerObj.line_num <= 8 :\\n continue\\n\\n year = int(row[0])\\n vp = float(row[8]) / 1000.0\\n month, day = get_month(int(row[1]))\\n T_ave = (float(row[6]) + float(row[7])) / 2\\n PrecipCM = float(row[3]) / 10\\n svp = .611 * math.e ** (5321 * ((1 / 273.0) - (1 / (T_ave + 273.15))))\\n rh_ave = round((vp / svp) * 100, 2)\\n\\n # print([[csvFilename], , row[0], row[1], row[3], row[6], row[7], row[8]])\\n # print(readerObj.line_num)\\n # print([csvFilename.split(\\\"_\\\")[0], csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0], row[0], row[1], row[3],\\n # row[6], row[7], row[8]])\\n\\n master_csv.write(str(csvFilename.split(\\\"_\\\")[0]) + \\\",\\\" + str(csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0]) +\\n \\\",\\\" + str(year) + \\\",\\\" + str(month) + \\\",\\\" + str(day) + \\\",\\\" + str(row[6]) + \\\",\\\" + str(row[7])\\n + \\\",\\\" + str(row[3]) + \\\",\\\" + str(T_ave) + \\\",\\\" + str(PrecipCM) + \\\",\\\" + str(rh_ave) + \\\"\\\\n\\\")\\n MoLS_comp_csv.write(str(year) + \\\",\\\" + str(month) + \\\",\\\" + str(day) + \\\",\\\" + str(row[6]) + \\\",\\\" + str(row[7])\\n + \\\",\\\" + str(row[3]) + \\\",\\\" + str(T_ave) + \\\",\\\" + str(PrecipCM) + \\\",\\\" + str(rh_ave) + \\\"\\\\n\\\")\\n lat_lon_csv.write(str(csvFilename.split(\\\"_\\\")[0]) + \\\",\\\" + str(csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0]) + \\\"\\\\n\\\")\\n\\n master_csv.close()\\n MoLS_comp_csv.close()\\n lat_lon_csv.close()\",\n \"def merge_cat(UT):\\n csv_path = Path(\\\"./catalog\\\"+UT+\\\".csv\\\")\\n if csv_path.exists() != 1:\\n Popen('rm -rf merged'+UT+'.log', shell=True)\\n Popen('touch merged'+UT+'.log', shell=True)\\n all_files = glob.glob(\\\"./results/20*/\\\"+UT+\\\"/*\\\")\\n print('merging table: {} (1/{})'.format(all_files[0],len(all_files)))\\n tab = pd.read_csv(all_files[0])\\n cat = tab.copy()\\n merged = open('merged'+UT+'.log','a+')\\n merged.write(all_files[0]+'\\\\n')\\n try:\\n for i, file in enumerate(all_files[1:]):\\n print('merging table: {} ({}/{})'.format(file,i+2,len(all_files)))\\n tab = pd.read_csv(file)\\n cat = pd.merge(cat, tab, how='outer')\\n merged.write(file+'\\\\n')\\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\\n merged.close()\\n except:\\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\\n merged.close()\\n else:\\n cat = pd.read_csv('catalog'+UT+'.csv')\\n all_files = glob.glob(\\\"./results/20*/\\\"+UT+\\\"/*\\\")\\n merged = list(pd.read_table('merged'+UT+'.log', header=None).values)\\n merged = [i[0] for i in merged]\\n if set(all_files) == set(merged):\\n print('GOOD NEWS: No new table is needed to be merged.')\\n else:\\n non_processed = list(set(all_files) - set(merged))\\n merged = open('merged'+UT+'.log','a+')\\n try:\\n for i, new_img in enumerate(non_processed):\\n print('merging table: {} ({}/{})'.format(new_img,i+1,len(non_processed)))\\n tab = pd.read_csv(new_img)\\n cat = pd.merge(cat, tab, how='outer')\\n merged.write(new_img+'\\\\n')\\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\\n merged.close()\\n except:\\n cat.to_csv('catalog'+UT+'.csv', index=False, header=True)\\n merged.close()\\n cat = pd.read_csv('catalog'+UT+'.csv')\\n m = Table(cat.values, names=cat.columns)\\n hdu = fits.table_to_hdu(m)\\n hdulist = fits.HDUList([fits.PrimaryHDU(), hdu])\\n hdulist.writeto('catalog'+UT+'.fits', overwrite=True)\",\n \"def _read_csv(self):\\n self.function_name = '_read_csv'\\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\\n reader = csv.reader(csv_file, dialect='excel')\\n for row in reader:\\n self.input_data.append(row)\",\n \"def process_csv_data(file_for_processing: FileForProcessing):\\n \\n if file_for_processing.file_to_process.os_type == ANDROID_API:\\n # Do fixes for Android\\n if file_for_processing.data_type == ANDROID_LOG_FILE:\\n file_for_processing.file_contents = fix_app_log_file(\\n file_for_processing.file_contents, file_for_processing.file_to_process.s3_file_path\\n )\\n \\n header, csv_rows_list = csv_to_list(file_for_processing.file_contents)\\n if file_for_processing.data_type != ACCELEROMETER:\\n # If the data is not accelerometer data, convert the generator to a list.\\n # For accelerometer data, the data is massive and so we don't want it all\\n # in memory at once.\\n csv_rows_list = list(csv_rows_list)\\n \\n if file_for_processing.data_type == CALL_LOG:\\n header = fix_call_log_csv(header, csv_rows_list)\\n if file_for_processing.data_type == WIFI:\\n header = fix_wifi_csv(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\\n else:\\n # Do fixes for iOS\\n header, csv_rows_list = csv_to_list(file_for_processing.file_contents)\\n \\n if file_for_processing.data_type != ACCELEROMETER:\\n csv_rows_list = list(csv_rows_list)\\n \\n # Memory saving measure: this data is now stored in its entirety in csv_rows_list\\n file_for_processing.clear_file_content()\\n \\n # Do these fixes for data whether from Android or iOS\\n if file_for_processing.data_type == IDENTIFIERS:\\n header = fix_identifier_csv(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\\n if file_for_processing.data_type == SURVEY_TIMINGS:\\n header = fix_survey_timings(header, csv_rows_list, file_for_processing.file_to_process.s3_file_path)\\n \\n header = b\\\",\\\".join([column_name.strip() for column_name in header.split(b\\\",\\\")])\\n if csv_rows_list:\\n return (\\n # return item 1: the data as a defaultdict\\n binify_csv_rows(\\n csv_rows_list,\\n file_for_processing.file_to_process.study.object_id,\\n file_for_processing.file_to_process.participant.patient_id,\\n file_for_processing.data_type,\\n header\\n ),\\n # return item 2: the tuple that we use as a key for the defaultdict\\n (\\n file_for_processing.file_to_process.study.object_id,\\n file_for_processing.file_to_process.participant.patient_id,\\n file_for_processing.data_type,\\n header\\n )\\n )\\n else:\\n return None, None\",\n \"def pre_process_books(csv, outputname):\\n df = pd.read_csv(csv, error_bad_lines=False, encoding = \\\"ISO-8859-1\\\")\\n df.to_csv(outputname, index=False)\",\n \"def process(self, filename=None):\\n if not filename:\\n filename = self.input_csv\\n\\n if filename.endswith('.csv'):\\n\\n with open(filename) as _file:\\n reader = csv.reader(_file)\\n data = list(reader)\\n\\n self.save(self.format(self.purify(data)))\\n return\\n\\n raise TypeError(\\n \\\"Excepting csv filetype got %s \\\\\\n filetype instead.\\\" % (filename.split('.', 1)[1])\\n )\",\n \"def import_csv(item):\\n (f_csv, f_csv_out, target_column, merge_columns) = item\\n has_checked_keys = False\\n\\n if not merge_columns:\\n raise ValueError(\\\"merge_columns must not be empty\\\")\\n\\n with open(f_csv_out, \\\"w\\\") as FOUT:\\n CSV_HANDLE = None\\n total_rows = 0\\n\\n for row in csv_iterator(f_csv):\\n\\n output = {\\\"_ref\\\": next(_ref_counter)}\\n\\n if not has_checked_keys:\\n for key in merge_columns:\\n if key not in row.keys():\\n msg = \\\"Column **{}** not in csv file {}\\\"\\n raise KeyError(msg.format(key, f_csv))\\n has_checked_keys = True\\n\\n if target_column in row.keys():\\n msg = \\\"Generated column **{}** already in csv file {}\\\"\\n raise KeyError(msg.format(target_column, f_csv))\\n\\n text = []\\n for key in merge_columns:\\n val = row[key].strip()\\n if not val:\\n continue\\n if val[-1] not in \\\".?!,\\\":\\n val += \\\".\\\"\\n text.append(val)\\n\\n output[target_column] = \\\"\\\\n\\\".join(text).strip()\\n\\n if CSV_HANDLE is None:\\n CSV_HANDLE = csv.DictWriter(FOUT, sorted(output.keys()))\\n CSV_HANDLE.writeheader()\\n\\n CSV_HANDLE.writerow(output)\\n total_rows += 1\\n\\n logger.info(\\\"Imported {}, {} entries\\\".format(f_csv, total_rows))\",\n \"def pre_process_multispace(filepath, delimiter=\\\" \\\"):\\n newpath = filepath+\\\".rev.csv\\\"\\n with open(filepath, \\\"r\\\") as src_csv_file:\\n with open(newpath, \\\"w\\\") as dst_csv_file:\\n for src_line in src_csv_file:\\n dst_csv_file.write(delimiter.join(src_line.split())+\\\"\\\\n\\\")\",\n \"def managecsv(data):\\n\\n checkfolderdata()\\n if not datafileexist(data[7]):\\n createcsv(data[7])\\n managecsv(data)\\n else:\\n addcsv(data, data[7])\",\n \"def import_input_set(name, csv_fn, my_session):\\n input_set = InputSet(name=name)\\n n_added_input = 0\\n with open(csv_fn, 'r') as csv_fh:\\n for ln in csv_fh:\\n ln = ln.rstrip()\\n if len(ln) == 0:\\n continue\\n toks = ln.split(',')\\n if len(toks) != 9:\\n raise ValueError('Line did not have 9 tokens: \\\"%s\\\"' % ln)\\n toks = list(map(lambda x: None if x == 'NA' else x, toks))\\n acc_r, acc_s, url_1, url_2, url_3, checksum_1, checksum_2, checksum_3, retrieval_method = toks\\n input = Input(acc_r=acc_r, acc_s=acc_s, url_1=url_1, url_2=url_2, url_3=url_3,\\n checksum_1=checksum_1, checksum_2=checksum_2, checksum_3=checksum_3,\\n retrieval_method=retrieval_method)\\n my_session.add(input)\\n input_set.inputs.append(input)\\n n_added_input += 1\\n log.info('Imported %d items from input set' % len(input_set.inputs), 'input.py')\\n my_session.add(input_set)\\n my_session.commit()\\n return input_set.id, n_added_input\",\n \"def clean_file(csv_file):\\n my_list = []\\n with open(csv_file, newline='') as csvfile:\\n file_reader = csv.reader(csvfile, delimiter=',', quotechar=\\\" \\\")\\n for row in file_reader:\\n my_list.append(row)\\n\\n \\\"\\\"\\\"\\n > Part Two\\n Input: Nested list csv_table and a string file_name\\n Action: Write fields in csv_table into a comma-separated CSV file with the name file_name\\n Mutates output: Yes\\n \\\"\\\"\\\"\\n with open(csv_file, 'w', newline='') as csvfile:\\n my_csv_writer = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_NONE)\\n for row in my_list:\\n row2 = []\\n for item in row:\\n a = item.lstrip('\\\"')\\n b = a.rstrip('\\\"')\\n row2.append(b)\\n my_csv_writer.writerow(row2)\",\n \"def collate(\\n batch,\\n config,\\n plate,\\n base_directory=\\\"../..\\\",\\n column=None,\\n munge=False,\\n csv_dir=\\\"analysis\\\",\\n aws_remote=None,\\n aggregate_only=False,\\n tmp_dir=\\\"/tmp\\\",\\n overwrite=False,\\n add_image_features=True,\\n image_feature_categories=[\\\"Granularity\\\", \\\"Texture\\\", \\\"ImageQuality\\\", \\\"Threshold\\\"],\\n printtoscreen=True,\\n):\\n\\n from pycytominer.cyto_utils.cells import SingleCells\\n\\n # Set up directories (these need to be abspaths to keep from confusing makedirs later)\\n input_dir = pathlib.Path(f\\\"{base_directory}/analysis/{batch}/{plate}/{csv_dir}\\\")\\n backend_dir = pathlib.Path(f\\\"{base_directory}/backend/{batch}/{plate}\\\")\\n cache_backend_dir = pathlib.Path(f\\\"{tmp_dir}/backend/{batch}/{plate}\\\")\\n\\n aggregated_file = pathlib.Path(f\\\"{backend_dir}/{plate}.csv\\\")\\n backend_file = pathlib.Path(f\\\"{backend_dir}/{plate}.sqlite\\\")\\n cache_backend_file = pathlib.Path(f\\\"{cache_backend_dir}/{plate}.sqlite\\\")\\n\\n if not aggregate_only:\\n if os.path.exists(cache_backend_file):\\n if not overwrite:\\n sys.exit(\\n f\\\"An SQLite file for {plate} already exists at {cache_backend_file} and overwrite is set to False. Terminating.\\\"\\n )\\n else:\\n os.remove(cache_backend_file)\\n\\n for eachdir in [input_dir, backend_dir, cache_backend_dir]:\\n if not os.path.exists(eachdir):\\n os.makedirs(eachdir, exist_ok=True)\\n\\n if aws_remote:\\n remote_input_dir = f\\\"{aws_remote}/analysis/{batch}/{plate}/{csv_dir}\\\"\\n\\n remote_backend_file = f\\\"{aws_remote}/backend/{batch}/{plate}/{plate}.sqlite\\\"\\n\\n remote_aggregated_file = f\\\"{aws_remote}/backend/{batch}/{plate}/{plate}.csv\\\"\\n\\n sync_cmd = f\\\"aws s3 sync --exclude * --include */Cells.csv --include */Nuclei.csv --include */Cytoplasm.csv --include */Image.csv {remote_input_dir} {input_dir}\\\"\\n if printtoscreen:\\n print(f\\\"Downloading CSVs from {remote_input_dir} to {input_dir}\\\")\\n run_check_errors(sync_cmd)\\n\\n if printtoscreen:\\n print(f\\\"Ingesting {input_dir}\\\")\\n # Run cytominer-database ingest\\n if munge:\\n cytominer_database.munge.munge(config_path=config, source=input_dir)\\n\\n cytominer_database.ingest.seed(\\n source=input_dir,\\n target=f\\\"sqlite:///{cache_backend_file}\\\",\\n config_file=config,\\n )\\n\\n # Create a sqlite3 connection\\n with sqlite3.connect(cache_backend_file, isolation_level=None) as connection:\\n cursor = connection.cursor()\\n if column:\\n if print:\\n print(f\\\"Adding a Metadata_Plate column based on column {column}\\\")\\n cursor.execute(\\\"ALTER TABLE Image ADD COLUMN Metadata_Plate TEXT;\\\")\\n cursor.execute(f\\\"UPDATE image SET Metadata_Plate ={column};\\\")\\n\\n if printtoscreen:\\n print(f\\\"Indexing database {cache_backend_file}\\\")\\n cursor.execute(\\n \\\"CREATE INDEX IF NOT EXISTS table_image_idx ON Image(TableNumber, ImageNumber);\\\"\\n )\\n for eachcompartment in [\\\"Cells\\\", \\\"Cytoplasm\\\", \\\"Nuclei\\\"]:\\n cursor.execute(\\n f\\\"\\\"\\\"CREATE INDEX IF NOT EXISTS table_image_object_{eachcompartment.lower()}_idx \\n ON {eachcompartment}(TableNumber, ImageNumber, ObjectNumber);\\\"\\\"\\\"\\n )\\n cursor.execute(\\n \\\"CREATE INDEX IF NOT EXISTS plate_well_image_idx ON Image(Metadata_Plate, Metadata_Well);\\\"\\n )\\n cursor.close()\\n connection.close()\\n\\n if aws_remote:\\n if printtoscreen:\\n print(f\\\"Uploading {cache_backend_file} to {remote_backend_file}\\\")\\n cp_cmd = [\\\"aws\\\", \\\"s3\\\", \\\"cp\\\", cache_backend_file, remote_backend_file]\\n run_check_errors(cp_cmd)\\n\\n if printtoscreen:\\n print(\\n f\\\"Removing analysis files from {input_dir} and {cache_backend_dir}\\\"\\n )\\n import shutil\\n\\n shutil.rmtree(input_dir)\\n\\n if printtoscreen:\\n print(f\\\"Renaming {cache_backend_file} to {backend_file}\\\")\\n os.rename(cache_backend_file, backend_file)\\n\\n if printtoscreen:\\n print(f\\\"Aggregating sqlite:///{backend_file}\\\")\\n\\n if aggregate_only and aws_remote:\\n remote_backend_file = f\\\"{aws_remote}/backend/{batch}/{plate}/{plate}.sqlite\\\"\\n\\n remote_aggregated_file = f\\\"{aws_remote}/backend/{batch}/{plate}/{plate}.csv\\\"\\n\\n cp_cmd = [\\\"aws\\\", \\\"s3\\\", \\\"cp\\\", remote_backend_file, backend_file]\\n if printtoscreen:\\n print(\\n f\\\"Downloading SQLite files from {remote_backend_file} to {backend_file}\\\"\\n )\\n run_check_errors(cp_cmd)\\n\\n if not os.path.exists(backend_file):\\n sys.exit(f\\\"{backend_file} does not exist. Exiting.\\\")\\n\\n if add_image_features:\\n pass\\n else:\\n image_feature_categories = None # defensive but not sure what will happen if we give a list but set to False\\n\\n database = SingleCells(\\n f\\\"sqlite:///{backend_file}\\\",\\n aggregation_operation=\\\"mean\\\",\\n add_image_features=add_image_features,\\n image_feature_categories=image_feature_categories,\\n )\\n database.aggregate_profiles(output_file=aggregated_file)\\n\\n if aws_remote:\\n if printtoscreen:\\n print(f\\\"Uploading {aggregated_file} to {remote_aggregated_file}\\\")\\n csv_cp_cmd = [\\\"aws\\\", \\\"s3\\\", \\\"cp\\\", aggregated_file, remote_aggregated_file]\\n run_check_errors(csv_cp_cmd)\\n\\n if printtoscreen:\\n print(f\\\"Removing backend files from {backend_dir}\\\")\\n import shutil\\n\\n shutil.rmtree(backend_dir)\",\n \"def annotation_csv_consolidator(filenames, sessions=[], subjects=[], sensors=[]):\\n \\n single_sess_annotats = []\\n c = 0\\n for filename in filenames:\\n single_sess_annotat = annotation_csv_importer(filename)\\n if np.iterable(sessions) and len(sessions) == len(filenames):\\n single_sess_index = [sessions[c],]*single_sess_annotat.shape[0]\\n single_sess_annotat['session'] = single_sess_index\\n if np.iterable(subjects) and len(subjects) == len(filenames):\\n single_subj_index = [subjects[c],]*single_sess_annotat.shape[0]\\n single_sess_annotat['subject'] = single_subj_index\\n if np.iterable(sensors) and len(sensors) == len(filenames):\\n single_sensor_index = [sensors[c],]*single_sess_annotat.shape[0]\\n single_sess_annotat['sensor'] = single_sensor_index\\n c += 1\\n single_sess_annotats.append(single_sess_annotat)\\n consolidate_annotation_data = pd.concat(single_sess_annotats)\\n # consolidate_annotation_data = consolidate_annotation_data.reset_index(drop=False)\\n # consolidate_annotation_data = consolidate_annotation_data.rename(columns={\\\"index\\\":\\\"index per sensor\\\"})\\n return consolidate_annotation_data\",\n \"def process_csv():\\n csv_rows = []\\n fieldnames = ['site',\\n 'latitude',\\n 'longitude',\\n 'city',\\n 'region_code',\\n 'country_code',\\n 'continent_code',\\n 'min_ip_hex',\\n 'max_ip_hex',\\n 'transit_provider',\\n 'min_ip',\\n 'max_ip',\\n 'ip_prefix',\\n 'min_ipv6_hex',\\n 'max_ipv6_hex',\\n 'min_ipv6',\\n 'max_ipv6',\\n 'ipv6_prefix']\\n\\n location_map = build_location_map()\\n\\n # Read in the CSV file and augment the columns\\n with open(INPUT_FILE, 'rb') as csvfile:\\n reader = csv.DictReader(csvfile)\\n\\n for row in reader:\\n csv_rows.append(process_row(row, location_map))\\n\\n # Write the new CSV file with new columns\\n with open(OUTPUT_FILE, 'w') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n writer.writeheader()\\n for row in csv_rows:\\n writer.writerow(row)\\n\\n print(\\\"MLab Sites CSV generated at {0}\\\".format(OUTPUT_FILE))\",\n \"def merge_csv_files(filelist):\\n data = tables.DictList()\\n for file_name in filelist:\\n reader = csv.DictReader(open(file_name))\\n data += list(reader)\\n\\n return data\",\n \"def import_from_csv(self) -> None:\\n logging.info('import_from_csv')\\n if self.target_table and str(self.target_table).lower() in [\\\"issue\\\", \\\"version\\\"]:\\n if self.file_path and exists(self.file_path):\\n # Read CSV file\\n csv_data = pd.read_csv(self.file_path).to_dict('records')\\n\\n # Import Version\\n if str(self.target_table).capitalize() == \\\"Version\\\":\\n # Overwrite option\\n if self.overwrite:\\n self.session.query(Version).delete()\\n click.echo('Overwrite Version table')\\n\\n for version in csv_data:\\n if all(item in list(version.keys()) for item in ['tag', 'start_date', 'end_date']):\\n newVersion=Version(\\n project_id=version['project_id'],\\n name=version[\\\"name\\\"], \\n tag=version[\\\"tag\\\"], \\n start_date=datetime.strptime(version[\\\"start_date\\\"], '%Y-%m-%d %H:%M:%S.%f'), \\n end_date=datetime.strptime(version[\\\"end_date\\\"], '%Y-%m-%d %H:%M:%S.%f'), \\n )\\n \\n try:\\n self.session.add(newVersion)\\n compute_version_metrics(self.session, self.configuration.current_branch, newVersion.project_id)\\n click.echo('Importing ' + str(len(csv_data)) + ' version(s) on database')\\n except Exception:\\n logging.error(Exception)\\n else:\\n logging.error(\\\"CSV file no contain minimal mandatory fields\\\")\\n sys.exit('CSV file no contain minimal mandatory fields')\\n\\n # Import Issue\\n if str(self.target_table).capitalize() == \\\"Issue\\\":\\n # Overwrite option\\n if self.overwrite:\\n self.session.query(Issue).delete()\\n click.echo('Overwrite Issue table')\\n\\n for issue in csv_data:\\n if all(item in list(issue.keys()) for item in ['number', 'created_at', 'updated_at']):\\n newIssue=Issue(\\n project_id=issue['project_id'],\\n number=issue[\\\"number\\\"],\\n title=issue[\\\"title\\\"],\\n created_at=datetime.strptime(issue[\\\"created_at\\\"], '%Y-%m-%d %H:%M:%S.%f'),\\n updated_at=datetime.strptime(issue[\\\"updated_at\\\"], '%Y-%m-%d %H:%M:%S.%f'))\\n\\n try:\\n self.session.add(newIssue)\\n click.echo('Importing ' + str(len(csv_data)) + ' issue(s) on database')\\n except Exception:\\n logging.error(Exception)\\n else:\\n logging.error(\\\"CSV file no contain minimal mandatory fields\\\")\\n sys.exit('CSV file no contain minimal mandatory fields') \\n\\n self.session.commit()\\n else:\\n logging.error('File not found')\\n sys.exit('File not found')\\n else:\\n logging.error('Target table not found')\\n sys.exit('Target table not found')\",\n \"def _enumerate_csv(self, csv_input):\\n csv_file = open(csv_input, 'rb') \\n csv_reader = csv.reader(csv_file)\\n next(csv_reader, None)\\n for row in reader:\\n yield row\",\n \"def read_csv(self, path):\\n for file in os.listdir(path):\\n if file[-4:] == \\\".csv\\\":\\n name = file[:-4]\\n table_index_header = cfg.get_list(\\\"table_index_header\\\", name)\\n filename = os.path.join(path, file)\\n self.input_data[name] = pd.read_csv(\\n filename,\\n index_col=list(range(int(table_index_header[0]))),\\n header=list(range(int(table_index_header[1]))),\\n squeeze=(\\\"series\\\" not in name),\\n )\\n self.check_input_data(warning=False)\\n self.add_meta_data()\\n return self\",\n \"def _process_csv_data(csv_file, user_data_map):\\n with open(csv_file, 'r') as csvfile:\\n rows = csv.reader(csvfile)\\n for row in rows:\\n if len(row) < 2:\\n print('The CSV file is not in expected format.')\\n raise Exception\\n user_data_map[row[1].lower()] = row[0]\",\n \"def load_from_csv(self):\\n\\n self._logger.info('Reading data coming from CSV files')\\n\\n sta = self.stations\\n\\n if sta != None:\\n msta = \\\", \\\".join(sta)\\n self._logger.debug('Using only stations {0}'.format(msta))\\n\\n # load the data\\n v = list(self.variables)\\n v.append('metadata')\\n for i in v:\\n if i in self.dataConfig:\\n\\n self._logger.debug('Reading %s...' % self.dataConfig[i])\\n if i == 'metadata':\\n dp_final = pd.read_csv(self.dataConfig[i],\\n index_col='primary_id')\\n #Ensure all stations are all caps.\\n dp_final.index = [s.upper() for s in dp_final.index]\\n\\n elif self.dataConfig[i]:\\n dp_full = pd.read_csv(self.dataConfig[i],\\n index_col='date_time',\\n parse_dates=[0])\\n dp_full.columns = [s.upper() for s in dp_full.columns]\\n\\n if sta is not None:\\n\\n data_sta = dp_full.columns.str.upper()\\n\\n # Grab IDs from user list thats also in Data\\n self.stations = [s for s in data_sta if s in sta]\\n dp = dp_full[dp_full.columns[(data_sta).isin(sta)]]\\n\\n else:\\n dp = dp_full\\n\\n # Only get the desired dates\\n dp_final = dp[self.start_date:self.end_date]\\n\\n if dp_final.empty:\\n raise Exception(\\\"No CSV data found for {0}\\\"\\n \\\"\\\".format(i))\\n\\n setattr(self, i, dp_final)\",\n \"def _reformat_csv(self, csv):\\n\\n # avoid using extra backslashes because sed uses them as delimiter\\n date = csv[-19:-9].replace('/', '-')\\n cmds = [f'cut -d , -f 1 --complement <{csv} >{csv}.new',\\n f'mv {csv}.new {csv}',\\n f'sed -i \\\"1d\\\" {csv}',\\n f'sed -i \\\"s/AS//g\\\" {csv}',\\n f'sed -i \\\"s/,/\\\\t/g\\\" {csv}',\\n f'sed -i \\\"s/$/\\\\t{date}/\\\" {csv}']\\n\\n utils.run_cmds(cmds)\",\n \"def get_files(self):\\n\\n # Grab master data - use existing header, remove unhappy columns\\n\\n self.df_mas_lab_data = pd.read_csv(\\n self.master_csv, dtype=str, usecols=self.columns\\n )\\n\\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\\n # Physician Office\\n facility_type_keep_list = [\\\"Independent\\\", \\\"Hospital\\\", \\\"Physician Office\\\"]\\n self.df_mas_lab_data = self.df_mas_lab_data[\\n self.df_mas_lab_data[\\\"FACILITY_TYPE\\\"].isin(facility_type_keep_list)\\n ]\\n\\n # Make everything a string and remove trailing and leading whitespaces\\n self.df_mas_lab_data = self.df_mas_lab_data.astype(str)\\n self.df_mas_lab_data = self.df_mas_lab_data.applymap(\\n lambda x: x.strip() if isinstance(x, str) else x\\n )\\n\\n print_banner(\\\"Computing all the Data\\\")\\n print(f\\\"{len(self.df_mas_lab_data)} original master CLIA labs...\\\")\\n\\n # Grab other inputed files to make new data file to compare with\\n self.df_new_lab_data = pd.concat(\\n [\\n pd.read_csv(file, names=self.columns, header=None, dtype=str, usecols=self.columns)\\n for file in self.new_files\\n ]\\n )\\n\\n # Probably not needed for the new data but just in case:\\n # Delete rows, where column FACILITY_TYPE != Independent, Hospital,\\n # Physician Office\\n self.df_new_lab_data = self.df_new_lab_data[\\n self.df_new_lab_data[\\\"FACILITY_TYPE\\\"].isin(facility_type_keep_list)\\n ]\\n\\n # Make everything a string and remove trailing and leading whitespaces\\n self.df_new_lab_data = self.df_new_lab_data.astype(str)\\n self.df_new_lab_data = self.df_new_lab_data.applymap(\\n lambda x: x.strip() if isinstance(x, str) else x\\n )\\n\\n print(f\\\"{len(self.df_new_lab_data)} inputted CLIA labs for comparison...\\\")\",\n \"def place_types_read_csv(self, csv_input):\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\",\n \"def renameCSVColumns(CSVPathOrList,targetDir,renameDict,indepToAdd=None):\\n if not isinstance(CSVPathOrList, list):\\n CSVPathOrList = [CSVPathOrList]\\n if indepToAdd is not None:\\n if not isinstance(indepToAdd, list):\\n indepToAdd = [indepToAdd]\\n if len(CSVPathOrList)!=len(indepToAdd):\\n print(\\\"each data set needs independed variables if you use them\\\")\\n return None\\n outList=[]\\n for CSVPath, i in zip(CSVPathOrList,range(len(CSVPathOrList))):\\n CSVData = pd.read_csv(CSVPath)\\n CSVData=CSVData.rename(columns=renameDict)\\n if indepToAdd is not None:\\n for myKey, myVal in indepToAdd[i].items():\\n CSVData[myKey+\\\"_indep\\\"]=myVal\\n newPath = os.path.join(targetDir,os.path.split(CSVPath)[1])\\n CSVData.to_csv(newPath,index=False)\\n outList.append(newPath)\\n if len(outList)==1:\\n outList=outList[0]\\n return outList\",\n \"def process(fileglob):\\n\\n filepaths = glob.glob(fileglob)\\n\\n for filepath in filepaths:\\n datum_list = []\\n aggregated_data = {'user_id': None, 'n': 0, 'sum': 0, 'min': 0, 'max': 0}\\n\\n for parsed_row in extract_csv_data(filepath):\\n\\n if aggregated_data['user_id'] is None:\\n aggregated_data['user_id'] = parsed_row['user_id']\\n\\n if aggregated_data['user_id'] != parsed_row['user_id']:\\n # We want earliest 'date' datum first.\\n sorted_datum = sorted(datum_list, key=lambda k: k['date'])\\n\\n for datum in sorted_datum:\\n aggregated_data = update_aggregated_data(aggregated_data, datum)\\n\\n aggregated_data = finalize_aggregated_data(aggregated_data)\\n\\n # Dump current stack of user info to output file.\\n dump_aggregated_data(aggregated_data, output_filepath(filepath))\\n\\n # Re-initialize\\n datum_list = []\\n aggregated_data = {'user_id': parsed_row['user_id'], 'n': 0, 'sum': 0, 'min': 0, 'max': 0}\\n\\n \\\"\\\"\\\"\\n We are still on same user_id so just append to datum_list.\\n \\\"\\\"\\\"\\n datum_list.append(parsed_row)\\n\\n\\n \\\"\\\"\\\"\\n At end of csv file, roll-up and dump last chunk of user_data.\\n \\\"\\\"\\\"\\n\\n sorted_datum = sorted(datum_list, key=lambda k: k['date'])\\n\\n for datum in sorted_datum:\\n aggregated_data = update_aggregated_data(aggregated_data, datum)\\n\\n aggregated_data = finalize_aggregated_data(aggregated_data)\\n\\n dump_aggregated_data(aggregated_data, output_filepath(filepath))\",\n \"def parse_csv_files(csv_files, **kwargs):\\n\\n per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\\n slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\\n\\n for file in csv_files:\\n per_file_base_prices = {}\\n for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):\\n if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token\\n per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes\\n\\n slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size\\n # i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]\\n\\n slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000\\n price_diff = (totle_price - exchange_price) / exchange_price\\n\\n slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))\\n per_token_savings[token][trade_size][exchange].append(pct_savings)\\n\\n\\n return per_token_savings, slip_price_diff_splits\",\n \"def process_file(input_file, output_good, output_bad):\\n\\t# Lists containing good and bad rows\\n\\tlist_good = []\\n\\tlist_bad = []\\n\\t# Open csv file \\n\\twith open(input_file, 'r') as f:\\n\\t\\t# Create reader from csv and store header row\\n\\t\\treader = csv.DictReader(f)\\n\\t\\theader = reader.fieldnames\\n\\t\\t# Store useful keys\\n\\t\\tyear = 'productionStartYear'\\n\\t\\turi = 'URI'\\n\\t\\t# Loop through all rows\\n\\t\\tfor row in reader:\\n\\t\\t\\t# Discard rows with a URI not from DBpedia\\n\\t\\t\\tif not row[uri].startswith('http://dbpedia.org'):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t# Extract year from datetime\\n\\t\\t\\tyear_value = row[year][:4]\\n\\t\\t\\t# Change row datetime value to its year\\n\\t\\t\\trow[year] = year_value\\n\\t\\t\\t# Check if year actually contains a year\\n\\t\\t\\tif not row[year].isdigit():\\n\\t\\t\\t\\t# Add to list_bad\\n\\t\\t\\t\\tlist_bad.append(row)\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t# Check if year falls within expected range\\n\\t\\t\\tif int(row[year]) < 1886 or int(row[year]) > 2014:\\n\\t\\t\\t\\t# Add list to bad\\n\\t\\t\\t\\tlist_bad.append(row)\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t# Row is proper, add to list_good\\n\\t\\t\\tlist_good.append(row)\\n\\t\\t\\n\\t\\t# Open good ouput file, write the good rows to it\\n\\t\\twith open(output_good, 'w') as csvfile:\\n\\t\\t\\twriter = csv.DictWriter(csvfile, delimiter = ',', fieldnames = header)\\n\\t\\t\\twriter.writeheader()\\n\\t\\t\\tfor item in list_good:\\n\\t\\t\\t\\twriter.writerow(item)\\n\\n\\t\\t# Open bad ouput file, write the nad rows to it\\n\\t\\twith open(output_bad, 'w') as csvfile:\\n\\t\\t\\twriter = csv.DictWriter(csvfile, delimiter = ',', fieldnames = header)\\n\\t\\t\\twriter.writeheader()\\n\\t\\t\\tfor item in list_bad:\\n\\t\\t\\t\\twriter.writerow(item)\",\n \"def test_36_bulk_csv_import_dup_header(self, Mock, mock):\\r\\n empty_file = FakeRequest('Foo,Bar,Foo\\\\n1,2,3', 200,\\r\\n {'content-type': 'text/plain'})\\r\\n Mock.return_value = empty_file\\r\\n self.register()\\r\\n self.new_application()\\r\\n app = db.session.query(App).first()\\r\\n url = '/app/%s/tasks/import?template=csv' % (app.short_name)\\r\\n res = self.app.post(url, data={'csv_url': 'http://myfakecsvurl.com',\\r\\n 'formtype': 'csv'},\\r\\n follow_redirects=True)\\r\\n msg = \\\"The file you uploaded has two headers with the same name\\\"\\r\\n assert msg in res.data\",\n \"def read_csv(self, csv_input):\\n # https://stackoverflow.com/a/45063514\\n dtypes = {\\n 'lat': 'U',\\n 'long': 'U'\\n }\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\\n\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\\n #print('Data read from CSV %s' % csv_input)\",\n \"def merge(df_list):\\n df_final = pd.read_csv(df_list[0])\\n for ind, df in enumerate(df_list):\\n if ind >= 1:\\n temp_df = pd.read_csv(df_list[ind])\\n temp_df = temp_df.drop(['lbl'], axis=1)\\n df_final = pd.merge(df_final, temp_df, on=['author_id'])\\n final_path = os.path.join(os.path.expanduser(\\\"~/Desktop/Age-Detection\\\"), \\\"merged-feature-collection.csv\\\")\\n df_final.to_csv(final_path, sep=',', index=False)\\n return final_path\",\n \"def collect_csv(source_dir, dest_dir):\\n source_dir = Path(source_dir)\\n dest_dir = Path(dest_dir)\\n for csvfile in source_dir.rglob(\\\"*.csv\\\"):\\n species = normalized_species(csvfile)\\n species_dir = dest_dir / species\\n species_dir.mkdir(exist_ok=True, parents=True)\\n date_time = normalized_datetime(csvfile)\\n print(f\\\"Renaming {csvfile} to {species_dir / (date_time + '.csv')}\\\")\\n csvfile.rename(species_dir / (date_time + \\\".csv\\\"))\",\n \"def execute_processor(self):\\n \\n # pull in the parameter that has the file names we will process\\n filename1 = self.param_dict['file1']\\n filename2 = self.param_dict['file2']\\n \\n ''' these next 2 lines are the ones that I added to create a dummy row '''\\n right_dummy = self.create_dummy_row( self.param_dict['dummy_rec_right'])\\n left_dummy = self.create_dummy_row( self.param_dict['dummy_rec_left'])\\n \\n \\n \\n\\n self.open_files(os.path.join(self.entry.working_directory,filename1), os.path.join(self.entry.working_directory,filename2))\\n self.process_params()\\n key_dict = self.create_key_match()\\n file1_rec = self.read_file1(first=True)\\n file2_rec = self.read_file2(first=True)\\n \\n file2_used = False\\n \\n # call the convenience method to setup the temp_csv file. This will also write the header row by default\\n self.setup_csv_temp_writer(self.get_temp_csv_name(), self.get_header(self.file1_reader.fieldnames,self.file2_reader.fieldnames),preserve_order=True)\\n \\n while file1_rec:\\n combined = {k:v for k,v in file1_rec.items()}\\n if file2_rec and self.get_key(file2_rec,self.file2_key) == self.get_key(file1_rec,self.file1_key):\\n # merge these two bad boys\\n combined.update(self.get_values(file2_rec))\\n file2_used = True\\n ### WRITE ###\\n self.write_temp_rec(combined)\\n file1_rec = self.read_file1()\\n elif file2_rec and self.get_key(file1_rec,self.file1_key) > self.get_key(file2_rec,self.file2_key):\\n if not file2_used and left_dummy:\\n ''' left side dummy \\n now use the already created dummy_row to updated the dictionary '''\\n left_dummy.update(self.get_values(file2_rec))\\n key_fields = {key_dict[k]:file2_rec[k] for k in self.file2_key.split(\\\",\\\")}\\n left_dummy.update(key_fields)\\n self.write_temp_rec(left_dummy)\\n left_dummy = self.create_dummy_row( self.param_dict['dummy_rec_left'])\\n \\n \\n file2_rec = self.read_file2()\\n file2_used = False\\n \\n elif not file2_rec or self.get_key(file1_rec,self.file1_key) < self.get_key(file2_rec,self.file2_key):\\n ### WRITE REC WITH NO MATCH ###\\n if self.keep_nomatch:\\n ''' right side dummy\\n now use the already created dummy_row to updated the dictionary '''\\n if right_dummy:\\n combined.update(self.get_values(right_dummy))\\n self.write_temp_rec(combined)\\n file1_rec = self.read_file1()\\n else:\\n raise Exception\\n self.close_temp_csv()\\n return 0\",\n \"def main(input_filepath, output_filepath):\\n # return processed data and save in the output files\\n in_data_y, y_output, in_data = make_data_set(input_filepath)\\n in_data_y.to_csv(output_filepath)\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n return in_data_y, y_output, in_data\",\n \"def recalc_csv(input_path, config_file, family_name, source_string, quiet):\\n csv_file = getCsvPath(input_path)\\n\\n if not config_file:\\n config_file = getConfigPath(input_path)\\n\\n # If config.json doesn't exist, it has to be created before.\\n if not os.path.exists(config_file):\\n configHandler(config_file).resetConfig()\\n click.secho('\\\\n{} didn\\\\'t exist and has been created'.format(\\n config_file), fg='yellow')\\n\\n if os.path.exists(csv_file) and not quiet:\\n confirmation = click.confirm(\\n '\\\\n{} already exists. Do you want to overwrite it?'.format(csv_file))\\n if confirmation is True:\\n csvHandler(csv_file).recalcCSV(\\n config_file=config_file, family_name=family_name, source_string=source_string)\\n click.secho('\\\\n{} created'.format(csv_file), fg='green')\\n else:\\n # Let's ensure that, if the data.csv file doesn't exist,\\n # it is created before recalculation.\\n if not os.path.exists(csv_file):\\n csvHandler(csv_file).resetCSV(config_file=config_file)\\n\\n csvHandler(csv_file).recalcCSV(\\n config_file=config_file, family_name=family_name, source_string=source_string)\\n click.secho('\\\\n{} created'.format(csv_file), fg='green')\",\n \"def process_csvs(conn: Connection, basedir: Path) -> None:\\n process_files(conn, basedir/\\\"files.csv\\\")\\n process_notes(conn, basedir/\\\"notes.csv\\\")\\n process_links(conn, basedir/\\\"links.csv\\\")\\n process_clusters(conn, basedir/\\\"clusters.csv\\\")\\n process_bibliography(conn, basedir/\\\"bibliography.csv\\\")\\n process_citations(conn, basedir/\\\"citations.csv\\\")\",\n \"def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\\n with open(attach_path(answer_file_path), 'r') as answer_file:\\n csv_file = open(attach_path(input_file_path))\\n assert str(read_csv(csv_file)) == answer_file.read().strip()\",\n \"def process_input_data(input_data_path):\\n if os.path.isdir(input_data_path):\\n input_data_glob = glob.glob(input_data_path + \\\"/*.csv\\\")\\n else:\\n if is_gcs_path(input_data_path):\\n # Download the input to a local\\n with tempfile.NamedTemporaryFile() as hf:\\n input_data = hf.name\\n\\n logging.info(\\\"Copying %s to %s\\\", input_data_path, input_data)\\n input_data_gcs_bucket, input_data_gcs_path = split_gcs_uri(\\n input_data_path)\\n\\n logging.info(\\\"Download bucket %s object %s.\\\", input_data_gcs_bucket,\\n input_data_gcs_path)\\n bucket = storage.Bucket(storage.Client(), input_data_gcs_bucket)\\n storage.Blob(input_data_gcs_path, bucket).download_to_filename(\\n input_data)\\n else:\\n input_data = input_data_path\\n\\n ext = os.path.splitext(input_data)[-1]\\n if ext.lower() == '.zip':\\n zip_ref = zipfile.ZipFile(input_data, 'r')\\n zip_ref.extractall('.')\\n zip_ref.close()\\n # TODO: Hardcoding the file in the Archive to use is brittle.\\n # We should probably just require the input to be a CSV file.:\\n csv_file = 'stackoverflow-questions.csv'\\n else:\\n csv_file = input_data\\n\\n input_data_glob = glob.glob(csv_file)\\n\\n return input_data_glob\",\n \"def mani2():\\r\\n #open the original file\\r\\n with open('csvfile1.csv', 'r') as csvfile1:\\r\\n #read the csv file\\r\\n csv_reader = csv.reader(csvfile1)\\r\\n\\r\\n #open the new csv file \\r\\n with open('csvfile2.csv', 'w') as csvfile2:\\r\\n #write to it with another delimeter\\r\\n csv_writer = csv.writer(csvfile2, delimiter='-')\\r\\n #loop through the line\\r\\n for line in csv_reader:\\r\\n csv_writer.writerow(line)\",\n \"def prepare_data(\\n self,\\n csv_file_path='../data/train-orig.csv',\\n tiff_folder_path='../data/train/', # for validation: '../data/valid'\\n mixup: bool = False,\\n for_training=True,\\n data_ratio_mixup=2,\\n alpha_mixup=0.2,\\n # if True, standardization parameters will be computed, if False then apply parameters computed from training data\\n ):\\n self.data = read_data(\\n csv_file_path=csv_file_path,\\n tiff_folder_path=tiff_folder_path,\\n )\\n # Mixup\\n if mixup:\\n self.mixup_data(data_ratio_produce=data_ratio_mixup, alpha=alpha_mixup)\\n\\n ### augment, do whatever you want (distinguish between train and validation setting!)\",\n \"def from_csv(\\n cls,\\n supply_csv: str,\\n requests_csv: str,\\n ) -> \\\"list[TransicationRecord]\\\":\\n results = [None] * cls.SUPPLIER_COUNT\\n with open(supply_csv, 'r', encoding='utf8') as s:\\n reader = csv.reader(s)\\n _header = next(reader)\\n for row in reader:\\n src_t = SrcType(row[1])\\n sid = int(row[0][1:]) - 1\\n data = [float(i) for i in row[2:]]\\n results[sid] = TransicationRecord(row[0], sid, src_t, data)\\n with open(requests_csv, 'r', encoding='utf8') as r:\\n reader = csv.reader(r)\\n _header = next(reader)\\n for row in reader:\\n sid = int(row[0][1:]) - 1\\n data = [float(i) for i in row[2:]]\\n results[sid].requests = np.array(data)\\n for r in results:\\n r.update_request_state()\\n return results\",\n \"def load_or_new(cls, csv_path, image_files):\\n if os.path.exists(csv_path):\\n return cls.from_csv(csv_path)\\n else:\\n return cls.graphical(image_files)\",\n \"def pre_process_reviews(csv, outputname):\\n df = pd.read_csv(csv)\\n df = df.drop(\\\"Unnamed: 0\\\", axis='columns')\\n df.to_csv(outputname, index=False)\",\n \"def merge_csvs(metrics_csv_dims,metrics_csv_int,region,wk_dir):\\n dict_dims = load_and_transpose_csv(metrics_csv_dims)\\n dict_int = load_and_transpose_csv(metrics_csv_int)\\n dict_dims.update(dict_int.copy())\\n fname = os.path.join(wk_dir,region.replace(' ','_') + '_summary.csv')\\n fields = [*dict_dims]\\n models = ['Metric']+[*dict_dims[fields[0]]]\\n\\n with open(fname,'w') as f:\\n writer = csv.DictWriter(f,fieldnames=models)\\n writer.writeheader()\\n for field in fields:\\n row = {'Metric': field}\\n row.update(dict_dims.get(field,{}))\\n writer.writerow(row)\\n\\n data_desc = {\\n os.path.basename(fname): {\\n 'longname': os.path.basename(fname).split('.')[1].replace('_',' '),\\n 'description': 'Parameters and metrics for ' + region + ' region'}}\\n\\n # add metadata to output.json\\n asop.update_output_json('metrics', data_desc, wk_dir)\",\n \"def merge_csv(csv_files):\\n results = dict()\\n data_all = list()\\n keys = set()\\n for filename in csv_files:\\n data, row_len = load_csv_to_dict(filename)\\n keys |= set(data.keys())\\n data_all.append((data, row_len))\\n for key in keys:\\n values = list()\\n for value, row_len in data_all:\\n fill = [\\\"0\\\"]*row_len\\n dt = value[key] if key in value else fill\\n values.extend(dt)\\n results[key] = values\\n return results\",\n \"def emp_import():\\n\\twhile True:\\n\\t\\ttry:\\n\\t\\t\\tfile_path = input(\\\"Enter the path of your file or enter 'quit' to go back to menu.\\\\n File Path: \\\")\\n\\t\\texcept FileNotFoundError:\\n\\t\\t\\tprint(\\\"File Not Found Error.\\\")\\n\\t\\t\\tcontinue\\n\\t\\tif file_path == \\\"quit\\\":\\n\\t\\t\\treturn\\n\\t\\telif not os.path.exists(file_path) and not os.path.isfile(file_path):\\n\\t\\t\\tprint(\\\"Invalid Path.\\\")\\n\\t\\t\\tcontinue\\n\\t\\telif file_path.lower().endswith(('.csv')) == False:\\n\\t\\t\\tprint(\\\"Please Choose a CSV File!\\\")\\n\\t\\t\\tcontinue\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"File Found!\\\")\\n\\t\\t\\tbreak\\n\\tnew_lines = list()\\n\\tlines = list()\\n\\twith open(file_path, 'r') as f:\\n\\t\\treader = csv.reader(f)\\n\\t\\tfor row in reader:\\n\\t\\t\\tnew_lines.append(row)\\n\\twith open(\\\"employees.csv\\\", 'r') as readFile:\\n\\t\\treader = csv.reader(readFile)\\n\\t\\tnext(reader, None)\\n\\t\\tfor row in reader:\\n\\t\\t\\tlines.append(row)\\n\\tnew_list = new_lines + lines\\n\\tto_add = set(tuple(row) for row in new_list)\\n\\twith open('employees.csv', 'w', newline='') as writeFile:\\n\\t\\twriter = csv.writer(writeFile)\\n\\t\\twriter.writerows(to_add)\\n\\t\\tprint(\\\"Employees Added.\\\")\\n\\t\\treturn\",\n \"def _load_single_file(self, table_name, manifest_row, csv_reader,\\n temp_filepath):\\n # get database interface and it's equivalent manifest row\\n sql_interface = self._configure_db_interface(\\n manifest_row=manifest_row, temp_filepath=temp_filepath)\\n\\n sql_manifest_row = sql_interface.get_sql_manifest_row()\\n\\n cleaner = self._get_cleaner(table_name=table_name,\\n manifest_row=manifest_row)\\n csv_writer = CSVWriter(meta=self.meta,\\n manifest_row=manifest_row,\\n filename=temp_filepath)\\n\\n # clean the file and save the output to a local pipe-delimited file\\n # if it doesn't have a 'loaded' status in the database manifest\\n if csv_reader.should_file_be_loaded(sql_manifest_row=sql_manifest_row):\\n print(\\\" Cleaning...\\\")\\n meta_only_fields = self._get_meta_only_fields(\\n table_name=table_name, data_fields=csv_reader.keys)\\n for idx, data_row in enumerate(csv_reader):\\n data_row.update(meta_only_fields) # insert other field dict\\n clean_data_row = cleaner.clean(data_row, idx)\\n if clean_data_row is not None:\\n csv_writer.write(clean_data_row)\\n\\n csv_writer.close()\\n\\n # write the data to the database\\n self._update_database(sql_interface=sql_interface)\\n\\n if not self._keep_temp_files:\\n csv_writer.remove_file()\",\n \"def perform_process(transformer: transformer_class.Transformer, check_md: dict) -> dict:\\n # Process each CSV file into BETYdb\\n start_timestamp = datetime.datetime.now()\\n files_count = 0\\n files_csv = 0\\n lines_read = 0\\n error_count = 0\\n files_loaded = []\\n for one_file in check_md['list_files']():\\n files_count += 1\\n if os.path.splitext(one_file)[1].lower() == '.csv':\\n files_csv += 1\\n\\n # Make sure we can access the file\\n if not os.path.exists(one_file):\\n msg = \\\"Unable to access csv file '%s'\\\" % one_file\\n logging.debug(msg)\\n return {'code': -1000,\\n 'error': msg}\\n\\n try:\\n # Read in the lines from the file\\n with open(one_file, 'r') as in_file:\\n reader = csv.DictReader(in_file)\\n files_loaded.append(one_file)\\n for row in reader:\\n centroid_lonlat = [row['lon'], row['lat']]\\n time_fmt = row['dp_time']\\n timestamp = row['timestamp']\\n dp_metadata = {\\n \\\"source\\\": row['source'],\\n \\\"value\\\": row['value']\\n }\\n trait = row['trait']\\n\\n __internal__.create_datapoint_with_dependencies(transformer.args.clowder_url, transformer.args.clowder_key,\\n trait, (centroid_lonlat[1], centroid_lonlat[0]), time_fmt,\\n time_fmt, dp_metadata, timestamp)\\n lines_read += 1\\n\\n except Exception:\\n logging.exception(\\\"Error reading CSV file '%s'. Continuing processing\\\", os.path.basename(one_file))\\n error_count += 1\\n\\n if files_csv <= 0:\\n logging.info(\\\"No CSV files were found in the list of files to process\\\")\\n if error_count > 0:\\n logging.error(\\\"Errors were found during processing\\\")\\n return {'code': -1001, 'error': \\\"Too many errors occurred during processing. Please correct and try again\\\"}\\n\\n return {\\n 'code': 0,\\n configuration.TRANSFORMER_NAME: {\\n 'version': configuration.TRANSFORMER_VERSION,\\n 'utc_timestamp': datetime.datetime.utcnow().isoformat(),\\n 'processing_time': str(datetime.datetime.now() - start_timestamp),\\n 'num_files_received': str(files_count),\\n 'num_csv_files': str(files_csv),\\n 'lines_loaded': str(lines_read),\\n 'files_processed': str(files_loaded)\\n }\\n }\",\n \"def csvs_scattered_to_grouped(path_dir, inlist, outlist, gcols,\\n sort=1, scols=None, catalog=\\\"\\\", supersede=False):\\n\\n filelist=[os.path.join(path_dir,i) for i in inlist]\\n n_split=len(outlist)\\n\\n pdfs=pd.read_csv(filelist[0],usecols=gcols)\\n pdfs.drop_duplicates(inplace=True)\\n\\n print(\\\"csvs_scattered_to_grouped: Collecting items for group.\\\\n\\\")\\n for i in range(1,len(filelist)):\\n pdfs=pdfs.append(pd.read_csv(filelist[i],usecols=gcols),ignore_index=True)\\n pdfs.drop_duplicates(inplace=True)\\n\\n if sort==1:\\n pdfs.sort_values(gcols,inplace=True, ascending=True)\\n elif sort==-1:\\n pdfs.sort_values(gcols,inplace=True, ascending=False)\\n\\n aa_ed=np.array_split(pdfs, n_split)\\n\\n if supersede:\\n for i in outlist:\\n if os.path.isfile(os.path.join(path_dir,i)):\\n os.remove(os.path.join(path_dir,i))\\n if os.path.isfile(os.path.join(path_dir,str(catalog))):\\n os.remove(os.path.join(path_dir,str(catalog)))\\n\\n print(\\\"csvs_scattered_to_grouped: Start processing files:\\\\n\\\")\\n for i in range(0,len(filelist)):\\n fi=pd.read_csv(filelist[i],usecols=scols)\\n for j,ja in enumerate(aa_ed):\\n wrtj=pd.merge(ja, fi, how='inner', on=gcols)\\n append_to_csv(wrtj, os.path.join(path_dir,outlist[j]))\\n print('csvs_scattered_to_grouped: '+str(i)+' file(s) finished.')\\n\\n if catalog:\\n for i, d in enumerate(aa_ed):\\n d['_@_FILE_']=outlist[i]\\n append_to_csv(d, os.path.join(path_dir,str(catalog)))\\n print('csvs_scattered_to_grouped: Catalog file created.')\",\n \"def load(*args):\\r\\n\\r\\n #args[0].to_csv(str(PATH.joinpath('./data/{}.csv'.format(args[1]))),index=False)\\r\\n\\r\\n try: # it will fail if duplicates\\r\\n args[0].to_sql('cmf', con=engine, if_exists='append', index=False)\\r\\n except:\\r\\n pass\",\n \"def ingest_file(input, fields, advanced_operators, output, delimiter=',', quotechar='\\\"'):\\n with open(input, 'rb') as csv_file:\\n reader = csv.DictReader(csv_file)\\n\\n with open(output, 'a') as write_csvfile:\\n fieldnames = ['acronym', 'title', 'projectUrl',\\n 'foundProjectUrl1', 'foundProjectUrl2',\\n 'foundProjectUrl3', 'foundProjectUrl4',\\n 'foundProjectUrl5', 'foundProjectUrl6',\\n 'foundProjectUrl7', 'foundProjectUrl8',\\n 'foundProjectUrl9', 'foundProjectUrl10']\\n\\n writer = csv.DictWriter(write_csvfile, fieldnames=fieldnames)\\n writer.writeheader() # this method only available at python 2.7\\n\\n search_engine = SearchWeb()\\n\\n # iterate reader\\n for row in reader:\\n query_string = str(concatenate(row, fields))\\n\\n response = search_engine.search(query_string, advanced_operators)\\n\\n projectsUrl = []\\n results_size = len(response)\\n\\n # TODO print with logger\\n print \\\"INFO: RESULT SIZE - %s\\\" % results_size\\n\\n for i in range(10):\\n if i < results_size:\\n projectsUrl.append(response[i]['Url'])\\n else:\\n projectsUrl.append('')\\n\\n # TODO print with logger\\n print \\\"INFO: FIRST RESULT - %s\\\" % projectsUrl[0]\\n writer.writerow(dict(acronym=row['acronym'], title=row['title'], projectUrl=row['projectUrl'],\\n foundProjectUrl1=projectsUrl[0], foundProjectUrl2=projectsUrl[1],\\n foundProjectUrl3=projectsUrl[2], foundProjectUrl4=projectsUrl[3],\\n foundProjectUrl5=projectsUrl[4], foundProjectUrl6=projectsUrl[5],\\n foundProjectUrl7=projectsUrl[6], foundProjectUrl8=projectsUrl[7],\\n foundProjectUrl9=projectsUrl[8], foundProjectUrl10=projectsUrl[9]))\",\n \"def prepare_csv(self, filename, *args, **kwargs):\\n x_possible = getattr(settings, 'IMPORT_CSV_X_FIELDS', ['Lon*', 'x', 'lon*'])\\n y_possible = getattr(settings, 'IMPORT_CSV_Y_FIELDS', ['Lat*', 'y', 'lat*'])\\n geom_possible = getattr(settings, 'IMPORT_CSV_GEOM_FIELDS',\\n ['geom', 'GEOM', 'WKT', 'the_geom', 'THE_GEOM', 'WKB'])\\n\\n oo = kwargs.get('open_options', [])\\n\\n oo.append('X_POSSIBLE_NAMES={0}'.format(','.join(x_possible)))\\n oo.append('Y_POSSIBLE_NAMES={0}'.format(','.join(y_possible)))\\n oo.append('GEOM_POSSIBLE_NAMES={0}'.format(','.join(geom_possible)))\\n\\n kwargs['open_options'] = oo\\n\\n return filename, args, kwargs\",\n \"def init_csv(input_path, config_file, quiet):\\n\\n if not config_file:\\n config_file = getConfigPath(input_path)\\n\\n if not os.path.exists(config_file) or quiet:\\n configHandler(config_file).resetConfig()\\n click.secho('\\\\n{} didn\\\\'t exist and has been created'.format(\\n config_file), fg='green')\\n\\n csv_file = getCsvPath(input_path)\\n if not os.path.exists(csv_file) or quiet:\\n confirm_overwrite = True\\n else:\\n confirm_overwrite = click.confirm(\\n '{} already exists. Do you want to overwrite it?'.format(csv_file))\\n\\n if confirm_overwrite:\\n if not os.path.exists(config_file):\\n configHandler(config_file).resetConfig()\\n csvHandler(csv_file).resetCSV(config_file=config_file)\\n click.secho('{} created'.format(csv_file), fg='green')\",\n \"def cell_map_from_csv(self, source_file: str) -> None:\\n if source_file[-4:] == '.csv':\\n try:\\n self._import_source_data(source_file)\\n except Exception:\\n print(\\\"Problem with that CSV file. File extension?\\\")\",\n \"def merge_duplicate_psm_rows(\\n csv_file_path=None,\\n psm_counter=None,\\n psm_defining_colnames=None,\\n psm_colnames_to_merge_multiple_values={},\\n joinchar=\\\"<|>\\\",\\n overwrite_file=True,\\n):\\n rows_to_merge_dict = defaultdict(list)\\n\\n if overwrite_file:\\n tmp_file = csv_file_path + \\\".tmp\\\"\\n os.rename(csv_file_path, tmp_file)\\n out_file = csv_file_path\\n else:\\n tmp_file = csv_file_path\\n out_file = csv_file_path.strip(\\\".csv\\\") + \\\"_merged_duplicates.csv\\\"\\n UNode.print_info(\\\"Merging rows of the same PSM...\\\", caller=\\\"postflight\\\")\\n # print('Merging rows of the same PSM...')\\n csv_kwargs = {}\\n if sys.platform == \\\"win32\\\":\\n csv_kwargs[\\\"lineterminator\\\"] = \\\"\\\\n\\\"\\n else:\\n csv_kwargs[\\\"lineterminator\\\"] = \\\"\\\\r\\\\n\\\"\\n with open(tmp_file, \\\"r\\\") as tmp, open(out_file, \\\"w\\\", newline=\\\"\\\") as out:\\n tmp_reader = csv.DictReader(tmp)\\n writer = csv.DictWriter(out, fieldnames=tmp_reader.fieldnames, **csv_kwargs)\\n writer.writeheader()\\n for row in tmp_reader:\\n psm = tuple([row[x] for x in psm_defining_colnames if x in row.keys()])\\n # each unique combination of these should only have ONE row!\\n # i.e. combination of seq+spec+score\\n if psm_counter[psm] == 1:\\n # no duplicate = no problem, we can just write the row again\\n writer.writerow(row)\\n elif psm_counter[psm] > 1:\\n # we have to collect all rows of this psm, and merge + write\\n # them later!\\n rows_to_merge_dict[psm].append(row)\\n else:\\n raise Exception(\\\"This should never happen.\\\")\\n # finished parsing the old unmerged unified csv\\n for rows_to_merge in rows_to_merge_dict.values():\\n writer.writerow(\\n merge_rowdicts(\\n rows_to_merge,\\n psm_colnames_to_merge_multiple_values,\\n joinchar=joinchar,\\n )\\n )\\n # remove the old unified csv that contains duplicate rows\\n if overwrite_file:\\n os.remove(tmp_file)\\n UNode.print_info(\\\"Done.\\\", caller=\\\"postflight\\\")\\n return out_file\",\n \"def combine_syllable_csv():\\n reading_csv = pd.read_csv(sys.argv[1])\\n memory_csv = pd.read_csv(sys.argv[2])\\n cookie_csv = pd.read_csv(sys.argv[3])\\n merged = reading_csv.merge(memory_csv, on=TRANSCRIPT_ID)\\n merged = merged.merge(cookie_csv, on=TRANSCRIPT_ID)\\n merged.to_csv('jan27_merged_syllabus.csv', sep=',', header=True, index=False)\",\n \"def test_37_bulk_csv_import_no_column_names(self, Mock, mock):\\r\\n empty_file = FakeRequest('Foo,Bar,Baz\\\\n1,2,3', 200,\\r\\n {'content-type': 'text/plain'})\\r\\n Mock.return_value = empty_file\\r\\n self.register()\\r\\n self.new_application()\\r\\n app = db.session.query(App).first()\\r\\n url = '/app/%s/tasks/import?template=csv' % (app.short_name)\\r\\n res = self.app.post(url, data={'csv_url': 'http://myfakecsvurl.com',\\r\\n 'formtype': 'csv'},\\r\\n follow_redirects=True)\\r\\n task = db.session.query(Task).first()\\r\\n assert {u'Bar': u'2', u'Foo': u'1', u'Baz': u'3'} == task.info\\r\\n assert \\\"1 Task imported successfully!\\\" in res.data\",\n \"def enhance(parent_folder):\\n parent_folder = Path(parent_folder).resolve()\\n address_csv_files = sorted(parent_folder.glob('*.csv'))\\n\\n print(f'enhancing {len(address_csv_files)} csv files in {parent_folder}')\\n\\n data = Path(__file__).parent.parent.parent / 'data'\\n workspace = (data / 'enhanced' / GDB_NAME).resolve()\\n\\n arcpy.env.workspace = str(workspace)\\n\\n for address_csv in address_csv_files:\\n job = enhance_data(address_csv)\\n\\n prepare_output(job)\\n convert_to_csv(job)\\n remove_temp_tables(job)\",\n \"def _check_duplicate_id_csv(self):\\n all_csv_ids = []\\n self.msg_args = []\\n for csv_file_rel in self.filter_files_ext('csv', relpath=True):\\n csv_file = os.path.join(self.module_path, csv_file_rel)\\n if os.path.basename(csv_file) == 'ir.model.access.csv':\\n all_csv_ids.extend(self.get_field_csv(csv_file))\\n duplicated_ids_csv = self.get_duplicated_items(all_csv_ids)\\n for duplicated_id_csv in duplicated_ids_csv:\\n self.msg_args.append((csv_file_rel, duplicated_id_csv))\\n if duplicated_ids_csv:\\n return False\\n return True\",\n \"def read_csv():\",\n \"def read_csv_input_file(self,\\n file_name: str,\\n usecols: list = None,\\n names: list = None,\\n remove_spurious_urls=False,\\n unique_key=None\\n ):\\n\\n # split the extension two time so we can also deal with a double extension bla.csv.zip\\n file_base, file_ext = os.path.splitext(file_name)\\n file_base2, file_ext2 = os.path.splitext(file_base)\\n\\n # build the cache file including the cache_directory\\n cache_file = Path(CACHE_DIRECTORY) / (file_base2 + \\\".pkl\\\")\\n\\n if os.path.exists(cache_file):\\n # add the type so we can recognise it is a data frame\\n self.logger.info(\\\"Reading from cache {}\\\".format(cache_file))\\n df: pd.DataFrame = pd.read_pickle(cache_file)\\n df.reset_index(inplace=True)\\n elif \\\".csv\\\" in (file_ext, file_ext2):\\n self.logger.info(\\\"Reading from file {}\\\".format(file_name))\\n df = pd.read_csv(file_name,\\n header=None,\\n usecols=usecols,\\n names=names\\n )\\n\\n if remove_spurious_urls:\\n self.logger.info(\\\"Removing spurious urls\\\")\\n df = self.remove_spurious_urls(df)\\n\\n df = self.clip_kvk_range(df, unique_key=unique_key, kvk_range=self.kvk_range_read)\\n\\n self.logger.info(\\\"Writing data to cache {}\\\".format(cache_file))\\n df.to_pickle(cache_file)\\n else:\\n raise AssertionError(\\\"Can only read h5 or csv files\\\")\\n\\n try:\\n df.drop(\\\"index\\\", axis=0, inplace=True)\\n except KeyError:\\n self.logger.debug(\\\"No index to drop\\\")\\n else:\\n self.logger.debug(\\\"Dropped index\\\")\\n\\n return df\",\n \"def read_whole_csv_file(csvfile, numpy_option, **kwargs):\\n import csv\\n import numpy as np\\n import sys\\n sys.dont_write_bytecode = True\\n # handles forgetting to type .csv\\n if len(csvfile.split('.'))==1:\\n csvfile = csvfile + '.csv'\\n data_file_info = []\\n if 'desired_lines' in kwargs:\\n lines = kwargs['desired_lines']\\n with open(csvfile, 'rb') as csvfile:\\n myread = csv.reader(csvfile)\\n for index, row in enumerate(myread):\\n if index in lines:\\n data_file_info.append(row)\\n else:\\n with open(csvfile, 'rb') as csvfile:\\n myread = csv.reader(csvfile)\\n for index, row in enumerate(myread):\\n data_file_info.append(row)\\n\\n if 'unnecessary_lines' in kwargs:\\n lines = kwargs['unnecessary_lines']\\n lines = sorted(lines, reverse=True)\\n for line in lines:\\n del data_file_info[line]\\n\\n if numpy_option is True:\\n data_file_info = np.array(data_file_info)\\n return data_file_info\",\n \"def read_csv():\\n global csvdata\\n global CONFIG\\n if type(csvdata) == type(None):\\n if not os.path.exists(CONFIG[\\\"csvfile\\\"]):\\n csvdata = pandas.read_csv(CONFIG[\\\"csvrepo\\\"],\\n na_values=[\\\"-999999\\\",\\\"NOT AVAILABLE\\\"])\\n os.makedirs(CONFIG[\\\"cachedir\\\"],exist_ok=True)\\n csvdata.to_csv(CONFIG[\\\"csvfile\\\"])\\n else:\\n csvdata = pandas.read_csv(CONFIG[\\\"csvfile\\\"])\\n return csvdata\",\n \"def process_header_data(spark, input_dir, output):\\n\\theader = spark.read \\\\\\n\\t\\t.option(\\\"header\\\", True) \\\\\\n\\t\\t.option(\\\"escape\\\", '\\\"') \\\\\\n\\t\\t.option(\\\"inferSchema\\\", True) \\\\\\n\\t\\t.csv(f\\\"{input_dir}/ams/*/*/ams__header_*__*.csv\\\") \\\\\\n\\t\\t.select(*header_cols) \\\\\\n\\t\\t.where(col('identifier').isNotNull())\\n\\n\\tbill = spark.read \\\\\\n\\t\\t.option(\\\"header\\\", True) \\\\\\n\\t\\t.option(\\\"escape\\\", '\\\"') \\\\\\n\\t\\t.option(\\\"inferSchema\\\", True) \\\\\\n\\t\\t.csv(f\\\"{input_dir}/ams/*/*/ams__billgen_*__*.csv\\\") \\\\\\n\\t\\t.select(*bill_cols)\\n\\n\\theader_full = header.join(bill, ['identifier'], how='left')\\n\\n\\theader_full.repartition(1).write.mode('overwrite').format(\\\"csv\\\") \\\\\\n\\t\\t.option(\\\"header\\\", True) \\\\\\n\\t\\t.option(\\\"escape\\\", '\\\"') \\\\\\n\\t\\t.save(f\\\"{output}/header/\\\")\",\n \"def test_csv_row_bug(script_runner, tmpdir, test_dir):\\n csv_file = tmpdir / 'csv_file.csv'\\n\\n ret = script_runner.run(\\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\\n print(ret.stdout)\\n print(ret.stderr, file=sys.stderr)\\n assert ret.success\\n\\n assert csv_file.exists()\\n\\n with csv_file.open('r') as fo:\\n reader = csv.reader(fo)\\n rows = list(reader)\\n assert len(rows) == len(test_dir.listdir()) + 1\\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\\n for i, row in enumerate(rows[1:]):\\n assert row[0] and row[1]\\n # Test entries except the timestamp and full file path.\\n assert row[2:] == [\\n 'fooconfigtest.txt',\\n 'example output file',\\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\\n '127.0.0.1',\\n ('[+] File test_{0}.txt identified as Foo.\\\\n'\\n '[+] size of inputfile is 23 bytes\\\\n'\\n '[+] operating on inputfile test_{0}.txt').format(i),\\n 'http://127.0.0.1',\\n ]\",\n \"def get_concatenated_csv_data(concatenated_filepath, concatenated_filename, device_id, output_create_files_filepath, output_create_files_filename):\\n\\n # Create the full file name of the concatenated filename.\\n concatenated_file = concatenated_filepath + \\\"/\\\" + concatenated_filename + \\\"_concatenated.csv\\\"\\n print(\\\"Looking for concatenated file name: \\\", concatenated_file)\\n\\n # Test if the concatenated file exists and if it does, return it.\\n if os.path.isfile(concatenated_file):\\n print(\\\"Concatenated file exists: \\\", concatenated_file)\\n return concatenated_file\\n\\n # If it does not exist, test if the individual files exist.\\n elif not os.path.isfile(concatenated_file):\\n print(\\\"Concatenated file does not exist. Create file: \\\", concatenated_file)\\n file_list = get_data_from_files(concatenated_filepath, concatenated_filename)\\n # print(\\\"File list:\\\", file_list)\\n\\n # If the individual files exist, create the concatenated file.\\n if len(file_list) > 0:\\n print(\\\"Individual csv files exist. Creating the concatenated file.\\\")\\n concatenated_file = create_concatenated_csvfile(concatenated_filepath, concatenated_filename)\\n return concatenated_file\\n\\n # If the individual files do not exist, get the data from the database, create the files then concatenate them.\\n else:\\n database_query = \\\"select * from ship_data_gpggagpsfix where device_id=\\\" + int(\\n device_id) + \\\" order by date_time;\\\"\\n # print(database_query)\\n password = input()\\n\\n db_connection = MySQLdb.connect(host='localhost', user='ace', passwd=password, db='ace2016', port=3306);\\n\\n track_df = get_data_from_database(database_query, db_connection)\\n track_df = string_to_datetime(track_df)\\n\\n # Output the data into daily files (as they do not already exist).\\n output_daily_files(track_df, output_create_files_filepath, output_create_files_filename)\\n\\n concatenated_file = create_concatenated_csvfile(concatenated_filepath, concatenated_filename)\\n return concatenated_file\",\n \"def preprocess_files(file_path):\\n # checking your current working directory\\n cur_dir = os.getcwd()\\n\\n # Get your current folder and sub folder event data\\n data_dir = os.path.join(cur_dir, 'event_data')\\n\\n # Create a for loop to create a list of files and collect each\\n # file_path\\n file_path_list = []\\n for root, dirs, files in os.walk(data_dir):\\n # join the file path and roots with the subdirectories using\\n # glob\\n file_path_list = glob.glob(os.path.join(root, '*'))\\n\\n full_data_rows_list = []\\n\\n # for every file_path in the file path list collect records\\n for f in file_path_list:\\n\\n # reading csv file\\n with open(f, 'r', encoding='utf8', newline='') as csvfile:\\n\\n # creating a csv reader object\\n csvreader = csv.reader(csvfile)\\n next(csvreader)\\n\\n # extracting each data row one by one and append it\\n for line in csvreader:\\n full_data_rows_list.append(line)\\n\\n csv.register_dialect('myDialect', quoting=csv.QUOTE_ALL,\\n skipinitialspace=True)\\n\\n # create one file with all the records\\n with open(file_path, 'w', encoding='utf8',\\n newline='') as f:\\n writer = csv.writer(f, dialect='myDialect')\\n writer.writerow(\\n ['artist', 'firstName', 'gender', 'itemInSession',\\n 'lastName', 'length', 'level', 'location', 'sessionId',\\n 'song', 'userId'])\\n for row in full_data_rows_list:\\n if row[0] == '':\\n continue\\n writer.writerow((row[0], row[2], row[3], row[4], row[5],\\n row[6], row[7], row[8], row[12], row[13],\\n row[16]))\",\n \"def merge_files():\\n # abs path of data folder\\n work_folder = os.path.join(CURRENT_FOLDER, \\\"..\\\\\\\\Data\\\\\\\\weather_data\\\\\\\\KORD\\\")\\n file_list = os.listdir(work_folder)\\n with open(os.path.join(work_folder, \\\"..\\\\\\\\merged_history_KORD.csv\\\"), \\\"w\\\") as outfile:\\n for line in open(os.path.join(work_folder, file_list[0])):\\n outfile.write(line)\\n print \\\"write the first line\\\"\\n for i in range(1, len(file_list)):\\n with open(os.path.join(work_folder, file_list[i])) as infile:\\n infile.next()\\n for line in infile:\\n outfile.write(line)\",\n \"def _init_train_valid(self, csv_path, csv_sep, csv_names):\\n # load groundtruth\\n # last element following a dot is file's extension\\n print('Loading data...') \\n if csv_path.split('.')[-1] == 'cache':\\n # load cache\\n # Assumes that the cache contains a list of all the identities, a dictionary containing metadata about those identities and the number of samples contained in the cache.\\n # The dictionary must have the same format as the 'groundtruth_metadata' dictionary that is built below.\\n # dati che mi servono: identities, groundtruth_metadata, num_samples\\n with open(csv_path, 'rb') as cache_file:\\n cache = pickle.load(cache_file)\\n self.identities = cache['identities']\\n self.groundtruth_metadata = cache['groundtruth_metadata']\\n self.num_samples = cache['num_samples']\\n else:\\n # Assumes for the provided csv the following structure:\\n # Path, ID, Gender, Age, x_min(roi_origin_x), y_min(roi_origin_y), width(roi_width), height(roi_height)\\n groundtruth = pd.read_csv(csv_path, sep=csv_sep, names=csv_names)\\n # for each groundtruth row\\n for gt_sample in groundtruth.iterrows():\\n identity = gt_sample[1][\\\"ID\\\"]\\n # this iteration is over all of the elements in groundtruth, so the same id can be encountered multiple times (same id associated to multiple images)\\n if identity not in self.identities:\\n self.identities.append(identity)\\n # load identity's metadata\\n id_data = {\\n 'age': gt_sample[1][\\\"Age\\\"],\\n 'roi': {\\n 'upper_left_x': gt_sample[1][\\\"x_min\\\"],\\n 'upper_left_y': gt_sample[1][\\\"y_min\\\"],\\n 'width': gt_sample[1][\\\"width\\\"],\\n 'height': gt_sample[1][\\\"height\\\"]\\n },\\n 'path': gt_sample[1][\\\"Path\\\"]\\n }\\n if identity not in self.groundtruth_metadata.keys():\\n self.groundtruth_metadata[identity] = {\\n 'index': 0,\\n 'metadata': []\\n }\\n # the other elements in the list associated to an identity are metadata \\n self.groundtruth_metadata[identity]['metadata'].append(id_data)\\n self.num_samples += 1\\n # Dump loaded data to cache\\n # Split csv path in directory path and filename\\n (csv_dir, csv_name) = os.path.split(csv_path)\\n # Create a name for cache file with the same name as csv file but different extension\\n cache_name = csv_name.split('.')[0]+'.cache'\\n # Create a path pointing to the new cache file, locating it in the same directory as the csv file\\n cache_path = os.path.join(csv_dir, cache_name)\\n # Write relevant data to file\\n with open(cache_path, 'wb') as cache_out_file:\\n out_dict = {}\\n out_dict['identities'] = self.identities\\n out_dict['groundtruth_metadata'] = self.groundtruth_metadata\\n out_dict['num_samples'] = self.num_samples\\n pickle.dump(out_dict, cache_out_file) \\n print('Finished loading data!')\\n if self.mode == 'training':\\n self._shuffle()\",\n \"def copy_csv_files(data_files_dict):\\n # Depending on your local settings, you may need to specify a user and password, e.g.\\n # conn = psycopg2.connect(dbname=DBNAME, user=\\\"postgres\\\", password=\\\"password\\\")\\n conn = psycopg2.connect(dbname=DBNAME)\\n\\n for name, files in data_files_dict.items():\\n csv_file = files[0]\\n # skip the header; this info is already in the table schema\\n next(csv_file)\\n if name == \\\"train\\\":\\n copy_csv_to_train_table(conn, csv_file)\\n elif name == \\\"questions\\\":\\n copy_csv_to_questions_table(conn, csv_file)\\n elif name == \\\"lectures\\\":\\n copy_csv_to_lectures_table(conn, csv_file)\\n elif name == \\\"example_test\\\":\\n copy_csv_to_example_test_table(conn, csv_file)\\n elif name == \\\"example_sample_submission\\\":\\n copy_csv_to_example_sample_submission_table(conn, csv_file)\\n\\n print(f\\\"\\\"\\\"Successfully loaded CSV file into `{name}` table\\n \\\"\\\"\\\")\\n\\n conn.close()\",\n \"def reformat_submission_files(self, submission_local_path=None):\\n if submission_local_path is not None:\\n sub_files = [f for f in listdir(submission_local_path) if isfile(join(submission_local_path, f))]\\n for sub_file in sub_files:\\n submission_local_file_path = '{}/{}'.format(submission_local_path, sub_file)\\n sub_df = pd.read_csv(submission_local_file_path)\\n if ('SK_ID_CURR' in sub_df.columns) and (sub_df.shape[0] == 48744):\\n sub_df['SK_ID_CURR'] = sub_df['SK_ID_CURR'].astype(int)\\n sub_df.to_csv(submission_local_file_path, index=False)\\n else:\\n os.remove(submission_local_file_path)\",\n \"def import_csv_dataset():\\n import_fields = pd.read_csv('redacted-2020-june-30-wprdc-.csv', header=None).to_numpy()[0, :]\\n import_values = pd.read_csv('redacted-2020-june-30-wprdc-.csv').to_numpy()\\n import_values = clean_values(import_values)\\n return import_fields, import_values\",\n \"def combine(self, input_file, output_file):\\n \\n csvOutput = self.csvData.readCsv(input_file)\\n \\n # Extract csv column names\\n columnsNmes = csvOutput[0]\\n \\n response = []\\n \\n # Remove first row from csv output (columns names)\\n iterCsvOutput = iter(csvOutput)\\n next(iterCsvOutput)\\n # Get all api data with one call\\n apiResponse = self.apiData.getContent(self.apiUrl)\\n\\n # Iterate over Csv lines\\n for item in iterCsvOutput: \\n\\n # For each CSV line find corresponding account in Api response\\n for apiItem in apiResponse['results']:\\n\\n # I Api response match Csv row combine data\\n if str(apiItem['account_id']) == item[0]: \\n # Add response form Api\\n item.insert(4, apiItem['status'])\\n item.insert(5, apiItem['created_on'])\\n response.append(item)\\n \\n # Add row with new column names\\n columnsNmes.insert(4, 'Status')\\n columnsNmes.insert(5, 'Status Set On')\\n response.insert(0, columnsNmes)\\n\\n # Generate csv output file\\n self.csvData.writeCsv(response, output_file)\\n \\n return 'Given output file has been generated'\",\n \"def csv_file(input_file):\\n\\n current_dir = os.getcwd()\\n directory_name = current_dir + '\\\\\\\\' + 'data' + '\\\\\\\\'\\n csv_out = directory_name + input_file\\n return csv_out\",\n \"def merge_csv_files(files: List[str], outfile: str):\\n\\tlogthis.say('Merging files starts.')\\n\\tdata: pd.DataFrame = pd.DataFrame([], columns=['Label', 'Repo', 'Text'])\\n\\tnum_files = len(files)\\n\\tfor index, file in enumerate(files):\\n\\t\\tlogthis.say(f'Merging files {100*(index+1)/num_files:.2f}% {index+1}/{num_files}')\\n\\t\\tdf = pd.read_csv(file, sep=';')\\n\\t\\tdata = pd.concat([df, data])\\n\\tlogthis.say(f'Write data to {outfile}')\\n\\tdata.to_csv(outfile, sep=';', index=False)\\n\\tlogthis.say('Merging files done.')\",\n \"def main(file1, file2, uniq1=False, uniq2=False, union=False, tab=False, col1=1, col2=1):\\n delimiter = \\\"\\\\t\\\" if tab else \\\",\\\"\\n\\n idx1 = col1 - 1\\n idx2 = col2 - 1\\n\\n # Figure out what the mode of operation is.\\n show = ISECT\\n show = UNIQ1 if uniq1 else show\\n show = UNIQ2 if uniq2 else show\\n show = UNION if union else show\\n\\n if not os.path.isfile(file1):\\n print(f\\\"file not found: {file1}\\\")\\n sys.exit(1)\\n\\n # Get a stream for each file\\n stream1 = get_stream(file1)\\n stream2 = get_stream(file2)\\n\\n # Process the file.\\n process(stream1=stream1, stream2=stream2, delimiter=delimiter, idx1=idx1, idx2=idx2, show=show)\",\n \"def run(self):\\n lineage_csv_gz = self.input_files_local[0][0]\\n output_db = self.output_files_local()[0]\\n log.write(f\\\"input: {lineage_csv_gz} output: {output_db}\\\")\\n\\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\\n batch_list = {}\\n with gzip.open(lineage_csv_gz, \\\"rt\\\") as gzf:\\n for line in gzf:\\n fields = line.rstrip().split(\\\",\\\")\\n taxid = fields[0]\\n species, genus, family = fields[-1:-4:-1]\\n batch_list[taxid] = [species, genus, family]\\n if len(batch_list) >= BATCH_INSERT_SIZE:\\n lineage_dict.batch_inserts(batch_list.items())\\n batch_list = {}\\n lineage_dict.batch_inserts(batch_list.items())\",\n \"def csv_to_ins_file(\\n csv_filename,\\n ins_filename=None,\\n only_cols=None,\\n only_rows=None,\\n marker=\\\"~\\\",\\n includes_header=True,\\n includes_index=True,\\n prefix=\\\"\\\",\\n head_lines_len=0,\\n sep=\\\",\\\",\\n gpname=False,\\n):\\n # process the csv_filename in case it is a dataframe\\n if isinstance(csv_filename, str):\\n df = pd.read_csv(csv_filename, index_col=0)\\n df.columns = df.columns.map(str.lower)\\n df.index = df.index.map(lambda x: str(x).lower())\\n else:\\n df = csv_filename\\n\\n # process only_cols\\n if only_cols is None:\\n only_cols = set(df.columns.map(lambda x: x.lower().strip()).tolist())\\n else:\\n if isinstance(only_cols, str): # incase it is a single name\\n only_cols = [only_cols]\\n only_cols = set(only_cols)\\n only_cols = {c.lower() if isinstance(c, str) else c for c in only_cols}\\n\\n if only_rows is None:\\n only_rows = set(df.index.map(lambda x: x.lower().strip()).tolist())\\n else:\\n if isinstance(only_rows, str): # incase it is a single name\\n only_rows = [only_rows]\\n only_rows = set(only_rows)\\n only_rows = {r.lower() if isinstance(r, str) else r for r in only_rows}\\n\\n # process the row labels, handling duplicates\\n rlabels = []\\n row_visit = {}\\n only_rlabels = []\\n for rname_org in df.index:\\n rname = str(rname_org).strip().lower()\\n if rname in row_visit:\\n rsuffix = \\\"_\\\" + str(int(row_visit[rname] + 1))\\n row_visit[rname] += 1\\n else:\\n row_visit[rname] = 1\\n rsuffix = \\\"\\\"\\n rlabel = rname + rsuffix\\n rlabels.append(rlabel)\\n if rname in only_rows or rname_org in only_rows:\\n only_rlabels.append(rlabel)\\n only_rlabels = set(only_rlabels)\\n\\n # process the col labels, handling duplicates\\n clabels = []\\n col_visit = {}\\n only_clabels = []\\n for cname_org in df.columns:\\n cname = str(cname_org).strip().lower()\\n if cname in col_visit:\\n csuffix = \\\"_\\\" + str(int(col_visit[cname] + 1))\\n col_visit[cname] += 1\\n else:\\n col_visit[cname] = 1\\n csuffix = \\\"\\\"\\n clabel = cname + csuffix\\n clabels.append(clabel)\\n if cname in only_cols or cname_org in only_cols:\\n only_clabels.append(clabel)\\n only_clabels = set(only_clabels)\\n if len(only_clabels) == 0:\\n print(\\\"only_cols:\\\", only_cols)\\n raise Exception(\\\"csv_to_ins_file(): only_clabels is empty\\\")\\n\\n if ins_filename is None:\\n if not isinstance(csv_filename, str):\\n raise Exception(\\\"ins_filename is None but csv_filename is not string\\\")\\n ins_filename = csv_filename + \\\".ins\\\"\\n row_visit, col_visit = {}, {}\\n onames = []\\n ovals = []\\n ognames = []\\n only_clabels_len = len(only_clabels)\\n clabels_len = len(clabels)\\n prefix_is_str = isinstance(prefix, str)\\n vals = df.values.copy() # wasteful but way faster\\n with open(ins_filename, \\\"w\\\") as f:\\n f.write(f\\\"pif {marker}\\\\n\\\")\\n [f.write(\\\"l1\\\\n\\\") for _ in range(head_lines_len)]\\n if includes_header:\\n f.write(\\\"l1\\\\n\\\") # skip the row (index) label\\n for i, rlabel in enumerate(rlabels): # loop over rows\\n f.write(\\\"l1\\\")\\n if rlabel not in only_rlabels:\\n f.write(\\\"\\\\n\\\")\\n continue\\n c_count = 0\\n line = \\\"\\\"\\n for j, clabel in enumerate(clabels): # loop over columns\\n\\n if j == 0:\\n # if first col and input file has an index need additional spacer\\n if includes_index:\\n if sep == \\\",\\\":\\n # f.write(f\\\" {marker},{marker}\\\")\\n line += f\\\" {marker},{marker}\\\"\\n else:\\n # f.write(\\\" !dum!\\\")\\n line += \\\" !dum! \\\"\\n\\n if c_count < only_clabels_len:\\n if clabel in only_clabels: # and rlabel in only_rlabels:\\n oname = \\\"\\\"\\n # define obs names\\n if not prefix_is_str:\\n nprefix = prefix[c_count]\\n else:\\n nprefix = prefix\\n if len(nprefix) > 0:\\n nname = f\\\"{nprefix}_usecol:{clabel}\\\"\\n else:\\n nname = f\\\"usecol:{clabel}\\\"\\n oname = f\\\"{nname}_{rlabel}\\\"\\n onames.append(oname) # append list of obs\\n ovals.append(vals[i, j]) # store current obs val\\n # defin group name\\n if gpname is False or gpname[c_count] is False:\\n # keeping consistent behaviour\\n ngpname = None # nname\\n elif gpname is True or gpname[c_count] is True:\\n ngpname = nname # set to base of obs name\\n else: # a group name has been specified\\n if not isinstance(gpname, str):\\n ngpname = gpname[c_count]\\n else:\\n ngpname = gpname\\n ognames.append(ngpname) # add to list of group names\\n # start defining string to write in ins\\n oname = f\\\" !{oname}!\\\"\\n line += f\\\" {oname} \\\"\\n if j < len(clabels) - 1:\\n if sep == \\\",\\\":\\n line += f\\\" {marker},{marker} \\\"\\n # else:\\n # line += \\\" !dum! \\\"\\n c_count += 1\\n elif (\\n j < len(clabels) - 1\\n ): # this isnt a row-col to observationalize (nice word!)\\n if sep == \\\",\\\":\\n line += f\\\" {marker},{marker} \\\"\\n else:\\n line += \\\" !dum! \\\"\\n f.write(line + \\\"\\\\n\\\")\\n odf = pd.DataFrame(\\n {\\\"obsnme\\\": onames, \\\"obsval\\\": ovals, \\\"obgnme\\\": ognames}, index=onames\\n ).dropna(\\n axis=1\\n ) # dropna to keep consistent after adding obgnme\\n return odf\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65366405","0.63891923","0.63422674","0.61547923","0.6103674","0.6021459","0.5971792","0.5885629","0.58756024","0.58568597","0.58556205","0.57153285","0.5673784","0.56549925","0.563907","0.5638952","0.56366646","0.56365585","0.56354904","0.5634072","0.56176865","0.56038743","0.5574694","0.5556697","0.55434877","0.55233854","0.5514754","0.5512221","0.5500699","0.54999685","0.5440125","0.5433223","0.54328316","0.5386259","0.5366862","0.5359258","0.5357224","0.5349799","0.534246","0.53389066","0.53312254","0.5331","0.53281605","0.5294164","0.52900803","0.5289064","0.52871144","0.52788985","0.52698755","0.52677447","0.5266594","0.5260223","0.52516145","0.5231102","0.5228633","0.5207665","0.51987725","0.51960087","0.5191364","0.51907927","0.5188677","0.51767594","0.51730466","0.5169588","0.5166003","0.5137591","0.5130186","0.5127642","0.5126867","0.5126489","0.5125314","0.5112406","0.51121926","0.5108806","0.5087467","0.508668","0.5083256","0.50775176","0.5072334","0.5065982","0.50638807","0.5062863","0.5048669","0.5039639","0.5036985","0.5034338","0.50309527","0.5030815","0.5030688","0.50299144","0.5029405","0.50277036","0.5019712","0.5014688","0.50130224","0.5004132","0.5003652","0.500136","0.49902296","0.49890152"],"string":"[\n \"0.65366405\",\n \"0.63891923\",\n \"0.63422674\",\n \"0.61547923\",\n \"0.6103674\",\n \"0.6021459\",\n \"0.5971792\",\n \"0.5885629\",\n \"0.58756024\",\n \"0.58568597\",\n \"0.58556205\",\n \"0.57153285\",\n \"0.5673784\",\n \"0.56549925\",\n \"0.563907\",\n \"0.5638952\",\n \"0.56366646\",\n \"0.56365585\",\n \"0.56354904\",\n \"0.5634072\",\n \"0.56176865\",\n \"0.56038743\",\n \"0.5574694\",\n \"0.5556697\",\n \"0.55434877\",\n \"0.55233854\",\n \"0.5514754\",\n \"0.5512221\",\n \"0.5500699\",\n \"0.54999685\",\n \"0.5440125\",\n \"0.5433223\",\n \"0.54328316\",\n \"0.5386259\",\n \"0.5366862\",\n \"0.5359258\",\n \"0.5357224\",\n \"0.5349799\",\n \"0.534246\",\n \"0.53389066\",\n \"0.53312254\",\n \"0.5331\",\n \"0.53281605\",\n \"0.5294164\",\n \"0.52900803\",\n \"0.5289064\",\n \"0.52871144\",\n \"0.52788985\",\n \"0.52698755\",\n \"0.52677447\",\n \"0.5266594\",\n \"0.5260223\",\n \"0.52516145\",\n \"0.5231102\",\n \"0.5228633\",\n \"0.5207665\",\n \"0.51987725\",\n \"0.51960087\",\n \"0.5191364\",\n \"0.51907927\",\n \"0.5188677\",\n \"0.51767594\",\n \"0.51730466\",\n \"0.5169588\",\n \"0.5166003\",\n \"0.5137591\",\n \"0.5130186\",\n \"0.5127642\",\n \"0.5126867\",\n \"0.5126489\",\n \"0.5125314\",\n \"0.5112406\",\n \"0.51121926\",\n \"0.5108806\",\n \"0.5087467\",\n \"0.508668\",\n \"0.5083256\",\n \"0.50775176\",\n \"0.5072334\",\n \"0.5065982\",\n \"0.50638807\",\n \"0.5062863\",\n \"0.5048669\",\n \"0.5039639\",\n \"0.5036985\",\n \"0.5034338\",\n \"0.50309527\",\n \"0.5030815\",\n \"0.5030688\",\n \"0.50299144\",\n \"0.5029405\",\n \"0.50277036\",\n \"0.5019712\",\n \"0.5014688\",\n \"0.50130224\",\n \"0.5004132\",\n \"0.5003652\",\n \"0.500136\",\n \"0.49902296\",\n \"0.49890152\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7068569"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81398,"cells":{"query":{"kind":"string","value":"Finds and notes decoys that share their sequence with a target PSM. Also counts the number of targets and decoys to get a quick estimate of how many positive/negative training examples can be \"claimed\"."},"document":{"kind":"string","value":"def find_shitty_decoys(self):\n target_seqs = set()\n decoy_seqs = set()\n with open(self.csv_path, \"r\") as f:\n\n reader = csv.DictReader(f)\n\n sorted_reader = sorted(\n reader,\n reverse=self[\"bigger_scores_better\"],\n key=lambda d: float(d[self.col_for_sorting]),\n )\n\n for row in sorted_reader:\n self.observed_charges.add(int(row[\"Charge\"]))\n if row_is_decoy(row):\n decoy_seqs.add(unify_sequence(row[\"Sequence\"]))\n self.counter[\"decoy\"] += 1\n else:\n target_seqs.add(unify_sequence(row[\"Sequence\"]))\n self.counter[\"target\"] += 1\n\n self.shitty_decoy_seqs = target_seqs.intersection(decoy_seqs)\n if len(self.shitty_decoy_seqs) > 0:\n print(\n \"Warning! Found {0} sequences that are target AND decoy \"\n \"(immutable peptides?). These will not be used for training.\\n\".format(\n len(self.shitty_decoy_seqs)\n )\n )\n return"},"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 count_target(self):\n tally = {}\n for obj in self.target:\n tally[obj] = 0\n\n ind = 0\n for label in self.labelList:\n filename = self.pathLabel + label\n f = open(filename, 'r')\n content = f.read().split('\\n')\n for line in content:\n items = line.split(' ')\n if items[0] in self.target:\n tally[items[0]] += 1\n f.close()\n if ind % 100 == 0:\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\n ind += 1\n \n print('[COUNT] done counting targets in dataset')\n print(tally)","def test_find_cycles_one_cycle(self):\n self._build_sample_graph()\n # Adding cycle a -> d -> a\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\n skill_map = SkillMap.load(self.course)\n self.assertEqual(6, len(skill_map.skills()))\n successors = skill_map.build_successors()\n self.assertEqual(\n sorted(SkillMapMetrics(skill_map).simple_cycles()[0]),\n [self.sa.id, self.sd.id])","def has_homolgs(target_seq, known_seqs):\n for k_seq in known_seqs:\n alignment = align.globalxx(target_seq, k_seq)[0] # Generates and selects the alignment with the best score\n aln_seq_1 = alignment[0] # Get the first sequence of the alignment (with - as gaps )\n aln_seq_2 = alignment[1] # Get the second one\n al_length = len(alignment[0])\n ident = sum(base1 == base2 for base1, base2 in zip(aln_seq_1, aln_seq_2)) # Calculate number of identities\n if ident/al_length >= 0.95: # If 95% of identity, return known sequence\n return k_seq","def countingPointMutations(seq1, seq2):\n seqLength = len(list(seq1))\n \n hammingDistance=0;\n for i in range(0,seqLength):\n if list(seq1)[i]!=list(seq2)[i]:\n hammingDistance = hammingDistance+1;\n return hammingDistance","def predict_hydrophobic_length( targets ):\n\n\t# Steps of this script\n\t# 1. read all of the targets in as a long list of oriented PDB files\n\t# 2. add the membrane framework\n\t# 3. Backwards compute for t range 0-30 what \n\t# 4. \n\t# 5. ","def test_find_cycles_multiple_cycles(self):\n self._build_sample_graph()\n # Adding cycle a -> d -> a\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\n # Adding cycle g -> h -> g\n sg = self.skill_graph.add(Skill.build('g', ''))\n sh = self.skill_graph.add(Skill.build('h', ''))\n self.skill_graph.add_prerequisite(sg.id, sh.id)\n self.skill_graph.add_prerequisite(sh.id, sg.id)\n\n expected = [[self.sa.id, self.sd.id], [sg.id, sh.id]]\n skill_map = SkillMap.load(self.course)\n successors = skill_map.build_successors()\n result = SkillMapMetrics(skill_map).simple_cycles()\n self.assertEqual(len(result), len(expected))\n for cycle in result:\n self.assertIn(sorted(cycle), expected)","def question2():\n \n # load sequences and scoring matrix\n score_matrix = read_scoring_matrix(PAM50_URL)\n human_seq = \"HSGVNQLGGVFVNGRPLPDSTRQKIVELAHSGARPCDISRILQVSNGCVSKILGRYYETGSIRPRAIGGSKPRVATPEVVSKIAQYKRECPSIFAWEIRDRLLSEGVCTNDNIPSVSSINRVLRNLASEKQQ\"\n frfly_seq = \"HSGVNQLGGVFVGGRPLPDSTRQKIVELAHSGARPCDISRILQVSNGCVSKILGRYYETGSIRPRAIGGSKPRVATAEVVSKISQYKRECPSIFAWEIRDRLLQENVCTNDNIPSVSSINRVLRNLAAQKEQQ\"\n consensus_pax = read_protein(CONSENSUS_PAX_URL)\n \n # compute human and fruitfly global alignment matrix with consensus pax\n human_align_matrix = student.compute_alignment_matrix(human_seq, consensus_pax, score_matrix, True)\n frfly_align_matrix = student.compute_alignment_matrix(frfly_seq, consensus_pax, score_matrix, True)\n \n # compute human and fruitfly global alignment sequences\n score_human, human_align, consensus_align = student.compute_global_alignment(human_seq, consensus_pax, \n score_matrix, human_align_matrix)\n score_fly, frfly_align, consensus_align_2 = student.compute_global_alignment(frfly_seq, consensus_pax,\n score_matrix, frfly_align_matrix)\n \n # compute percentages match for human and fruitfly\n human_count = 0.0\n for index in range(len(human_align)):\n if human_align[index] == consensus_align[index]:\n human_count += 1\n \n frfly_count = 0.0\n for index in range(len(frfly_align)):\n if frfly_align[index] == consensus_align_2[index]:\n frfly_count += 1\n \n print \"% Human: \" + str(human_count / len(human_align) * 100)\n print \"Hmn: \" + human_align\n print \"PAX: \" + consensus_align\n \n print \"\"\n \n print \"% FrFly: \" + str(frfly_count / len(frfly_align) * 100)\n print \"Fly: \" + frfly_align\n print \"PAX: \" + consensus_align_2","def _count_discordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\n return torch.cat([_discordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)","def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\n \n # Chapter Text - stokenize\n StokensCT = stokenize(ChapterTextS, StopWords) \n\n # Test question - stokenize\n StokensTest = stokenize(TestS, StopWords)\n\n # Knowledge Base Dict - stokenize\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\n\n # List (because list is mutable, set is not) of all stokens in document\n StokensDoc = StokensCT[:] # from chapter text\n StokensDoc.extend(StokensTest[:]) # += Test string\n\n # extend list of stokens in Doc\n for i in TargetQuestionsD:\n StokensDoc.extend(TargetQuestionsD[i][\"mq stokens\"][:]) # += KB target [matched Q]s\n StokensDoc.extend(TargetQuestionsD[i][\"ans stokens\"][:]) # += KB answers\n \n StokensTestV = set(StokensTest)\n StokensDocV = set(StokensDoc)\n StokensAntiTgtV = StokensDocV\n \n # Complement of all targets\n for i in TargetQuestionsD:\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\"mq stokens\"]))\n \n # calculate confusion matrix and DOR etc.\n LnDORD = {}\n # Anti Target\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN) \n \n LnDORD[\"AntiTgt\"] = {'lndor': LnDOR, 'theta': someAngle}\n\n # total occurences\n total_occ = 0\n for i in TargetQuestionsD:\n total_occ += TargetQuestionsD[i]['count']\n\n for i in TargetQuestionsD:\n StokensTgtV = set(TargetQuestionsD[i][\"mq stokens\"][:])\n\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \n priorOR = TargetQuestionsD[i]['count'] / total_occ\n\n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \n \n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \"AntiTgt\"\n\n return LnDORD","def test_find_cycles_not_conected(self):\n self._build_sample_graph()\n # Adding cycle g -> h -> g\n sg = self.skill_graph.add(Skill.build('g', ''))\n sh = self.skill_graph.add(Skill.build('h', ''))\n self.skill_graph.add_prerequisite(sg.id, sh.id)\n self.skill_graph.add_prerequisite(sh.id, sg.id)\n skill_map = SkillMap.load(self.course)\n expected0 = [sg.id, sh.id]\n successors = skill_map.build_successors()\n result = SkillMapMetrics(skill_map).simple_cycles()\n self.assertEqual(sorted(result[0]), expected0)","def extract_number_target_genes2(d, g, miranda_fnm):\n\tprint 'extract targets genes2'\n\toutput_nm = \"%s_counts2.txt\"%(miranda_fnm[:-4])\n\toutput = open(output_nm, 'w')\n\toutput.write(\"miRNA\\ttotal_target_genes\\ttarget_genes_down\\ttarget_genes\\n\")\n\tfor key in d:\n\t\tif len(d[key]) > 0:\n\t\t\t#print key, len(d[key])\n\t\t\toutput.write(\">>%s\\t%s\\t%s\\n\"%(key, len(d[key]),len(g[key])))\n\t\t\tfor gene in g[key]:\n\t\t\t\t#print gene\n\t\t\t\toutput.write(\"%s\\n\"%(gene[0]))\n\n\toutput.close()","def solve_p1_v1(target: int) -> int:\n\n elves = DeliveryService()\n\n house, n_presents = 0, 0\n while n_presents < target:\n house += 1\n n_presents = elves.visit(house)\n print(house, n_presents)\n\n return house","def test_merge_targets():\n uid1 = \"ACCT\"\n uid2 = \"GGGG\"\n uid3 = \"AAGG\"\n\n seq1 = [\"ACTGTTTGTCTAAGC\"]*2\n qual1 = ['I'*len(seq1[0])]*len(seq1)\n seq2 = [\"ACTGTTTTTCTAAGC\"]*5\n qual2 = ['I'*len(seq2[0])]*len(seq2)\n seq3 = [\"ACTGTTTTTCTAAGC\"]*2\n qual3 = ['I'*len(seq3[0])]*len(seq3)\n\n clusters = create_consensus([uid1 + uid1]*len(seq1) + \\\n [uid2 + uid2]*len(seq2),\n ['I'*(len(uid1)*2)]*(len(seq1) + len(seq2)),\n seq1 + seq2, qual1 + qual2)\n seq3 = [pseq.SequenceWithQuality(seq, qual) for seq, qual in zip(seq3, qual3)]\n uid = pseq.SequenceWithQuality(uid2 + uid3, 'I'*(len(uid2) + len(uid3)))\n cand = clusters.merge_target(uid, seq3[0], {}, 2)\n assert cand == uid2 + uid2, \"%r != %r\" % (cand, uid2 + uid2)\n cand = clusters.merge_target(uid, seq3[0], {}, 1)\n assert cand is None, \"%r != %r\" % (cand, None)","def test_target_greater_than_alp(self):\n alp = list(range(5))\n targets = generate_targets(alp, 10)\n self.assertEqual(len(targets), 10)\n\n counts = Counter(targets)\n\n for item in alp:\n self.assertEqual(counts[item], 2)","def getNumMarkedTargets(self):\n return len(self.getConTextModeNodes(\"target\"))","def getNumMarkedTargets(self):\n return len(self.getConTextModeNodes(\"target\"))","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = no_communication_skar(d, source, target, others)\n return uniques","def sim_stop_counts(simulations, seqs, dinucleotide_content, nucleotide_content, temp_dir, seeds=None, seq_seeds=None):\n\n temp_files = []\n\n dinucleotide_choices = [dn for dn in sorted(dinucleotide_content)]\n dinucleotide_probabilities = [dinucleotide_content[dn] for dn in sorted(dinucleotide_content)]\n nucleotide_choices = [n for n in sorted(nucleotide_content)]\n nucleotide_probabilities = [nucleotide_content[n] for n in sorted(nucleotide_content)]\n\n for sim_no, simulation in enumerate(simulations):\n\n # set the seed\n set_seed(seeds, simulation)\n\n # print the simulation number out\n gen.print_simulation(sim_no+1, simulations)\n\n simulated_seqs = {}\n # Generate a list of nucleotide matched sequences\n for i, name in enumerate(seqs):\n seq = seqs[name]\n generated = False\n\n seq_seed = get_seq_seed(seq_seeds, sim_no, i)\n\n while not generated:\n sim_seq = seqo.generate_nt_matched_seq(seq, dinucleotide_choices, dinucleotide_probabilities, nucleotide_choices, nucleotide_probabilities, seed=seq_seed)\n if sim_seq not in simulated_seqs:\n generated = True\n simulated_seqs[name] = sim_seq\n\n stop_counts = seqo.get_stop_counts(simulated_seqs)\n temp_file = \"{0}/{1}.{2}.txt\".format(temp_dir, random.random(), simulation+1)\n temp_files.append(temp_file)\n with open(temp_file, \"w\") as temp:\n for name in stop_counts:\n temp.write(\">{0}\\n{1}\\n\".format(name, stop_counts[name]))\n\n return temp_files","def choose_target(self, agents):\n\n number_of_suspects = [0]*(len(agents))\n number_of_suspects_per_agent = []\n\n index = 0\n for a1 in agents:\n if not a1.is_impostor():\n for a2 in agents:\n if self.km.suspects(a1.agent_id, a2.agent_id):\n number_of_suspects[index] = number_of_suspects[index] + 1\n else:\n number_of_suspects[index] = 999999\n number_of_suspects_per_agent.append((a1.agent_id,number_of_suspects[index]))\n index = index + 1\n\n self.target = min(number_of_suspects_per_agent, key = lambda t: t[1])[0]","def sim_motif_stop_counts(simulations, seqs, dinucleotide_content, nucleotide_content, temp_dir, seeds=None, seq_seeds=None):\n\n temp_files = []\n\n dinucleotide_choices = [dn for dn in sorted(dinucleotide_content)]\n dinucleotide_probabilities = [dinucleotide_content[dn] for dn in sorted(dinucleotide_content)]\n nucleotide_choices = [n for n in sorted(nucleotide_content)]\n nucleotide_probabilities = [nucleotide_content[n] for n in sorted(nucleotide_content)]\n\n for sim_no, simulation in enumerate(simulations):\n\n # set the seed\n set_seed(seeds, simulation)\n\n # print the simulation number out\n gen.print_simulation(sim_no+1, simulations)\n\n simulated_seqs = []\n # Generate a list of nucleotide matched sequences\n for i, seq in enumerate(seqs):\n generated = False\n seq_seed = get_seq_seed(seq_seeds, sim_no, i)\n\n while not generated:\n sim_seq = seqo.generate_nt_matched_seq(seq, dinucleotide_choices, dinucleotide_probabilities, nucleotide_choices, nucleotide_probabilities, seed=seq_seed)\n if sim_seq not in simulated_seqs:\n generated = True\n simulated_seqs.append(sim_seq)\n\n stop_counts = seqo.get_stop_counts(simulated_seqs)\n temp_file = \"{0}/{1}.{2}.txt\".format(temp_dir, random.random(), simulation+1)\n temp_files.append(temp_file)\n with open(temp_file, \"w\") as temp:\n temp.write(\">{0}\\n{1}\\n\".format(simulation+1, sum(stop_counts)))\n\n return temp_files","def GetTargetDepdency(self, target):\n return self._dependencies[target].strip()","def calculate_ec_targets_used(oclass, total_targets):\n data_shards, parity_shards, group_number = get_ec_data_parity_group(oclass)\n group_size = data_shards + parity_shards\n if group_number in ('x', 'X'):\n group_number = max(1, total_targets // group_size)\n return group_size * int(group_number)","async def recommendations(self, target: int) -> dict:\n plan = self.plan\n requested = self.requested\n observed = self.observed\n\n if target == len(plan):\n self.close_counts.clear()\n return {\"status\": \"same\"}\n\n if target > len(plan):\n self.close_counts.clear()\n return {\"status\": \"up\", \"n\": target}\n\n # target < len(plan)\n not_yet_arrived = requested - observed\n to_close = set()\n if not_yet_arrived:\n to_close.update(toolz.take(len(plan) - target, not_yet_arrived))\n\n if target < len(plan) - len(to_close):\n L = await self.workers_to_close(target=target)\n to_close.update(L)\n\n firmly_close = set()\n for w in to_close:\n self.close_counts[w] += 1\n if self.close_counts[w] >= self.wait_count:\n firmly_close.add(w)\n\n for k in list(self.close_counts): # clear out unseen keys\n if k in firmly_close or k not in to_close:\n del self.close_counts[k]\n\n if firmly_close:\n return {\"status\": \"down\", \"workers\": list(firmly_close)}\n else:\n return {\"status\": \"same\"}","def test_remainder(self):\n alp = list(range(5))\n targets = generate_targets(alp, 12)\n\n counts = Counter(targets)\n for item in alp:\n self.assertGreaterEqual(counts[item], 2)\n self.assertLessEqual(counts[item], 3)","def extract_number_target_genes(d, g, miranda_fnm):\n\toutput_nm = \"%s_counts.txt\"%(miranda_fnm[:-4])\n\toutput = open(output_nm, 'w')\n\toutput.write(\"miRNA\\ttotal_target_genes\\ttarget_genes_down\\ttarget_genes\\n\")\n\tfor key in d:\n\t\tif len(d[key]) > 0:\n\t\t\t#print key, len(d[key])\n\t\t\toutput.write(\"%s\\t%s\\t%s\\t%s\\n\"%(key, len(d[key]), \n\t\t\t\tlen(g[key]), str(g[key]).strip('[]')))\n\n\toutput.close()","def classifyDocumentTargets(context, allow_uncertainty=False):\n rslts = {}\n alerts = {}\n cntxt = context\n cntxt.computeDocumentGraph()\n g = cntxt.getDocumentGraph()\n targets = [n[0] for n in g.nodes(data = True) if n[1].get(\"category\",\"\") == 'target']\n \n if( not targets ):\n return alerts,rslts\n if(allow_uncertainty):\n pos_filters = [\"definite_existence\",\"probable_existence\"]#[\"PROBABLE_NEGATED_EXISTENCE\",\"DEFINITE_NEGATED_EXISTENCE\"]#\n else:\n pos_filters = [\"definite_existence\"]\n for t in targets:\n mods = g.predecessors(t)\n tL = t.getLiteral()\n rslts[tL] = {}\n if( not mods ): # an unmodified target is disease positive,certain, and acute \n rslts[tL]['disease'] = 'Pos'\n rslts[tL]['uncertainty'] = 'No'\n rslts[tL]['temporality'] = 'New'\n rslts[tL]['experiencer'] = 'Patient'\n else:\n if ((modifies(g,t,pos_filters) and not modifies(g,t,[\"future\",\"indication\",\"pseudoneg\"]))):\n rslts[tL]['disease'] = 'Pos'\n elif(modifies(g,t,[\"probables\",\n \"probableNegations\"]) ):\n rslts[tL]['disease'] = 'Probable'\n else:\n rslts[tL]['disease'] = 'Neg'\n if( modifies(g,t,[\"probable_existence\",\n \"probable_negated_existence\"]) ):\n rslts[tL]['uncertainty'] = 'Yes'\n else:\n rslts[tL]['uncertainty'] = 'No'\n if (modifies(g,t,[\"historical\"]) ):\n rslts[tL]['temporality'] = 'Old'\n elif(modifies(g,t,[\"hypothetical\"])):\n if rslts[tL]['disease']=='Neg':\n rslts[tL]['temporality'] = 'Hypothetical'\n else: ## disease == pos or probable\n rslts[tL]['temporality'] = 'New' ## not sure if this is correct\n else:\n if (rslts[tL]['disease'] == 'Neg'):\n rslts[tL]['temporality'] = 'NA'\n else:\n rslts[tL]['temporality'] = 'New'\n \n if ((modifies(g,t,[\"experiencers\"])) and not (modifies(g,t,[\"pseudoexperiencers\"]))):\n rslts[tL]['experiencer'] = 'Other'\n else:\n rslts[tL]['experiencer'] = 'Patient'\n rsum = alerts.get(t.getCategory(),0)\n if( rslts[tL][\"disease\"] == 'Pos' and rslts[tL][\"temporality\"] == 'New'):\n alert = 1\n else:\n alert = 0\n rsum = max(rsum,alert)\n alerts[t.getCategory()] = rsum\n \n\n return rslts#alerts, ","def hits_and_misses(guess_seq, true_seq):\n num_hits = sum(guess_token == true_token\n for guess_token, true_token\n in zip(guess_seq, true_seq))\n num_misses = sum((Counter(guess_seq) & Counter(true_seq)).values()) - num_hits\n return num_hits, num_misses","def get_target_proportions_of_current_trial(individuals, target):\n ambulance_waits, ambulance_target_waits = 0, 0\n other_waits, other_target_waits = 0, 0\n for individual in individuals:\n ind_class = len(individual.data_records) - 1\n rec = individual.data_records[-1]\n if rec.node == 2 and ind_class == 0:\n other_waits += 1\n if rec.waiting_time < target:\n other_target_waits += 1\n elif rec.node == 2 and ind_class == 1:\n ambulance_waits += 1\n if rec.waiting_time < target:\n ambulance_target_waits += 1\n\n return ambulance_waits, ambulance_target_waits, other_waits, other_target_waits","def test_get_diagnose(self):\n self._build_sample_graph()\n # Adding cycle a -> d -> a\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\n # Adding singleton\n sg = self.skill_graph.add(Skill.build('g', ''))\n skill_map = SkillMap.load(self.course)\n result = SkillMapMetrics(skill_map).diagnose()\n expected = {\n 'cycles': [[self.sd.id, self.sa.id]],\n 'singletons': [sg.id],\n 'long_chains': []\n }\n self.assertEqual(result, expected)","def get_generalized_targets_distances(generalized_targets, board):\n representative = generalized_targets[0]\n sm = 0\n for i in range(1, len(generalized_targets)):\n cur_gen_target = generalized_targets[i]\n sm += representative.get_distance(board, cur_gen_target)\n return sm","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = two_way_skar(d, [source, target], others)\n return uniques","def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)","def test_target_number_less_than_alp(self):\n alp = list(range(10))\n targets = generate_targets(alp, 5)\n self.assertEqual(len(targets), 5)\n self.assertEqual(len(targets), len(set(targets)))","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, source, target, others)\n return uniques","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, target, source, others)\n return uniques","def solvePostNoOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains as many dummy targets as defenders, for defenders and attackers\"\"\"\n # Add the extra dummy targets\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n for defenderCount in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n attackerActions = targetRange\n # Get the suggestions that occur with no overlap\n overlapPlacements = getPlacements(defenders, targetNumWithDummies)\n placements = list(filter(lambda x: len(set(x)) == len(x), overlapPlacements))\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Build the model\n model = Model('PrimalWithOverlap')\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\"w\")\n objectiveFunction = sum([q[lam] * sum([w[s,a,lam] * defenderSocialUtility(s,a,defenders,_dRewards,_dCosts,_dPenalties) for s in placements for a in attackerActions]) for lam in aTypes])\n c1 = [sum([w[s,a,lam] * aUtility(s,a,lam,_aPenalties,_aRewards) for s in placements]) \\\n >= sum([w[s,a,lam] * aUtility(s,b,lam,_aPenalties,_aRewards) for s in placements])\n for lam in aTypes for a in attackerActions for b in attackerActions if a != b]\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\n c1 = model.add_constraints(c1)\n c2 = model.add_constraints([sum([q[lam] * sum([w[s,a,lam] * utilityM(d,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes]) \\\n >= sum([q[lam] * sum([w[s,a,lam] * utilityM(e,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes])\n for m in defenders for d in targetRange for e in targetRange if d!=e])\n c3 = model.add_constraints([sum([w[(s,a,lam)] for s in placements for a in attackerActions]) == 1 for lam in aTypes])\n # Solve the model\n model.maximize(objectiveFunction)\n model.solve()\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\n utilityPerAttacker = 0\n for k,v in w.items():\n prob = float(v)\n s,a,lam = k\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\n utilityPerAttacker /= len(aTypes)\n utilityPerDefender = model.solution.get_objective_value()\n utilityPerDefender /= len(defenders)\n return utilityPerDefender, utilityPerAttacker, None","def test_counts(contrib_data):\n ## Find the probands - they should always contribute their own alleles\n P = ped.Pedigree(args.pedfile)\n\n ## TODO: Test individuals with multiple offspring +p2 id:112\n ## Case when no regions are specified - only all probands\n regions = contrib_data.keys()\n if len(regions) == 1:\n all_contribs = contrib_data[regions[0]]\n for prob in P.probands:\n ## Probands should always contribute 1 allele\n assert all_contribs[prob, 1] == args.iterations\n\n ## Test specific individuals\n counts = Counter(all_contribs[11])\n binomial_sd = np.sqrt(args.iterations * 0.25)\n mean = np.mean(counts.values())\n conf95 = (mean - 2 * binomial_sd, mean + 2 * binomial_sd)\n\n for count in counts.values():\n assert conf95[0] < count < conf95[1]","def kmer_distance(seq1,seq2,k=3):\n seq1_set = set(count_kmers(seq1,k).keys())\n seq2_set = set(count_kmers(seq2,k).keys())\n union_seq = seq1_set.union(seq2_set)\n dissimilarity = seq1_set ^ seq2_set\n distance = len(dissimilarity)/len(union_seq)\n print(dissimilarity)\n return distance","def count_targets(searchList):\n targets = {}\n for x in searchList:\n loVal = -10000 - x\n hiVal = 10000 - x\n loInd = bisect_left(searchList, loVal)\n hiInd = bisect_right(searchList, hiVal)\n for y in searchList[loInd:hiInd]:\n if y == x:\n continue\n t = x + y\n targets[t] = 1\n return len(targets)","def find_solution_count(target, max_coin=None):\n if target == 0:\n return 1\n if max_coin is None:\n max_coin = 200\n key = '%d_%d' % (target, max_coin)\n if key in seen:\n return seen[key]\n count = 0\n for coin in DENOMINATIONS:\n if coin > max_coin:\n continue\n if coin <= target:\n count += find_solution_count(target - coin, coin)\n seen[key] = count\n return count","def solve_p1_v2(target: int) -> int:\n house, n_presents = 0, 0\n while n_presents < target:\n house += 1\n n_presents = 0\n for elf in range(1, 1+house):\n if house % elf == 0:\n n_presents += 10*elf\n if DEBUG and house % 10000 == 0:\n print(f\"House: {house} got {n_presents}\")\n return house","def get_diseases(self):\n self.diseases = self.data.groupby('topic')['topic'].count()","def test(output_seq,M1,M2,M3,obs_file):\n predicted = []\n mus_c = 0\n mod_c = 0\n arn_c = 0\n next = 0\n t = 0.000\n d=dict()\n d[\"other\"]=0\n d[\"modi\"]=0\n d[\"arnab\"]=0\n print(obs_file+\":\")\n for obs in output_seq:\n p1 = M1.forward(obs)\n p2 = M2.forward(obs)\n p3 = M3.forward(obs)\n\n\n if(p1 > p2 and p1 > p3):\n predicted.append(\"Other\")\n mus_c+=1\n d[\"other\"]+=1\n elif(p2 > p3 and p2 > p1):\n predicted.append(\"Modi\")\n mod_c+=1\n d[\"modi\"]+=1\n else:\n predicted.append(\"Arnab\")\n arn_c+=1\n d[\"arnab\"]+=1\n t+=0.05\n next+=1\n\n if(next % 20 == 0):\n p_other = d[\"other\"]/20.0\n p_modi = d[\"modi\"]/20.0\n p_arnab = d[\"arnab\"]/20.0\n #print(\"{0} : Modi = {1}, Arnab = {2}, Other = {3}\".format(t,p_modi,p_arnab,p_other))\n if p_other>p_modi and p_other>p_arnab:\n print \"{0} : Speech : Other\".format(t)\n elif p_modi>p_other and p_modi>p_arnab:\n print \"{0} : Speech : Modi\".format(t)\n else:\n print \"{0} : Speech : Arnab\".format(t)\n d[\"other\"]=0\n d[\"modi\"]=0\n d[\"arnab\"]=0\n\n time = 0.000\n with open(\"op_\"+obs_file,\"w\") as g:\n for val in predicted:\n g.write(str(time)+\" :\\t\"+val+\"\\n\")\n time+=0.005\n\n return predicted","def test_input_target_different():\n for day in range(len(departure_cameras)):\n which_targets_day = which_targets[day]\n when_targets_day = when_targets[day]\n where_targets_day = where_targets[day]\n departure_cameras_day = departure_cameras[day]\n # Which\n for departure_camera, target in zip(departure_cameras_day, which_targets_day):\n entrance_cameras = np.argwhere(target == 1) + 1\n assert departure_camera not in entrance_cameras\n # When\n for departure_camera, when_target in zip(departure_cameras_day, when_targets_day):\n target = when_target.sum(axis=1) > 1\n entrance_cameras = np.argwhere(target == 1) + 1\n assert departure_camera not in entrance_cameras\n # Where\n for departure_camera, where_target in zip(departure_cameras_day, where_targets_day):\n target = where_target.sum(axis=3).sum(axis=2).sum(axis=1) > 1\n entrance_cameras = np.argwhere(target == 1) + 1\n assert departure_camera not in entrance_cameras","def test_measure_deterministic_with_sampling(self):\n shots = 100\n circuits = ref_measure.measure_circuits_deterministic(allow_sampling=True)\n targets = ref_measure.measure_counts_deterministic(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def test_which_targets():\n num_multi_targets = 0\n for which_targets_day in which_targets:\n # All inputs have a label\n assert np.all(which_targets_day.sum(axis=1) > 0)\n # No inputs have more than 3 targets\n assert np.all(which_targets_day.sum(axis=1) < 4)\n\n num_multi_targets += np.sum(which_targets_day.sum(axis=1) > 1)\n\n # Some days have multi-targets\n assert num_multi_targets > 0","def train(self, documents):\n ###DONE\n\n #entire vocab in document set D\n vocab_sod = set()\n vocab_pop = set()\n \n #Calcuates prior probabilities\n priorSOD = 0 #how many docs are spam\n priorPOP = 0 #how many docs are ham\n \n #Cacluates Tct\n term_freq_sod = {} #{term:occur, term:occur}\n term_freq_pop = {}\n \n #Tct'\n Tct_sod = 0 #Tct' = sum of (every term occurence in class c + 1)\n Tct_pop = 0\n \n for doc in documents: \n if 'sod' in doc.label:\n priorSOD += 1\n for token in doc.tokens:\n Tct_sod += 1\n if token in term_freq_sod.keys():\n term_freq_sod[token] = term_freq_sod[token] + 1\n else:\n term_freq_sod[token] = 1\n vocab_sod.add(token) \n else:\n priorPOP += 1\n for token in doc.tokens:\n Tct_pop += 1\n if token in term_freq_pop.keys():\n term_freq_pop[token] = term_freq_pop[token] + 1\n else:\n term_freq_pop[token] = 1\n vocab_pop.add(token)\n \n \n #endfor\n # | is for set join\n self.vocab = vocab_sod | vocab_pop #gets rid of duplicate words (those in both 'ham' and 'spam') \n \n #Tct Primes\n #tct' = term freq of all terms in class c + 1*(total terms)\n Tct_sod = Tct_sod + len(self.vocab) \n Tct_pop = Tct_pop + len(self.vocab) \n \n \n print(\"PriorSod: \" + str(priorSOD))\n print(\"PriorPop: \" + str(priorPOP))\n print(\"LEN Docum: \" + str(len(documents)))\n \n self.priorSOD = priorSOD / len(documents)\n self.priorPOP = priorPOP / len(documents)\n \n for term in self.vocab:\n if term in term_freq_pop.keys():\n self.cond_prob_pop[term] = (term_freq_pop[term] + 1) / Tct_pop\n else:\n self.cond_prob_pop[term] = 1 / Tct_pop\n \n if term in term_freq_sod.keys():\n self.cond_prob_sod[term] = (term_freq_sod[term] + 1) / Tct_sod\n else:\n self.cond_prob_sod[term] = 1 / Tct_sod\n \n \n pass","def test_find_cycles_no_cycle(self):\n self._build_sample_graph()\n skill_map = SkillMap.load(self.course)\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])","def find_mutual_nn(self):\n best_match_src = self.scores.argmax(1) # Best match for each source word\n best_match_trg = self.scores.argmax(0) # Best match for each source word\n\n # ONELIENER\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\n paired = []\n for i in range(self.ns):\n m = best_match_src[i]\n if best_match_trg[m] == i:\n paired.append((i,m))\n\n paired_toks = []\n if self.src_words and self.trg_words:\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\n else:\n paired_toks = paired\n return paired_toks","def get_target_per_score(self):\n pass","def get_closeness(pats,seq_dict,isdiagonal=False,log=False):\n similarities= np.zeros((len(pats),len(pats)))\n intersectCount = np.zeros((len(pats),len(pats)))\n for i,patI in enumerate(pats):\n seqsI=list(zip(*seq_dict[patI]))[1]\n for j,patJ in enumerate(pats):\n seqsJ=list(zip(*seq_dict[patJ]))[1]\n if isdiagonal and i!=j: continue\n if j>i: continue\n if i==j and len(seqsI) < clim:\n similarities[i][j]=0\n continue\n keys1=set(list(zip(*seq_dict[pats[i]]))[0])\n keys2=set(list(zip(*seq_dict[pats[j]]))[0])\n intersectCount[i][j] = len(list(keys1 & keys2))\n random_score=get_random_score(seqsI,seqsJ,nsample=10)\n identical_score=get_identical_score(seqsI,seqsJ)\n score=0.0\n norm=0\n if mixvec:\n vecI=_seqs2vec(seqsI)\n vecJ=_seqs2vec(seqsJ)\n score=get_subscore_mixvec(vecI,vecJ)\n else:\n score=get_subscore_pairwise(list(seqsI),list(seqsJ)) \n print \"idscore (max):\", round(identical_score,4), \"randscore (min):\", round(random_score,4), \"score:\", round(score,4)\n if log: similarity = -math.log(1-((float(score)-float(random_score))/(float(identical_score)-float(random_score))))\n else: similarity = ((float(score)-float(random_score))/(float(identical_score)-float(random_score)))\n similarities[i][j]= similarity\n similarities[j][i]= similarity\n print patI,patJ,similarity\n dfDists=pd.DataFrame(similarities,columns=pats,index=pats)\n dfCount=pd.DataFrame(intersectCount,columns=pats,index=pats)\n return dfDists, dfCount","def test_measure_deterministic_multi_qubit_without_sampling(self):\n shots = 100\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=False)\n qobj.config.shots = shots\n circuits = [experiment.header.name for experiment in qobj.experiments]\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\n job = QasmSimulator().run(qobj)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def test_measure_deterministic_multi_qubit_with_sampling(self):\n shots = 100\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=True)\n qobj.config.shots = shots\n circuits = [experiment.header.name for experiment in qobj.experiments]\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\n job = QasmSimulator().run(qobj)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def solveExNoOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains as many dummy targets as defenders, for defenders and attackers\"\"\"\n \"\"\"In this game the attacker and defender reason ex-ante\n (they choose to follow signals or not before a signal is sent).\"\"\"\n # Add the extra dummy targets\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n for defenderCount in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n attackerActions = targetRange\n # Get the suggestions that occur with no overlap\n overlapPlacements = getPlacements(defenders, targetNumWithDummies)\n placements = list(filter(lambda x: len(set(x)) == len(x), overlapPlacements))\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Build the model\n model = Model('ExAnteWithOverlap')\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\"w\")\n objectiveFunction = sum([q[lam] * sum([w[sd,sa,lam] * defenderSocialUtility(sd,sa,defenders,_dRewards,_dCosts,_dPenalties) for sd in placements for sa in attackerActions]) for lam in aTypes])\n # Define the constraints\n c1 = [sum([w[sd,sa,lam] * aUtility(sd,sa,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions]) \\\n >= sum([w[sd,sa,lam] * aUtility(sd,tPrime,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions])\n for lam in aTypes for tPrime in targetRange]\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\n c2 = [sum([q[lam] * sum([w[sd,sa,lam] * utilityM(sd[d],sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\n >= sum([q[lam] * sum([w[sd,sa,lam] * utilityM(tPrime,sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\n for d in defenders for tPrime in targetRange]\n c3 = [sum([w[sd,sa,lam] for sd in placements for sa in attackerActions]) == 1\n for lam in aTypes]\n # Add the constraints\n c1 = model.add_constraints(c1)\n c2 = model.add_constraints(c2)\n c3 = model.add_constraints(c3)\n # Solve the model\n model.maximize(objectiveFunction)\n model.solve()\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\n utilityPerAttacker = 0\n for k,v in w.items():\n prob = float(v)\n s,a,lam = k\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\n utilityPerAttacker /= len(aTypes)\n utilityPerDefender = model.solution.get_objective_value()\n utilityPerDefender /= len(defenders)\n return utilityPerDefender, utilityPerAttacker, None","def get_hint(target, scores, users_visited):\n target = target.data.cpu().numpy()\n val, idxx = scores.data.topk(1, 1)\n predx = idxx.cpu().numpy()\n hint = np.zeros((3,))\n count = np.zeros((3,))\n count[0] = len(target)\n for i, p in enumerate(predx):\n t = target[i]\n if t == p[0] and t > 0:\n hint[0] += 1\n if t in users_visited:\n count[1] += 1\n if t == p[0] and t > 0:\n hint[1] += 1\n else:\n count[2] += 1\n if t == p[0] and t > 0:\n hint[2] += 1\n return hint, count","def solve_p2(target: int) -> int:\n mh = 1 + int(target / 10)\n npresents = [0] * mh\n for elf in range(1, mh):\n for h in range(elf, min(mh, elf*50), elf):\n npresents[h] += 11*elf\n if DEBUG:\n print(target, [(i, n) for i, n in enumerate(npresents)])\n for h, np in enumerate(npresents):\n if np >= target:\n return h\n return -1","def analyse_target(target, aligned_path):\n\n # Get Target from database\n target.root_data_directory = relative_to_media_root(aligned_path)\n target.save()\n\n mols = list(Molecule.objects.filter(prot_id__target_id=target))\n\n # This can probably be improved to count molecules as they are processed when the code is further refactored\n mols_processed = len(mols)\n\n logger.debug(\"Analysing '%s' molecules for '%s'\", len(mols), target.title)\n\n # Do site mapping\n if os.path.isfile(os.path.join(aligned_path, 'metadata.csv')):\n\n target.metadata.save(\n os.path.basename(os.path.join(aligned_path, 'metadata.csv')),\n File(open(os.path.join(aligned_path, 'metadata.csv')))\n )\n\n # remove any existing files so that we don't create a messy file when appending\n if os.path.isfile(os.path.join(aligned_path, 'hits_ids.csv')):\n os.remove(os.path.join(aligned_path, 'hits_ids.csv'))\n\n if os.path.isfile(os.path.join(aligned_path, 'sites.csv')):\n os.remove(os.path.join(aligned_path, 'sites.csv'))\n\n if os.path.isfile(os.path.join(aligned_path, 'alternate_names.csv')):\n os.remove(os.path.join(aligned_path, 'alternate_names.csv'))\n\n new_frame = pd.read_csv(os.path.join(aligned_path, 'metadata.csv'))\n new_frame.sort_values(by='site_name', inplace=True)\n\n # one file for new names\n with open(os.path.join(aligned_path, 'alternate_names.csv'), 'a', encoding='utf-8') as f:\n f.write('name,alternate_name\\n')\n\n for _, row in new_frame.iterrows():\n if isinstance(row['alternate_name'], str):\n crystal_name = row['crystal_name']\n # find the correct crystal\n crystal = Protein.objects.filter(code__contains=crystal_name, target_id=target)\n alternate_name = row['alternate_name']\n # Only take first part of code\n for crys in list(set([c.code.split(\":\")[0] for c in crystal])):\n f.write(str(crys) + ',' + str(alternate_name) + '\\n')\n\n # hits and sites files\n site_mapping = {}\n unique_sites = list(set(list(new_frame['site_name'])))\n for i in range(0, len(sorted(unique_sites))):\n site_mapping[unique_sites[i]] = i\n\n with open(os.path.join(aligned_path, 'hits_ids.csv'), 'a', encoding='utf-8') as f:\n f.write('crystal_id,site_number\\n')\n\n for _, row in new_frame.iterrows():\n crystal_name = row['crystal_name']\n crystal = Protein.objects.filter(code__contains=crystal_name, target_id=target)\n site = row['site_name']\n s_id = site_mapping[site]\n for crys in list(set([c.code for c in crystal])):\n f.write(str(crys) + ',' + str(s_id) + '\\n')\n\n with open(os.path.join(aligned_path, 'sites.csv'), 'a', encoding='utf-8') as f:\n f.write('site,id\\n')\n for key in site_mapping.keys():\n f.write(str(key) + ',' + str(site_mapping[key]) + '\\n')\n\n if os.path.isfile(os.path.join(aligned_path, 'hits_ids.csv')) and os.path.isfile(\n os.path.join(aligned_path, 'sites.csv')):\n\n hits_sites = pd.read_csv(os.path.join(aligned_path, 'hits_ids.csv'))\n sites = pd.read_csv(os.path.join(aligned_path, 'sites.csv'))\n sites.sort_values(by='site', inplace=True)\n\n # Delete the old mol_groups\n # Note that this will not delete associated MoleculeTags - the tags\n # will have their mol_group set to Null, but be left on the\n # database so that any existing Tags will not be broken.\n mol_groups = MolGroup.objects.filter(target_id=target)\n for m in mol_groups:\n m.delete()\n\n for _, row in sites.iterrows():\n description = row['site']\n number = row['id']\n logger.debug('Processing user input site: %s', description)\n matches = []\n for _, row in hits_sites.iterrows():\n if str(row['site_number']) == str(number):\n matches.append(row['crystal_id'])\n logger.debug('HIT IDS: %s', matches)\n if matches:\n mols = list(Molecule.objects.filter(prot_id__target_id=target, prot_id__code__in=matches))\n analyse_mols(mols=mols, target=target, specified_site=True, site_description=description)\n\n if os.path.isfile(os.path.join(aligned_path, 'alternate_names.csv')):\n rename_proteins(names_csv=os.path.join(aligned_path, 'alternate_names.csv'))\n else:\n analyse_mols(mols=mols, target=target)\n\n # move anything that's not a directory in 'aligned' up a level\n files = (f for f in os.listdir(aligned_path)\n if os.path.isfile(os.path.join(aligned_path, f)))\n\n for f in files:\n shutil.move(os.path.join(aligned_path, f), os.path.join(aligned_path, f).replace('aligned', ''))\n\n # delete NEW_DATA VISITS PROPOSALS. These are not used by the new loader but might be in\n # old data sets.\n to_delete = ['NEW_DATA', 'VISITS', 'PROPOSALS']\n for file in to_delete:\n filepath = os.path.join(aligned_path.replace('aligned', ''), file)\n if os.path.isfile(filepath):\n os.remove(filepath)\n\n # last step - zip up the input file and move it to the archive\n zipped = shutil.make_archive(aligned_path.replace('aligned', ''), 'zip', aligned_path.replace('aligned', ''))\n target.zip_archive.name = relative_to_media_root(zipped)\n\n target.save()\n\n return mols_processed","def delta_prob_raw(variants, tx, clf1, clf2, model='cterm', is_sum=True):\n # fetch c-terminal sequence\n term_seq = [] ; vars_considered = []\n for v in variants:\n if v.mutant_protein_sequence:\n if model=='cterm' and type(v) in utils.indels+utils.nmd_sub_vars:\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\n if not is_sum: vars_considered.append(v)\n elif type(v) in utils.base_substitutions:\n if model=='cterm' and v.aa_mutation_start_offset>(len(v.transcript.protein_sequence) - 23):\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\n if not is_sum: vars_considered.append(v)\n elif model=='nterm' and v.aa_mutation_start_offset<=24:\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\n if not is_sum: vars_considered.append(v)\n\n # return None if no variants\n if not term_seq:\n if is_sum: return 0\n else: return [], [], []\n # return None if U in protein sequence\n if 'U' in utils.fetch_seq(tx.protein_sequence, model=model):\n if is_sum: return 0\n else: return [], [], []\n\n # construct dataframe\n result_df = pd.DataFrame({'seq': term_seq})\n\n # create feature matrix\n X = compute_feature_matrix(result_df['seq'], 6, dinuc=True, model=model)\n X2 = compute_feature_matrix(result_df['seq'], 0, dinuc=False, model=model)\n\n # predict scores\n result_df['prob'] = clf1.predict_proba(X)[:, 0]\n\n # adjust for baseline score\n wt_seq = utils.fetch_seq(tx.protein_sequence, model=model)\n wt_df = pd.DataFrame({'seq': [wt_seq]})\n # create feature matrix\n X = compute_feature_matrix(wt_df['seq'], 6, dinuc=True, model=model)\n wt_df['prob'] = clf1.predict_proba(X)[:, 0]\n baseline = wt_df['prob'].iloc[0]\n\n # add up scores\n tmp = result_df['prob'] - baseline\n if is_sum:\n prob_sum = tmp.sum()\n return prob_sum\n else:\n return vars_considered, tmp, result_df['prob']","def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\n \"\"\"return value is a sum of all alignment scores in input rangerange.\"\"\" \n (start, finish) = wrapped_data \n score_sum = 0.\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\"Training process\"):\n score_sum += self.aligner.score(seq, dna_record.seq)\n return score_sum\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))","def test1_denovo(self):\n gimme_motifs(\n \"test/data/denovo/input.fa\",\n self.outdir,\n params={\n \"tools\": \"MDmodule\",\n \"fraction\": 0.5,\n \"background\": \"random\",\n \"genome\": \"test/data/background/genome.fa\",\n },\n filter_significant=True,\n cluster=True,\n )\n\n fnames = [\n \"gimme.denovo.pfm\",\n \"gimme.denovo.html\",\n \"gimme.clustereds.html\",\n \"params.txt\",\n \"stats.random.txt\",\n ]\n\n with open(os.path.join(self.outdir, \"gimmemotifs.log\")) as f:\n log = f.read()\n self.assertIn(\"clustering\", log)\n\n # Check if all output files are there\n for fname in fnames:\n self.assertTrue(os.path.exists(os.path.join(self.outdir, fname)))\n\n # Check if correct motif is predicted\n with open(os.path.join(self.outdir, \"gimme.denovo.pfm\")) as f:\n predicted_motifs = read_motifs(f)\n ap1 = motif_from_consensus(\"TGASTCA\")\n\n mc = MotifComparer()\n ap1_predicted = False\n for motif in predicted_motifs:\n match = mc.get_closest_match(ap1, motif)\n if match[\"TGASTCA\"][1][3] < 1e-5:\n ap1_predicted = True\n break\n\n self.assertTrue(ap1_predicted)","def calculate_on_target(ax, barcodes, expected, barcode_map=barcode_map):\n total = 0\n on_target = 0\n off_target = 0\n no_target = 0\n\n expected_counts = []\n off_target_counts = []\n expected_names = []\n off_target_names = []\n for barcode, count in barcodes.items():\n if barcode in barcode_map:\n if count > 10000:\n if barcode_map[barcode] in expected:\n on_target += count\n expected_counts.append(count)\n expected_names.append(barcode_map[barcode])\n else:\n off_target += count\n off_target_counts.append(count)\n off_target_names.append(barcode_map[barcode])\n else:\n no_target += count\n total += count\n\n expected_colors = cm.Blues(np.linspace(0, 1, len(expected_counts)))\n off_target_colors = cm.Reds(np.linspace(0, 1, len(off_target_counts) + 1))\n patches, texts = ax.pie(expected_counts + off_target_counts + [no_target],\n labels=expected_names + off_target_names + [\"No Barcode\"],\n colors=np.concatenate((expected_colors, off_target_colors)),\n )\n [text.set_fontsize(16) for text in texts]","def spreadOutAndFindDot(self, gameState):\n # Here are some useful elements of the startState\n currentPosition = gameState.getPacmanPosition(self.index)\n foodList = gameState.getFood().asList()\n walls = gameState.getWalls()\n randomFood = []\n problem = []\n\n #problem = AnyFoodSearchProblem(gameState, self.index)\n\n # if min(manhattan(currentPosition, foodPosition) for foodPosition in food.asList()) > 10:\n # return [Directions.STOP]\n #print(\"self.targets = \", self.targets)\n if self.index == 0:\n TargetFood = ClosestFood(currentPosition, foodList)\n #self.targets.append(TargetFood)\n problem = PositionSearchProblem(gameState, 0, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 1:\n TargetFood = ClosestFood(currentPosition, foodList)\n \"\"\"\n want to find a way to avoid both agents coming up with the same target. But the below doesn't work because\n each agent has their own self.targets. How to keep a common list of targets?\n \"\"\"\n # if TargetFood in self.targets:\n # tempFoodList = foodList.copy()\n # tempFoodList.pop(tempFoodList.index(TargetFood))\n # TargetFood = ClosestFood(currentPosition, tempFoodList)\n # self.targets.append(TargetFood)\n # else:\n # self.targets.append(TargetFood)\n problem = PositionSearchProblem(gameState, 1, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 2:\n TargetFood = RandomFood(currentPosition, foodList)\n problem = PositionSearchProblem(gameState, 2, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 3:\n TargetFood = RandomFood(currentPosition, foodList)\n problem = PositionSearchProblem(gameState, 3, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n #return search.bfs(problem)\n\n #util.raiseNotDefined()","def main():\n\n pv = str(sys.argv[1])\n\n print \"Testing count parameters on \" + pv\n \n lib = adned_lib()\n g = adned_globals()\n \n lib.init_check(pv)\n\n cycles = range(10)\n tests = range(10)\n wait_time = 5 #Time to wait between checking counters\n \n total_counts = []\n pulse_counter = 0\n proton_charge = 0\n seq_counter = 0\n\n total_counts_after = []\n pulse_counter_after = 0\n proton_charge_after = 0\n seq_counter_after = 0\n\n for i in range(g.AD_MAX_DET):\n total_counts.append(0)\n total_counts_after.append(0)\n \n for i in cycles:\n print \"Counter cycle \" + str(i)\n\n stat = lib.start(pv)\n if (stat == g.FAIL):\n sys.exit(lib.testComplete(g.FAIL))\n\n #Read counters immediately after a start \n for det in range(g.AD_MAX_DET):\n counts_pv = pv + \":Det\" + str(det+1) + \":EventTotal_RBV\"\n total_counts[det] = caget(counts_pv)\n pulse_counter = caget(pv + \":PulseCounter_RBV\")\n proton_charge = caget(pv + \":PChargeIntegrated_RBV\")\n seq_counter = caget(pv + \":SeqCounter0_RBV\")\n\n for test in tests:\n\n time.sleep(wait_time)\n\n #Check all counters have increased\n for det in range(g.AD_MAX_DET):\n counts_pv = pv + \":Det\" + str(det+1) + \":EventTotal_RBV\"\n total_counts_after[det] = caget(counts_pv)\n pulse_counter_after = caget(pv + \":PulseCounter_RBV\")\n proton_charge_after = caget(pv + \":PChargeIntegrated_RBV\")\n seq_counter_after = caget(pv + \":SeqCounter0_RBV\")\n\n for det in range(g.AD_MAX_DET):\n if (total_counts[det] >= total_counts_after[det]):\n print \"ERROR: Count problem. total_counts[\" + str(det) + \"]: \" + str(total_counts[det]) \\\n + \" total_counts_after[\" + str(det) + \"]: \" + str(total_counts_after[det])\n sys.exit(lib.testComplete(g.FAIL))\n\n if (pulse_counter >= pulse_counter_after):\n print \"ERROR: Count problem. pulse_counter: \" + str(pulse_counter) + \" pulse_counter_after: \" + str(pulse_counter_after)\n sys.exit(lib.testComplete(g.FAIL))\n if (proton_charge >= proton_charge_after):\n print \"ERROR: Count problem. proton_charge: \" + str(proton_charge) + \" proton_charge_after: \" + str(proton_charge_after)\n sys.exit(lib.testComplete(g.FAIL))\n if (seq_counter >= seq_counter_after):\n print \"ERROR: Count problem. seq_counter: \" + str(seq_counter) + \" seq_counter_after: \" + str(seq_counter_after)\n sys.exit(lib.testComplete(g.FAIL))\n\n print \"Test \" + str(test) + \" on cycle \" + str(i) + \" is OK.\" \n \n stat = lib.stop(pv)\n if (stat == g.FAIL):\n sys.exit(lib.testComplete(g.FAIL))\n\n #Check event rate (should be zero after a stop)\n for det in range(g.AD_MAX_DET):\n rate_pv = pv + \":Det\" + str(det+1) + \":EventRate_RBV\"\n rate = caget(rate_pv)\n if (rate != 0):\n print \"ERROR: Stop problem. Rate is non zero after a stop. Rate: \" + str(rate)\n sys.exit(lib.testComplete(g.FAIL))\n \n sys.exit(lib.testComplete(g.SUCCESS))","def mark_duplicates():\n\n mkdir(MD_DIR)\n\n printp(\"\"\"# drmr:label mark-duplicates\\n\"\"\")\n printp(\"\"\"# drmr:job nodes=1 processors=1 memory=12g working_directory={} time_limit=8h\"\"\".format(MD_DIR))\n\n for sample, info in DATA.items():\n for x in ['treatment', 'control']:\n srr = get_srr(sample) if x == 'treatment' else get_input_control_srr(sample)\n input_bam = get_bwa_bam(sample, control=False) if x == 'treatment' else get_bwa_bam(sample, control=True)\n output_bam = get_md_bam(sample, control=False) if x == 'treatment' else get_md_bam(sample, control=True)\n printp(\"\"\"picard -m 8g MarkDuplicates I={input_bam} O={output_bam} ASSUME_SORTED=true METRICS_FILE={srr}.markdup.metrics VALIDATION_STRINGENCY=LENIENT TMP_DIR=.; samtools index {output_bam}\"\"\".format(**locals()), timed=True)\n\n printp(\"\"\"\\n# drmr:wait\"\"\")","def same(item, target):\r\n return len([c for (c, t) in zip(item, target) if c == t])","def coverage(self, user_list):\n all_recom_set = set()\n all_item = set(self.train['movieId'].values)\n print('\\nCalculated coverage: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n all_recom_set.update(recom_item)\n print('\\nCoverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\n return len(all_recom_set) / (len(all_item) * 1.0)","def test_create_Context_with_targets_ranks(self):\n client = IPythonClient()\n targets = [3, 2]\n dac = Context(client, targets=targets)\n self.assertEqual(set(dac.targets), set(targets))\n dac.close()\n client.close()","def graph_helper(device, output,input,target):\n output = output.clone().squeeze()\n corrects = torch.zeros(output.shape[0])\n for i in range(output.shape[0]): # goes through each iteration\n outputi = output[i]\n golden_label = convert_to_bits(device, outputi, input)\n target = target.view(target.size(0), -1)\n corrects[i] += torch.amin(golden_label == target, dim=[0]).sum().item() # counts the number that are the same i.e. correct predictions\n correct = corrects.cpu().detach().numpy()\n return correct","def solveExCompact(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n #\n # NEEDS ATTACKER AVG PER ATTACKER\n #\n \"\"\"In this game the attacker and defender reason ex-ante\n (they choose to follow signals or not before a signal is sent).\"\"\"\n # Add the extra dummy targets\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n for defenderCount in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n attackerActions = targetRange\n # Get the suggestions that occur with no overlap\n omegaKeys = [(t,d,tPrime,lam) for t in targetRange for d in defenders for tPrime in targetRange for lam in aTypes]\n omegaKeys2 = [(t,lam) for t in targetRange for lam in aTypes]\n\n # Build the model\n model = Model('ExAnteWithOverlap')\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, name=\"w\")\n w2 = model.continuous_var_dict(keys=omegaKeys2, lb=0, name=\"w2\")\n objectiveFunction = sum([q[lam] * sum([w[t,d,t,lam] * _dRewards[d][t] for t in targetRange for d in defenders]) for lam in aTypes]) \\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * sum([_dPenalties[d][t] for d in defenders]) for t in targetRange]) for lam in aTypes]) \\\n + sum([q[lam] * sum([sum([w[t,d,tPrime,lam] for t in targetRange]) * _dCosts[d][tPrime] for tPrime in targetRange for d in defenders]) for lam in aTypes])\n\n # Define the constraints\n # Attacker\n attackerConstraints = [sum([w[t,d,t,lam] * _aPenalties[lam][t] for t in targetRange for d in defenders]) \\\n + sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * _aRewards[lam][t] for t in targetRange]) \\\n >= sum([w[t,d,tPrime,lam] * _aPenalties[lam][tPrime] for t in targetRange for d in defenders]) \\\n + sum([(w2[t,lam] - sum([w[t,d,tPrime,lam] for d in defenders])) * _aRewards[lam][tPrime] for t in targetRange]) \\\n for lam in aTypes for tPrime in targetRange]\n # Defender\n defenderConstraints = [sum([q[lam] * sum([w[t,d,t,lam] * _dRewards[d][t] for t in targetRange]) for lam in aTypes]) \\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * _dPenalties[d][t] for t in targetRange]) for lam in aTypes]) \\\n + sum([q[lam] * sum([sum([w[t,d,tPrimePrime,lam] for t in targetRange]) * _dCosts[d][tPrimePrime] for tPrimePrime in targetRange]) for lam in aTypes]) \\\n >= sum([q[lam] * w2[tPrime,lam] * _dRewards[d][tPrime] for lam in aTypes]) \\\n + sum([q[lam] * sum([sum([w[t,dPrime,t,lam] for dPrime in defenders if dPrime != d]) * _dRewards[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\n + sum([q[lam] * sum([w[t,d,t,lam] * _dPenalties[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,dPrime,t,lam] for dPrime in defenders])) * _dPenalties[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\n + _dCosts[d][tPrime] \\\n for d in defenders for tPrime in targetRange]\n # Proposition constraints\n p11Constraints = [sum([w2[t,lam] for t in targetRange]) == 1 for lam in aTypes]\n p12Constraints = [sum([w[t,d,tPrime,lam] for tPrime in targetRange]) == w2[t,lam] for lam in aTypes for d in defenders for t in targetRange]\n p13Constraints = [sum([w[t,d,tPrime,lam] for d in defenders]) <= w2[t,lam] for lam in aTypes for tPrime in targetRange for t in targetRange]\n # Add the constraints\n attackerConstraints = model.add_constraints(attackerConstraints)\n defenderConstraints = model.add_constraints(defenderConstraints)\n p11Constraints = model.add_constraints(p11Constraints)\n p12Constraints = model.add_constraints(p12Constraints)\n p13Constraints = model.add_constraints(p13Constraints)\n # Solve the model\n model.maximize(objectiveFunction)\n model.solve()\n print(model.get_solve_status())\n return model.solution.get_objective_value(), model, None","def test_determinism_2():\n\n def run_sgd(mode):\n # Must be seeded the same both times run_sgd is called\n disturb_mem.disturb_mem()\n rng = np.random.RandomState([2012, 11, 27])\n\n batch_size = 5\n train_batches = 3\n valid_batches = 4\n num_features = 2\n\n # Synthesize dataset with a linear decision boundary\n w = rng.randn(num_features)\n\n def make_dataset(num_batches):\n disturb_mem.disturb_mem()\n m = num_batches*batch_size\n X = rng.randn(m, num_features)\n y = np.zeros((m, 1))\n y[:, 0] = np.dot(X, w) > 0.\n\n rval = DenseDesignMatrix(X=X, y=y)\n\n rval.yaml_src = \"\" # suppress no yaml_src warning\n\n X = rval.get_batch_design(batch_size)\n assert X.shape == (batch_size, num_features)\n\n return rval\n\n train = make_dataset(train_batches)\n valid = make_dataset(valid_batches)\n\n num_chunks = 10\n chunk_width = 2\n\n class ManyParamsModel(Model):\n \"\"\"\n Make a model with lots of parameters, so that there are many\n opportunities for their updates to get accidentally re-ordered\n non-deterministically. This makes non-determinism bugs manifest\n more frequently.\n \"\"\"\n\n def __init__(self):\n super(ManyParamsModel, self).__init__()\n self.W1 = [sharedX(rng.randn(num_features, chunk_width)) for i\n in xrange(num_chunks)]\n disturb_mem.disturb_mem()\n self.W2 = [sharedX(rng.randn(chunk_width))\n for i in xrange(num_chunks)]\n self._params = safe_union(self.W1, self.W2)\n self.input_space = VectorSpace(num_features)\n self.output_space = VectorSpace(1)\n\n disturb_mem.disturb_mem()\n model = ManyParamsModel()\n disturb_mem.disturb_mem()\n\n class LotsOfSummingCost(Cost):\n \"\"\"\n Make a cost whose gradient on the parameters involves summing many\n terms together, so that T.grad is more likely to sum things in a\n random order.\n \"\"\"\n\n supervised = True\n\n def expr(self, model, data, **kwargs):\n self.get_data_specs(model)[0].validate(data)\n X, Y = data\n disturb_mem.disturb_mem()\n\n def mlp_pred(non_linearity):\n Z = [T.dot(X, W) for W in model.W1]\n H = [non_linearity(z) for z in Z]\n Z = [T.dot(h, W) for h, W in safe_izip(H, model.W2)]\n pred = sum(Z)\n return pred\n\n nonlinearity_predictions = map(mlp_pred,\n [T.nnet.sigmoid,\n T.nnet.softplus,\n T.sqr,\n T.sin])\n pred = sum(nonlinearity_predictions)\n disturb_mem.disturb_mem()\n\n return abs(pred-Y[:, 0]).sum()\n\n def get_data_specs(self, model):\n data = CompositeSpace((model.get_input_space(),\n model.get_output_space()))\n source = (model.get_input_source(), model.get_target_source())\n return (data, source)\n\n cost = LotsOfSummingCost()\n\n disturb_mem.disturb_mem()\n\n algorithm = SGD(cost=cost,\n batch_size=batch_size,\n learning_rule=Momentum(.5),\n learning_rate=1e-3,\n monitoring_dataset={'train': train, 'valid': valid},\n update_callbacks=[ExponentialDecay(decay_factor=2.,\n min_lr=.0001)],\n termination_criterion=EpochCounter(max_epochs=5))\n\n disturb_mem.disturb_mem()\n\n train_object = Train(dataset=train,\n model=model,\n algorithm=algorithm,\n extensions=[PolyakAveraging(start=0),\n MomentumAdjustor(final_momentum=.9,\n start=1,\n saturate=5), ],\n save_freq=0)\n\n disturb_mem.disturb_mem()\n\n train_object.main_loop()\n\n output = cStringIO()\n record = Record(file_object=output, replay=False)\n record_mode = RecordMode(record)\n\n run_sgd(record_mode)\n\n output = cStringIO(output.getvalue())\n playback = Record(file_object=output, replay=True)\n playback_mode = RecordMode(playback)\n\n run_sgd(playback_mode)","def culggroup_donecount(group, dones):\n return sum(dones[l] for l in group)","def count_houses_delivered_with_robot(s):\n s_santa, s_robot = s[::2], s[1::2]\n deliveries_santa = make_deliveries(s_santa)\n deliveries_robot = make_deliveries(s_robot)\n all_deliveries = combine_dicts(deliveries_santa, deliveries_robot, lambda x,y: x+y, 0)\n return len(all_deliveries)","def make_emotion_data(emotion: str, dict_to_use: dd.DataFrame, ck=True):\n emotion_data = []\n target_data = []\n\n for row in tqdm(dict_to_use.iterrows(), total = len(dict_to_use.index)):\n index, data = row\n annotated_emote = data[\"annotated\"]\n\n if annotated_emote == \"N/A\":\n continue\n all_columns = data.keys()\n columns_to_use = [x for x in all_columns if 'annotated' not in x and 'predicted' not in x and 'patient' not in x]\n # data = data.loc[:, columns_to_use].compute()\n data = data[columns_to_use]\n # data = data.loc[:, df.columns != \"annotated\" and df.columns != \"Happy_predicted\"].compute()\n emotion_data.append(data.tolist())\n\n if annotated_emote == emotion:\n target_data.append(1)\n else:\n target_data.append(0)\n\n return emotion_data, target_data\n\n\n # if dict_to_use is None:\n # dict_to_use = json.load(open('au_emotes.txt'))\n # emotion_data = [\n # item for sublist in (b for b in ((a for a in x.values() if a)\n # for x in dict_to_use.values()\n\n # if x) if b) for item in sublist\n # ]\n\n # if ck:\n # ck_dict = json.load(open('ck_dict.txt'))\n\n # for patient_list in ck_dict.values():\n # to_add = AUScorer.TrainList\n # au_dict = {\n # str(int(float(x))): y\n\n # for x, y in patient_list[0].items()\n # }\n\n # for add in to_add:\n # if add not in au_dict:\n # au_dict[add] = 0\n # emotion_data.append([au_dict, patient_list[1]])\n\n # au_data = []\n # target_data = []\n # aus_list = AUScorer.TrainList\n\n # for frame in emotion_data:\n # aus = frame[0]\n\n # if frame[1] == emotion:\n # au_data.append([float(aus[str(x)]) for x in aus_list])\n # target_data.append(1)\n # index = 0\n # happy_len = len(target_data)\n\n # for frame in emotion_data:\n # aus = frame[0]\n\n # if frame[1] and frame[1] != emotion:\n # au_data.append([float(aus[str(x)]) for x in aus_list])\n # target_data.append(0)\n # index += 1\n\n # if index == happy_len:\n # break\n\n # return au_data, target_data","def count_mutations_sequence(seq1, seq2):\n # If the lengths of these two sequences are not equal, raise error \n if len(seq1) != len(seq2) and len(seq1) == 0 and len(seq2) == 0:\n text = \"The two sequences have different amino acids\"\n raise DeimmunizationError(text)\n # Define the mutations\n mutCount = 0\n # Calculate the mutations\n for i in range(len(seq1)):\n if seq1[i] != seq2[i]:\n mutCount += 1\n\n return mutCount","def DOPE(atmsel):\n return ('DOPE score', atmsel.assess_dope())","def get_number_seqs_for_primer(percent_match,\n seq_count):\n \n total_seq_use=int((1-percent_match)*seq_count)\n \n return total_seq_use","def findNearestTss(chrom, loops, gs, pdis=2000):\n ts = np.array([[tss] for tss in gs.keys()])\n cov = {}\n for tss, g in gs.items():\n cov[tss] = g\n tree = KDTree(ts)\n ds = {}\n for loop in loops:\n xgs, xds = findOverlapOrNearest(gs, ts, tree, loop.x_start, loop.x_end)\n ygs, yds = findOverlapOrNearest(gs, ts, tree, loop.y_start, loop.y_end)\n if len(xgs) > 1:\n xt = \"Promoter\"\n xd = 0\n else:\n xd = xds[0]\n if abs(xd) <= pdis:\n xt = \"Promoter\"\n else:\n xt = \"Enhancer\"\n if len(ygs) > 1:\n yt = \"Promoter\"\n yd = 0\n else:\n yd = yds[0]\n if abs(yd) <= pdis:\n yt = \"Promoter\"\n else:\n yt = \"Enhancer\"\n ds[loop.id] = {\n \"typeAnchorA\":\n xt,\n \"typeAnchorB\":\n yt,\n \"nearestDistanceToGeneAnchorA\":\n xd,\n \"nearestDistanceToGeneAnchorB\":\n yd,\n \"nearestTargetGeneAnchorA\":\n \",\".join([\n xg.chrom + \":\" + str(xg.start) + \"-\" + str(xg.end) + \"|\" +\n xg.strand + \"|\" + xg.name for xg in xgs\n ]),\n \"nearestTargetGeneAnchorB\":\n \",\".join([\n yg.chrom + \":\" + str(yg.start) + \"-\" + str(yg.end) + \"|\" +\n yg.strand + \"|\" + yg.name for yg in ygs\n ]),\n }\n return ds","def solveExOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains a dummy target for defenders and attackers\"\"\"\n \"\"\"In this game the attacker and defender reason ex-ante\n (they choose to follow signals or not before a signal is sent).\"\"\"\n # Add the extra dummy target\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n for defenderCount in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n attackerActions = targetRange\n placements = getPlacements(defenders, targetNumWithDummies)\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Build the model\n model = Model('ExAnteWithOverlap')\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\"w\")\n objectiveFunction = sum([q[lam] * sum([w[sd,sa,lam] * defenderSocialUtility(sd,sa,defenders,_dRewards,_dCosts,_dPenalties) for sd in placements for sa in attackerActions]) for lam in aTypes])\n # Define the constraints\n c1 = [sum([w[sd,sa,lam] * aUtility(sd,sa,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions]) \\\n >= sum([w[sd,sa,lam] * aUtility(sd,tPrime,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions])\n for lam in aTypes for tPrime in targetRange]\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\n c2 = [sum([q[lam] * sum([w[sd,sa,lam] * utilityM(sd[d],sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\n >= sum([q[lam] * sum([w[sd,sa,lam] * utilityM(tPrime,sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\n for d in defenders for tPrime in targetRange]\n c3 = [sum([w[sd,sa,lam] for sd in placements for sa in attackerActions]) == 1\n for lam in aTypes]\n # Add the constraints\n c1 = model.add_constraints(c1)\n c2 = model.add_constraints(c2)\n c3 = model.add_constraints(c3)\n # Solve the model\n model.maximize(objectiveFunction)\n model.solve()\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\n utilityPerAttacker = 0\n for k,v in w.items():\n prob = float(v)\n s,a,lam = k\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\n utilityPerAttacker /= len(aTypes)\n utilityPerDefender = model.solution.get_objective_value()\n utilityPerDefender /= len(defenders)\n return utilityPerDefender, utilityPerAttacker, None","def calculate_single_cycle_gan_metrics(source, target):\n metric_results = MetricsContainer(len(source))\n for i, x in enumerate(source):\n scores = torch.mean(torch.abs(x.view(1, -1) - target), dim=1)\n _, indices = torch.sort(scores, descending=False)\n indices = indices.cpu().numpy()\n rank = np.nonzero(indices == i)[0][0] + 1\n metric_results.update(rank)\n return metric_results.get_results()","def dp_cal_and_pro_only(foods, cal_goal, pro_goal):\n macros = init_two_d_array((cal_goal, pro_goal), 999999999)\n foods_used = init_two_d_array((cal_goal, pro_goal), {})\n\n for i in range(cal_goal):\n for j in range(pro_goal):\n for n in range(len(foods)):\n food = foods[n]\n if (int(food['calories']) > i and int(food['protein']) > j):\n continue\n if (macros[i - int(food['calories'])]\n [j - int(food['protein'])]\n == 999999999):\n prev_cost = 0\n prev_foods_used = {}\n else:\n prev_cost = (macros[i - int(food['calories'])]\n [j - int(food['protein'])])\n prev_foods_used = \\\n (foods_used[i - int(food['calories'])]\n [j - int(food['protein'])]).copy()\n new_cal = calories(foods, prev_foods_used) + food['calories']\n new_pro = protein(foods, prev_foods_used) + food['protein']\n if (macros[i][j] > prev_cost + food['serving_cost']\n and new_cal > i - 50 and new_cal < i + 10\n and new_pro > j - 5 and new_pro < j + 5):\n macros[i][j] = prev_cost + food['serving_cost']\n try:\n prev_foods_used[n] += 1\n except KeyError:\n prev_foods_used[n] = 1\n foods_used[i][j] = prev_foods_used\n return foods_used[cal_goal - 1][pro_goal - 1]","def information_content_similarity(s1, s2):\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\n\n # Disambiguate words and create list of sysnsets \n synsets_sentence_1 = []\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_1.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_1.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n synsets_sentence_2 = []\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_2.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_2.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n\n score, count = 0.0, 0\n # For each word in the first sentence\n for synset in synsets_sentence_1:\n L = []\n for ss in synsets_sentence_2:\n try:\n L.append(synset.lin_similarity(ss, brown_ic))\n except:\n continue\n if L: \n best_score = max(L)\n score += best_score\n count += 1\n # Average the values\n if count > 0: score /= count\n return score","def delete_tulips_by_target(target_id):\r\n associated_tulips = self._db().select(self._db.tulip.target_id==target_id)\r\n tulips_removed = 0\r\n for single_tulip in associated_tulips:\r\n tulips_removed += 1\r\n self._db(self._db.tulip.id==single_tulip.it).delete()\r\n return tulips_removed","def solveBaseline(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains a dummy target for defenders and attackers\"\"\"\n # Add the dummy target\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n\n # Generate the placements and keys\n placements = getPlacements(defenders, targetNumWithDummies)\n attackerActions = targetRange\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Construct the model for each defender\n utilityPerDefender = 0\n utilityPerAttacker = 0\n attackerUtility = []\n dStrat = {}\n models2 = {}\n for m in defenders:\n model2 = Model(f\"defenderStrategy{m}\")\n x = model2.continuous_var_list(keys=targetNumWithDummies, lb=0, ub=1, name=f\"x{m}\")\n h = model2.binary_var_dict(keys=[(lam, k) for lam in aTypes for k in targetRange], lb=0, ub=1, name=f\"h{m}\")\n ul = model2.continuous_var_dict(keys=aTypes, lb=-model2.infinity, name=f\"ua{m}\")\n ud = model2.continuous_var_dict(keys=[lam for lam in aTypes], lb=-model2.infinity, name=f\"ud{m}\")\n objectiveFunction = sum([q[lam] * ud[lam] for lam in aTypes])\n model2.add_constraints([ud[lam] <= utilityDI(m,x,i,_dRewards,_dPenalties,_dCosts) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\"defender utility for lam {lam}, i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([ul[lam] <= utilityLamI(x,lam,i,_aRewards,_aPenalties) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\"lam {lam} utility leq for i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([ul[lam] >= utilityLamI(x,lam,i,_aRewards,_aPenalties) for i in targetRange for lam in aTypes], names=[f\"lam {lam} utility geq, for i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([sum([h[(lam,i)] for i in targetRange]) == 1 for lam in aTypes], names=[f\"h sum is 1 for lam {lam}\" for lam in aTypes])\n model2.add_constraint(sum([x[i] for i in targetRange]) == 1)\n # Solve the model for each defender\n model2.maximize(objectiveFunction)\n model2.solve()\n dStrat[m] = list([float(xVal) for xVal in x])\n models[m] = model2\n # Attacker best response (for each attacker type)\n aStrat = {}\n protectionOdds = probabilityProtected(dStrat, targetNumWithDummies)\n for lam in aTypes:\n expectedUtilities = []\n for i in targetRange:\n expectedUtilities.append(((1-protectionOdds[i])*_aRewards[lam][i]) + (protectionOdds[i]*_aPenalties[lam][i]))\n aStrat[lam] = argmax(expectedUtilities)\n attackerUtility.append(expectedUtilities[aStrat[lam]])\n utilityPerAttacker = sum(attackerUtility)/len(aTypes)\n\n\n # Calculate defender expected utility for attacker best response\n for m in defenders:\n for lam in aTypes:\n attackedTarget = aStrat[lam] # The target attacked by this attacker\n coveredUtility = protectionOdds[attackedTarget] * (_dRewards[m][attackedTarget]) # The expected utility we catch this attacker\n uncoveredUtility = (1-protectionOdds[attackedTarget]) * (_dPenalties[m][attackedTarget]) # The expected utility we miss this attacker\n utilityPerDefender += q[lam] * (coveredUtility + uncoveredUtility)\n expectedCost = sum([dStrat[m][target] * _dCosts[m][target] for target in targetRange])\n utilityPerDefender += expectedCost\n utilityPerDefender /= len(defenders)\n\n return utilityPerDefender, utilityPerAttacker, None","def gen_target(self):\n df_iwp = self.get_df_iwp()\n df_iwes = self.get_df_iwes()\n df_iwes = df_iwes.rename(columns={'exitsitedate':'ft_data_dt'})\n df_iwp = df_iwp.rename(columns={'peritonitisdate':'ft_data_dt'})\n df_infect = df_iwes.merge(df_iwp, how='outer')\n df_infect = df_infect.dropna(axis=0)\n first_infect = df_infect.groupby(['idd']).min()\n first_infect = first_infect.reset_index()\n first_infect['target'] = 1\n first_infect['ft_data_dt'] = pd.to_datetime(first_infect['ft_data_dt'], format=\"%Y%m\") + MonthEnd(1)\n all_target = []\n end_data_dt = self.get_end_data_dt()\n print(end_data_dt)\n for index, row in first_infect.iterrows():\n date_series = pd.date_range(*(pd.to_datetime([row['ft_data_dt'], end_data_dt]) + pd.offsets.MonthEnd()), freq='M', name='ft_data_dt')\n idd_list = [row['idd']]\n idd_series = pd.Series(data=idd_list, name='idd')\n date_frame = date_series.to_frame()\n idd_frame = idd_series.to_frame()\n date_frame['key'] = 0\n idd_frame['key'] = 0\n tmp_target = idd_frame.merge(date_frame, on='key', how='outer').drop(columns=['key'])\n all_target.append(tmp_target)\n target = pd.concat(all_target)\n target['target'] = 1\n self.set_target_df(target)","def labelled_attachment(gold_trees, pred_trees):\n count_match, count_total = 0, 0\n for gold, pred in zip(gold_trees, pred_trees):\n triples_pairs = zip(\n gold.get_triples(include_root=True),\n pred.get_triples(include_root=True),\n )\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\n assert g_src == p_src\n count_total += 1\n if g_trg == p_trg and g_rel == p_rel:\n count_match += 1\n if count_match == 0 or count_total == 0:\n return 0.0\n else:\n return float(count_match) / count_total","def _compute_exclusives_conflicts(self, targets):\r\n exclusives_map = defaultdict(set)\r\n for t in targets:\r\n if t.exclusives is not None:\r\n for k in t.exclusives:\r\n exclusives_map[k] |= t.exclusives[k]\r\n conflicting_keys = defaultdict(set)\r\n for k in exclusives_map:\r\n if len(exclusives_map[k]) > 1:\r\n conflicting_keys[k] = exclusives_map[k]\r\n return conflicting_keys","def TargetDistrObj(x,t,newsamps,oldsamps,oldsetcounts) :\r\n\t\terror = 0\r\n\t\tnewtotal = newsamps+oldsamps\r\n\t\tfor ii in range(0,len(t)) :\r\n\t\t\tval = (t[ii] - (oldsetcounts[ii] + x[ii]*newsamps)/newtotal)\r\n\t\t\terror += val*val\r\n\t\treturn error","def test_measure_deterministic_without_sampling(self):\n shots = 100\n circuits = ref_measure.measure_circuits_deterministic(allow_sampling=False)\n targets = ref_measure.measure_counts_deterministic(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def solvePostOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains a dummy target for defenders and attackers\"\"\"\n # Add the extra dummy target\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n for defenderCount in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n attackerActions = targetRange\n placements = getPlacements(defenders, targetNumWithDummies)\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Build the model\n model = Model('PrimalWithOverlap')\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\"w\")\n objectiveFunction = sum([q[lam] * sum([w[s,a,lam] * defenderSocialUtility(s,a,defenders,_dRewards,_dCosts,_dPenalties) for s in placements for a in attackerActions]) for lam in aTypes])\n c1 = [sum([w[s,a,lam] * aUtility(s,a,lam,_aPenalties,_aRewards) for s in placements]) \\\n >= sum([w[s,a,lam] * aUtility(s,b,lam,_aPenalties,_aRewards) for s in placements])\n for lam in aTypes for a in attackerActions for b in attackerActions if a != b]\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\n c1 = model.add_constraints(c1)\n c2 = model.add_constraints([sum([q[lam] * sum([w[s,a,lam] * utilityM(d,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes]) \\\n >= sum([q[lam] * sum([w[s,a,lam] * utilityM(e,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes])\n for m in defenders for d in targetRange for e in targetRange if d!=e])\n c3 = model.add_constraints([sum([w[(s,a,lam)] for s in placements for a in attackerActions]) == 1 for lam in aTypes])\n # Solve the model\n model.maximize(objectiveFunction)\n model.solve()\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\n utilityPerAttacker = 0\n for k,v in w.items():\n prob = float(v)\n s,a,lam = k\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\n utilityPerAttacker /= len(aTypes)\n utilityPerDefender = model.solution.get_objective_value()\n utilityPerDefender /= len(defenders)\n\n return utilityPerDefender, utilityPerAttacker, None","def make_set_cover_pos(gRNA_hits, num_sets = 1, target_ids = [], algorithm = \"LAR\",\n id_key = lambda x: x, tie_breaker = tie_break_first, suppress_warning = False):\n # exclude_seqs = set(str(s).upper() for s in exclude_seqs)\n # gRNA_coverage = {seq: hits for seq, hits in gRNA_hits.hits.items()\n # if str(seq).upper() not in exclude_seqs}\n gRNA_coverage = gRNA_hits.hits\n eliminated_gRNA = {}\n ## prepare target ids\n if not target_ids:\n target_ids = set(hit.target_id for hit in gRNA_hits.flatten_hits())\n else:\n target_ids = set(target_ids)\n ## selected set cover algorithm\n if algorithm in (\"LAR\", \"greedy\"):\n set_cover_algo = set_cover_LAR if algorithm == \"LAR\" else set_cover_greedy\n else:\n raise Exception(f\"Invalid algorithm name: '{algorithm}'\")\n def coverage_possible():\n return set(id_key(hit) for hits in gRNA_coverage.values() for hit in hits) >= set(target_ids)\n ## function to generate set covers\n def make_set_cover(restore = []):\n for grna in restore:\n gRNA_coverage[grna.seq] = eliminated_gRNA[grna.seq]\n if not coverage_possible():\n if not suppress_warning:\n print((\"\\nError: The provided gRNA sequences cannot cover all target sequences\"\n \" at least once.\\n\"))\n return []\n selected_grnas = set_cover_algo(gRNA_coverage, target_ids, id_key = id_key, tie_breaker = tie_breaker)\n ## remove selected gRNA from candidates, and covert to gRNA object\n output = []\n for grna_seq in selected_grnas:\n ## remove\n eliminated_gRNA[grna_seq] = gRNA_coverage[grna_seq]\n del gRNA_coverage[grna_seq]\n ## convert gRNA sequences to gRNA object\n grna_seq_obj = gRNA_hits.get_gRNAseq_by_seq(grna_seq)\n output.append(gRNA(grna_seq_obj.id, grna_seq_obj))\n return output\n return make_set_cover","def evaluate(self, model, data):\n model.eval()\n\n loss = self.loss\n loss.reset()\n match = 0\n total = 0\n correct_spk = 0\n total_response = 0\n y_true = np.array([])\n y_pred = np.array([])\n\n device = None if torch.cuda.is_available() else -1\n batch_iterator = torchtext.data.BucketIterator(\n dataset=data, batch_size=self.batch_size,\n sort=True, sort_key=lambda x: len(x.src),\n device=device, train=False)\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\n\n for batch in batch_iterator:\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\n\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs)\n\n # Predict Speaker:\n target_spk = spk_inputs[-1]\n target_lengths = target_lengths.cpu().numpy()\n prob_per_spk = []\n for i in range(self.args.num_spk):\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\n spk_inputs_.append(spk_inputs_predict)\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs_)\n prob_per_responce = []\n target = target_variables.transpose(0,1)\n for word, prob in zip(target[1:], decoder_outputs):\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\n indices = zip(np.arange(len(word)), word)\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\n prob_per_responce.append(prob_per_word)\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\n\n predicts = np.argmax(prob_per_spk, axis=1)\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\n total_response += len(batch.tgt[0])\n\n # Evaluation\n seqlist = other['sequence']\n for step, step_output in enumerate(decoder_outputs):\n target = target_variables[:, step + 1]\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\n\n non_padding = target.ne(pad)\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\n match += correct\n total += non_padding.sum().data[0]\n\n y_pred = np.append(y_pred, predicts)\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\n\n print(y_pred.shape)\n\n print(accuracy_score(y_true, y_pred))\n print(confusion_matrix(y_true, y_pred))\n\n if total == 0:\n accuracy = float('nan')\n else:\n accuracy = match / total\n\n if total_response == 0:\n accuracy_spk = float('nan')\n else:\n accuracy_spk = correct_spk / total_response\n\n return loss.get_loss(), accuracy, accuracy_spk","def fit(self, seqs):\n self._saved = self.cov(seqs1=seqs, seqs2=seqs)\n return self._n_hypers","def Counting(seq):\n\n #Scan the sequence, looking for motifs\n\n counting = {k: 0 for k in MOT} # Initialize the counting dictionary.\n # Scan all the motifs and find them in the sequence\n for motif in MOT:\n if len(seq) > len(motif): # Check if the sequence is longer than the motif itself.\n for i in range(len(seq)-len(motif)+1):\n if i == 0: # In case the motif is in the beginning of the sequence\n # print(\"start: \" + seq[i:i+len(motif)] + \" next nuc: \" + seq[i+len(motif)])\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0]: # Check if the next nucleotide is in not part of the motif.\n counting[motif] += 1\n elif i == len(seq)-len(motif): # In case the motif is in the end of the sequence\n \n if seq[i:i+len(motif)] == motif and seq[i-1] != motif[0]: # Check if the previuos nucleotide is in not part of the motif.\n counting[motif] += 1\n elif len(seq) > len(motif)+1: # In case the motif is in the middle of the sequence.\n # Check if the motif is not part of another motif (e.g. TT is in TTT).\n\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0] and seq[i-1] != motif[0]:\n counting[motif] += 1\n for nuc_nr in NUC_NR:\n counting[nuc_nr+\"_NR\"] = seq.count(nuc_nr)\n\n return counting","def checkTargets(targets, strings, propagation, output):\n result = \"\"\n #Do not check an URL twice\n #Here, two different pages on the same target can be checked\n #This is because a page can be \"alone\" on a website\n targetViewed = set([])\n for url in targets:\n if url not in targetViewed:\n string, otherLinks, linksViewed = checkSite(url, strings, output)\n result += string\n result += \"\\n\"\n targetViewed = targetViewed | set([url])\n\n #If user want use propagation, add other links to the targets\n if propagation > 0:\n targets += list(otherLinks)\n propagation -= 1\n #Add all viewed links in targetViewed in order to do not check\n #twice the same URL\n targetViewed = targetViewed | linksViewed\n return result","def next_target(self, old_sInd, modes):\n\n OS = self.OpticalSystem\n ZL = self.ZodiacalLight\n Comp = self.Completeness\n TL = self.TargetList\n Obs = self.Observatory\n TK = self.TimeKeeping\n \n # create DRM\n DRM = {}\n \n # allocate settling time + overhead time\n tmpCurrentTimeAbs = TK.currentTimeAbs.copy() + Obs.settlingTime + modes[0]['syst']['ohTime']\n tmpCurrentTimeNorm = TK.currentTimeNorm.copy() + Obs.settlingTime + modes[0]['syst']['ohTime']\n\n # look for available targets\n # 1. initialize arrays\n slewTimes = np.zeros(TL.nStars)*u.d\n fZs = np.zeros(TL.nStars)/u.arcsec**2\n dV = np.zeros(TL.nStars)*u.m/u.s\n intTimes = np.zeros(TL.nStars)*u.d\n obsTimes = np.zeros([2,TL.nStars])*u.d\n sInds = np.arange(TL.nStars)\n \n # 2. find spacecraft orbital START positions (if occulter, positions \n # differ for each star) and filter out unavailable targets \n sd = None\n if OS.haveOcculter == True:\n sd = Obs.star_angularSep(TL, old_sInd, sInds, tmpCurrentTimeAbs)\n obsTimes = Obs.calculate_observableTimes(TL,sInds,tmpCurrentTimeAbs,self.koMap,self.koTimes,modes[0])\n slewTimes = Obs.calculate_slewTimes(TL, old_sInd, sInds, sd, obsTimes, tmpCurrentTimeAbs) \n \n # 2.1 filter out totTimes > integration cutoff\n if len(sInds.tolist()) > 0:\n sInds = np.intersect1d(self.intTimeFilterInds, sInds)\n \n # start times, including slew times\n startTimes = tmpCurrentTimeAbs.copy() + slewTimes\n startTimesNorm = tmpCurrentTimeNorm.copy() + slewTimes\n\n # 2.5 Filter stars not observable at startTimes\n try:\n koTimeInd = np.where(np.round(startTimes[0].value)-self.koTimes.value==0)[0][0] # find indice where koTime is startTime[0]\n sInds = sInds[np.where(np.transpose(self.koMap)[koTimeInd].astype(bool)[sInds])[0]]# filters inds by koMap #verified against v1.35\n except:#If there are no target stars to observe \n sInds = np.asarray([],dtype=int)\n \n # 3. filter out all previously (more-)visited targets, unless in \n if len(sInds.tolist()) > 0:\n sInds = self.revisitFilter(sInds, tmpCurrentTimeNorm)\n\n # 4.1 calculate integration times for ALL preselected targets\n maxIntTimeOBendTime, maxIntTimeExoplanetObsTime, maxIntTimeMissionLife = TK.get_ObsDetectionMaxIntTime(Obs, modes[0])\n maxIntTime = min(maxIntTimeOBendTime, maxIntTimeExoplanetObsTime, maxIntTimeMissionLife)#Maximum intTime allowed\n\n if len(sInds.tolist()) > 0:\n if OS.haveOcculter == True and old_sInd is not None:\n sInds,slewTimes[sInds],intTimes[sInds],dV[sInds] = self.refineOcculterSlews(old_sInd, sInds, slewTimes, obsTimes, sd, mode) \n endTimes = tmpCurrentTimeAbs.copy() + intTimes + slewTimes\n else: \n intTimes[sInds] = self.calc_targ_intTime(sInds, startTimes[sInds], modes[0])\n sInds = sInds[np.where(intTimes[sInds] <= maxIntTime)] # Filters targets exceeding end of OB\n endTimes = startTimes + intTimes\n \n if maxIntTime.value <= 0:\n sInds = np.asarray([],dtype=int)\n\n # 5.1 TODO Add filter to filter out stars entering and exiting keepout between startTimes and endTimes\n \n # 5.2 find spacecraft orbital END positions (for each candidate target), \n # and filter out unavailable targets\n if len(sInds.tolist()) > 0 and Obs.checkKeepoutEnd:\n try: # endTimes may exist past koTimes so we have an exception to hand this case\n koTimeInd = np.where(np.round(endTimes[0].value)-self.koTimes.value==0)[0][0]#koTimeInd[0][0] # find indice where koTime is endTime[0]\n sInds = sInds[np.where(np.transpose(self.koMap)[koTimeInd].astype(bool)[sInds])[0]]# filters inds by koMap #verified against v1.35\n except:\n sInds = np.asarray([],dtype=int)\n\n # 6. choose best target from remaining\n if len(sInds.tolist()) > 0:\n # choose sInd of next target\n sInd, waitTime = self.choose_next_target(old_sInd, sInds, slewTimes, intTimes[sInds])\n \n if sInd == None and waitTime is not None:#Should Choose Next Target decide there are no stars it wishes to observe at this time.\n self.vprint('There are no stars Choose Next Target would like to Observe. Waiting %dd'%waitTime.value)\n return DRM, None, None, waitTime, None\n elif sInd == None and waitTime == None:\n self.vprint('There are no stars Choose Next Target would like to Observe and waitTime is None')\n return DRM, None, None, waitTime, None\n # store selected star integration time\n det_mode = copy.deepcopy(modes[0])\n if self.WAint[sInd] > modes[1]['IWA'] and self.WAint[sInd] < modes[1]['OWA']:\n det_mode['BW'] = det_mode['BW'] + modes[1]['BW']\n det_mode['OWA'] = modes[1]['OWA']\n det_mode['inst']['sread'] = det_mode['inst']['sread'] + modes[1]['inst']['sread']\n det_mode['inst']['idark'] = det_mode['inst']['idark'] + modes[1]['inst']['idark']\n det_mode['inst']['CIC'] = det_mode['inst']['CIC'] + modes[1]['inst']['CIC']\n det_mode['syst']['optics'] = np.mean((det_mode['syst']['optics'], modes[1]['syst']['optics']))\n det_mode['instName'] = 'combined'\n intTime = self.calc_targ_intTime(sInd, startTimes[sInd], det_mode)[0]\n else:\n intTime = intTimes[sInd]\n \n # if no observable target, advanceTime to next Observable Target\n else:\n self.vprint('No Observable Targets at currentTimeNorm= ' + str(TK.currentTimeNorm.copy()))\n return DRM, None, None, None, None\n \n # update visited list for selected star\n self.starVisits[sInd] += 1\n # store normalized start time for future completeness update\n self.lastObsTimes[sInd] = startTimesNorm[sInd]\n \n # populate DRM with occulter related values\n if OS.haveOcculter:\n DRM = Obs.log_occulterResults(DRM,slewTimes[sInd],sInd,sd[sInd],dV[sInd])\n return DRM, sInd, intTime, waitTime, det_mode\n\n return DRM, sInd, intTime, waitTime, det_mode","def calculate_appropriate_target(self):\n pass","def calculate_appropriate_target(self):\n pass","def _getNumberOfAlignedNucleotides(self, dominant, subdominant):\n\t\tnumAligned = 0\n\t\tfor i in range(len(dominant)):\n\t\t\tif dominant[i] is not \" \" and subdominant[i] is not \" \":\n\t\t\t\tif dominant[i] == subdominant[i]:\n\t\t\t\t\tnumAligned += 1\n\t\treturn numAligned","def exon_finder(tstart,tend,strand,qstart,qend,qlen,qstartphase,qendphase,seqdict,seqname,\n max_offset = 30, is_start = False, is_stop = False, nevermind_atg = False,\n cluster = None,exon_number = None,log_file = open(os.devnull, 'w'),full_pseudoexon_search = True,\n exon_info_dict = False):\n start = None\n end = None\n pseudo = False\n max_coord = len(seqdict[seqname]) - 1\n if strand == \"+\":\n phasestart_offset = (3 - qstartphase) % 3\n phasestop_offset = qendphase\n start_match_offset, stop_match_offset = 3 * (qstart - 1),3 * (qlen - qend)\n elif strand == '-':\n phasestart_offset = qendphase\n phasestop_offset = (3 - qstartphase) % 3\n start_match_offset, stop_match_offset = 3 * (qlen - qend), 3 * qstart\n ideal_start = tstart - phasestart_offset - start_match_offset\n ideal_end = tend + stop_match_offset + phasestop_offset\n pseudo_start = tstart - phasestart_offset\n pseudo_end = tend + phasestop_offset\n gc_start, gc_end = None, None\n for offset in range(0,max_offset + 3,3):\n if start:\n break\n for direction in [1,-1]:\n test_start = ideal_start - offset * direction\n test_seq = genome.Sequence(seqdict[seqname][test_start-1 + phasestart_offset:tend])\n if strand == \"-\":\n test_seq = test_seq.reverse_compliment()\n if not test_seq.translate():\n continue\n elif is_stop and strand == \"-\":\n if ideal_start - 1 < test_start < pseudo_start:\n pseudo_start = test_start\n lastcodon = seqdict[seqname][test_start - 1:test_start + 2]\n if lastcodon.upper() in ['TTA','TCA','CTA'] and test_seq.translate().count('*') == 1:\n start = test_start\n break\n elif not \"*\" in test_seq.translate():\n if ideal_start - 1 < test_start < pseudo_start:\n pseudo_start = test_start\n if is_start and strand == '+':\n if nevermind_atg:\n start = test_start\n break\n else:\n firstcodon = seqdict[seqname][test_start - 1:test_start + 2]\n if firstcodon.upper() == \"ATG\":\n start = test_start\n break\n else:\n splicesite = seqdict[seqname][test_start-3:test_start-1]\n if (strand == '+' and splicesite.upper() == \"AG\") or (strand == '-' and splicesite.upper() == \"AC\"):\n start = test_start\n break\n elif strand == '-' and splicesite.upper() == \"GC\" and not gc_start:\n gc_start = test_start\n if not start:\n if gc_start:\n start = gc_start\n else:\n pseudo = \"P\"\n start = pseudo_start\n for offset in range(0,max_offset + 3,3):\n if end:\n break\n for direction in [-1,1]:\n test_end = ideal_end - offset * direction\n if test_end - start < 3:\n break\n test_seq = genome.Sequence(seqdict[seqname][start - 1 + phasestart_offset:test_end - phasestop_offset])\n if strand == \"-\":\n test_seq = test_seq.reverse_compliment()\n if not test_seq.translate():\n continue\n elif is_stop and strand == \"+\":\n if ideal_end + 1 > test_end > pseudo_end:\n pseudo_end = test_end\n lastcodon = seqdict[seqname][test_end - 3:test_end]\n if lastcodon.upper() in ['TAA','TGA','TAG'] and test_seq.translate().count('*') == 1:\n end = test_end\n break\n elif not \"*\" in test_seq.translate() or (is_stop and not \"*\" in test_seq.translate()[:-1]):\n if ideal_end + 1 > test_end > pseudo_end:\n pseudo_end = test_end\n if is_start and strand == '-':\n if nevermind_atg:\n end = test_end\n break\n else:\n firstcodon = seqdict[seqname][test_end - 3:test_end]\n if firstcodon.upper() == \"CAT\":\n end = test_end\n break\n else:\n splicesite = seqdict[seqname][test_end:test_end + 2]\n if (strand == '+' and splicesite.upper() == \"GT\") or (strand == '-' and splicesite.upper() == \"CT\"):\n end = test_end\n break\n elif strand == \"+\" and splicesite.upper() == \"GC\" and not gc_end:\n gc_end = test_end\n if not end:\n if gc_end:\n end = gc_end\n else:\n pseudo = \"P\"\n end = pseudo_end\n start = max([1,start])\n end = min([end,max_coord])\n if pseudo and full_pseudoexon_search and cluster != None and exon_number != None and exon_info_dict:\n gwexons = genewisesearch(seqdict[seqname],qstartphase,qendphase,strand,\n exon_info_dict[str(cluster) + ':' + str(exon_number)][6], \n search_coords = [ideal_start - 3 - max_offset,ideal_end + 3 + max_offset],\n seqname = seqname,log_file=log_file)\n if gwexons != []:\n return gwexons\n return [[start,end,pseudo]]","def target_will_be_deleted(cls, ctx, user, target):\n # For every rover feature that was enabled/used by this target being deleted (as passed via\n # the target metadata) and that is listed in any rover_features field in the capability definitions,\n # decrement its uses count to both free up any free uses and keep an accurate count of the number of uses.\n for rover_feature in (f for f in target.metadata.iterkeys() if f in capability_module.all_rover_features()):\n if target.rover.can_reuse_feature(rover_feature):\n target.rover.reuse_feature(rover_feature)\n else:\n logger.warn(\"No available capabilities when trying to reuse rover feature [%s][%s]\",\n rover_feature, target.user.capabilities)"],"string":"[\n \"def count_target(self):\\n tally = {}\\n for obj in self.target:\\n tally[obj] = 0\\n\\n ind = 0\\n for label in self.labelList:\\n filename = self.pathLabel + label\\n f = open(filename, 'r')\\n content = f.read().split('\\\\n')\\n for line in content:\\n items = line.split(' ')\\n if items[0] in self.target:\\n tally[items[0]] += 1\\n f.close()\\n if ind % 100 == 0:\\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\\n ind += 1\\n \\n print('[COUNT] done counting targets in dataset')\\n print(tally)\",\n \"def test_find_cycles_one_cycle(self):\\n self._build_sample_graph()\\n # Adding cycle a -> d -> a\\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\\n skill_map = SkillMap.load(self.course)\\n self.assertEqual(6, len(skill_map.skills()))\\n successors = skill_map.build_successors()\\n self.assertEqual(\\n sorted(SkillMapMetrics(skill_map).simple_cycles()[0]),\\n [self.sa.id, self.sd.id])\",\n \"def has_homolgs(target_seq, known_seqs):\\n for k_seq in known_seqs:\\n alignment = align.globalxx(target_seq, k_seq)[0] # Generates and selects the alignment with the best score\\n aln_seq_1 = alignment[0] # Get the first sequence of the alignment (with - as gaps )\\n aln_seq_2 = alignment[1] # Get the second one\\n al_length = len(alignment[0])\\n ident = sum(base1 == base2 for base1, base2 in zip(aln_seq_1, aln_seq_2)) # Calculate number of identities\\n if ident/al_length >= 0.95: # If 95% of identity, return known sequence\\n return k_seq\",\n \"def countingPointMutations(seq1, seq2):\\n seqLength = len(list(seq1))\\n \\n hammingDistance=0;\\n for i in range(0,seqLength):\\n if list(seq1)[i]!=list(seq2)[i]:\\n hammingDistance = hammingDistance+1;\\n return hammingDistance\",\n \"def predict_hydrophobic_length( targets ):\\n\\n\\t# Steps of this script\\n\\t# 1. read all of the targets in as a long list of oriented PDB files\\n\\t# 2. add the membrane framework\\n\\t# 3. Backwards compute for t range 0-30 what \\n\\t# 4. \\n\\t# 5. \",\n \"def test_find_cycles_multiple_cycles(self):\\n self._build_sample_graph()\\n # Adding cycle a -> d -> a\\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\\n # Adding cycle g -> h -> g\\n sg = self.skill_graph.add(Skill.build('g', ''))\\n sh = self.skill_graph.add(Skill.build('h', ''))\\n self.skill_graph.add_prerequisite(sg.id, sh.id)\\n self.skill_graph.add_prerequisite(sh.id, sg.id)\\n\\n expected = [[self.sa.id, self.sd.id], [sg.id, sh.id]]\\n skill_map = SkillMap.load(self.course)\\n successors = skill_map.build_successors()\\n result = SkillMapMetrics(skill_map).simple_cycles()\\n self.assertEqual(len(result), len(expected))\\n for cycle in result:\\n self.assertIn(sorted(cycle), expected)\",\n \"def question2():\\n \\n # load sequences and scoring matrix\\n score_matrix = read_scoring_matrix(PAM50_URL)\\n human_seq = \\\"HSGVNQLGGVFVNGRPLPDSTRQKIVELAHSGARPCDISRILQVSNGCVSKILGRYYETGSIRPRAIGGSKPRVATPEVVSKIAQYKRECPSIFAWEIRDRLLSEGVCTNDNIPSVSSINRVLRNLASEKQQ\\\"\\n frfly_seq = \\\"HSGVNQLGGVFVGGRPLPDSTRQKIVELAHSGARPCDISRILQVSNGCVSKILGRYYETGSIRPRAIGGSKPRVATAEVVSKISQYKRECPSIFAWEIRDRLLQENVCTNDNIPSVSSINRVLRNLAAQKEQQ\\\"\\n consensus_pax = read_protein(CONSENSUS_PAX_URL)\\n \\n # compute human and fruitfly global alignment matrix with consensus pax\\n human_align_matrix = student.compute_alignment_matrix(human_seq, consensus_pax, score_matrix, True)\\n frfly_align_matrix = student.compute_alignment_matrix(frfly_seq, consensus_pax, score_matrix, True)\\n \\n # compute human and fruitfly global alignment sequences\\n score_human, human_align, consensus_align = student.compute_global_alignment(human_seq, consensus_pax, \\n score_matrix, human_align_matrix)\\n score_fly, frfly_align, consensus_align_2 = student.compute_global_alignment(frfly_seq, consensus_pax,\\n score_matrix, frfly_align_matrix)\\n \\n # compute percentages match for human and fruitfly\\n human_count = 0.0\\n for index in range(len(human_align)):\\n if human_align[index] == consensus_align[index]:\\n human_count += 1\\n \\n frfly_count = 0.0\\n for index in range(len(frfly_align)):\\n if frfly_align[index] == consensus_align_2[index]:\\n frfly_count += 1\\n \\n print \\\"% Human: \\\" + str(human_count / len(human_align) * 100)\\n print \\\"Hmn: \\\" + human_align\\n print \\\"PAX: \\\" + consensus_align\\n \\n print \\\"\\\"\\n \\n print \\\"% FrFly: \\\" + str(frfly_count / len(frfly_align) * 100)\\n print \\\"Fly: \\\" + frfly_align\\n print \\\"PAX: \\\" + consensus_align_2\",\n \"def _count_discordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\\n return torch.cat([_discordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)\",\n \"def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\\n \\n # Chapter Text - stokenize\\n StokensCT = stokenize(ChapterTextS, StopWords) \\n\\n # Test question - stokenize\\n StokensTest = stokenize(TestS, StopWords)\\n\\n # Knowledge Base Dict - stokenize\\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\\n\\n # List (because list is mutable, set is not) of all stokens in document\\n StokensDoc = StokensCT[:] # from chapter text\\n StokensDoc.extend(StokensTest[:]) # += Test string\\n\\n # extend list of stokens in Doc\\n for i in TargetQuestionsD:\\n StokensDoc.extend(TargetQuestionsD[i][\\\"mq stokens\\\"][:]) # += KB target [matched Q]s\\n StokensDoc.extend(TargetQuestionsD[i][\\\"ans stokens\\\"][:]) # += KB answers\\n \\n StokensTestV = set(StokensTest)\\n StokensDocV = set(StokensDoc)\\n StokensAntiTgtV = StokensDocV\\n \\n # Complement of all targets\\n for i in TargetQuestionsD:\\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\\\"mq stokens\\\"]))\\n \\n # calculate confusion matrix and DOR etc.\\n LnDORD = {}\\n # Anti Target\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN) \\n \\n LnDORD[\\\"AntiTgt\\\"] = {'lndor': LnDOR, 'theta': someAngle}\\n\\n # total occurences\\n total_occ = 0\\n for i in TargetQuestionsD:\\n total_occ += TargetQuestionsD[i]['count']\\n\\n for i in TargetQuestionsD:\\n StokensTgtV = set(TargetQuestionsD[i][\\\"mq stokens\\\"][:])\\n\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \\n priorOR = TargetQuestionsD[i]['count'] / total_occ\\n\\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \\n \\n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \\\"AntiTgt\\\"\\n\\n return LnDORD\",\n \"def test_find_cycles_not_conected(self):\\n self._build_sample_graph()\\n # Adding cycle g -> h -> g\\n sg = self.skill_graph.add(Skill.build('g', ''))\\n sh = self.skill_graph.add(Skill.build('h', ''))\\n self.skill_graph.add_prerequisite(sg.id, sh.id)\\n self.skill_graph.add_prerequisite(sh.id, sg.id)\\n skill_map = SkillMap.load(self.course)\\n expected0 = [sg.id, sh.id]\\n successors = skill_map.build_successors()\\n result = SkillMapMetrics(skill_map).simple_cycles()\\n self.assertEqual(sorted(result[0]), expected0)\",\n \"def extract_number_target_genes2(d, g, miranda_fnm):\\n\\tprint 'extract targets genes2'\\n\\toutput_nm = \\\"%s_counts2.txt\\\"%(miranda_fnm[:-4])\\n\\toutput = open(output_nm, 'w')\\n\\toutput.write(\\\"miRNA\\\\ttotal_target_genes\\\\ttarget_genes_down\\\\ttarget_genes\\\\n\\\")\\n\\tfor key in d:\\n\\t\\tif len(d[key]) > 0:\\n\\t\\t\\t#print key, len(d[key])\\n\\t\\t\\toutput.write(\\\">>%s\\\\t%s\\\\t%s\\\\n\\\"%(key, len(d[key]),len(g[key])))\\n\\t\\t\\tfor gene in g[key]:\\n\\t\\t\\t\\t#print gene\\n\\t\\t\\t\\toutput.write(\\\"%s\\\\n\\\"%(gene[0]))\\n\\n\\toutput.close()\",\n \"def solve_p1_v1(target: int) -> int:\\n\\n elves = DeliveryService()\\n\\n house, n_presents = 0, 0\\n while n_presents < target:\\n house += 1\\n n_presents = elves.visit(house)\\n print(house, n_presents)\\n\\n return house\",\n \"def test_merge_targets():\\n uid1 = \\\"ACCT\\\"\\n uid2 = \\\"GGGG\\\"\\n uid3 = \\\"AAGG\\\"\\n\\n seq1 = [\\\"ACTGTTTGTCTAAGC\\\"]*2\\n qual1 = ['I'*len(seq1[0])]*len(seq1)\\n seq2 = [\\\"ACTGTTTTTCTAAGC\\\"]*5\\n qual2 = ['I'*len(seq2[0])]*len(seq2)\\n seq3 = [\\\"ACTGTTTTTCTAAGC\\\"]*2\\n qual3 = ['I'*len(seq3[0])]*len(seq3)\\n\\n clusters = create_consensus([uid1 + uid1]*len(seq1) + \\\\\\n [uid2 + uid2]*len(seq2),\\n ['I'*(len(uid1)*2)]*(len(seq1) + len(seq2)),\\n seq1 + seq2, qual1 + qual2)\\n seq3 = [pseq.SequenceWithQuality(seq, qual) for seq, qual in zip(seq3, qual3)]\\n uid = pseq.SequenceWithQuality(uid2 + uid3, 'I'*(len(uid2) + len(uid3)))\\n cand = clusters.merge_target(uid, seq3[0], {}, 2)\\n assert cand == uid2 + uid2, \\\"%r != %r\\\" % (cand, uid2 + uid2)\\n cand = clusters.merge_target(uid, seq3[0], {}, 1)\\n assert cand is None, \\\"%r != %r\\\" % (cand, None)\",\n \"def test_target_greater_than_alp(self):\\n alp = list(range(5))\\n targets = generate_targets(alp, 10)\\n self.assertEqual(len(targets), 10)\\n\\n counts = Counter(targets)\\n\\n for item in alp:\\n self.assertEqual(counts[item], 2)\",\n \"def getNumMarkedTargets(self):\\n return len(self.getConTextModeNodes(\\\"target\\\"))\",\n \"def getNumMarkedTargets(self):\\n return len(self.getConTextModeNodes(\\\"target\\\"))\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = no_communication_skar(d, source, target, others)\\n return uniques\",\n \"def sim_stop_counts(simulations, seqs, dinucleotide_content, nucleotide_content, temp_dir, seeds=None, seq_seeds=None):\\n\\n temp_files = []\\n\\n dinucleotide_choices = [dn for dn in sorted(dinucleotide_content)]\\n dinucleotide_probabilities = [dinucleotide_content[dn] for dn in sorted(dinucleotide_content)]\\n nucleotide_choices = [n for n in sorted(nucleotide_content)]\\n nucleotide_probabilities = [nucleotide_content[n] for n in sorted(nucleotide_content)]\\n\\n for sim_no, simulation in enumerate(simulations):\\n\\n # set the seed\\n set_seed(seeds, simulation)\\n\\n # print the simulation number out\\n gen.print_simulation(sim_no+1, simulations)\\n\\n simulated_seqs = {}\\n # Generate a list of nucleotide matched sequences\\n for i, name in enumerate(seqs):\\n seq = seqs[name]\\n generated = False\\n\\n seq_seed = get_seq_seed(seq_seeds, sim_no, i)\\n\\n while not generated:\\n sim_seq = seqo.generate_nt_matched_seq(seq, dinucleotide_choices, dinucleotide_probabilities, nucleotide_choices, nucleotide_probabilities, seed=seq_seed)\\n if sim_seq not in simulated_seqs:\\n generated = True\\n simulated_seqs[name] = sim_seq\\n\\n stop_counts = seqo.get_stop_counts(simulated_seqs)\\n temp_file = \\\"{0}/{1}.{2}.txt\\\".format(temp_dir, random.random(), simulation+1)\\n temp_files.append(temp_file)\\n with open(temp_file, \\\"w\\\") as temp:\\n for name in stop_counts:\\n temp.write(\\\">{0}\\\\n{1}\\\\n\\\".format(name, stop_counts[name]))\\n\\n return temp_files\",\n \"def choose_target(self, agents):\\n\\n number_of_suspects = [0]*(len(agents))\\n number_of_suspects_per_agent = []\\n\\n index = 0\\n for a1 in agents:\\n if not a1.is_impostor():\\n for a2 in agents:\\n if self.km.suspects(a1.agent_id, a2.agent_id):\\n number_of_suspects[index] = number_of_suspects[index] + 1\\n else:\\n number_of_suspects[index] = 999999\\n number_of_suspects_per_agent.append((a1.agent_id,number_of_suspects[index]))\\n index = index + 1\\n\\n self.target = min(number_of_suspects_per_agent, key = lambda t: t[1])[0]\",\n \"def sim_motif_stop_counts(simulations, seqs, dinucleotide_content, nucleotide_content, temp_dir, seeds=None, seq_seeds=None):\\n\\n temp_files = []\\n\\n dinucleotide_choices = [dn for dn in sorted(dinucleotide_content)]\\n dinucleotide_probabilities = [dinucleotide_content[dn] for dn in sorted(dinucleotide_content)]\\n nucleotide_choices = [n for n in sorted(nucleotide_content)]\\n nucleotide_probabilities = [nucleotide_content[n] for n in sorted(nucleotide_content)]\\n\\n for sim_no, simulation in enumerate(simulations):\\n\\n # set the seed\\n set_seed(seeds, simulation)\\n\\n # print the simulation number out\\n gen.print_simulation(sim_no+1, simulations)\\n\\n simulated_seqs = []\\n # Generate a list of nucleotide matched sequences\\n for i, seq in enumerate(seqs):\\n generated = False\\n seq_seed = get_seq_seed(seq_seeds, sim_no, i)\\n\\n while not generated:\\n sim_seq = seqo.generate_nt_matched_seq(seq, dinucleotide_choices, dinucleotide_probabilities, nucleotide_choices, nucleotide_probabilities, seed=seq_seed)\\n if sim_seq not in simulated_seqs:\\n generated = True\\n simulated_seqs.append(sim_seq)\\n\\n stop_counts = seqo.get_stop_counts(simulated_seqs)\\n temp_file = \\\"{0}/{1}.{2}.txt\\\".format(temp_dir, random.random(), simulation+1)\\n temp_files.append(temp_file)\\n with open(temp_file, \\\"w\\\") as temp:\\n temp.write(\\\">{0}\\\\n{1}\\\\n\\\".format(simulation+1, sum(stop_counts)))\\n\\n return temp_files\",\n \"def GetTargetDepdency(self, target):\\n return self._dependencies[target].strip()\",\n \"def calculate_ec_targets_used(oclass, total_targets):\\n data_shards, parity_shards, group_number = get_ec_data_parity_group(oclass)\\n group_size = data_shards + parity_shards\\n if group_number in ('x', 'X'):\\n group_number = max(1, total_targets // group_size)\\n return group_size * int(group_number)\",\n \"async def recommendations(self, target: int) -> dict:\\n plan = self.plan\\n requested = self.requested\\n observed = self.observed\\n\\n if target == len(plan):\\n self.close_counts.clear()\\n return {\\\"status\\\": \\\"same\\\"}\\n\\n if target > len(plan):\\n self.close_counts.clear()\\n return {\\\"status\\\": \\\"up\\\", \\\"n\\\": target}\\n\\n # target < len(plan)\\n not_yet_arrived = requested - observed\\n to_close = set()\\n if not_yet_arrived:\\n to_close.update(toolz.take(len(plan) - target, not_yet_arrived))\\n\\n if target < len(plan) - len(to_close):\\n L = await self.workers_to_close(target=target)\\n to_close.update(L)\\n\\n firmly_close = set()\\n for w in to_close:\\n self.close_counts[w] += 1\\n if self.close_counts[w] >= self.wait_count:\\n firmly_close.add(w)\\n\\n for k in list(self.close_counts): # clear out unseen keys\\n if k in firmly_close or k not in to_close:\\n del self.close_counts[k]\\n\\n if firmly_close:\\n return {\\\"status\\\": \\\"down\\\", \\\"workers\\\": list(firmly_close)}\\n else:\\n return {\\\"status\\\": \\\"same\\\"}\",\n \"def test_remainder(self):\\n alp = list(range(5))\\n targets = generate_targets(alp, 12)\\n\\n counts = Counter(targets)\\n for item in alp:\\n self.assertGreaterEqual(counts[item], 2)\\n self.assertLessEqual(counts[item], 3)\",\n \"def extract_number_target_genes(d, g, miranda_fnm):\\n\\toutput_nm = \\\"%s_counts.txt\\\"%(miranda_fnm[:-4])\\n\\toutput = open(output_nm, 'w')\\n\\toutput.write(\\\"miRNA\\\\ttotal_target_genes\\\\ttarget_genes_down\\\\ttarget_genes\\\\n\\\")\\n\\tfor key in d:\\n\\t\\tif len(d[key]) > 0:\\n\\t\\t\\t#print key, len(d[key])\\n\\t\\t\\toutput.write(\\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\n\\\"%(key, len(d[key]), \\n\\t\\t\\t\\tlen(g[key]), str(g[key]).strip('[]')))\\n\\n\\toutput.close()\",\n \"def classifyDocumentTargets(context, allow_uncertainty=False):\\n rslts = {}\\n alerts = {}\\n cntxt = context\\n cntxt.computeDocumentGraph()\\n g = cntxt.getDocumentGraph()\\n targets = [n[0] for n in g.nodes(data = True) if n[1].get(\\\"category\\\",\\\"\\\") == 'target']\\n \\n if( not targets ):\\n return alerts,rslts\\n if(allow_uncertainty):\\n pos_filters = [\\\"definite_existence\\\",\\\"probable_existence\\\"]#[\\\"PROBABLE_NEGATED_EXISTENCE\\\",\\\"DEFINITE_NEGATED_EXISTENCE\\\"]#\\n else:\\n pos_filters = [\\\"definite_existence\\\"]\\n for t in targets:\\n mods = g.predecessors(t)\\n tL = t.getLiteral()\\n rslts[tL] = {}\\n if( not mods ): # an unmodified target is disease positive,certain, and acute \\n rslts[tL]['disease'] = 'Pos'\\n rslts[tL]['uncertainty'] = 'No'\\n rslts[tL]['temporality'] = 'New'\\n rslts[tL]['experiencer'] = 'Patient'\\n else:\\n if ((modifies(g,t,pos_filters) and not modifies(g,t,[\\\"future\\\",\\\"indication\\\",\\\"pseudoneg\\\"]))):\\n rslts[tL]['disease'] = 'Pos'\\n elif(modifies(g,t,[\\\"probables\\\",\\n \\\"probableNegations\\\"]) ):\\n rslts[tL]['disease'] = 'Probable'\\n else:\\n rslts[tL]['disease'] = 'Neg'\\n if( modifies(g,t,[\\\"probable_existence\\\",\\n \\\"probable_negated_existence\\\"]) ):\\n rslts[tL]['uncertainty'] = 'Yes'\\n else:\\n rslts[tL]['uncertainty'] = 'No'\\n if (modifies(g,t,[\\\"historical\\\"]) ):\\n rslts[tL]['temporality'] = 'Old'\\n elif(modifies(g,t,[\\\"hypothetical\\\"])):\\n if rslts[tL]['disease']=='Neg':\\n rslts[tL]['temporality'] = 'Hypothetical'\\n else: ## disease == pos or probable\\n rslts[tL]['temporality'] = 'New' ## not sure if this is correct\\n else:\\n if (rslts[tL]['disease'] == 'Neg'):\\n rslts[tL]['temporality'] = 'NA'\\n else:\\n rslts[tL]['temporality'] = 'New'\\n \\n if ((modifies(g,t,[\\\"experiencers\\\"])) and not (modifies(g,t,[\\\"pseudoexperiencers\\\"]))):\\n rslts[tL]['experiencer'] = 'Other'\\n else:\\n rslts[tL]['experiencer'] = 'Patient'\\n rsum = alerts.get(t.getCategory(),0)\\n if( rslts[tL][\\\"disease\\\"] == 'Pos' and rslts[tL][\\\"temporality\\\"] == 'New'):\\n alert = 1\\n else:\\n alert = 0\\n rsum = max(rsum,alert)\\n alerts[t.getCategory()] = rsum\\n \\n\\n return rslts#alerts, \",\n \"def hits_and_misses(guess_seq, true_seq):\\n num_hits = sum(guess_token == true_token\\n for guess_token, true_token\\n in zip(guess_seq, true_seq))\\n num_misses = sum((Counter(guess_seq) & Counter(true_seq)).values()) - num_hits\\n return num_hits, num_misses\",\n \"def get_target_proportions_of_current_trial(individuals, target):\\n ambulance_waits, ambulance_target_waits = 0, 0\\n other_waits, other_target_waits = 0, 0\\n for individual in individuals:\\n ind_class = len(individual.data_records) - 1\\n rec = individual.data_records[-1]\\n if rec.node == 2 and ind_class == 0:\\n other_waits += 1\\n if rec.waiting_time < target:\\n other_target_waits += 1\\n elif rec.node == 2 and ind_class == 1:\\n ambulance_waits += 1\\n if rec.waiting_time < target:\\n ambulance_target_waits += 1\\n\\n return ambulance_waits, ambulance_target_waits, other_waits, other_target_waits\",\n \"def test_get_diagnose(self):\\n self._build_sample_graph()\\n # Adding cycle a -> d -> a\\n self.skill_graph.add_prerequisite(self.sa.id, self.sd.id)\\n # Adding singleton\\n sg = self.skill_graph.add(Skill.build('g', ''))\\n skill_map = SkillMap.load(self.course)\\n result = SkillMapMetrics(skill_map).diagnose()\\n expected = {\\n 'cycles': [[self.sd.id, self.sa.id]],\\n 'singletons': [sg.id],\\n 'long_chains': []\\n }\\n self.assertEqual(result, expected)\",\n \"def get_generalized_targets_distances(generalized_targets, board):\\n representative = generalized_targets[0]\\n sm = 0\\n for i in range(1, len(generalized_targets)):\\n cur_gen_target = generalized_targets[i]\\n sm += representative.get_distance(board, cur_gen_target)\\n return sm\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = two_way_skar(d, [source, target], others)\\n return uniques\",\n \"def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)\",\n \"def test_target_number_less_than_alp(self):\\n alp = list(range(10))\\n targets = generate_targets(alp, 5)\\n self.assertEqual(len(targets), 5)\\n self.assertEqual(len(targets), len(set(targets)))\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, source, target, others)\\n return uniques\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, target, source, others)\\n return uniques\",\n \"def solvePostNoOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains as many dummy targets as defenders, for defenders and attackers\\\"\\\"\\\"\\n # Add the extra dummy targets\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n for defenderCount in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n attackerActions = targetRange\\n # Get the suggestions that occur with no overlap\\n overlapPlacements = getPlacements(defenders, targetNumWithDummies)\\n placements = list(filter(lambda x: len(set(x)) == len(x), overlapPlacements))\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Build the model\\n model = Model('PrimalWithOverlap')\\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\\\"w\\\")\\n objectiveFunction = sum([q[lam] * sum([w[s,a,lam] * defenderSocialUtility(s,a,defenders,_dRewards,_dCosts,_dPenalties) for s in placements for a in attackerActions]) for lam in aTypes])\\n c1 = [sum([w[s,a,lam] * aUtility(s,a,lam,_aPenalties,_aRewards) for s in placements]) \\\\\\n >= sum([w[s,a,lam] * aUtility(s,b,lam,_aPenalties,_aRewards) for s in placements])\\n for lam in aTypes for a in attackerActions for b in attackerActions if a != b]\\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\\n c1 = model.add_constraints(c1)\\n c2 = model.add_constraints([sum([q[lam] * sum([w[s,a,lam] * utilityM(d,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes]) \\\\\\n >= sum([q[lam] * sum([w[s,a,lam] * utilityM(e,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes])\\n for m in defenders for d in targetRange for e in targetRange if d!=e])\\n c3 = model.add_constraints([sum([w[(s,a,lam)] for s in placements for a in attackerActions]) == 1 for lam in aTypes])\\n # Solve the model\\n model.maximize(objectiveFunction)\\n model.solve()\\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\\n utilityPerAttacker = 0\\n for k,v in w.items():\\n prob = float(v)\\n s,a,lam = k\\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\\n utilityPerAttacker /= len(aTypes)\\n utilityPerDefender = model.solution.get_objective_value()\\n utilityPerDefender /= len(defenders)\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def test_counts(contrib_data):\\n ## Find the probands - they should always contribute their own alleles\\n P = ped.Pedigree(args.pedfile)\\n\\n ## TODO: Test individuals with multiple offspring +p2 id:112\\n ## Case when no regions are specified - only all probands\\n regions = contrib_data.keys()\\n if len(regions) == 1:\\n all_contribs = contrib_data[regions[0]]\\n for prob in P.probands:\\n ## Probands should always contribute 1 allele\\n assert all_contribs[prob, 1] == args.iterations\\n\\n ## Test specific individuals\\n counts = Counter(all_contribs[11])\\n binomial_sd = np.sqrt(args.iterations * 0.25)\\n mean = np.mean(counts.values())\\n conf95 = (mean - 2 * binomial_sd, mean + 2 * binomial_sd)\\n\\n for count in counts.values():\\n assert conf95[0] < count < conf95[1]\",\n \"def kmer_distance(seq1,seq2,k=3):\\n seq1_set = set(count_kmers(seq1,k).keys())\\n seq2_set = set(count_kmers(seq2,k).keys())\\n union_seq = seq1_set.union(seq2_set)\\n dissimilarity = seq1_set ^ seq2_set\\n distance = len(dissimilarity)/len(union_seq)\\n print(dissimilarity)\\n return distance\",\n \"def count_targets(searchList):\\n targets = {}\\n for x in searchList:\\n loVal = -10000 - x\\n hiVal = 10000 - x\\n loInd = bisect_left(searchList, loVal)\\n hiInd = bisect_right(searchList, hiVal)\\n for y in searchList[loInd:hiInd]:\\n if y == x:\\n continue\\n t = x + y\\n targets[t] = 1\\n return len(targets)\",\n \"def find_solution_count(target, max_coin=None):\\n if target == 0:\\n return 1\\n if max_coin is None:\\n max_coin = 200\\n key = '%d_%d' % (target, max_coin)\\n if key in seen:\\n return seen[key]\\n count = 0\\n for coin in DENOMINATIONS:\\n if coin > max_coin:\\n continue\\n if coin <= target:\\n count += find_solution_count(target - coin, coin)\\n seen[key] = count\\n return count\",\n \"def solve_p1_v2(target: int) -> int:\\n house, n_presents = 0, 0\\n while n_presents < target:\\n house += 1\\n n_presents = 0\\n for elf in range(1, 1+house):\\n if house % elf == 0:\\n n_presents += 10*elf\\n if DEBUG and house % 10000 == 0:\\n print(f\\\"House: {house} got {n_presents}\\\")\\n return house\",\n \"def get_diseases(self):\\n self.diseases = self.data.groupby('topic')['topic'].count()\",\n \"def test(output_seq,M1,M2,M3,obs_file):\\n predicted = []\\n mus_c = 0\\n mod_c = 0\\n arn_c = 0\\n next = 0\\n t = 0.000\\n d=dict()\\n d[\\\"other\\\"]=0\\n d[\\\"modi\\\"]=0\\n d[\\\"arnab\\\"]=0\\n print(obs_file+\\\":\\\")\\n for obs in output_seq:\\n p1 = M1.forward(obs)\\n p2 = M2.forward(obs)\\n p3 = M3.forward(obs)\\n\\n\\n if(p1 > p2 and p1 > p3):\\n predicted.append(\\\"Other\\\")\\n mus_c+=1\\n d[\\\"other\\\"]+=1\\n elif(p2 > p3 and p2 > p1):\\n predicted.append(\\\"Modi\\\")\\n mod_c+=1\\n d[\\\"modi\\\"]+=1\\n else:\\n predicted.append(\\\"Arnab\\\")\\n arn_c+=1\\n d[\\\"arnab\\\"]+=1\\n t+=0.05\\n next+=1\\n\\n if(next % 20 == 0):\\n p_other = d[\\\"other\\\"]/20.0\\n p_modi = d[\\\"modi\\\"]/20.0\\n p_arnab = d[\\\"arnab\\\"]/20.0\\n #print(\\\"{0} : Modi = {1}, Arnab = {2}, Other = {3}\\\".format(t,p_modi,p_arnab,p_other))\\n if p_other>p_modi and p_other>p_arnab:\\n print \\\"{0} : Speech : Other\\\".format(t)\\n elif p_modi>p_other and p_modi>p_arnab:\\n print \\\"{0} : Speech : Modi\\\".format(t)\\n else:\\n print \\\"{0} : Speech : Arnab\\\".format(t)\\n d[\\\"other\\\"]=0\\n d[\\\"modi\\\"]=0\\n d[\\\"arnab\\\"]=0\\n\\n time = 0.000\\n with open(\\\"op_\\\"+obs_file,\\\"w\\\") as g:\\n for val in predicted:\\n g.write(str(time)+\\\" :\\\\t\\\"+val+\\\"\\\\n\\\")\\n time+=0.005\\n\\n return predicted\",\n \"def test_input_target_different():\\n for day in range(len(departure_cameras)):\\n which_targets_day = which_targets[day]\\n when_targets_day = when_targets[day]\\n where_targets_day = where_targets[day]\\n departure_cameras_day = departure_cameras[day]\\n # Which\\n for departure_camera, target in zip(departure_cameras_day, which_targets_day):\\n entrance_cameras = np.argwhere(target == 1) + 1\\n assert departure_camera not in entrance_cameras\\n # When\\n for departure_camera, when_target in zip(departure_cameras_day, when_targets_day):\\n target = when_target.sum(axis=1) > 1\\n entrance_cameras = np.argwhere(target == 1) + 1\\n assert departure_camera not in entrance_cameras\\n # Where\\n for departure_camera, where_target in zip(departure_cameras_day, where_targets_day):\\n target = where_target.sum(axis=3).sum(axis=2).sum(axis=1) > 1\\n entrance_cameras = np.argwhere(target == 1) + 1\\n assert departure_camera not in entrance_cameras\",\n \"def test_measure_deterministic_with_sampling(self):\\n shots = 100\\n circuits = ref_measure.measure_circuits_deterministic(allow_sampling=True)\\n targets = ref_measure.measure_counts_deterministic(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def test_which_targets():\\n num_multi_targets = 0\\n for which_targets_day in which_targets:\\n # All inputs have a label\\n assert np.all(which_targets_day.sum(axis=1) > 0)\\n # No inputs have more than 3 targets\\n assert np.all(which_targets_day.sum(axis=1) < 4)\\n\\n num_multi_targets += np.sum(which_targets_day.sum(axis=1) > 1)\\n\\n # Some days have multi-targets\\n assert num_multi_targets > 0\",\n \"def train(self, documents):\\n ###DONE\\n\\n #entire vocab in document set D\\n vocab_sod = set()\\n vocab_pop = set()\\n \\n #Calcuates prior probabilities\\n priorSOD = 0 #how many docs are spam\\n priorPOP = 0 #how many docs are ham\\n \\n #Cacluates Tct\\n term_freq_sod = {} #{term:occur, term:occur}\\n term_freq_pop = {}\\n \\n #Tct'\\n Tct_sod = 0 #Tct' = sum of (every term occurence in class c + 1)\\n Tct_pop = 0\\n \\n for doc in documents: \\n if 'sod' in doc.label:\\n priorSOD += 1\\n for token in doc.tokens:\\n Tct_sod += 1\\n if token in term_freq_sod.keys():\\n term_freq_sod[token] = term_freq_sod[token] + 1\\n else:\\n term_freq_sod[token] = 1\\n vocab_sod.add(token) \\n else:\\n priorPOP += 1\\n for token in doc.tokens:\\n Tct_pop += 1\\n if token in term_freq_pop.keys():\\n term_freq_pop[token] = term_freq_pop[token] + 1\\n else:\\n term_freq_pop[token] = 1\\n vocab_pop.add(token)\\n \\n \\n #endfor\\n # | is for set join\\n self.vocab = vocab_sod | vocab_pop #gets rid of duplicate words (those in both 'ham' and 'spam') \\n \\n #Tct Primes\\n #tct' = term freq of all terms in class c + 1*(total terms)\\n Tct_sod = Tct_sod + len(self.vocab) \\n Tct_pop = Tct_pop + len(self.vocab) \\n \\n \\n print(\\\"PriorSod: \\\" + str(priorSOD))\\n print(\\\"PriorPop: \\\" + str(priorPOP))\\n print(\\\"LEN Docum: \\\" + str(len(documents)))\\n \\n self.priorSOD = priorSOD / len(documents)\\n self.priorPOP = priorPOP / len(documents)\\n \\n for term in self.vocab:\\n if term in term_freq_pop.keys():\\n self.cond_prob_pop[term] = (term_freq_pop[term] + 1) / Tct_pop\\n else:\\n self.cond_prob_pop[term] = 1 / Tct_pop\\n \\n if term in term_freq_sod.keys():\\n self.cond_prob_sod[term] = (term_freq_sod[term] + 1) / Tct_sod\\n else:\\n self.cond_prob_sod[term] = 1 / Tct_sod\\n \\n \\n pass\",\n \"def test_find_cycles_no_cycle(self):\\n self._build_sample_graph()\\n skill_map = SkillMap.load(self.course)\\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])\",\n \"def find_mutual_nn(self):\\n best_match_src = self.scores.argmax(1) # Best match for each source word\\n best_match_trg = self.scores.argmax(0) # Best match for each source word\\n\\n # ONELIENER\\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\\n paired = []\\n for i in range(self.ns):\\n m = best_match_src[i]\\n if best_match_trg[m] == i:\\n paired.append((i,m))\\n\\n paired_toks = []\\n if self.src_words and self.trg_words:\\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\\n else:\\n paired_toks = paired\\n return paired_toks\",\n \"def get_target_per_score(self):\\n pass\",\n \"def get_closeness(pats,seq_dict,isdiagonal=False,log=False):\\n similarities= np.zeros((len(pats),len(pats)))\\n intersectCount = np.zeros((len(pats),len(pats)))\\n for i,patI in enumerate(pats):\\n seqsI=list(zip(*seq_dict[patI]))[1]\\n for j,patJ in enumerate(pats):\\n seqsJ=list(zip(*seq_dict[patJ]))[1]\\n if isdiagonal and i!=j: continue\\n if j>i: continue\\n if i==j and len(seqsI) < clim:\\n similarities[i][j]=0\\n continue\\n keys1=set(list(zip(*seq_dict[pats[i]]))[0])\\n keys2=set(list(zip(*seq_dict[pats[j]]))[0])\\n intersectCount[i][j] = len(list(keys1 & keys2))\\n random_score=get_random_score(seqsI,seqsJ,nsample=10)\\n identical_score=get_identical_score(seqsI,seqsJ)\\n score=0.0\\n norm=0\\n if mixvec:\\n vecI=_seqs2vec(seqsI)\\n vecJ=_seqs2vec(seqsJ)\\n score=get_subscore_mixvec(vecI,vecJ)\\n else:\\n score=get_subscore_pairwise(list(seqsI),list(seqsJ)) \\n print \\\"idscore (max):\\\", round(identical_score,4), \\\"randscore (min):\\\", round(random_score,4), \\\"score:\\\", round(score,4)\\n if log: similarity = -math.log(1-((float(score)-float(random_score))/(float(identical_score)-float(random_score))))\\n else: similarity = ((float(score)-float(random_score))/(float(identical_score)-float(random_score)))\\n similarities[i][j]= similarity\\n similarities[j][i]= similarity\\n print patI,patJ,similarity\\n dfDists=pd.DataFrame(similarities,columns=pats,index=pats)\\n dfCount=pd.DataFrame(intersectCount,columns=pats,index=pats)\\n return dfDists, dfCount\",\n \"def test_measure_deterministic_multi_qubit_without_sampling(self):\\n shots = 100\\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=False)\\n qobj.config.shots = shots\\n circuits = [experiment.header.name for experiment in qobj.experiments]\\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\\n job = QasmSimulator().run(qobj)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def test_measure_deterministic_multi_qubit_with_sampling(self):\\n shots = 100\\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=True)\\n qobj.config.shots = shots\\n circuits = [experiment.header.name for experiment in qobj.experiments]\\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\\n job = QasmSimulator().run(qobj)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def solveExNoOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains as many dummy targets as defenders, for defenders and attackers\\\"\\\"\\\"\\n \\\"\\\"\\\"In this game the attacker and defender reason ex-ante\\n (they choose to follow signals or not before a signal is sent).\\\"\\\"\\\"\\n # Add the extra dummy targets\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n for defenderCount in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n attackerActions = targetRange\\n # Get the suggestions that occur with no overlap\\n overlapPlacements = getPlacements(defenders, targetNumWithDummies)\\n placements = list(filter(lambda x: len(set(x)) == len(x), overlapPlacements))\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Build the model\\n model = Model('ExAnteWithOverlap')\\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\\\"w\\\")\\n objectiveFunction = sum([q[lam] * sum([w[sd,sa,lam] * defenderSocialUtility(sd,sa,defenders,_dRewards,_dCosts,_dPenalties) for sd in placements for sa in attackerActions]) for lam in aTypes])\\n # Define the constraints\\n c1 = [sum([w[sd,sa,lam] * aUtility(sd,sa,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions]) \\\\\\n >= sum([w[sd,sa,lam] * aUtility(sd,tPrime,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions])\\n for lam in aTypes for tPrime in targetRange]\\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\\n c2 = [sum([q[lam] * sum([w[sd,sa,lam] * utilityM(sd[d],sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\\\\n >= sum([q[lam] * sum([w[sd,sa,lam] * utilityM(tPrime,sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\\\\n for d in defenders for tPrime in targetRange]\\n c3 = [sum([w[sd,sa,lam] for sd in placements for sa in attackerActions]) == 1\\n for lam in aTypes]\\n # Add the constraints\\n c1 = model.add_constraints(c1)\\n c2 = model.add_constraints(c2)\\n c3 = model.add_constraints(c3)\\n # Solve the model\\n model.maximize(objectiveFunction)\\n model.solve()\\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\\n utilityPerAttacker = 0\\n for k,v in w.items():\\n prob = float(v)\\n s,a,lam = k\\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\\n utilityPerAttacker /= len(aTypes)\\n utilityPerDefender = model.solution.get_objective_value()\\n utilityPerDefender /= len(defenders)\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def get_hint(target, scores, users_visited):\\n target = target.data.cpu().numpy()\\n val, idxx = scores.data.topk(1, 1)\\n predx = idxx.cpu().numpy()\\n hint = np.zeros((3,))\\n count = np.zeros((3,))\\n count[0] = len(target)\\n for i, p in enumerate(predx):\\n t = target[i]\\n if t == p[0] and t > 0:\\n hint[0] += 1\\n if t in users_visited:\\n count[1] += 1\\n if t == p[0] and t > 0:\\n hint[1] += 1\\n else:\\n count[2] += 1\\n if t == p[0] and t > 0:\\n hint[2] += 1\\n return hint, count\",\n \"def solve_p2(target: int) -> int:\\n mh = 1 + int(target / 10)\\n npresents = [0] * mh\\n for elf in range(1, mh):\\n for h in range(elf, min(mh, elf*50), elf):\\n npresents[h] += 11*elf\\n if DEBUG:\\n print(target, [(i, n) for i, n in enumerate(npresents)])\\n for h, np in enumerate(npresents):\\n if np >= target:\\n return h\\n return -1\",\n \"def analyse_target(target, aligned_path):\\n\\n # Get Target from database\\n target.root_data_directory = relative_to_media_root(aligned_path)\\n target.save()\\n\\n mols = list(Molecule.objects.filter(prot_id__target_id=target))\\n\\n # This can probably be improved to count molecules as they are processed when the code is further refactored\\n mols_processed = len(mols)\\n\\n logger.debug(\\\"Analysing '%s' molecules for '%s'\\\", len(mols), target.title)\\n\\n # Do site mapping\\n if os.path.isfile(os.path.join(aligned_path, 'metadata.csv')):\\n\\n target.metadata.save(\\n os.path.basename(os.path.join(aligned_path, 'metadata.csv')),\\n File(open(os.path.join(aligned_path, 'metadata.csv')))\\n )\\n\\n # remove any existing files so that we don't create a messy file when appending\\n if os.path.isfile(os.path.join(aligned_path, 'hits_ids.csv')):\\n os.remove(os.path.join(aligned_path, 'hits_ids.csv'))\\n\\n if os.path.isfile(os.path.join(aligned_path, 'sites.csv')):\\n os.remove(os.path.join(aligned_path, 'sites.csv'))\\n\\n if os.path.isfile(os.path.join(aligned_path, 'alternate_names.csv')):\\n os.remove(os.path.join(aligned_path, 'alternate_names.csv'))\\n\\n new_frame = pd.read_csv(os.path.join(aligned_path, 'metadata.csv'))\\n new_frame.sort_values(by='site_name', inplace=True)\\n\\n # one file for new names\\n with open(os.path.join(aligned_path, 'alternate_names.csv'), 'a', encoding='utf-8') as f:\\n f.write('name,alternate_name\\\\n')\\n\\n for _, row in new_frame.iterrows():\\n if isinstance(row['alternate_name'], str):\\n crystal_name = row['crystal_name']\\n # find the correct crystal\\n crystal = Protein.objects.filter(code__contains=crystal_name, target_id=target)\\n alternate_name = row['alternate_name']\\n # Only take first part of code\\n for crys in list(set([c.code.split(\\\":\\\")[0] for c in crystal])):\\n f.write(str(crys) + ',' + str(alternate_name) + '\\\\n')\\n\\n # hits and sites files\\n site_mapping = {}\\n unique_sites = list(set(list(new_frame['site_name'])))\\n for i in range(0, len(sorted(unique_sites))):\\n site_mapping[unique_sites[i]] = i\\n\\n with open(os.path.join(aligned_path, 'hits_ids.csv'), 'a', encoding='utf-8') as f:\\n f.write('crystal_id,site_number\\\\n')\\n\\n for _, row in new_frame.iterrows():\\n crystal_name = row['crystal_name']\\n crystal = Protein.objects.filter(code__contains=crystal_name, target_id=target)\\n site = row['site_name']\\n s_id = site_mapping[site]\\n for crys in list(set([c.code for c in crystal])):\\n f.write(str(crys) + ',' + str(s_id) + '\\\\n')\\n\\n with open(os.path.join(aligned_path, 'sites.csv'), 'a', encoding='utf-8') as f:\\n f.write('site,id\\\\n')\\n for key in site_mapping.keys():\\n f.write(str(key) + ',' + str(site_mapping[key]) + '\\\\n')\\n\\n if os.path.isfile(os.path.join(aligned_path, 'hits_ids.csv')) and os.path.isfile(\\n os.path.join(aligned_path, 'sites.csv')):\\n\\n hits_sites = pd.read_csv(os.path.join(aligned_path, 'hits_ids.csv'))\\n sites = pd.read_csv(os.path.join(aligned_path, 'sites.csv'))\\n sites.sort_values(by='site', inplace=True)\\n\\n # Delete the old mol_groups\\n # Note that this will not delete associated MoleculeTags - the tags\\n # will have their mol_group set to Null, but be left on the\\n # database so that any existing Tags will not be broken.\\n mol_groups = MolGroup.objects.filter(target_id=target)\\n for m in mol_groups:\\n m.delete()\\n\\n for _, row in sites.iterrows():\\n description = row['site']\\n number = row['id']\\n logger.debug('Processing user input site: %s', description)\\n matches = []\\n for _, row in hits_sites.iterrows():\\n if str(row['site_number']) == str(number):\\n matches.append(row['crystal_id'])\\n logger.debug('HIT IDS: %s', matches)\\n if matches:\\n mols = list(Molecule.objects.filter(prot_id__target_id=target, prot_id__code__in=matches))\\n analyse_mols(mols=mols, target=target, specified_site=True, site_description=description)\\n\\n if os.path.isfile(os.path.join(aligned_path, 'alternate_names.csv')):\\n rename_proteins(names_csv=os.path.join(aligned_path, 'alternate_names.csv'))\\n else:\\n analyse_mols(mols=mols, target=target)\\n\\n # move anything that's not a directory in 'aligned' up a level\\n files = (f for f in os.listdir(aligned_path)\\n if os.path.isfile(os.path.join(aligned_path, f)))\\n\\n for f in files:\\n shutil.move(os.path.join(aligned_path, f), os.path.join(aligned_path, f).replace('aligned', ''))\\n\\n # delete NEW_DATA VISITS PROPOSALS. These are not used by the new loader but might be in\\n # old data sets.\\n to_delete = ['NEW_DATA', 'VISITS', 'PROPOSALS']\\n for file in to_delete:\\n filepath = os.path.join(aligned_path.replace('aligned', ''), file)\\n if os.path.isfile(filepath):\\n os.remove(filepath)\\n\\n # last step - zip up the input file and move it to the archive\\n zipped = shutil.make_archive(aligned_path.replace('aligned', ''), 'zip', aligned_path.replace('aligned', ''))\\n target.zip_archive.name = relative_to_media_root(zipped)\\n\\n target.save()\\n\\n return mols_processed\",\n \"def delta_prob_raw(variants, tx, clf1, clf2, model='cterm', is_sum=True):\\n # fetch c-terminal sequence\\n term_seq = [] ; vars_considered = []\\n for v in variants:\\n if v.mutant_protein_sequence:\\n if model=='cterm' and type(v) in utils.indels+utils.nmd_sub_vars:\\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\\n if not is_sum: vars_considered.append(v)\\n elif type(v) in utils.base_substitutions:\\n if model=='cterm' and v.aa_mutation_start_offset>(len(v.transcript.protein_sequence) - 23):\\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\\n if not is_sum: vars_considered.append(v)\\n elif model=='nterm' and v.aa_mutation_start_offset<=24:\\n term_seq.append(utils.fetch_seq(v.mutant_protein_sequence, model=model))\\n if not is_sum: vars_considered.append(v)\\n\\n # return None if no variants\\n if not term_seq:\\n if is_sum: return 0\\n else: return [], [], []\\n # return None if U in protein sequence\\n if 'U' in utils.fetch_seq(tx.protein_sequence, model=model):\\n if is_sum: return 0\\n else: return [], [], []\\n\\n # construct dataframe\\n result_df = pd.DataFrame({'seq': term_seq})\\n\\n # create feature matrix\\n X = compute_feature_matrix(result_df['seq'], 6, dinuc=True, model=model)\\n X2 = compute_feature_matrix(result_df['seq'], 0, dinuc=False, model=model)\\n\\n # predict scores\\n result_df['prob'] = clf1.predict_proba(X)[:, 0]\\n\\n # adjust for baseline score\\n wt_seq = utils.fetch_seq(tx.protein_sequence, model=model)\\n wt_df = pd.DataFrame({'seq': [wt_seq]})\\n # create feature matrix\\n X = compute_feature_matrix(wt_df['seq'], 6, dinuc=True, model=model)\\n wt_df['prob'] = clf1.predict_proba(X)[:, 0]\\n baseline = wt_df['prob'].iloc[0]\\n\\n # add up scores\\n tmp = result_df['prob'] - baseline\\n if is_sum:\\n prob_sum = tmp.sum()\\n return prob_sum\\n else:\\n return vars_considered, tmp, result_df['prob']\",\n \"def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \\n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\\n \\\"\\\"\\\"return value is a sum of all alignment scores in input rangerange.\\\"\\\"\\\" \\n (start, finish) = wrapped_data \\n score_sum = 0.\\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\\\"Training process\\\"):\\n score_sum += self.aligner.score(seq, dna_record.seq)\\n return score_sum\\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))\",\n \"def test1_denovo(self):\\n gimme_motifs(\\n \\\"test/data/denovo/input.fa\\\",\\n self.outdir,\\n params={\\n \\\"tools\\\": \\\"MDmodule\\\",\\n \\\"fraction\\\": 0.5,\\n \\\"background\\\": \\\"random\\\",\\n \\\"genome\\\": \\\"test/data/background/genome.fa\\\",\\n },\\n filter_significant=True,\\n cluster=True,\\n )\\n\\n fnames = [\\n \\\"gimme.denovo.pfm\\\",\\n \\\"gimme.denovo.html\\\",\\n \\\"gimme.clustereds.html\\\",\\n \\\"params.txt\\\",\\n \\\"stats.random.txt\\\",\\n ]\\n\\n with open(os.path.join(self.outdir, \\\"gimmemotifs.log\\\")) as f:\\n log = f.read()\\n self.assertIn(\\\"clustering\\\", log)\\n\\n # Check if all output files are there\\n for fname in fnames:\\n self.assertTrue(os.path.exists(os.path.join(self.outdir, fname)))\\n\\n # Check if correct motif is predicted\\n with open(os.path.join(self.outdir, \\\"gimme.denovo.pfm\\\")) as f:\\n predicted_motifs = read_motifs(f)\\n ap1 = motif_from_consensus(\\\"TGASTCA\\\")\\n\\n mc = MotifComparer()\\n ap1_predicted = False\\n for motif in predicted_motifs:\\n match = mc.get_closest_match(ap1, motif)\\n if match[\\\"TGASTCA\\\"][1][3] < 1e-5:\\n ap1_predicted = True\\n break\\n\\n self.assertTrue(ap1_predicted)\",\n \"def calculate_on_target(ax, barcodes, expected, barcode_map=barcode_map):\\n total = 0\\n on_target = 0\\n off_target = 0\\n no_target = 0\\n\\n expected_counts = []\\n off_target_counts = []\\n expected_names = []\\n off_target_names = []\\n for barcode, count in barcodes.items():\\n if barcode in barcode_map:\\n if count > 10000:\\n if barcode_map[barcode] in expected:\\n on_target += count\\n expected_counts.append(count)\\n expected_names.append(barcode_map[barcode])\\n else:\\n off_target += count\\n off_target_counts.append(count)\\n off_target_names.append(barcode_map[barcode])\\n else:\\n no_target += count\\n total += count\\n\\n expected_colors = cm.Blues(np.linspace(0, 1, len(expected_counts)))\\n off_target_colors = cm.Reds(np.linspace(0, 1, len(off_target_counts) + 1))\\n patches, texts = ax.pie(expected_counts + off_target_counts + [no_target],\\n labels=expected_names + off_target_names + [\\\"No Barcode\\\"],\\n colors=np.concatenate((expected_colors, off_target_colors)),\\n )\\n [text.set_fontsize(16) for text in texts]\",\n \"def spreadOutAndFindDot(self, gameState):\\n # Here are some useful elements of the startState\\n currentPosition = gameState.getPacmanPosition(self.index)\\n foodList = gameState.getFood().asList()\\n walls = gameState.getWalls()\\n randomFood = []\\n problem = []\\n\\n #problem = AnyFoodSearchProblem(gameState, self.index)\\n\\n # if min(manhattan(currentPosition, foodPosition) for foodPosition in food.asList()) > 10:\\n # return [Directions.STOP]\\n #print(\\\"self.targets = \\\", self.targets)\\n if self.index == 0:\\n TargetFood = ClosestFood(currentPosition, foodList)\\n #self.targets.append(TargetFood)\\n problem = PositionSearchProblem(gameState, 0, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 1:\\n TargetFood = ClosestFood(currentPosition, foodList)\\n \\\"\\\"\\\"\\n want to find a way to avoid both agents coming up with the same target. But the below doesn't work because\\n each agent has their own self.targets. How to keep a common list of targets?\\n \\\"\\\"\\\"\\n # if TargetFood in self.targets:\\n # tempFoodList = foodList.copy()\\n # tempFoodList.pop(tempFoodList.index(TargetFood))\\n # TargetFood = ClosestFood(currentPosition, tempFoodList)\\n # self.targets.append(TargetFood)\\n # else:\\n # self.targets.append(TargetFood)\\n problem = PositionSearchProblem(gameState, 1, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 2:\\n TargetFood = RandomFood(currentPosition, foodList)\\n problem = PositionSearchProblem(gameState, 2, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 3:\\n TargetFood = RandomFood(currentPosition, foodList)\\n problem = PositionSearchProblem(gameState, 3, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n #return search.bfs(problem)\\n\\n #util.raiseNotDefined()\",\n \"def main():\\n\\n pv = str(sys.argv[1])\\n\\n print \\\"Testing count parameters on \\\" + pv\\n \\n lib = adned_lib()\\n g = adned_globals()\\n \\n lib.init_check(pv)\\n\\n cycles = range(10)\\n tests = range(10)\\n wait_time = 5 #Time to wait between checking counters\\n \\n total_counts = []\\n pulse_counter = 0\\n proton_charge = 0\\n seq_counter = 0\\n\\n total_counts_after = []\\n pulse_counter_after = 0\\n proton_charge_after = 0\\n seq_counter_after = 0\\n\\n for i in range(g.AD_MAX_DET):\\n total_counts.append(0)\\n total_counts_after.append(0)\\n \\n for i in cycles:\\n print \\\"Counter cycle \\\" + str(i)\\n\\n stat = lib.start(pv)\\n if (stat == g.FAIL):\\n sys.exit(lib.testComplete(g.FAIL))\\n\\n #Read counters immediately after a start \\n for det in range(g.AD_MAX_DET):\\n counts_pv = pv + \\\":Det\\\" + str(det+1) + \\\":EventTotal_RBV\\\"\\n total_counts[det] = caget(counts_pv)\\n pulse_counter = caget(pv + \\\":PulseCounter_RBV\\\")\\n proton_charge = caget(pv + \\\":PChargeIntegrated_RBV\\\")\\n seq_counter = caget(pv + \\\":SeqCounter0_RBV\\\")\\n\\n for test in tests:\\n\\n time.sleep(wait_time)\\n\\n #Check all counters have increased\\n for det in range(g.AD_MAX_DET):\\n counts_pv = pv + \\\":Det\\\" + str(det+1) + \\\":EventTotal_RBV\\\"\\n total_counts_after[det] = caget(counts_pv)\\n pulse_counter_after = caget(pv + \\\":PulseCounter_RBV\\\")\\n proton_charge_after = caget(pv + \\\":PChargeIntegrated_RBV\\\")\\n seq_counter_after = caget(pv + \\\":SeqCounter0_RBV\\\")\\n\\n for det in range(g.AD_MAX_DET):\\n if (total_counts[det] >= total_counts_after[det]):\\n print \\\"ERROR: Count problem. total_counts[\\\" + str(det) + \\\"]: \\\" + str(total_counts[det]) \\\\\\n + \\\" total_counts_after[\\\" + str(det) + \\\"]: \\\" + str(total_counts_after[det])\\n sys.exit(lib.testComplete(g.FAIL))\\n\\n if (pulse_counter >= pulse_counter_after):\\n print \\\"ERROR: Count problem. pulse_counter: \\\" + str(pulse_counter) + \\\" pulse_counter_after: \\\" + str(pulse_counter_after)\\n sys.exit(lib.testComplete(g.FAIL))\\n if (proton_charge >= proton_charge_after):\\n print \\\"ERROR: Count problem. proton_charge: \\\" + str(proton_charge) + \\\" proton_charge_after: \\\" + str(proton_charge_after)\\n sys.exit(lib.testComplete(g.FAIL))\\n if (seq_counter >= seq_counter_after):\\n print \\\"ERROR: Count problem. seq_counter: \\\" + str(seq_counter) + \\\" seq_counter_after: \\\" + str(seq_counter_after)\\n sys.exit(lib.testComplete(g.FAIL))\\n\\n print \\\"Test \\\" + str(test) + \\\" on cycle \\\" + str(i) + \\\" is OK.\\\" \\n \\n stat = lib.stop(pv)\\n if (stat == g.FAIL):\\n sys.exit(lib.testComplete(g.FAIL))\\n\\n #Check event rate (should be zero after a stop)\\n for det in range(g.AD_MAX_DET):\\n rate_pv = pv + \\\":Det\\\" + str(det+1) + \\\":EventRate_RBV\\\"\\n rate = caget(rate_pv)\\n if (rate != 0):\\n print \\\"ERROR: Stop problem. Rate is non zero after a stop. Rate: \\\" + str(rate)\\n sys.exit(lib.testComplete(g.FAIL))\\n \\n sys.exit(lib.testComplete(g.SUCCESS))\",\n \"def mark_duplicates():\\n\\n mkdir(MD_DIR)\\n\\n printp(\\\"\\\"\\\"# drmr:label mark-duplicates\\\\n\\\"\\\"\\\")\\n printp(\\\"\\\"\\\"# drmr:job nodes=1 processors=1 memory=12g working_directory={} time_limit=8h\\\"\\\"\\\".format(MD_DIR))\\n\\n for sample, info in DATA.items():\\n for x in ['treatment', 'control']:\\n srr = get_srr(sample) if x == 'treatment' else get_input_control_srr(sample)\\n input_bam = get_bwa_bam(sample, control=False) if x == 'treatment' else get_bwa_bam(sample, control=True)\\n output_bam = get_md_bam(sample, control=False) if x == 'treatment' else get_md_bam(sample, control=True)\\n printp(\\\"\\\"\\\"picard -m 8g MarkDuplicates I={input_bam} O={output_bam} ASSUME_SORTED=true METRICS_FILE={srr}.markdup.metrics VALIDATION_STRINGENCY=LENIENT TMP_DIR=.; samtools index {output_bam}\\\"\\\"\\\".format(**locals()), timed=True)\\n\\n printp(\\\"\\\"\\\"\\\\n# drmr:wait\\\"\\\"\\\")\",\n \"def same(item, target):\\r\\n return len([c for (c, t) in zip(item, target) if c == t])\",\n \"def coverage(self, user_list):\\n all_recom_set = set()\\n all_item = set(self.train['movieId'].values)\\n print('\\\\nCalculated coverage: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n all_recom_set.update(recom_item)\\n print('\\\\nCoverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\\n return len(all_recom_set) / (len(all_item) * 1.0)\",\n \"def test_create_Context_with_targets_ranks(self):\\n client = IPythonClient()\\n targets = [3, 2]\\n dac = Context(client, targets=targets)\\n self.assertEqual(set(dac.targets), set(targets))\\n dac.close()\\n client.close()\",\n \"def graph_helper(device, output,input,target):\\n output = output.clone().squeeze()\\n corrects = torch.zeros(output.shape[0])\\n for i in range(output.shape[0]): # goes through each iteration\\n outputi = output[i]\\n golden_label = convert_to_bits(device, outputi, input)\\n target = target.view(target.size(0), -1)\\n corrects[i] += torch.amin(golden_label == target, dim=[0]).sum().item() # counts the number that are the same i.e. correct predictions\\n correct = corrects.cpu().detach().numpy()\\n return correct\",\n \"def solveExCompact(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n #\\n # NEEDS ATTACKER AVG PER ATTACKER\\n #\\n \\\"\\\"\\\"In this game the attacker and defender reason ex-ante\\n (they choose to follow signals or not before a signal is sent).\\\"\\\"\\\"\\n # Add the extra dummy targets\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n for defenderCount in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n attackerActions = targetRange\\n # Get the suggestions that occur with no overlap\\n omegaKeys = [(t,d,tPrime,lam) for t in targetRange for d in defenders for tPrime in targetRange for lam in aTypes]\\n omegaKeys2 = [(t,lam) for t in targetRange for lam in aTypes]\\n\\n # Build the model\\n model = Model('ExAnteWithOverlap')\\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, name=\\\"w\\\")\\n w2 = model.continuous_var_dict(keys=omegaKeys2, lb=0, name=\\\"w2\\\")\\n objectiveFunction = sum([q[lam] * sum([w[t,d,t,lam] * _dRewards[d][t] for t in targetRange for d in defenders]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * sum([_dPenalties[d][t] for d in defenders]) for t in targetRange]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([sum([w[t,d,tPrime,lam] for t in targetRange]) * _dCosts[d][tPrime] for tPrime in targetRange for d in defenders]) for lam in aTypes])\\n\\n # Define the constraints\\n # Attacker\\n attackerConstraints = [sum([w[t,d,t,lam] * _aPenalties[lam][t] for t in targetRange for d in defenders]) \\\\\\n + sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * _aRewards[lam][t] for t in targetRange]) \\\\\\n >= sum([w[t,d,tPrime,lam] * _aPenalties[lam][tPrime] for t in targetRange for d in defenders]) \\\\\\n + sum([(w2[t,lam] - sum([w[t,d,tPrime,lam] for d in defenders])) * _aRewards[lam][tPrime] for t in targetRange]) \\\\\\n for lam in aTypes for tPrime in targetRange]\\n # Defender\\n defenderConstraints = [sum([q[lam] * sum([w[t,d,t,lam] * _dRewards[d][t] for t in targetRange]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,d,t,lam] for d in defenders])) * _dPenalties[d][t] for t in targetRange]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([sum([w[t,d,tPrimePrime,lam] for t in targetRange]) * _dCosts[d][tPrimePrime] for tPrimePrime in targetRange]) for lam in aTypes]) \\\\\\n >= sum([q[lam] * w2[tPrime,lam] * _dRewards[d][tPrime] for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([sum([w[t,dPrime,t,lam] for dPrime in defenders if dPrime != d]) * _dRewards[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([w[t,d,t,lam] * _dPenalties[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\\\\n + sum([q[lam] * sum([(w2[t,lam] - sum([w[t,dPrime,t,lam] for dPrime in defenders])) * _dPenalties[d][t] for t in targetRange if t != tPrime]) for lam in aTypes]) \\\\\\n + _dCosts[d][tPrime] \\\\\\n for d in defenders for tPrime in targetRange]\\n # Proposition constraints\\n p11Constraints = [sum([w2[t,lam] for t in targetRange]) == 1 for lam in aTypes]\\n p12Constraints = [sum([w[t,d,tPrime,lam] for tPrime in targetRange]) == w2[t,lam] for lam in aTypes for d in defenders for t in targetRange]\\n p13Constraints = [sum([w[t,d,tPrime,lam] for d in defenders]) <= w2[t,lam] for lam in aTypes for tPrime in targetRange for t in targetRange]\\n # Add the constraints\\n attackerConstraints = model.add_constraints(attackerConstraints)\\n defenderConstraints = model.add_constraints(defenderConstraints)\\n p11Constraints = model.add_constraints(p11Constraints)\\n p12Constraints = model.add_constraints(p12Constraints)\\n p13Constraints = model.add_constraints(p13Constraints)\\n # Solve the model\\n model.maximize(objectiveFunction)\\n model.solve()\\n print(model.get_solve_status())\\n return model.solution.get_objective_value(), model, None\",\n \"def test_determinism_2():\\n\\n def run_sgd(mode):\\n # Must be seeded the same both times run_sgd is called\\n disturb_mem.disturb_mem()\\n rng = np.random.RandomState([2012, 11, 27])\\n\\n batch_size = 5\\n train_batches = 3\\n valid_batches = 4\\n num_features = 2\\n\\n # Synthesize dataset with a linear decision boundary\\n w = rng.randn(num_features)\\n\\n def make_dataset(num_batches):\\n disturb_mem.disturb_mem()\\n m = num_batches*batch_size\\n X = rng.randn(m, num_features)\\n y = np.zeros((m, 1))\\n y[:, 0] = np.dot(X, w) > 0.\\n\\n rval = DenseDesignMatrix(X=X, y=y)\\n\\n rval.yaml_src = \\\"\\\" # suppress no yaml_src warning\\n\\n X = rval.get_batch_design(batch_size)\\n assert X.shape == (batch_size, num_features)\\n\\n return rval\\n\\n train = make_dataset(train_batches)\\n valid = make_dataset(valid_batches)\\n\\n num_chunks = 10\\n chunk_width = 2\\n\\n class ManyParamsModel(Model):\\n \\\"\\\"\\\"\\n Make a model with lots of parameters, so that there are many\\n opportunities for their updates to get accidentally re-ordered\\n non-deterministically. This makes non-determinism bugs manifest\\n more frequently.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n super(ManyParamsModel, self).__init__()\\n self.W1 = [sharedX(rng.randn(num_features, chunk_width)) for i\\n in xrange(num_chunks)]\\n disturb_mem.disturb_mem()\\n self.W2 = [sharedX(rng.randn(chunk_width))\\n for i in xrange(num_chunks)]\\n self._params = safe_union(self.W1, self.W2)\\n self.input_space = VectorSpace(num_features)\\n self.output_space = VectorSpace(1)\\n\\n disturb_mem.disturb_mem()\\n model = ManyParamsModel()\\n disturb_mem.disturb_mem()\\n\\n class LotsOfSummingCost(Cost):\\n \\\"\\\"\\\"\\n Make a cost whose gradient on the parameters involves summing many\\n terms together, so that T.grad is more likely to sum things in a\\n random order.\\n \\\"\\\"\\\"\\n\\n supervised = True\\n\\n def expr(self, model, data, **kwargs):\\n self.get_data_specs(model)[0].validate(data)\\n X, Y = data\\n disturb_mem.disturb_mem()\\n\\n def mlp_pred(non_linearity):\\n Z = [T.dot(X, W) for W in model.W1]\\n H = [non_linearity(z) for z in Z]\\n Z = [T.dot(h, W) for h, W in safe_izip(H, model.W2)]\\n pred = sum(Z)\\n return pred\\n\\n nonlinearity_predictions = map(mlp_pred,\\n [T.nnet.sigmoid,\\n T.nnet.softplus,\\n T.sqr,\\n T.sin])\\n pred = sum(nonlinearity_predictions)\\n disturb_mem.disturb_mem()\\n\\n return abs(pred-Y[:, 0]).sum()\\n\\n def get_data_specs(self, model):\\n data = CompositeSpace((model.get_input_space(),\\n model.get_output_space()))\\n source = (model.get_input_source(), model.get_target_source())\\n return (data, source)\\n\\n cost = LotsOfSummingCost()\\n\\n disturb_mem.disturb_mem()\\n\\n algorithm = SGD(cost=cost,\\n batch_size=batch_size,\\n learning_rule=Momentum(.5),\\n learning_rate=1e-3,\\n monitoring_dataset={'train': train, 'valid': valid},\\n update_callbacks=[ExponentialDecay(decay_factor=2.,\\n min_lr=.0001)],\\n termination_criterion=EpochCounter(max_epochs=5))\\n\\n disturb_mem.disturb_mem()\\n\\n train_object = Train(dataset=train,\\n model=model,\\n algorithm=algorithm,\\n extensions=[PolyakAveraging(start=0),\\n MomentumAdjustor(final_momentum=.9,\\n start=1,\\n saturate=5), ],\\n save_freq=0)\\n\\n disturb_mem.disturb_mem()\\n\\n train_object.main_loop()\\n\\n output = cStringIO()\\n record = Record(file_object=output, replay=False)\\n record_mode = RecordMode(record)\\n\\n run_sgd(record_mode)\\n\\n output = cStringIO(output.getvalue())\\n playback = Record(file_object=output, replay=True)\\n playback_mode = RecordMode(playback)\\n\\n run_sgd(playback_mode)\",\n \"def culggroup_donecount(group, dones):\\n return sum(dones[l] for l in group)\",\n \"def count_houses_delivered_with_robot(s):\\n s_santa, s_robot = s[::2], s[1::2]\\n deliveries_santa = make_deliveries(s_santa)\\n deliveries_robot = make_deliveries(s_robot)\\n all_deliveries = combine_dicts(deliveries_santa, deliveries_robot, lambda x,y: x+y, 0)\\n return len(all_deliveries)\",\n \"def make_emotion_data(emotion: str, dict_to_use: dd.DataFrame, ck=True):\\n emotion_data = []\\n target_data = []\\n\\n for row in tqdm(dict_to_use.iterrows(), total = len(dict_to_use.index)):\\n index, data = row\\n annotated_emote = data[\\\"annotated\\\"]\\n\\n if annotated_emote == \\\"N/A\\\":\\n continue\\n all_columns = data.keys()\\n columns_to_use = [x for x in all_columns if 'annotated' not in x and 'predicted' not in x and 'patient' not in x]\\n # data = data.loc[:, columns_to_use].compute()\\n data = data[columns_to_use]\\n # data = data.loc[:, df.columns != \\\"annotated\\\" and df.columns != \\\"Happy_predicted\\\"].compute()\\n emotion_data.append(data.tolist())\\n\\n if annotated_emote == emotion:\\n target_data.append(1)\\n else:\\n target_data.append(0)\\n\\n return emotion_data, target_data\\n\\n\\n # if dict_to_use is None:\\n # dict_to_use = json.load(open('au_emotes.txt'))\\n # emotion_data = [\\n # item for sublist in (b for b in ((a for a in x.values() if a)\\n # for x in dict_to_use.values()\\n\\n # if x) if b) for item in sublist\\n # ]\\n\\n # if ck:\\n # ck_dict = json.load(open('ck_dict.txt'))\\n\\n # for patient_list in ck_dict.values():\\n # to_add = AUScorer.TrainList\\n # au_dict = {\\n # str(int(float(x))): y\\n\\n # for x, y in patient_list[0].items()\\n # }\\n\\n # for add in to_add:\\n # if add not in au_dict:\\n # au_dict[add] = 0\\n # emotion_data.append([au_dict, patient_list[1]])\\n\\n # au_data = []\\n # target_data = []\\n # aus_list = AUScorer.TrainList\\n\\n # for frame in emotion_data:\\n # aus = frame[0]\\n\\n # if frame[1] == emotion:\\n # au_data.append([float(aus[str(x)]) for x in aus_list])\\n # target_data.append(1)\\n # index = 0\\n # happy_len = len(target_data)\\n\\n # for frame in emotion_data:\\n # aus = frame[0]\\n\\n # if frame[1] and frame[1] != emotion:\\n # au_data.append([float(aus[str(x)]) for x in aus_list])\\n # target_data.append(0)\\n # index += 1\\n\\n # if index == happy_len:\\n # break\\n\\n # return au_data, target_data\",\n \"def count_mutations_sequence(seq1, seq2):\\n # If the lengths of these two sequences are not equal, raise error \\n if len(seq1) != len(seq2) and len(seq1) == 0 and len(seq2) == 0:\\n text = \\\"The two sequences have different amino acids\\\"\\n raise DeimmunizationError(text)\\n # Define the mutations\\n mutCount = 0\\n # Calculate the mutations\\n for i in range(len(seq1)):\\n if seq1[i] != seq2[i]:\\n mutCount += 1\\n\\n return mutCount\",\n \"def DOPE(atmsel):\\n return ('DOPE score', atmsel.assess_dope())\",\n \"def get_number_seqs_for_primer(percent_match,\\n seq_count):\\n \\n total_seq_use=int((1-percent_match)*seq_count)\\n \\n return total_seq_use\",\n \"def findNearestTss(chrom, loops, gs, pdis=2000):\\n ts = np.array([[tss] for tss in gs.keys()])\\n cov = {}\\n for tss, g in gs.items():\\n cov[tss] = g\\n tree = KDTree(ts)\\n ds = {}\\n for loop in loops:\\n xgs, xds = findOverlapOrNearest(gs, ts, tree, loop.x_start, loop.x_end)\\n ygs, yds = findOverlapOrNearest(gs, ts, tree, loop.y_start, loop.y_end)\\n if len(xgs) > 1:\\n xt = \\\"Promoter\\\"\\n xd = 0\\n else:\\n xd = xds[0]\\n if abs(xd) <= pdis:\\n xt = \\\"Promoter\\\"\\n else:\\n xt = \\\"Enhancer\\\"\\n if len(ygs) > 1:\\n yt = \\\"Promoter\\\"\\n yd = 0\\n else:\\n yd = yds[0]\\n if abs(yd) <= pdis:\\n yt = \\\"Promoter\\\"\\n else:\\n yt = \\\"Enhancer\\\"\\n ds[loop.id] = {\\n \\\"typeAnchorA\\\":\\n xt,\\n \\\"typeAnchorB\\\":\\n yt,\\n \\\"nearestDistanceToGeneAnchorA\\\":\\n xd,\\n \\\"nearestDistanceToGeneAnchorB\\\":\\n yd,\\n \\\"nearestTargetGeneAnchorA\\\":\\n \\\",\\\".join([\\n xg.chrom + \\\":\\\" + str(xg.start) + \\\"-\\\" + str(xg.end) + \\\"|\\\" +\\n xg.strand + \\\"|\\\" + xg.name for xg in xgs\\n ]),\\n \\\"nearestTargetGeneAnchorB\\\":\\n \\\",\\\".join([\\n yg.chrom + \\\":\\\" + str(yg.start) + \\\"-\\\" + str(yg.end) + \\\"|\\\" +\\n yg.strand + \\\"|\\\" + yg.name for yg in ygs\\n ]),\\n }\\n return ds\",\n \"def solveExOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains a dummy target for defenders and attackers\\\"\\\"\\\"\\n \\\"\\\"\\\"In this game the attacker and defender reason ex-ante\\n (they choose to follow signals or not before a signal is sent).\\\"\\\"\\\"\\n # Add the extra dummy target\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n for defenderCount in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n attackerActions = targetRange\\n placements = getPlacements(defenders, targetNumWithDummies)\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Build the model\\n model = Model('ExAnteWithOverlap')\\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\\\"w\\\")\\n objectiveFunction = sum([q[lam] * sum([w[sd,sa,lam] * defenderSocialUtility(sd,sa,defenders,_dRewards,_dCosts,_dPenalties) for sd in placements for sa in attackerActions]) for lam in aTypes])\\n # Define the constraints\\n c1 = [sum([w[sd,sa,lam] * aUtility(sd,sa,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions]) \\\\\\n >= sum([w[sd,sa,lam] * aUtility(sd,tPrime,lam,_aPenalties,_aRewards) for sd in placements for sa in attackerActions])\\n for lam in aTypes for tPrime in targetRange]\\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\\n c2 = [sum([q[lam] * sum([w[sd,sa,lam] * utilityM(sd[d],sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\\\\n >= sum([q[lam] * sum([w[sd,sa,lam] * utilityM(tPrime,sd,sa,d,_dRewards,_dPenalties,_dCosts) for sd in placements for sa in attackerActions]) for lam in aTypes]) \\\\\\n for d in defenders for tPrime in targetRange]\\n c3 = [sum([w[sd,sa,lam] for sd in placements for sa in attackerActions]) == 1\\n for lam in aTypes]\\n # Add the constraints\\n c1 = model.add_constraints(c1)\\n c2 = model.add_constraints(c2)\\n c3 = model.add_constraints(c3)\\n # Solve the model\\n model.maximize(objectiveFunction)\\n model.solve()\\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\\n utilityPerAttacker = 0\\n for k,v in w.items():\\n prob = float(v)\\n s,a,lam = k\\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\\n utilityPerAttacker /= len(aTypes)\\n utilityPerDefender = model.solution.get_objective_value()\\n utilityPerDefender /= len(defenders)\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def calculate_single_cycle_gan_metrics(source, target):\\n metric_results = MetricsContainer(len(source))\\n for i, x in enumerate(source):\\n scores = torch.mean(torch.abs(x.view(1, -1) - target), dim=1)\\n _, indices = torch.sort(scores, descending=False)\\n indices = indices.cpu().numpy()\\n rank = np.nonzero(indices == i)[0][0] + 1\\n metric_results.update(rank)\\n return metric_results.get_results()\",\n \"def dp_cal_and_pro_only(foods, cal_goal, pro_goal):\\n macros = init_two_d_array((cal_goal, pro_goal), 999999999)\\n foods_used = init_two_d_array((cal_goal, pro_goal), {})\\n\\n for i in range(cal_goal):\\n for j in range(pro_goal):\\n for n in range(len(foods)):\\n food = foods[n]\\n if (int(food['calories']) > i and int(food['protein']) > j):\\n continue\\n if (macros[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n == 999999999):\\n prev_cost = 0\\n prev_foods_used = {}\\n else:\\n prev_cost = (macros[i - int(food['calories'])]\\n [j - int(food['protein'])])\\n prev_foods_used = \\\\\\n (foods_used[i - int(food['calories'])]\\n [j - int(food['protein'])]).copy()\\n new_cal = calories(foods, prev_foods_used) + food['calories']\\n new_pro = protein(foods, prev_foods_used) + food['protein']\\n if (macros[i][j] > prev_cost + food['serving_cost']\\n and new_cal > i - 50 and new_cal < i + 10\\n and new_pro > j - 5 and new_pro < j + 5):\\n macros[i][j] = prev_cost + food['serving_cost']\\n try:\\n prev_foods_used[n] += 1\\n except KeyError:\\n prev_foods_used[n] = 1\\n foods_used[i][j] = prev_foods_used\\n return foods_used[cal_goal - 1][pro_goal - 1]\",\n \"def information_content_similarity(s1, s2):\\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\\n\\n # Disambiguate words and create list of sysnsets \\n synsets_sentence_1 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_1.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_1.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n synsets_sentence_2 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_2.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_2.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n\\n score, count = 0.0, 0\\n # For each word in the first sentence\\n for synset in synsets_sentence_1:\\n L = []\\n for ss in synsets_sentence_2:\\n try:\\n L.append(synset.lin_similarity(ss, brown_ic))\\n except:\\n continue\\n if L: \\n best_score = max(L)\\n score += best_score\\n count += 1\\n # Average the values\\n if count > 0: score /= count\\n return score\",\n \"def delete_tulips_by_target(target_id):\\r\\n associated_tulips = self._db().select(self._db.tulip.target_id==target_id)\\r\\n tulips_removed = 0\\r\\n for single_tulip in associated_tulips:\\r\\n tulips_removed += 1\\r\\n self._db(self._db.tulip.id==single_tulip.it).delete()\\r\\n return tulips_removed\",\n \"def solveBaseline(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains a dummy target for defenders and attackers\\\"\\\"\\\"\\n # Add the dummy target\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n\\n # Generate the placements and keys\\n placements = getPlacements(defenders, targetNumWithDummies)\\n attackerActions = targetRange\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Construct the model for each defender\\n utilityPerDefender = 0\\n utilityPerAttacker = 0\\n attackerUtility = []\\n dStrat = {}\\n models2 = {}\\n for m in defenders:\\n model2 = Model(f\\\"defenderStrategy{m}\\\")\\n x = model2.continuous_var_list(keys=targetNumWithDummies, lb=0, ub=1, name=f\\\"x{m}\\\")\\n h = model2.binary_var_dict(keys=[(lam, k) for lam in aTypes for k in targetRange], lb=0, ub=1, name=f\\\"h{m}\\\")\\n ul = model2.continuous_var_dict(keys=aTypes, lb=-model2.infinity, name=f\\\"ua{m}\\\")\\n ud = model2.continuous_var_dict(keys=[lam for lam in aTypes], lb=-model2.infinity, name=f\\\"ud{m}\\\")\\n objectiveFunction = sum([q[lam] * ud[lam] for lam in aTypes])\\n model2.add_constraints([ud[lam] <= utilityDI(m,x,i,_dRewards,_dPenalties,_dCosts) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\\\"defender utility for lam {lam}, i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([ul[lam] <= utilityLamI(x,lam,i,_aRewards,_aPenalties) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\\\"lam {lam} utility leq for i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([ul[lam] >= utilityLamI(x,lam,i,_aRewards,_aPenalties) for i in targetRange for lam in aTypes], names=[f\\\"lam {lam} utility geq, for i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([sum([h[(lam,i)] for i in targetRange]) == 1 for lam in aTypes], names=[f\\\"h sum is 1 for lam {lam}\\\" for lam in aTypes])\\n model2.add_constraint(sum([x[i] for i in targetRange]) == 1)\\n # Solve the model for each defender\\n model2.maximize(objectiveFunction)\\n model2.solve()\\n dStrat[m] = list([float(xVal) for xVal in x])\\n models[m] = model2\\n # Attacker best response (for each attacker type)\\n aStrat = {}\\n protectionOdds = probabilityProtected(dStrat, targetNumWithDummies)\\n for lam in aTypes:\\n expectedUtilities = []\\n for i in targetRange:\\n expectedUtilities.append(((1-protectionOdds[i])*_aRewards[lam][i]) + (protectionOdds[i]*_aPenalties[lam][i]))\\n aStrat[lam] = argmax(expectedUtilities)\\n attackerUtility.append(expectedUtilities[aStrat[lam]])\\n utilityPerAttacker = sum(attackerUtility)/len(aTypes)\\n\\n\\n # Calculate defender expected utility for attacker best response\\n for m in defenders:\\n for lam in aTypes:\\n attackedTarget = aStrat[lam] # The target attacked by this attacker\\n coveredUtility = protectionOdds[attackedTarget] * (_dRewards[m][attackedTarget]) # The expected utility we catch this attacker\\n uncoveredUtility = (1-protectionOdds[attackedTarget]) * (_dPenalties[m][attackedTarget]) # The expected utility we miss this attacker\\n utilityPerDefender += q[lam] * (coveredUtility + uncoveredUtility)\\n expectedCost = sum([dStrat[m][target] * _dCosts[m][target] for target in targetRange])\\n utilityPerDefender += expectedCost\\n utilityPerDefender /= len(defenders)\\n\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def gen_target(self):\\n df_iwp = self.get_df_iwp()\\n df_iwes = self.get_df_iwes()\\n df_iwes = df_iwes.rename(columns={'exitsitedate':'ft_data_dt'})\\n df_iwp = df_iwp.rename(columns={'peritonitisdate':'ft_data_dt'})\\n df_infect = df_iwes.merge(df_iwp, how='outer')\\n df_infect = df_infect.dropna(axis=0)\\n first_infect = df_infect.groupby(['idd']).min()\\n first_infect = first_infect.reset_index()\\n first_infect['target'] = 1\\n first_infect['ft_data_dt'] = pd.to_datetime(first_infect['ft_data_dt'], format=\\\"%Y%m\\\") + MonthEnd(1)\\n all_target = []\\n end_data_dt = self.get_end_data_dt()\\n print(end_data_dt)\\n for index, row in first_infect.iterrows():\\n date_series = pd.date_range(*(pd.to_datetime([row['ft_data_dt'], end_data_dt]) + pd.offsets.MonthEnd()), freq='M', name='ft_data_dt')\\n idd_list = [row['idd']]\\n idd_series = pd.Series(data=idd_list, name='idd')\\n date_frame = date_series.to_frame()\\n idd_frame = idd_series.to_frame()\\n date_frame['key'] = 0\\n idd_frame['key'] = 0\\n tmp_target = idd_frame.merge(date_frame, on='key', how='outer').drop(columns=['key'])\\n all_target.append(tmp_target)\\n target = pd.concat(all_target)\\n target['target'] = 1\\n self.set_target_df(target)\",\n \"def labelled_attachment(gold_trees, pred_trees):\\n count_match, count_total = 0, 0\\n for gold, pred in zip(gold_trees, pred_trees):\\n triples_pairs = zip(\\n gold.get_triples(include_root=True),\\n pred.get_triples(include_root=True),\\n )\\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\\n assert g_src == p_src\\n count_total += 1\\n if g_trg == p_trg and g_rel == p_rel:\\n count_match += 1\\n if count_match == 0 or count_total == 0:\\n return 0.0\\n else:\\n return float(count_match) / count_total\",\n \"def _compute_exclusives_conflicts(self, targets):\\r\\n exclusives_map = defaultdict(set)\\r\\n for t in targets:\\r\\n if t.exclusives is not None:\\r\\n for k in t.exclusives:\\r\\n exclusives_map[k] |= t.exclusives[k]\\r\\n conflicting_keys = defaultdict(set)\\r\\n for k in exclusives_map:\\r\\n if len(exclusives_map[k]) > 1:\\r\\n conflicting_keys[k] = exclusives_map[k]\\r\\n return conflicting_keys\",\n \"def TargetDistrObj(x,t,newsamps,oldsamps,oldsetcounts) :\\r\\n\\t\\terror = 0\\r\\n\\t\\tnewtotal = newsamps+oldsamps\\r\\n\\t\\tfor ii in range(0,len(t)) :\\r\\n\\t\\t\\tval = (t[ii] - (oldsetcounts[ii] + x[ii]*newsamps)/newtotal)\\r\\n\\t\\t\\terror += val*val\\r\\n\\t\\treturn error\",\n \"def test_measure_deterministic_without_sampling(self):\\n shots = 100\\n circuits = ref_measure.measure_circuits_deterministic(allow_sampling=False)\\n targets = ref_measure.measure_counts_deterministic(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def solvePostOverlap(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains a dummy target for defenders and attackers\\\"\\\"\\\"\\n # Add the extra dummy target\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n for defenderCount in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n attackerActions = targetRange\\n placements = getPlacements(defenders, targetNumWithDummies)\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Build the model\\n model = Model('PrimalWithOverlap')\\n w = model.continuous_var_dict(keys=omegaKeys, lb=0, ub=1, name=\\\"w\\\")\\n objectiveFunction = sum([q[lam] * sum([w[s,a,lam] * defenderSocialUtility(s,a,defenders,_dRewards,_dCosts,_dPenalties) for s in placements for a in attackerActions]) for lam in aTypes])\\n c1 = [sum([w[s,a,lam] * aUtility(s,a,lam,_aPenalties,_aRewards) for s in placements]) \\\\\\n >= sum([w[s,a,lam] * aUtility(s,b,lam,_aPenalties,_aRewards) for s in placements])\\n for lam in aTypes for a in attackerActions for b in attackerActions if a != b]\\n c1 = [constraint for constraint in c1 if not isinstance(constraint, bool)]\\n c1 = model.add_constraints(c1)\\n c2 = model.add_constraints([sum([q[lam] * sum([w[s,a,lam] * utilityM(d,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes]) \\\\\\n >= sum([q[lam] * sum([w[s,a,lam] * utilityM(e,s,a,m,_dRewards,_dPenalties,_dCosts) for a in attackerActions for s in placements if s[m] == d]) for lam in aTypes])\\n for m in defenders for d in targetRange for e in targetRange if d!=e])\\n c3 = model.add_constraints([sum([w[(s,a,lam)] for s in placements for a in attackerActions]) == 1 for lam in aTypes])\\n # Solve the model\\n model.maximize(objectiveFunction)\\n model.solve()\\n # Now that w contains all the outcomes and their probabilities, sum the attacker utilities up.\\n utilityPerAttacker = 0\\n for k,v in w.items():\\n prob = float(v)\\n s,a,lam = k\\n utilityPerAttacker += aUtility(s,a,lam,_aPenalties,_aRewards) * prob\\n utilityPerAttacker /= len(aTypes)\\n utilityPerDefender = model.solution.get_objective_value()\\n utilityPerDefender /= len(defenders)\\n\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def make_set_cover_pos(gRNA_hits, num_sets = 1, target_ids = [], algorithm = \\\"LAR\\\",\\n id_key = lambda x: x, tie_breaker = tie_break_first, suppress_warning = False):\\n # exclude_seqs = set(str(s).upper() for s in exclude_seqs)\\n # gRNA_coverage = {seq: hits for seq, hits in gRNA_hits.hits.items()\\n # if str(seq).upper() not in exclude_seqs}\\n gRNA_coverage = gRNA_hits.hits\\n eliminated_gRNA = {}\\n ## prepare target ids\\n if not target_ids:\\n target_ids = set(hit.target_id for hit in gRNA_hits.flatten_hits())\\n else:\\n target_ids = set(target_ids)\\n ## selected set cover algorithm\\n if algorithm in (\\\"LAR\\\", \\\"greedy\\\"):\\n set_cover_algo = set_cover_LAR if algorithm == \\\"LAR\\\" else set_cover_greedy\\n else:\\n raise Exception(f\\\"Invalid algorithm name: '{algorithm}'\\\")\\n def coverage_possible():\\n return set(id_key(hit) for hits in gRNA_coverage.values() for hit in hits) >= set(target_ids)\\n ## function to generate set covers\\n def make_set_cover(restore = []):\\n for grna in restore:\\n gRNA_coverage[grna.seq] = eliminated_gRNA[grna.seq]\\n if not coverage_possible():\\n if not suppress_warning:\\n print((\\\"\\\\nError: The provided gRNA sequences cannot cover all target sequences\\\"\\n \\\" at least once.\\\\n\\\"))\\n return []\\n selected_grnas = set_cover_algo(gRNA_coverage, target_ids, id_key = id_key, tie_breaker = tie_breaker)\\n ## remove selected gRNA from candidates, and covert to gRNA object\\n output = []\\n for grna_seq in selected_grnas:\\n ## remove\\n eliminated_gRNA[grna_seq] = gRNA_coverage[grna_seq]\\n del gRNA_coverage[grna_seq]\\n ## convert gRNA sequences to gRNA object\\n grna_seq_obj = gRNA_hits.get_gRNAseq_by_seq(grna_seq)\\n output.append(gRNA(grna_seq_obj.id, grna_seq_obj))\\n return output\\n return make_set_cover\",\n \"def evaluate(self, model, data):\\n model.eval()\\n\\n loss = self.loss\\n loss.reset()\\n match = 0\\n total = 0\\n correct_spk = 0\\n total_response = 0\\n y_true = np.array([])\\n y_pred = np.array([])\\n\\n device = None if torch.cuda.is_available() else -1\\n batch_iterator = torchtext.data.BucketIterator(\\n dataset=data, batch_size=self.batch_size,\\n sort=True, sort_key=lambda x: len(x.src),\\n device=device, train=False)\\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\\n\\n for batch in batch_iterator:\\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\\n\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs)\\n\\n # Predict Speaker:\\n target_spk = spk_inputs[-1]\\n target_lengths = target_lengths.cpu().numpy()\\n prob_per_spk = []\\n for i in range(self.args.num_spk):\\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\\n spk_inputs_.append(spk_inputs_predict)\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs_)\\n prob_per_responce = []\\n target = target_variables.transpose(0,1)\\n for word, prob in zip(target[1:], decoder_outputs):\\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\\n indices = zip(np.arange(len(word)), word)\\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\\n prob_per_responce.append(prob_per_word)\\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\\n\\n predicts = np.argmax(prob_per_spk, axis=1)\\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\\n total_response += len(batch.tgt[0])\\n\\n # Evaluation\\n seqlist = other['sequence']\\n for step, step_output in enumerate(decoder_outputs):\\n target = target_variables[:, step + 1]\\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\\n\\n non_padding = target.ne(pad)\\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\\n match += correct\\n total += non_padding.sum().data[0]\\n\\n y_pred = np.append(y_pred, predicts)\\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\\n\\n print(y_pred.shape)\\n\\n print(accuracy_score(y_true, y_pred))\\n print(confusion_matrix(y_true, y_pred))\\n\\n if total == 0:\\n accuracy = float('nan')\\n else:\\n accuracy = match / total\\n\\n if total_response == 0:\\n accuracy_spk = float('nan')\\n else:\\n accuracy_spk = correct_spk / total_response\\n\\n return loss.get_loss(), accuracy, accuracy_spk\",\n \"def fit(self, seqs):\\n self._saved = self.cov(seqs1=seqs, seqs2=seqs)\\n return self._n_hypers\",\n \"def Counting(seq):\\n\\n #Scan the sequence, looking for motifs\\n\\n counting = {k: 0 for k in MOT} # Initialize the counting dictionary.\\n # Scan all the motifs and find them in the sequence\\n for motif in MOT:\\n if len(seq) > len(motif): # Check if the sequence is longer than the motif itself.\\n for i in range(len(seq)-len(motif)+1):\\n if i == 0: # In case the motif is in the beginning of the sequence\\n # print(\\\"start: \\\" + seq[i:i+len(motif)] + \\\" next nuc: \\\" + seq[i+len(motif)])\\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0]: # Check if the next nucleotide is in not part of the motif.\\n counting[motif] += 1\\n elif i == len(seq)-len(motif): # In case the motif is in the end of the sequence\\n \\n if seq[i:i+len(motif)] == motif and seq[i-1] != motif[0]: # Check if the previuos nucleotide is in not part of the motif.\\n counting[motif] += 1\\n elif len(seq) > len(motif)+1: # In case the motif is in the middle of the sequence.\\n # Check if the motif is not part of another motif (e.g. TT is in TTT).\\n\\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0] and seq[i-1] != motif[0]:\\n counting[motif] += 1\\n for nuc_nr in NUC_NR:\\n counting[nuc_nr+\\\"_NR\\\"] = seq.count(nuc_nr)\\n\\n return counting\",\n \"def checkTargets(targets, strings, propagation, output):\\n result = \\\"\\\"\\n #Do not check an URL twice\\n #Here, two different pages on the same target can be checked\\n #This is because a page can be \\\"alone\\\" on a website\\n targetViewed = set([])\\n for url in targets:\\n if url not in targetViewed:\\n string, otherLinks, linksViewed = checkSite(url, strings, output)\\n result += string\\n result += \\\"\\\\n\\\"\\n targetViewed = targetViewed | set([url])\\n\\n #If user want use propagation, add other links to the targets\\n if propagation > 0:\\n targets += list(otherLinks)\\n propagation -= 1\\n #Add all viewed links in targetViewed in order to do not check\\n #twice the same URL\\n targetViewed = targetViewed | linksViewed\\n return result\",\n \"def next_target(self, old_sInd, modes):\\n\\n OS = self.OpticalSystem\\n ZL = self.ZodiacalLight\\n Comp = self.Completeness\\n TL = self.TargetList\\n Obs = self.Observatory\\n TK = self.TimeKeeping\\n \\n # create DRM\\n DRM = {}\\n \\n # allocate settling time + overhead time\\n tmpCurrentTimeAbs = TK.currentTimeAbs.copy() + Obs.settlingTime + modes[0]['syst']['ohTime']\\n tmpCurrentTimeNorm = TK.currentTimeNorm.copy() + Obs.settlingTime + modes[0]['syst']['ohTime']\\n\\n # look for available targets\\n # 1. initialize arrays\\n slewTimes = np.zeros(TL.nStars)*u.d\\n fZs = np.zeros(TL.nStars)/u.arcsec**2\\n dV = np.zeros(TL.nStars)*u.m/u.s\\n intTimes = np.zeros(TL.nStars)*u.d\\n obsTimes = np.zeros([2,TL.nStars])*u.d\\n sInds = np.arange(TL.nStars)\\n \\n # 2. find spacecraft orbital START positions (if occulter, positions \\n # differ for each star) and filter out unavailable targets \\n sd = None\\n if OS.haveOcculter == True:\\n sd = Obs.star_angularSep(TL, old_sInd, sInds, tmpCurrentTimeAbs)\\n obsTimes = Obs.calculate_observableTimes(TL,sInds,tmpCurrentTimeAbs,self.koMap,self.koTimes,modes[0])\\n slewTimes = Obs.calculate_slewTimes(TL, old_sInd, sInds, sd, obsTimes, tmpCurrentTimeAbs) \\n \\n # 2.1 filter out totTimes > integration cutoff\\n if len(sInds.tolist()) > 0:\\n sInds = np.intersect1d(self.intTimeFilterInds, sInds)\\n \\n # start times, including slew times\\n startTimes = tmpCurrentTimeAbs.copy() + slewTimes\\n startTimesNorm = tmpCurrentTimeNorm.copy() + slewTimes\\n\\n # 2.5 Filter stars not observable at startTimes\\n try:\\n koTimeInd = np.where(np.round(startTimes[0].value)-self.koTimes.value==0)[0][0] # find indice where koTime is startTime[0]\\n sInds = sInds[np.where(np.transpose(self.koMap)[koTimeInd].astype(bool)[sInds])[0]]# filters inds by koMap #verified against v1.35\\n except:#If there are no target stars to observe \\n sInds = np.asarray([],dtype=int)\\n \\n # 3. filter out all previously (more-)visited targets, unless in \\n if len(sInds.tolist()) > 0:\\n sInds = self.revisitFilter(sInds, tmpCurrentTimeNorm)\\n\\n # 4.1 calculate integration times for ALL preselected targets\\n maxIntTimeOBendTime, maxIntTimeExoplanetObsTime, maxIntTimeMissionLife = TK.get_ObsDetectionMaxIntTime(Obs, modes[0])\\n maxIntTime = min(maxIntTimeOBendTime, maxIntTimeExoplanetObsTime, maxIntTimeMissionLife)#Maximum intTime allowed\\n\\n if len(sInds.tolist()) > 0:\\n if OS.haveOcculter == True and old_sInd is not None:\\n sInds,slewTimes[sInds],intTimes[sInds],dV[sInds] = self.refineOcculterSlews(old_sInd, sInds, slewTimes, obsTimes, sd, mode) \\n endTimes = tmpCurrentTimeAbs.copy() + intTimes + slewTimes\\n else: \\n intTimes[sInds] = self.calc_targ_intTime(sInds, startTimes[sInds], modes[0])\\n sInds = sInds[np.where(intTimes[sInds] <= maxIntTime)] # Filters targets exceeding end of OB\\n endTimes = startTimes + intTimes\\n \\n if maxIntTime.value <= 0:\\n sInds = np.asarray([],dtype=int)\\n\\n # 5.1 TODO Add filter to filter out stars entering and exiting keepout between startTimes and endTimes\\n \\n # 5.2 find spacecraft orbital END positions (for each candidate target), \\n # and filter out unavailable targets\\n if len(sInds.tolist()) > 0 and Obs.checkKeepoutEnd:\\n try: # endTimes may exist past koTimes so we have an exception to hand this case\\n koTimeInd = np.where(np.round(endTimes[0].value)-self.koTimes.value==0)[0][0]#koTimeInd[0][0] # find indice where koTime is endTime[0]\\n sInds = sInds[np.where(np.transpose(self.koMap)[koTimeInd].astype(bool)[sInds])[0]]# filters inds by koMap #verified against v1.35\\n except:\\n sInds = np.asarray([],dtype=int)\\n\\n # 6. choose best target from remaining\\n if len(sInds.tolist()) > 0:\\n # choose sInd of next target\\n sInd, waitTime = self.choose_next_target(old_sInd, sInds, slewTimes, intTimes[sInds])\\n \\n if sInd == None and waitTime is not None:#Should Choose Next Target decide there are no stars it wishes to observe at this time.\\n self.vprint('There are no stars Choose Next Target would like to Observe. Waiting %dd'%waitTime.value)\\n return DRM, None, None, waitTime, None\\n elif sInd == None and waitTime == None:\\n self.vprint('There are no stars Choose Next Target would like to Observe and waitTime is None')\\n return DRM, None, None, waitTime, None\\n # store selected star integration time\\n det_mode = copy.deepcopy(modes[0])\\n if self.WAint[sInd] > modes[1]['IWA'] and self.WAint[sInd] < modes[1]['OWA']:\\n det_mode['BW'] = det_mode['BW'] + modes[1]['BW']\\n det_mode['OWA'] = modes[1]['OWA']\\n det_mode['inst']['sread'] = det_mode['inst']['sread'] + modes[1]['inst']['sread']\\n det_mode['inst']['idark'] = det_mode['inst']['idark'] + modes[1]['inst']['idark']\\n det_mode['inst']['CIC'] = det_mode['inst']['CIC'] + modes[1]['inst']['CIC']\\n det_mode['syst']['optics'] = np.mean((det_mode['syst']['optics'], modes[1]['syst']['optics']))\\n det_mode['instName'] = 'combined'\\n intTime = self.calc_targ_intTime(sInd, startTimes[sInd], det_mode)[0]\\n else:\\n intTime = intTimes[sInd]\\n \\n # if no observable target, advanceTime to next Observable Target\\n else:\\n self.vprint('No Observable Targets at currentTimeNorm= ' + str(TK.currentTimeNorm.copy()))\\n return DRM, None, None, None, None\\n \\n # update visited list for selected star\\n self.starVisits[sInd] += 1\\n # store normalized start time for future completeness update\\n self.lastObsTimes[sInd] = startTimesNorm[sInd]\\n \\n # populate DRM with occulter related values\\n if OS.haveOcculter:\\n DRM = Obs.log_occulterResults(DRM,slewTimes[sInd],sInd,sd[sInd],dV[sInd])\\n return DRM, sInd, intTime, waitTime, det_mode\\n\\n return DRM, sInd, intTime, waitTime, det_mode\",\n \"def calculate_appropriate_target(self):\\n pass\",\n \"def calculate_appropriate_target(self):\\n pass\",\n \"def _getNumberOfAlignedNucleotides(self, dominant, subdominant):\\n\\t\\tnumAligned = 0\\n\\t\\tfor i in range(len(dominant)):\\n\\t\\t\\tif dominant[i] is not \\\" \\\" and subdominant[i] is not \\\" \\\":\\n\\t\\t\\t\\tif dominant[i] == subdominant[i]:\\n\\t\\t\\t\\t\\tnumAligned += 1\\n\\t\\treturn numAligned\",\n \"def exon_finder(tstart,tend,strand,qstart,qend,qlen,qstartphase,qendphase,seqdict,seqname,\\n max_offset = 30, is_start = False, is_stop = False, nevermind_atg = False,\\n cluster = None,exon_number = None,log_file = open(os.devnull, 'w'),full_pseudoexon_search = True,\\n exon_info_dict = False):\\n start = None\\n end = None\\n pseudo = False\\n max_coord = len(seqdict[seqname]) - 1\\n if strand == \\\"+\\\":\\n phasestart_offset = (3 - qstartphase) % 3\\n phasestop_offset = qendphase\\n start_match_offset, stop_match_offset = 3 * (qstart - 1),3 * (qlen - qend)\\n elif strand == '-':\\n phasestart_offset = qendphase\\n phasestop_offset = (3 - qstartphase) % 3\\n start_match_offset, stop_match_offset = 3 * (qlen - qend), 3 * qstart\\n ideal_start = tstart - phasestart_offset - start_match_offset\\n ideal_end = tend + stop_match_offset + phasestop_offset\\n pseudo_start = tstart - phasestart_offset\\n pseudo_end = tend + phasestop_offset\\n gc_start, gc_end = None, None\\n for offset in range(0,max_offset + 3,3):\\n if start:\\n break\\n for direction in [1,-1]:\\n test_start = ideal_start - offset * direction\\n test_seq = genome.Sequence(seqdict[seqname][test_start-1 + phasestart_offset:tend])\\n if strand == \\\"-\\\":\\n test_seq = test_seq.reverse_compliment()\\n if not test_seq.translate():\\n continue\\n elif is_stop and strand == \\\"-\\\":\\n if ideal_start - 1 < test_start < pseudo_start:\\n pseudo_start = test_start\\n lastcodon = seqdict[seqname][test_start - 1:test_start + 2]\\n if lastcodon.upper() in ['TTA','TCA','CTA'] and test_seq.translate().count('*') == 1:\\n start = test_start\\n break\\n elif not \\\"*\\\" in test_seq.translate():\\n if ideal_start - 1 < test_start < pseudo_start:\\n pseudo_start = test_start\\n if is_start and strand == '+':\\n if nevermind_atg:\\n start = test_start\\n break\\n else:\\n firstcodon = seqdict[seqname][test_start - 1:test_start + 2]\\n if firstcodon.upper() == \\\"ATG\\\":\\n start = test_start\\n break\\n else:\\n splicesite = seqdict[seqname][test_start-3:test_start-1]\\n if (strand == '+' and splicesite.upper() == \\\"AG\\\") or (strand == '-' and splicesite.upper() == \\\"AC\\\"):\\n start = test_start\\n break\\n elif strand == '-' and splicesite.upper() == \\\"GC\\\" and not gc_start:\\n gc_start = test_start\\n if not start:\\n if gc_start:\\n start = gc_start\\n else:\\n pseudo = \\\"P\\\"\\n start = pseudo_start\\n for offset in range(0,max_offset + 3,3):\\n if end:\\n break\\n for direction in [-1,1]:\\n test_end = ideal_end - offset * direction\\n if test_end - start < 3:\\n break\\n test_seq = genome.Sequence(seqdict[seqname][start - 1 + phasestart_offset:test_end - phasestop_offset])\\n if strand == \\\"-\\\":\\n test_seq = test_seq.reverse_compliment()\\n if not test_seq.translate():\\n continue\\n elif is_stop and strand == \\\"+\\\":\\n if ideal_end + 1 > test_end > pseudo_end:\\n pseudo_end = test_end\\n lastcodon = seqdict[seqname][test_end - 3:test_end]\\n if lastcodon.upper() in ['TAA','TGA','TAG'] and test_seq.translate().count('*') == 1:\\n end = test_end\\n break\\n elif not \\\"*\\\" in test_seq.translate() or (is_stop and not \\\"*\\\" in test_seq.translate()[:-1]):\\n if ideal_end + 1 > test_end > pseudo_end:\\n pseudo_end = test_end\\n if is_start and strand == '-':\\n if nevermind_atg:\\n end = test_end\\n break\\n else:\\n firstcodon = seqdict[seqname][test_end - 3:test_end]\\n if firstcodon.upper() == \\\"CAT\\\":\\n end = test_end\\n break\\n else:\\n splicesite = seqdict[seqname][test_end:test_end + 2]\\n if (strand == '+' and splicesite.upper() == \\\"GT\\\") or (strand == '-' and splicesite.upper() == \\\"CT\\\"):\\n end = test_end\\n break\\n elif strand == \\\"+\\\" and splicesite.upper() == \\\"GC\\\" and not gc_end:\\n gc_end = test_end\\n if not end:\\n if gc_end:\\n end = gc_end\\n else:\\n pseudo = \\\"P\\\"\\n end = pseudo_end\\n start = max([1,start])\\n end = min([end,max_coord])\\n if pseudo and full_pseudoexon_search and cluster != None and exon_number != None and exon_info_dict:\\n gwexons = genewisesearch(seqdict[seqname],qstartphase,qendphase,strand,\\n exon_info_dict[str(cluster) + ':' + str(exon_number)][6], \\n search_coords = [ideal_start - 3 - max_offset,ideal_end + 3 + max_offset],\\n seqname = seqname,log_file=log_file)\\n if gwexons != []:\\n return gwexons\\n return [[start,end,pseudo]]\",\n \"def target_will_be_deleted(cls, ctx, user, target):\\n # For every rover feature that was enabled/used by this target being deleted (as passed via\\n # the target metadata) and that is listed in any rover_features field in the capability definitions,\\n # decrement its uses count to both free up any free uses and keep an accurate count of the number of uses.\\n for rover_feature in (f for f in target.metadata.iterkeys() if f in capability_module.all_rover_features()):\\n if target.rover.can_reuse_feature(rover_feature):\\n target.rover.reuse_feature(rover_feature)\\n else:\\n logger.warn(\\\"No available capabilities when trying to reuse rover feature [%s][%s]\\\",\\n rover_feature, target.user.capabilities)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59328616","0.54016626","0.53880644","0.53279763","0.5304748","0.5270805","0.52698284","0.52169853","0.5192627","0.5187703","0.5163138","0.5144442","0.5137317","0.51321214","0.5109379","0.5109379","0.5092773","0.5085388","0.5081025","0.50582725","0.50424445","0.50401765","0.50243765","0.49981254","0.49659073","0.49546963","0.49212652","0.49192932","0.48715812","0.48643383","0.48435473","0.48243335","0.48115188","0.48106438","0.48073557","0.47974992","0.47858918","0.47816196","0.47459802","0.4742005","0.4736688","0.47320426","0.4717577","0.47151303","0.47110134","0.47107196","0.47103956","0.4708652","0.470777","0.47037297","0.47033694","0.46928075","0.46905383","0.46871394","0.4671568","0.46693018","0.46678767","0.46660462","0.46637547","0.4658477","0.46571907","0.4646872","0.46365184","0.46349272","0.46305853","0.46298987","0.4629194","0.46266136","0.4622204","0.46209246","0.46102372","0.460695","0.46003312","0.45995358","0.45918724","0.45879757","0.4587815","0.45869428","0.45845947","0.4582618","0.45757797","0.45718002","0.4570719","0.45654455","0.45638752","0.4560521","0.45573413","0.4549151","0.45480165","0.45442545","0.4543782","0.45337477","0.45297036","0.4526915","0.4522996","0.45218933","0.45218933","0.45179743","0.45133978","0.45109767"],"string":"[\n \"0.59328616\",\n \"0.54016626\",\n \"0.53880644\",\n \"0.53279763\",\n \"0.5304748\",\n \"0.5270805\",\n \"0.52698284\",\n \"0.52169853\",\n \"0.5192627\",\n \"0.5187703\",\n \"0.5163138\",\n \"0.5144442\",\n \"0.5137317\",\n \"0.51321214\",\n \"0.5109379\",\n \"0.5109379\",\n \"0.5092773\",\n \"0.5085388\",\n \"0.5081025\",\n \"0.50582725\",\n \"0.50424445\",\n \"0.50401765\",\n \"0.50243765\",\n \"0.49981254\",\n \"0.49659073\",\n \"0.49546963\",\n \"0.49212652\",\n \"0.49192932\",\n \"0.48715812\",\n \"0.48643383\",\n \"0.48435473\",\n \"0.48243335\",\n \"0.48115188\",\n \"0.48106438\",\n \"0.48073557\",\n \"0.47974992\",\n \"0.47858918\",\n \"0.47816196\",\n \"0.47459802\",\n \"0.4742005\",\n \"0.4736688\",\n \"0.47320426\",\n \"0.4717577\",\n \"0.47151303\",\n \"0.47110134\",\n \"0.47107196\",\n \"0.47103956\",\n \"0.4708652\",\n \"0.470777\",\n \"0.47037297\",\n \"0.47033694\",\n \"0.46928075\",\n \"0.46905383\",\n \"0.46871394\",\n \"0.4671568\",\n \"0.46693018\",\n \"0.46678767\",\n \"0.46660462\",\n \"0.46637547\",\n \"0.4658477\",\n \"0.46571907\",\n \"0.4646872\",\n \"0.46365184\",\n \"0.46349272\",\n \"0.46305853\",\n \"0.46298987\",\n \"0.4629194\",\n \"0.46266136\",\n \"0.4622204\",\n \"0.46209246\",\n \"0.46102372\",\n \"0.460695\",\n \"0.46003312\",\n \"0.45995358\",\n \"0.45918724\",\n \"0.45879757\",\n \"0.4587815\",\n \"0.45869428\",\n \"0.45845947\",\n \"0.4582618\",\n \"0.45757797\",\n \"0.45718002\",\n \"0.4570719\",\n \"0.45654455\",\n \"0.45638752\",\n \"0.4560521\",\n \"0.45573413\",\n \"0.4549151\",\n \"0.45480165\",\n \"0.45442545\",\n \"0.4543782\",\n \"0.45337477\",\n \"0.45297036\",\n \"0.4526915\",\n \"0.4522996\",\n \"0.45218933\",\n \"0.45218933\",\n \"0.45179743\",\n \"0.45133978\",\n \"0.45109767\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60678124"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81399,"cells":{"query":{"kind":"string","value":"Turns the unified CSV column \"Protein ID\" into a set of all protein IDs."},"document":{"kind":"string","value":"def parse_protein_ids(csv_field, sep=\"<|>\"):\n clean = csv_field.replace(\"decoy_\", \"\").strip()\n prot_id_set = set(clean.split(sep))\n return prot_id_set"},"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 get_award_ids (self, column):\n raw = self[column]\n vals = map (lambda x:x.strip(), raw.split(','))\n # return list (set (vals))\n return vals\n\n if 0:\n # truncated = filter (None, map (lambda x: len(x)>5 and x[-5:] or None, vals))\n truncated = filter (None, map (lambda x: len(x)>5 and normalize_id(x) or None, vals))\n\n # we only want the unique values (e.g. crossref lists dups sometimes)\n return list (set (truncated))","def genes():\n data=pd.read_csv(config['stan'], sep=\" \")\n return list(set(data['Gene_id']))","def protein_name_collector():\n resL = []\n with open(\"bob/processed/bobprots_down.csv\", \"r\") as inpF:\n for inpLine in inpF:\n inpLine = inpLine.split(\",\")\n resL.append(inpLine[0].strip(\" \\n\"))\n return resL","def _flattenMergedProteins(proteins):\n proteinSet = set()\n for protein in proteins:\n if isinstance(protein, tuple):\n proteinSet.update(protein)\n else:\n proteinSet.add(protein)\n return proteinSet","def ids(filename):\n with open(filename) as file:\n contents = file.read()\n return [int(x) for x in contents.split(\",\")]","def get_ids_from_web_table(self, path_file: str = None) -> List[str]:\n if path_file is None:\n path_file = \"_Materials Project.csv\"\n ids_data = pd.read_csv(path_file)\n ids = ids_data[\"Materials Id\"]\n self.ids = ids\n return ids","def _convert_pert_id_to_InChI(pert_ids):\n _download_metadata()\n l1000meta_df = pd.read_csv(L1000FWD_METADATA, index_col=0)\n return list(map(lambda s: s.replace('InChIKey=', '') if isinstance(s, str) else s, l1000meta_df['inchi_key'].loc[pert_ids]))","def get_ids():\n # Filename for SALAMI IA metadata\n metadata_file = os.path.join(\n dpath.SALAMI, 'metadata', 'id_index_internetarchive.csv')\n\n ids = []\n\n with open(metadata_file, \"r\") as rwc_file:\n reader = csv.reader(rwc_file)\n next(reader) #skip header\n for row in reader:\n ids.append(int(row[0]))\n\n return ids","def kegg_converter():\n from tools import prot_id_converter\n \n protList = []\n headerFlag = True\n with open(\"../bob/processed/24h_bobprots_up_full.csv\",\"r\") as inpF:\n for inpLine in inpF:\n if headerFlag:\n headerFlag = False\n continue\n inpList = inpLine.split(\",\")\n protList.append(inpList[1])\n print(prot_id_converter(protList, outDB=\"kegggeneid\"))","def get_sample_ids(maptable):\n return [line[0] for line in maptable[1:]]","def get_id_set(self):\n s = set()\n for player in Player.select(Player.player_id):\n s.add(player.player_id)\n return s","def get_tweets_ids_from_csv(self):\n for fname in self.filelist:\n with open(fname) as f:\n fakenews = csv.reader(f)\n next(fakenews) # Discard top CSV row\n for fake in fakenews:\n yield fake[3].split(\"\t\")","def purify(self, csv_list):\n for row in csv_list:\n if row[0].strip(\" \") == \"ID\":\n return csv_list[csv_list.index(row) + 1:]\n return csv_list","def produce_uniqueGene_swissProtIDs (inPath, geneMapFile, outPath):\n with open(inPath, 'r') as f:\n swissProtIDs = pd.Series(list(set(f.read().split())))\n with open(geneMapFile, 'rb') as f:\n geneMap = pickle.load(f)\n swissProtIDGenes = swissProtIDs.apply(lambda x: geneMap[x] if x in geneMap else 'no_name')\n duplicates = swissProtIDGenes.duplicated(keep=False)\n uniqueGeneSwissProtIDs = swissProtIDs[(duplicates==False) & (swissProtIDGenes!='no_name')]\n uniqueGeneSwissProtIDs.to_csv(outPath, index=False)","def orthologueGeneIds(self):\n\t\tgeneIds = []\n\t\tfor geneId,row in self._dataframe.iterrows():\n\t\t\tfor item in row['Orthologue'].split(','):\t# looks like 'ENSG00003435:Gene1,ENSG00002525:Gene2' (multiple orthologues possible)\n\t\t\t\tif item.split(':')[0]: geneIds.append(item.split(':')[0])\n\t\treturn list(set(geneIds))","def get_ids(self) -> List[str]:","def parseAtomid(self, line):\n\n\t\tcols = string.split(line, \",\")\n\n\t\tfor col in cols:\n\t\t\tif \"-\" in col:\n\t\t\t\t(beg, end) = string.split(col, \"-\")\n\t\t\t\tbeg = int(beg)\n\t\t\t\tend = int(end)\n\t\t\t\tfor i in range(beg,end+1):\n\t\t\t\t\tself.atomid.append(i)\n\t\t\telse:\n\t\t\t\tself.atomid.append(col)","def get_taxids(read_from_flat_files=False, fn=None):\n if read_from_flat_files:\n taxids = []\n if fn is None:\n # Taxid_2_Proteins_table_STRING = os.path.join(variables.TABLES_DIR, \"Taxid_2_Proteins_table_STRING.txt\")\n Taxid_2_Proteins_table_STRING = variables.tables_dict[\"Taxid_2_Proteins_table\"]\n with open(Taxid_2_Proteins_table_STRING, \"r\") as fh:\n for line in fh:\n taxids.append(line.split(\"\\t\")[0])\n return taxids\n else:\n result = get_results_of_statement(\"SELECT taxid_2_protein.taxid FROM taxid_2_protein;\")\n return sorted([rec[0] for rec in result])","def Get_Uniprot_IDs(Neg_cases):\r\n workbook= xlrd.open_workbook(\"../Data/Negative_cases/Uniprot_total_neg_cases.xlsx\")\r\n worksheet= workbook.sheet_by_name(\"Uniprot_negative_cases\")\r\n UniprotEntries=[]\r\n for i in Neg_cases:\r\n EntryText=str(worksheet.cell(i,0))\r\n Entry=EntryText[6:(len(EntryText)-1)]\r\n UniprotEntries.append(Entry)\r\n return UniprotEntries","def get_vendor_ids(tools_csv):\n\n import csv\n\n vendors = {}\n\n with open(tools_csv, 'r') as csvfile:\n\n reader = csv.reader(csvfile, delimiter=',', quotechar='\"')\n\n next(reader) # skip the header\n\n for row in reader:\n\n tool_name, tool_id, vendor_id = row[:3]\n\n if vendor_id in vendors:\n vendors[vendor_id].append((tool_id, tool_name))\n else:\n vendors[vendor_id] = [(tool_id, tool_name)]\n\n return vendors","def get_set_of_ids(self, elements):\n\n new_set = set()\n for e in set(elements):\n new_set.add(self._reaction_system.get_entity_id(e))\n return new_set","def get_input(data_file: str) -> Set[int]:\n with open(data_file) as f:\n return {int(x.strip()) for x in f.readlines()}","def read_ID(ID_fn):\n print(\"Reading id_to_ethnicity file...\")\n with open(ID_fn, newline='') as f:\n readCSV = csv.reader(f, delimiter=',')\n id_to_ethnicity = []\n for array in readCSV:\n if len(array) != 2: # avoid empty rows\n break\n id_to_ethnicity.append([array[0], array[1]]) #[0]: patient_ID, [1]: Ethnicity\n\n return id_to_ethnicity","def fasta2csv(self, is_local_interpro):\n\t\tprint(\"Creating row for each protein with domain, please wait..\")\n\t\tdataset_name = \"toxin_dataset.csv\"\n\t\tnum_all_proteins = 0\n\t\tnum_proteins_with_domains = 0\n\t\tnum_remain_proteins = 0\n\t\tcsv_already_exists = True\n\t\tif not isfile(join(self.output_path, dataset_name)): # if csv not exists then firstly write header\n\t\t\tcsv_already_exists = False\n\t\tfor fasta_file in listdir(self.fasta_dir_path):\n\t\t\tshort_label = splitext(basename(fasta_file))[0].split(\".\")[0]\n\t\t\twith open(join(self.fasta_dir_path, fasta_file), 'r') as fasta_data, open(self.domains_path,\n\t\t\t 'r') as domains_data, open(\n\t\t\t\t\tjoin(self.output_path, dataset_name), 'a') as dataset_csv, open(\n\t\t\t\t\tjoin(self.output_path, \"toxin_remaining_seq\" + \"_\" + short_label + \".fasta\"),\n\t\t\t\t\t'a') as remain_seqs_file:\n\t\t\t\tproteins_dict = SeqIO.to_dict(SeqIO.parse(fasta_data, \"fasta\"))\n\t\t\t\tnum_all_proteins += len(proteins_dict)\n\t\t\t\tuniprot2prot = self.extract_uniprot4protein_keys(proteins_dict)\n\t\t\t\twriter = csv.writer(dataset_csv, delimiter=',')\n\t\t\t\tif not csv_already_exists: # if csv not exists then firstly write header\n\t\t\t\t\tproteins_domains_header = [\"uniprot_id\", \"toxin\", \"seq\", \"seq_len\", \"interpro_domains\",\n\t\t\t\t\t \"evidence_db_domains\"]\n\t\t\t\t\twriter.writerow(proteins_domains_header)\n\t\t\t\t\tcsv_already_exists = True\n\t\t\t\tbatch_num_lines = 10000\n\n\t\t\t\tfor i, batch in enumerate(batch_iterator(domains_data, batch_num_lines)):\n\t\t\t\t\tfor line in batch:\n\t\t\t\t\t\tline_split = line.strip().split(\"\\t\")\n\t\t\t\t\t\tassert len(line_split) == 3, \"AssertionError: {} does not have 3 tabs.\".format(line)\n\t\t\t\t\t\tuniprot_id = line_split[0]\n\t\t\t\t\t\tif uniprot_id == \"uniprot_id\":\n\t\t\t\t\t\t\tprint(\"Skipping first line\")\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tif is_local_interpro:\n\t\t\t\t\t\t\tuniprot_id = uniprot_id.split(\"|\")[1]\n\t\t\t\t\t\tif uniprot_id in uniprot2prot:\n\t\t\t\t\t\t\tinterpro_ids = line_split[1]\n\t\t\t\t\t\t\tevidence_db_ids = line_split[2]\n\t\t\t\t\t\t\tlabel = self.get_labels(fasta_file)\n\t\t\t\t\t\t\t# make the row of the current protein\n\t\t\t\t\t\t\tprotein_row = [uniprot_id, label, str(uniprot2prot[uniprot_id].seq),\n\t\t\t\t\t\t\t len(str(uniprot2prot[uniprot_id].seq)), interpro_ids, evidence_db_ids]\n\t\t\t\t\t\t\twriter.writerow(protein_row)\n\t\t\t\t\t\t\tnum_proteins_with_domains += 1\n\t\t\t\t\t\t\t# remove found protein from the dictionary, to keep track of the remaining proteins\n\t\t\t\t\t\t\tuniprot2prot.pop(uniprot_id)\n\n\t\t\t\tnum_remain_proteins += len(uniprot2prot) # update num of remain proteins\n\t\t\t\tSeqIO.write(uniprot2prot.values(), remain_seqs_file, \"fasta\") # append remaining proteins to fasta\n\t\t\t\tprint(\"num of remaining proteins for {} label: {} saved on remaining fasta\".format(\n\t\t\t\t\tself.get_labels(fasta_file), len(uniprot2prot)))\n\t\tassert num_all_proteins == num_proteins_with_domains + num_remain_proteins, \"AssertionError: total num of proteins should be equal to proteins with domains + proteins without domains.\"\n\t\tprint(\"num of Toxin proteins: {}\".format(num_all_proteins))\n\t\tprint(\"num of Toxin proteins with found domains: {}\".format(num_proteins_with_domains))\n\t\tprint(\"num of remaining proteins with not found domains: {}\".format(num_remain_proteins))","def prepare_hpa_data(d):\n # Prep protein class lists\n d['Protein classes'] = (\n # Split class string on commas (missing protein class will become empty tuple)\n d['Protein class'].fillna('').str.split(',')\n # Apply clean function to each item is split sequences and deduplicate tuple\n .apply(lambda v: tuple(set(map(clean_protein_class_name, v))))\n )\n return d.drop('Protein class', axis=1)","def get_ids(self, year, switch):\n ids = list()\n path = os.path.join(self.get_ids_path(switch), '{}.csv'.format(year))\n with open(path, 'r') as file:\n reader = csv.reader(file)\n ids = [row[0] for row in reader]\n return ids","def dataFromFile(fname):\n file_iter = open(fname, 'rU')\n for line in file_iter:\n line = line.strip().rstrip(',') # Remove trailing comma\n record = frozenset(line.split(','))\n yield record","def produce_uniqueGene_sequences (inPath,\n uniqueGeneSwissProtIDFile,\n geneMapFile,\n outPath):\n with open(uniqueGeneSwissProtIDFile, 'r') as f:\n uniqueGeneSwissProtIDs = set(f.read().split())\n with open(geneMapFile, 'rb') as f:\n geneMap = pickle.load(f)\n sequences = pd.read_table(inPath, sep=\"\\t\")\n sequencesRefID = sequences[\"ID\"].apply(lambda x: x if x.find('-') == -1 else x[:x.find('-')])\n sequences[\"Gene_Name\"] = sequencesRefID.apply(lambda x: geneMap[x] if x in geneMap else x)\n sequences = sequences[sequencesRefID.isin(uniqueGeneSwissProtIDs)].reset_index(drop=True)\n sequences.to_csv(outPath, index=False, sep='\\t')","def fasta_ids(fasta_files, verbose=False):\r\n all_ids = set([])\r\n for fasta_in in fasta_files:\r\n for label, seq in parse_fasta(fasta_in):\r\n rid = label.split()[0]\r\n if rid in all_ids:\r\n raise ValueError(\r\n \"Duplicate ID found in FASTA/qual file: %s\" %\r\n label)\r\n all_ids.add(rid)\r\n return all_ids","def getRiverIDs(lookupCsv):\n\n d = {}\n with open(lookupCsv, \"rb\") as f:\n reader = csv.reader(f)\n\n # Discard header row\n reader.next()\n\n for row in reader:\n d[row[0]] = row[1]\n\n return d","def dataFromFile(fname):\n file_iter = open(fname, 'rU')\n for line in file_iter:\n #print(line)\n line = line.strip().rstrip(',') # Remove trailing comma\n record = frozenset(line.split(','))\n yield record","def extract_uniprot4protein_keys(self, proteins_dict):\n\t\treturn {key.split(\"|\")[1]: value for (key, value) in proteins_dict.items()}","def get_ids_values(path):\n \n def read_txt(path):\n \"\"\"read text file from path.\"\"\"\n \n with open(path, \"r\") as f:\n return f.read().splitlines()\n \n raw_data = read_txt(path)[1:]\n \n def deal_line(line):\n ids, values = line.split(',')\n return ids, values\n \n ids_values = [deal_line(line) for line in raw_data]\n ids = [x[0] for x in ids_values]\n values = [x[1] for x in ids_values]\n values = list(map(int, values))\n \n return ids, values","def ids(self):\n return frozenset([seq.id for seq in self])","def open_csv(filename):\n with open(filename) as csv_file:\n file_reader = reader(csv_file, delimiter=',')\n id_list = []\n for row in file_reader:\n id_list.append(row[0])\n\n return id_list","def produce_uniprotID_dict(inPath, spList, outPath):\n with open(spList, 'r') as f:\n swissProtIDs = set(f.read().split())\n with open(inPath, 'r') as fIn:\n idMap = {}\n for line in fIn:\n uniprotID, otherIDtype, otherID = line.strip().split('\\t')\n if uniprotID in swissProtIDs:\n if otherIDtype == 'Gene_Name':\n otherID = otherID.upper()\n idMap[otherID] = uniprotID\n with open(outPath, 'wb') as fOut:\n pickle.dump(idMap, fOut)","def _eidset():\n\n dbrosters = set()\n with sqlite3.connect(DB) as db:\n cursor = db.cursor()\n cursor.execute(\"SELECT eid FROM players\")\n rows = cursor.fetchall()\n for row in rows:\n dbrosters.add(int(row[0]))\n # return set.\n return dbrosters","def _findSamesetProteins(protToPeps, proteins=None):\n proteins = viewkeys(protToPeps) if proteins is None else proteins\n\n equalEvidence = ddict(set)\n for protein in proteins:\n peptides = protToPeps[protein]\n equalEvidence[tuple(sorted(peptides))].add(protein)\n equalProteins = list()\n for proteins in viewvalues(equalEvidence):\n if len(proteins) > 1:\n equalProteins.append(tuple(sorted(proteins)))\n return equalProteins","def get_ids(self, sentence):\n return [self.get_id(word) for word in sentence.strip().split(' ')]","def generate_company_list():\n path = 'companylist.csv'\n companyids = []\n with open(path, 'r') as csv_file:\n csv_reader = csv.reader(csv_file)\n for line in csv_reader:\n companyids.append(line[0])\n companyids.pop(0)\n return companyids","def _as_delimited_set(self, name):\n org_type = self._get_type(name)\n if org_type == 'delimited set': return None\n valid = ['single', 'string']\n if not org_type in valid:\n msg = 'Cannot convert variable {} of type {} to delimited set!'\n raise TypeError(msg.format(name, org_type))\n if org_type == 'single':\n self._meta['columns'][name]['type'] = 'delimited set'\n self._data[name] = self._data[name].apply(\n lambda x: str(int(x)) + ';' if not np.isnan(x) else np.NaN)\n return None\n elif org_type == 'string':\n # we assume we have a delimited set in the string variable\n # delimited with a semicolon agree;disagree;agree\n original_column = self._data[name]\n # we encapsulate each line with !; ;! so that the string\n # replacement works correctly\n if original_column.dropna().tolist()[0][-1] == \";\":\n original_column = \"!;\" + original_column + \"!\"\n else:\n original_column = \"!;\" + original_column + \";!\"\n\n original_column = original_column.replace(pd.np.nan,'')\n original_column = original_column.str.replace(\"; \",\";\")\n original_column = original_column.str.replace(\" ;\",\";\")\n\n all_values_split = [i.split(\";\") for i in original_column]\n flat = [i for sublist in all_values_split for i in sublist]\n trim = [i.strip() for i in flat]\n trim = [i for i in trim if len(i)>0]\n unique = list(set(trim))\n if \"!\" in unique:\n unique.remove(\"!\")\n unique.sort()\n value_map = []\n quantipy_values = []\n for k,item in enumerate(unique):\n value_map.append((k,item))\n quantipy_values.append({'text':{self.meta()['lib']['default text']:item},'value':k})\n original_column = original_column.str.replace(\";\" + re.escape(item) + \";\",\";\" + str(k) + \";\")\n original_column = original_column.str.replace(\"; \",\";\")\n # remove the ;! !; we placed at the beginning and end of each string\n original_column = original_column.str.replace(\"!;\",\"\")\n original_column = original_column.str.replace(\"!\",\"\")\n self._meta['columns'][name]['values'] = quantipy_values\n self._meta['columns'][name]['type'] = 'delimited set'\n self._data[name] = original_column","def _load_protein():\n data_file = os.path.join(data_dir, \"protein/CASP.csv\")\n data = pd.read_csv(data_file, sep=\",\")\n X = data.values[:, 1:]\n y = data.values[:, 0]\n return X, y","def CSV(id_poke):\r\n poke = [] #creer une liste vide\r\n with open('BDD/pokemon.csv') as csv_file: #ouvre le fichier pokemon.csv\r\n csv_reader = csv.reader(csv_file, delimiter=',') #place les lignes du csv dans une variable\r\n for row in csv_reader: #parcours des lignes du csv\r\n if row[0] == str(id_poke): #si l'id de la ligne = id du pokemon\r\n poke = list(row) #variable = ligne correspondante dans le csv\r\n return(poke) #retourne une liste avec les caracteristiques du poke\r","def getById(self, ids):\n\t\tproteins = []\n\t\tids = [ids] if isinstance(ids, str) else ids\n\t\tfor id in ids:\n\t\t\turl = self.composeQueryUrl({'query': id, 'format':'xml'})\n\t\t\tr = requests.get(url)\n\t\t\t\n\t\t\tif len(r.text) > 0:\n\t\t\t\tprotein = self.convertXmlToProtein(r.text)\n\t\t\telse:\n\t\t\t\tprotein = None\n\t\t\tproteins.append(protein)\n\t\t\t\n\t\treturn proteins","def getIDs():","def get_pids_formatted(self, site: str) -> List[str]:\n try:\n self._cursor.execute(f\"SELECT productIdStr FROM {site}\")\n except sqlite3.OperationalError:\n raise sqlite3.OperationalError(f\"Table '{site}' does not exist. You can create it by the `create_table_safe` method.\")\n rows: List[Tuple[int]] = self._cursor.fetchall()\n return [row[0] for row in rows]","def makePeptideOutputList(self, protein, peptide):\n attributeList = self.pcssRunner.pfa.getColumnSortedOutputAttributes()\n outputList = []\n for attribute in attributeList:\n if (attribute.attributeType == \"protein\"):\n outputList.append(attribute.getProteinValue(protein))\n else:\n outputList.append(attribute.getPeptideValue(peptide))\n return outputList","def updateImportList(self):\n\t\tids_new = self.ids\n\t\tids_list = []\n\n\t\tif not os.path.exists(ids_file):\n\t\t\twith open(ids_file, 'a') as ids:\n\t\t\t\tpass\n\n\t\twith open(ids_file, \"rb\") as ids:\n\t\t\tids_reader = csv.reader(ids)\n\t\t\tfor row in ids_reader:\n\t\t\t\tids_list.append(row[0])\n\n\t\tids_new = set(ids_new) - set(ids_list)\n\n\t\twith open(ids_file, \"a\") as ids:\n\t\t\tids_writer = csv.writer(ids)\n\t\t\tfor idx in ids_new:\n\t\t\t\tids_writer.writerow( str(idx) )\n\n\t\tself.ids = ids_new","def select_unique_ids(self):\n utk = self.metadata\n utk_ids = []\n for gg in set(utk['gender']):\n for rg in set(utk['race']):\n for ag in set(utk['age']):\n try:\n intersection_ids = list(utk[np.logical_and(utk['gender'] == gg,\n np.logical_and(utk['race'] == rg,\n utk['age'] == ag))]['filename'])\n if len(intersection_ids) <= CAP:\n utk_ids += intersection_ids\n else:\n x = list(np.random.choice(intersection_ids, CAP, replace=False))\n utk_ids += x\n\n except:\n continue\n self.unique_ids = utk_ids\n return utk_ids","def _get_set_pairs(uprow, types):\n pairs = []\n for key, val in uprow.items():\n pairs.append(\"{0}={1}\".format(key, _for_pgsql(val, types[key])))\n return \", \".join(pairs)","def get_unique_tags(df):\n tags = []\n\n for index, row in df.iterrows():\n tags = list(set(tags + ast.literal_eval(row.tags)))\n\n pdb.set_trace()","def from_csv_line(line):\r\n return line.strip().split(',')","def get_first_id(lines):\r\n result = set()\r\n for line in lines:\r\n if line.startswith('>'):\r\n result.add(line[1:].split()[0])\r\n return result","def preset_ids(self):\r\n\r\n return map(lambda item: item[0], self.preset_items())","def extract_protein(fileReport, INFO, PROTEIN_FUNCTION):\n\n\tprint \"\\n#################\"\n\tprint \"# Protein extraction\"\n\tprint \"#################\\n\"\n\n\treport_table = np.loadtxt(fileReport, dtype='string')\n\tnumber_prot = report_table.shape[0]\n\tindex_remove = []\n\n\tfor index in xrange(number_prot):\n\t\tif report_table[index][4] in PROTEIN_FUNCTION :\n\t\t\tsystem_number = report_table[index][7].split('_')[-1]\n\n\t\t\tif int(system_number) > 1 :\n\t\t\t\treport_table[index][1] = \"_\".join(report_table[index][1].split('_')[:-1])+\"_\"+system_number\n\t\t\telse:\n\t\t\t\treport_table[index][1] = \"_\".join(report_table[index][1].split('_')[:-1])\n\t\telse :\n\t\t\tindex_remove.append(index)\n\n\tnp.savetxt(os.path.join(INFO, \"remove_report.seq\"), report_table[np.array(index_remove),:], delimiter=\"\\t\", fmt=\"%s\")\n\treport_table = np.delete(report_table, index_remove, axis=0)\n\tnumber_remove_protein = len(index_remove)\n\n\tprint \"There are {} proteins remove during this operation because they are not in the dictionnary\".format(number_remove_protein)\n\n\t# NOTE NC_XXXXXX[_numero de systeme si deux systemes trouvés]_nomSysteme_D_nomProteine\n\tnew_name = [report_table[i][1]+'_'+report_table[i][6]+'_D_'+\"_\".join(report_table[i][4].split('_')[1:]) for i in xrange(report_table.shape[0])]\n\n\treturn report_table[:,0].tolist(), new_name, report_table[:,4].tolist()","def read_data(filename, use):\r\n with open(os.path.join(os.getcwd(), filename)) as csvfile:\r\n read_csv = csv.reader(csvfile, delimiter=',')\r\n if use == 'exp':\r\n data = set()\r\n for row in read_csv:\r\n data.add(tuple(row))\r\n elif use == 'field':\r\n data = {}\r\n for row in read_csv:\r\n data[row[0]] = int(row[1])\r\n return data","def getTransListSet(self, filePath):\n transListSet = []\n with open(filePath, 'r') as file:\n reader = csv.reader(file, delimiter=',')\n for line in reader:\n transListSet.append(set(line)) \n return transListSet","def getPersonIDs(cohort, **kargs):\n def read_ids(fpath):\n fname = os.path.basename(fpath) \n assert fname.find('.id') > 0\n assert os.path.exists(fpath), 'Invalid input: %s' % fpath\n df = pd.read_csv(fpath, sep=sep, header=0, index_col=False, error_bad_lines=True)\n assert id_field in df.columns, 'Invalid ID field: %s | header=%s' % (id_field, df.columns.values)\n return df[id_field].values\n\n # cohort_name = kargs['cohort']\n sep = kargs.get('sep', ',')\n basedir = inputdir = kargs.get('inputdir', seqparams.getCohortDir(cohort=cohort))\n fname = seqparams.getIDFile(cohort, **kargs)\n fpath = os.path.join(basedir, fname)\n id_field = kargs.get('id_field', 'person_id')\n\n return read_ids(fpath)","def get_apids(config):\n csv_info = get_csv_info(config)\n apids = []\n for line in csv_info:\n if int(line['apid']) not in apids:\n apids.append(int(line['apid']))\n return apids","def load_uniprot(filepath):\n print('Loading uniprot dataset')\n with open(filepath) as handle:\n uniprot = [r for r in SeqIO.parse(handle, 'swiss')]\n repeated_seqs = set(seq for seq, count in Counter(u._seq._data for u in uniprot).items() if count > 1)\n return uniprot, repeated_seqs","def _convert_ids(self, ids):\n ids_list_int = []\n\n for id_ in ids:\n if not self._validate_identifier(id_):\n raise PhabfiveDataException(f\"Identifier '{id_}' is not valid\")\n\n id_ = id_.replace(\"P\", \"\")\n # constraints takes int\n id_ = int(id_)\n ids_list_int.append(id_)\n\n return ids_list_int","def convert2int(self,seq_pep):\n\t\treturn [self.aminoacids.index(pep) for pep in seq_pep]","def get_ids(corpus):\n corpusids = []\n for chunk in corpus:\n for _id in chunk.keys():\n corpusids.append(_id)\n return corpusids","def get_seqs(in_fpath):\n f = open(in_fpath, 'r')\n csvread = csv.reader(f)\n seqs = [str(row) for row in csvread]\n seq1 = re.sub('[^A-Z]+', \"\", seqs[0])\n seq2 = re.sub('[^A-Z]+', \"\", seqs[1])\n return seq1, seq2","def convert_to_ids(self, vocab):\n for data_set in [self.train_set, self.dev_set, self.test_set]:\n if data_set is None:\n continue\n for sample in data_set:\n sample['question_token_ids'] = vocab.convert_to_ids(sample['question_tokens'])\n for passage in sample['passages']:\n passage['passage_token_ids'] = vocab.convert_to_ids(passage['passage_tokens'])","def readInputFile(self, proteinFastaFile):\n fh = open(proteinFastaFile, 'r')\n fastaIterator = SeqIO.FastaIO.FastaIterator(fh)\n pcssProteins = []\n \n for seqRecord in fastaIterator:\n \n pcssProtein = self.parseFastaHeader(seqRecord)\n pcssProtein.setProteinSequence(seqRecord.seq)\n pcssPeptideList = self.parseFastaSequence(seqRecord)\n pcssProtein.setPeptides(pcssPeptideList)\n\n pcssProteins.append(pcssProtein)\n \n log.info(\"PeptideImporter: read %s proteins from input file\" % len(pcssProteins))\n fh.close()\n return pcssProteins","def get_fasta_sequence_ids(fasta):\n if not os.path.exists(fasta) or (not os.path.isfile(fasta)):\n raise FileNotFoundError(fasta)\n seq_ids = set()\n with open(fasta, \"r\") as f:\n # 'fasta' is https://biopython.org/wiki/SeqIO file type.\n for record in SeqIO.parse(f, \"fasta\"):\n seq_ids.add(record.id)\n return seq_ids","def ptb_nomenclature(infilename):\n istream = open(infilename)\n V = set([])\n for line in istream:\n V.update(line.split())\n istream.close()\n return V","def get_all_customer_ids_from_table(table):\n return {row[CUSTOMER_ID] for row in table}","def seqids_from_otu_to_seqid(otu_to_seqid):\r\n return set(flatten(otu_to_seqid.values()))","def list_of_gene_IDs_and_symbols_from_file(input_seq_file):\n print(\"Find entrezgene IDs for reporter genes in RNAseq run\")\n lines = []\n with open(input_seq_file, 'U') as input_seq_file:\n next(input_seq_file)\n for line in input_seq_file:\n new_line = line.strip().split('\\t')[0]\n new_line = re.sub('\"', '', new_line) # inputs contained quotes\n lines.append(new_line)\n\n query_list = pd.Series(data=lines).tolist()\n\n print(\"length of query list: \", len(query_list))\n return query_list","def find_all_ids(rows):\r\n lines = []\r\n road_list=['ML']\r\n# road_list=['ML','HV', 'FR']\r\n for row in rows:\r\n strings=string.split(row,'\\n')[1:]\r\n for stringI in strings:\r\n tokens=string.split(stringI,'\\t')\r\n if len(tokens)>1:\r\n if tokens[11] in road_list:\r\n try:\r\n lines.append([int(tokens[0]), float(tokens[7]), tokens[2], [float(tokens[8]), float(tokens[9])], int(tokens[1])])\r\n except ValueError:\r\n print 'bad tokens: ', tokens\r\n continue\r\n print lines\r\n return lines","def gene_to_protein(gene: str, intrones: Union[str, Collection[str]]) -> str:\n intrones = intrones if not isinstance(intrones, str) else (intrones,)\n for introne in intrones:\n gene = gene.replace(introne, \"\")\n return dna_to_protein(gene)","def _decode_v1(self, line: str) -> Set[str]:\n\n result = set()\n\n local_line = line.strip()\n\n if local_line.startswith(\"||\") and (\n local_line.endswith(\"^\") or local_line.endswith(\"$\")\n ):\n local_line = local_line.replace(\"||\", \"\", 1)\n\n if local_line.endswith(\"^\"):\n local_line = \"\".join(local_line.rsplit(\"^\", 1))\n elif local_line.endswith(\"$\"):\n local_line = \"\".join(local_line.rsplit(\"$\", 1))\n\n result.update(self._decode_multiple_subject(local_line))\n\n return {x for x in result if \".\" in x}","def get_rsids(input_file: str) -> list:\n\n column_names: list = [\"rsid\", \"chr\"]\n # catching the error if the file does not have the column names\n try:\n rsid_file: pd.DataFrame = pd.read_csv(input_file, usecols=column_names)\n except KeyError:\n print(\"The expected header was not found within the file\")\n print(\n \"Please ensure that the file has at least two columns: 'rsid' and 'chr'\"\n )\n sys.exit(1)\n\n rsid_list: list = rsid_file.rsid.values.tolist()\n chr_list: list = rsid_file[\"chr\"].values.tolist()\n\n total_rsid_list: list = list(zip(rsid_list, chr_list))\n\n return total_rsid_list","def get_pubmed_ids(self):\n return self.pmids","def get_value_set(self, tag_pattern=None, normalise=False):\n value_set = set([])\n if tag_pattern:\n tag_pattern = TagPattern.parse(tag_pattern)\n for row in self:\n if tag_pattern:\n new_values = row.get_all(tag_pattern)\n else:\n new_values = row.values\n if normalise:\n new_values = [hxl.datatypes.normalise(s) for s in new_values]\n else:\n new_values = [hxl.datatypes.normalise_space(s) for s in new_values]\n value_set.update(new_values)\n return value_set","def get_person_ids(self) -> np.ndarray:\n return self.person_ids","def manual_uniprot_mapping(self, gene_to_uniprot_dict, outdir=None, set_as_representative=True):\n for g, u in tqdm(gene_to_uniprot_dict.items()):\n g = str(g)\n gene = self.genes.get_by_id(g)\n\n try:\n uniprot_prop = gene.protein.load_uniprot(uniprot_id=u,\n outdir=outdir, download=True,\n set_as_representative=set_as_representative)\n except HTTPError as e:\n log.error('{}, {}: unable to complete web request'.format(g, u))\n print(e)\n continue\n\n log.info('Completed manual ID mapping --> UniProt. See the \"df_uniprot_metadata\" attribute for a summary dataframe.')","def get_all_ids(self):\r\n return self.__person_repository.get_all_ids()","def primary(self):\n return Seq(''.join([r.aa for r in self.residues]), protein_alphabet)","def get_uniqueZIP(df):\n return df.ZIP.unique().tolist()","def get_unique_semantic_labels() -> Set[int]:\n idxs = set()\n data = SUNRGBDTrainDataset(True)\n for i in range(len(data)):\n idxs.update([x.item() for x in t.unique(data[i][1])])\n return idxs","def get_all_customer_ids():\n table = data_manager.get_table_from_file(\"sales/sales.csv\")\n return get_all_customer_ids_from_table(table)","def produce_protein_interaction_dict (inPath, outPath): \n PPIs = pd.read_table(inPath, sep=\"\\t\")\n proteins = set(PPIs[[\"Protein_1\", \"Protein_2\"]].values.flatten())\n proteinPartners = {}\n for protein in proteins:\n partners = set(PPIs.loc[(PPIs[[\"Protein_1\", \"Protein_2\"]]==protein).any(1),\n [\"Protein_1\", \"Protein_2\"]].values.flatten()) - {protein}\n if sum((PPIs[[\"Protein_1\", \"Protein_2\"]]==protein).all(1)) > 0:\n partners.add(protein)\n proteinPartners[protein] = partners\n with open(outPath, 'wb') as fOut:\n pickle.dump(proteinPartners, fOut)","def _get_genes(self, genes: Union[str, List[str]]) -> List[str]:\n if isinstance(genes, str):\n up = pd.read_table(genes, header=None, comment=\"#\", dtype=str)\n ups= up.values.astype(str)\n ups = list(np.squeeze(ups))\n elif isinstance(genes, (list, tuple)):\n ups = genes\n else:\n raise Exception(\"genes must be filepath, list or tuple\")\n # filter genes\n ups_new = [str(i) for i in ups if str(i) in self.genes]\n\n if len(ups_new) < 1: \n raise Exception(\"No genes found. Please input proper Entrez id\")\n return ups_new","def ids(self) -> Sequence[str]:\n return pulumi.get(self, \"ids\")","def ids(self) -> Sequence[str]:\n return pulumi.get(self, \"ids\")","def get_all_identifiers(self, cmpd_rows_df):\n\n num_rows = cmpd_rows_df.shape[0]\n # Get all the identifiers for a single PiMP compound (could be one but want this as list).\n identifiers = []\n for i in range(0, (num_rows)):\n new_id = cmpd_rows_df.iloc[i]['identifier']\n identifiers.append(new_id)\n\n # Take one of the rows for this compound, add identifiers and save in the final df.\n\n return identifiers","def ent_ids(self) -> Tuple[Optional[str], ...]:\n keys = set(self.fuzzy_patterns.keys())\n keys.update(self.regex_patterns.keys())\n all_ent_ids = set()\n\n for k in keys:\n if self.ent_id_sep in k:\n _, ent_id = self._split_label(k)\n all_ent_ids.add(ent_id)\n all_ent_ids_tuple = tuple(all_ent_ids)\n return all_ent_ids_tuple","def get_user_id(file_path: str, column: int, foreign_import=False) -> list:\n data = pd.read_csv(file_path, sep=',', header=None)\n\n if foreign_import:\n data.dropna(how='all', inplace=True)\n return data[0].values\n\n else:\n data = data.loc[data[column].isna()]\n data.dropna(how='all', inplace=True)\n return data[1].values","def __preprocess_line(line):\n return [int(element) for element in line.lstrip().rstrip().split()] # preprocess the input line","def get_primary_dids(self, rows):\n\n\t\tprimary_dids = {}\n\t\tfor row in rows:\n\t\t\t(account_number, phone_number) = (int(row[0]), row[1])\n\t\t\tif primary_dids.has_key(account_number):\n\t\t\t\tprimary_dids[account_number].append(phone_number)\n\t\t\telse:\n\t\t\t\tprimary_dids[account_number] = [phone_number]\n\n\t\treturn primary_dids","def parse_fasta_use_bio(file_name):\n pro_id_list = []\n for seq_record in SeqIO.parse(file_name, \"fasta\"):\n tmp_list = seq_record.id.strip('\\n').split('|')\n pro_id_list.append(tmp_list[1])\n # break\n\n return pro_id_list","def test_get_sam_ids(self):\r\n map_file = StringIO.StringIO(\"\"\"#SampleID\tCountry\tAgeYears\tFamily\tAgeCat\r\n h208A.1\tMalawi\t0.032854209\th208\tChild\r\n h301A.1\tMalawi\t0.05\th301\tChild\r\n h301B.1\tMalawi\t0.05\th301\tChild\r\n USinfTw20.1\tUSA\t0.083333333\tUSinfTw20\tChild\r\n USinfTw20.2\tUSA\t0.083333333\tUSinfTw20\tChild\r\n USinfTw1.1\tUSA\t0.083333333\tUSinfTw1\tChild\r\n h10M\tMalawi\t26\th10\tAdult\r\n h68M\tMalawi\t26\th68\tAdult\r\n TS25\tUSA\t26\tUSts9\tAdult\r\n TS26\tUSA\t26\tUSts9\tAdult\"\"\")\r\n\r\n map_data, map_header, comments = parse_mapping_file(map_file)\r\n colorby = 'Country'\r\n cat = 'USA'\r\n primary_state = 'AgeCat:Child'\r\n ids1, ids2 = get_sam_ids(map_data, map_header, colorby, cat,\r\n primary_state, secondary_state=None)\r\n self.assertEqual(set(ids1),\r\n set(['USinfTw20.1', 'USinfTw20.2', 'USinfTw1.1']))\r\n self.assertEqual(set(ids2), set(['TS25', 'TS26']))","def _translate_line_to_pid_pair(self, line):","def get_training_ids(mydb):\n\treturn list(mydb.fetch_table(table_name='training_set',field_names=['CaseId']).CaseId)","def __sub_set_from_linescsv(self, csv_path):\n # gather line ids\n ids = []\n with open(csv_path, 'r') as f_csv:\n reader = csv.reader(f_csv, delimiter=' ')\n for line_id in reader:\n ids.append(line_id[0])\n # create sub-set based on the indices\n sub_set = self.__line_id_subset(ids=ids)\n return sub_set","def get_plate_ids(self) -> Union[List[int], None]:\n if self.imported is not True:\n logging.error(f'File {self.file_path} has not been imported')\n return None\n else:\n print(\"time to get some IDs\")\n q = self.conn.getQueryService()\n print(q)\n params = Parameters()\n path_query = str(self.file_path).strip('/')\n print(f\"path query: f{path_query}\")\n params.map = {\"cpath\": rstring(path_query)}\n print(params)\n results = q.projection(\n \"SELECT DISTINCT p.id FROM Plate p\"\n \" JOIN p.plateAcquisitions pa\"\n \" JOIN pa.wellSample ws\"\n \" JOIN ws.image i\"\n \" JOIN i.fileset fs\"\n \" JOIN fs.usedFiles u\"\n \" WHERE u.clientPath=:cpath\",\n params,\n self.conn.SERVICE_OPTS\n )\n print(results)\n self.plate_ids = [r[0].val for r in results]\n return self.plate_ids","def select_unique_ids(self):\n adience = self.metadata\n adi_ids = []\n for gg in set(adience['gender']):\n for ag in set(adience['age_group']):\n try:\n idx = np.logical_and(adience['gender'] == gg,adience['age_group'] == ag)\n intersection_ids = list(adience[idx]['user_id'] +\n '/coarse_tilt_aligned_face.' +\n adience[idx]['face_id'].astype(str) +\n '.' + adience[idx]['original_image'])\n if len(intersection_ids) <= CAP:\n adi_ids += intersection_ids\n else:\n x = list(np.random.choice(intersection_ids, CAP, replace=False))\n adi_ids += x\n\n except:\n continue\n self.unique_ids = adi_ids\n return adi_ids"],"string":"[\n \"def get_award_ids (self, column):\\n raw = self[column]\\n vals = map (lambda x:x.strip(), raw.split(','))\\n # return list (set (vals))\\n return vals\\n\\n if 0:\\n # truncated = filter (None, map (lambda x: len(x)>5 and x[-5:] or None, vals))\\n truncated = filter (None, map (lambda x: len(x)>5 and normalize_id(x) or None, vals))\\n\\n # we only want the unique values (e.g. crossref lists dups sometimes)\\n return list (set (truncated))\",\n \"def genes():\\n data=pd.read_csv(config['stan'], sep=\\\" \\\")\\n return list(set(data['Gene_id']))\",\n \"def protein_name_collector():\\n resL = []\\n with open(\\\"bob/processed/bobprots_down.csv\\\", \\\"r\\\") as inpF:\\n for inpLine in inpF:\\n inpLine = inpLine.split(\\\",\\\")\\n resL.append(inpLine[0].strip(\\\" \\\\n\\\"))\\n return resL\",\n \"def _flattenMergedProteins(proteins):\\n proteinSet = set()\\n for protein in proteins:\\n if isinstance(protein, tuple):\\n proteinSet.update(protein)\\n else:\\n proteinSet.add(protein)\\n return proteinSet\",\n \"def ids(filename):\\n with open(filename) as file:\\n contents = file.read()\\n return [int(x) for x in contents.split(\\\",\\\")]\",\n \"def get_ids_from_web_table(self, path_file: str = None) -> List[str]:\\n if path_file is None:\\n path_file = \\\"_Materials Project.csv\\\"\\n ids_data = pd.read_csv(path_file)\\n ids = ids_data[\\\"Materials Id\\\"]\\n self.ids = ids\\n return ids\",\n \"def _convert_pert_id_to_InChI(pert_ids):\\n _download_metadata()\\n l1000meta_df = pd.read_csv(L1000FWD_METADATA, index_col=0)\\n return list(map(lambda s: s.replace('InChIKey=', '') if isinstance(s, str) else s, l1000meta_df['inchi_key'].loc[pert_ids]))\",\n \"def get_ids():\\n # Filename for SALAMI IA metadata\\n metadata_file = os.path.join(\\n dpath.SALAMI, 'metadata', 'id_index_internetarchive.csv')\\n\\n ids = []\\n\\n with open(metadata_file, \\\"r\\\") as rwc_file:\\n reader = csv.reader(rwc_file)\\n next(reader) #skip header\\n for row in reader:\\n ids.append(int(row[0]))\\n\\n return ids\",\n \"def kegg_converter():\\n from tools import prot_id_converter\\n \\n protList = []\\n headerFlag = True\\n with open(\\\"../bob/processed/24h_bobprots_up_full.csv\\\",\\\"r\\\") as inpF:\\n for inpLine in inpF:\\n if headerFlag:\\n headerFlag = False\\n continue\\n inpList = inpLine.split(\\\",\\\")\\n protList.append(inpList[1])\\n print(prot_id_converter(protList, outDB=\\\"kegggeneid\\\"))\",\n \"def get_sample_ids(maptable):\\n return [line[0] for line in maptable[1:]]\",\n \"def get_id_set(self):\\n s = set()\\n for player in Player.select(Player.player_id):\\n s.add(player.player_id)\\n return s\",\n \"def get_tweets_ids_from_csv(self):\\n for fname in self.filelist:\\n with open(fname) as f:\\n fakenews = csv.reader(f)\\n next(fakenews) # Discard top CSV row\\n for fake in fakenews:\\n yield fake[3].split(\\\"\\t\\\")\",\n \"def purify(self, csv_list):\\n for row in csv_list:\\n if row[0].strip(\\\" \\\") == \\\"ID\\\":\\n return csv_list[csv_list.index(row) + 1:]\\n return csv_list\",\n \"def produce_uniqueGene_swissProtIDs (inPath, geneMapFile, outPath):\\n with open(inPath, 'r') as f:\\n swissProtIDs = pd.Series(list(set(f.read().split())))\\n with open(geneMapFile, 'rb') as f:\\n geneMap = pickle.load(f)\\n swissProtIDGenes = swissProtIDs.apply(lambda x: geneMap[x] if x in geneMap else 'no_name')\\n duplicates = swissProtIDGenes.duplicated(keep=False)\\n uniqueGeneSwissProtIDs = swissProtIDs[(duplicates==False) & (swissProtIDGenes!='no_name')]\\n uniqueGeneSwissProtIDs.to_csv(outPath, index=False)\",\n \"def orthologueGeneIds(self):\\n\\t\\tgeneIds = []\\n\\t\\tfor geneId,row in self._dataframe.iterrows():\\n\\t\\t\\tfor item in row['Orthologue'].split(','):\\t# looks like 'ENSG00003435:Gene1,ENSG00002525:Gene2' (multiple orthologues possible)\\n\\t\\t\\t\\tif item.split(':')[0]: geneIds.append(item.split(':')[0])\\n\\t\\treturn list(set(geneIds))\",\n \"def get_ids(self) -> List[str]:\",\n \"def parseAtomid(self, line):\\n\\n\\t\\tcols = string.split(line, \\\",\\\")\\n\\n\\t\\tfor col in cols:\\n\\t\\t\\tif \\\"-\\\" in col:\\n\\t\\t\\t\\t(beg, end) = string.split(col, \\\"-\\\")\\n\\t\\t\\t\\tbeg = int(beg)\\n\\t\\t\\t\\tend = int(end)\\n\\t\\t\\t\\tfor i in range(beg,end+1):\\n\\t\\t\\t\\t\\tself.atomid.append(i)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.atomid.append(col)\",\n \"def get_taxids(read_from_flat_files=False, fn=None):\\n if read_from_flat_files:\\n taxids = []\\n if fn is None:\\n # Taxid_2_Proteins_table_STRING = os.path.join(variables.TABLES_DIR, \\\"Taxid_2_Proteins_table_STRING.txt\\\")\\n Taxid_2_Proteins_table_STRING = variables.tables_dict[\\\"Taxid_2_Proteins_table\\\"]\\n with open(Taxid_2_Proteins_table_STRING, \\\"r\\\") as fh:\\n for line in fh:\\n taxids.append(line.split(\\\"\\\\t\\\")[0])\\n return taxids\\n else:\\n result = get_results_of_statement(\\\"SELECT taxid_2_protein.taxid FROM taxid_2_protein;\\\")\\n return sorted([rec[0] for rec in result])\",\n \"def Get_Uniprot_IDs(Neg_cases):\\r\\n workbook= xlrd.open_workbook(\\\"../Data/Negative_cases/Uniprot_total_neg_cases.xlsx\\\")\\r\\n worksheet= workbook.sheet_by_name(\\\"Uniprot_negative_cases\\\")\\r\\n UniprotEntries=[]\\r\\n for i in Neg_cases:\\r\\n EntryText=str(worksheet.cell(i,0))\\r\\n Entry=EntryText[6:(len(EntryText)-1)]\\r\\n UniprotEntries.append(Entry)\\r\\n return UniprotEntries\",\n \"def get_vendor_ids(tools_csv):\\n\\n import csv\\n\\n vendors = {}\\n\\n with open(tools_csv, 'r') as csvfile:\\n\\n reader = csv.reader(csvfile, delimiter=',', quotechar='\\\"')\\n\\n next(reader) # skip the header\\n\\n for row in reader:\\n\\n tool_name, tool_id, vendor_id = row[:3]\\n\\n if vendor_id in vendors:\\n vendors[vendor_id].append((tool_id, tool_name))\\n else:\\n vendors[vendor_id] = [(tool_id, tool_name)]\\n\\n return vendors\",\n \"def get_set_of_ids(self, elements):\\n\\n new_set = set()\\n for e in set(elements):\\n new_set.add(self._reaction_system.get_entity_id(e))\\n return new_set\",\n \"def get_input(data_file: str) -> Set[int]:\\n with open(data_file) as f:\\n return {int(x.strip()) for x in f.readlines()}\",\n \"def read_ID(ID_fn):\\n print(\\\"Reading id_to_ethnicity file...\\\")\\n with open(ID_fn, newline='') as f:\\n readCSV = csv.reader(f, delimiter=',')\\n id_to_ethnicity = []\\n for array in readCSV:\\n if len(array) != 2: # avoid empty rows\\n break\\n id_to_ethnicity.append([array[0], array[1]]) #[0]: patient_ID, [1]: Ethnicity\\n\\n return id_to_ethnicity\",\n \"def fasta2csv(self, is_local_interpro):\\n\\t\\tprint(\\\"Creating row for each protein with domain, please wait..\\\")\\n\\t\\tdataset_name = \\\"toxin_dataset.csv\\\"\\n\\t\\tnum_all_proteins = 0\\n\\t\\tnum_proteins_with_domains = 0\\n\\t\\tnum_remain_proteins = 0\\n\\t\\tcsv_already_exists = True\\n\\t\\tif not isfile(join(self.output_path, dataset_name)): # if csv not exists then firstly write header\\n\\t\\t\\tcsv_already_exists = False\\n\\t\\tfor fasta_file in listdir(self.fasta_dir_path):\\n\\t\\t\\tshort_label = splitext(basename(fasta_file))[0].split(\\\".\\\")[0]\\n\\t\\t\\twith open(join(self.fasta_dir_path, fasta_file), 'r') as fasta_data, open(self.domains_path,\\n\\t\\t\\t 'r') as domains_data, open(\\n\\t\\t\\t\\t\\tjoin(self.output_path, dataset_name), 'a') as dataset_csv, open(\\n\\t\\t\\t\\t\\tjoin(self.output_path, \\\"toxin_remaining_seq\\\" + \\\"_\\\" + short_label + \\\".fasta\\\"),\\n\\t\\t\\t\\t\\t'a') as remain_seqs_file:\\n\\t\\t\\t\\tproteins_dict = SeqIO.to_dict(SeqIO.parse(fasta_data, \\\"fasta\\\"))\\n\\t\\t\\t\\tnum_all_proteins += len(proteins_dict)\\n\\t\\t\\t\\tuniprot2prot = self.extract_uniprot4protein_keys(proteins_dict)\\n\\t\\t\\t\\twriter = csv.writer(dataset_csv, delimiter=',')\\n\\t\\t\\t\\tif not csv_already_exists: # if csv not exists then firstly write header\\n\\t\\t\\t\\t\\tproteins_domains_header = [\\\"uniprot_id\\\", \\\"toxin\\\", \\\"seq\\\", \\\"seq_len\\\", \\\"interpro_domains\\\",\\n\\t\\t\\t\\t\\t \\\"evidence_db_domains\\\"]\\n\\t\\t\\t\\t\\twriter.writerow(proteins_domains_header)\\n\\t\\t\\t\\t\\tcsv_already_exists = True\\n\\t\\t\\t\\tbatch_num_lines = 10000\\n\\n\\t\\t\\t\\tfor i, batch in enumerate(batch_iterator(domains_data, batch_num_lines)):\\n\\t\\t\\t\\t\\tfor line in batch:\\n\\t\\t\\t\\t\\t\\tline_split = line.strip().split(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tassert len(line_split) == 3, \\\"AssertionError: {} does not have 3 tabs.\\\".format(line)\\n\\t\\t\\t\\t\\t\\tuniprot_id = line_split[0]\\n\\t\\t\\t\\t\\t\\tif uniprot_id == \\\"uniprot_id\\\":\\n\\t\\t\\t\\t\\t\\t\\tprint(\\\"Skipping first line\\\")\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\tif is_local_interpro:\\n\\t\\t\\t\\t\\t\\t\\tuniprot_id = uniprot_id.split(\\\"|\\\")[1]\\n\\t\\t\\t\\t\\t\\tif uniprot_id in uniprot2prot:\\n\\t\\t\\t\\t\\t\\t\\tinterpro_ids = line_split[1]\\n\\t\\t\\t\\t\\t\\t\\tevidence_db_ids = line_split[2]\\n\\t\\t\\t\\t\\t\\t\\tlabel = self.get_labels(fasta_file)\\n\\t\\t\\t\\t\\t\\t\\t# make the row of the current protein\\n\\t\\t\\t\\t\\t\\t\\tprotein_row = [uniprot_id, label, str(uniprot2prot[uniprot_id].seq),\\n\\t\\t\\t\\t\\t\\t\\t len(str(uniprot2prot[uniprot_id].seq)), interpro_ids, evidence_db_ids]\\n\\t\\t\\t\\t\\t\\t\\twriter.writerow(protein_row)\\n\\t\\t\\t\\t\\t\\t\\tnum_proteins_with_domains += 1\\n\\t\\t\\t\\t\\t\\t\\t# remove found protein from the dictionary, to keep track of the remaining proteins\\n\\t\\t\\t\\t\\t\\t\\tuniprot2prot.pop(uniprot_id)\\n\\n\\t\\t\\t\\tnum_remain_proteins += len(uniprot2prot) # update num of remain proteins\\n\\t\\t\\t\\tSeqIO.write(uniprot2prot.values(), remain_seqs_file, \\\"fasta\\\") # append remaining proteins to fasta\\n\\t\\t\\t\\tprint(\\\"num of remaining proteins for {} label: {} saved on remaining fasta\\\".format(\\n\\t\\t\\t\\t\\tself.get_labels(fasta_file), len(uniprot2prot)))\\n\\t\\tassert num_all_proteins == num_proteins_with_domains + num_remain_proteins, \\\"AssertionError: total num of proteins should be equal to proteins with domains + proteins without domains.\\\"\\n\\t\\tprint(\\\"num of Toxin proteins: {}\\\".format(num_all_proteins))\\n\\t\\tprint(\\\"num of Toxin proteins with found domains: {}\\\".format(num_proteins_with_domains))\\n\\t\\tprint(\\\"num of remaining proteins with not found domains: {}\\\".format(num_remain_proteins))\",\n \"def prepare_hpa_data(d):\\n # Prep protein class lists\\n d['Protein classes'] = (\\n # Split class string on commas (missing protein class will become empty tuple)\\n d['Protein class'].fillna('').str.split(',')\\n # Apply clean function to each item is split sequences and deduplicate tuple\\n .apply(lambda v: tuple(set(map(clean_protein_class_name, v))))\\n )\\n return d.drop('Protein class', axis=1)\",\n \"def get_ids(self, year, switch):\\n ids = list()\\n path = os.path.join(self.get_ids_path(switch), '{}.csv'.format(year))\\n with open(path, 'r') as file:\\n reader = csv.reader(file)\\n ids = [row[0] for row in reader]\\n return ids\",\n \"def dataFromFile(fname):\\n file_iter = open(fname, 'rU')\\n for line in file_iter:\\n line = line.strip().rstrip(',') # Remove trailing comma\\n record = frozenset(line.split(','))\\n yield record\",\n \"def produce_uniqueGene_sequences (inPath,\\n uniqueGeneSwissProtIDFile,\\n geneMapFile,\\n outPath):\\n with open(uniqueGeneSwissProtIDFile, 'r') as f:\\n uniqueGeneSwissProtIDs = set(f.read().split())\\n with open(geneMapFile, 'rb') as f:\\n geneMap = pickle.load(f)\\n sequences = pd.read_table(inPath, sep=\\\"\\\\t\\\")\\n sequencesRefID = sequences[\\\"ID\\\"].apply(lambda x: x if x.find('-') == -1 else x[:x.find('-')])\\n sequences[\\\"Gene_Name\\\"] = sequencesRefID.apply(lambda x: geneMap[x] if x in geneMap else x)\\n sequences = sequences[sequencesRefID.isin(uniqueGeneSwissProtIDs)].reset_index(drop=True)\\n sequences.to_csv(outPath, index=False, sep='\\\\t')\",\n \"def fasta_ids(fasta_files, verbose=False):\\r\\n all_ids = set([])\\r\\n for fasta_in in fasta_files:\\r\\n for label, seq in parse_fasta(fasta_in):\\r\\n rid = label.split()[0]\\r\\n if rid in all_ids:\\r\\n raise ValueError(\\r\\n \\\"Duplicate ID found in FASTA/qual file: %s\\\" %\\r\\n label)\\r\\n all_ids.add(rid)\\r\\n return all_ids\",\n \"def getRiverIDs(lookupCsv):\\n\\n d = {}\\n with open(lookupCsv, \\\"rb\\\") as f:\\n reader = csv.reader(f)\\n\\n # Discard header row\\n reader.next()\\n\\n for row in reader:\\n d[row[0]] = row[1]\\n\\n return d\",\n \"def dataFromFile(fname):\\n file_iter = open(fname, 'rU')\\n for line in file_iter:\\n #print(line)\\n line = line.strip().rstrip(',') # Remove trailing comma\\n record = frozenset(line.split(','))\\n yield record\",\n \"def extract_uniprot4protein_keys(self, proteins_dict):\\n\\t\\treturn {key.split(\\\"|\\\")[1]: value for (key, value) in proteins_dict.items()}\",\n \"def get_ids_values(path):\\n \\n def read_txt(path):\\n \\\"\\\"\\\"read text file from path.\\\"\\\"\\\"\\n \\n with open(path, \\\"r\\\") as f:\\n return f.read().splitlines()\\n \\n raw_data = read_txt(path)[1:]\\n \\n def deal_line(line):\\n ids, values = line.split(',')\\n return ids, values\\n \\n ids_values = [deal_line(line) for line in raw_data]\\n ids = [x[0] for x in ids_values]\\n values = [x[1] for x in ids_values]\\n values = list(map(int, values))\\n \\n return ids, values\",\n \"def ids(self):\\n return frozenset([seq.id for seq in self])\",\n \"def open_csv(filename):\\n with open(filename) as csv_file:\\n file_reader = reader(csv_file, delimiter=',')\\n id_list = []\\n for row in file_reader:\\n id_list.append(row[0])\\n\\n return id_list\",\n \"def produce_uniprotID_dict(inPath, spList, outPath):\\n with open(spList, 'r') as f:\\n swissProtIDs = set(f.read().split())\\n with open(inPath, 'r') as fIn:\\n idMap = {}\\n for line in fIn:\\n uniprotID, otherIDtype, otherID = line.strip().split('\\\\t')\\n if uniprotID in swissProtIDs:\\n if otherIDtype == 'Gene_Name':\\n otherID = otherID.upper()\\n idMap[otherID] = uniprotID\\n with open(outPath, 'wb') as fOut:\\n pickle.dump(idMap, fOut)\",\n \"def _eidset():\\n\\n dbrosters = set()\\n with sqlite3.connect(DB) as db:\\n cursor = db.cursor()\\n cursor.execute(\\\"SELECT eid FROM players\\\")\\n rows = cursor.fetchall()\\n for row in rows:\\n dbrosters.add(int(row[0]))\\n # return set.\\n return dbrosters\",\n \"def _findSamesetProteins(protToPeps, proteins=None):\\n proteins = viewkeys(protToPeps) if proteins is None else proteins\\n\\n equalEvidence = ddict(set)\\n for protein in proteins:\\n peptides = protToPeps[protein]\\n equalEvidence[tuple(sorted(peptides))].add(protein)\\n equalProteins = list()\\n for proteins in viewvalues(equalEvidence):\\n if len(proteins) > 1:\\n equalProteins.append(tuple(sorted(proteins)))\\n return equalProteins\",\n \"def get_ids(self, sentence):\\n return [self.get_id(word) for word in sentence.strip().split(' ')]\",\n \"def generate_company_list():\\n path = 'companylist.csv'\\n companyids = []\\n with open(path, 'r') as csv_file:\\n csv_reader = csv.reader(csv_file)\\n for line in csv_reader:\\n companyids.append(line[0])\\n companyids.pop(0)\\n return companyids\",\n \"def _as_delimited_set(self, name):\\n org_type = self._get_type(name)\\n if org_type == 'delimited set': return None\\n valid = ['single', 'string']\\n if not org_type in valid:\\n msg = 'Cannot convert variable {} of type {} to delimited set!'\\n raise TypeError(msg.format(name, org_type))\\n if org_type == 'single':\\n self._meta['columns'][name]['type'] = 'delimited set'\\n self._data[name] = self._data[name].apply(\\n lambda x: str(int(x)) + ';' if not np.isnan(x) else np.NaN)\\n return None\\n elif org_type == 'string':\\n # we assume we have a delimited set in the string variable\\n # delimited with a semicolon agree;disagree;agree\\n original_column = self._data[name]\\n # we encapsulate each line with !; ;! so that the string\\n # replacement works correctly\\n if original_column.dropna().tolist()[0][-1] == \\\";\\\":\\n original_column = \\\"!;\\\" + original_column + \\\"!\\\"\\n else:\\n original_column = \\\"!;\\\" + original_column + \\\";!\\\"\\n\\n original_column = original_column.replace(pd.np.nan,'')\\n original_column = original_column.str.replace(\\\"; \\\",\\\";\\\")\\n original_column = original_column.str.replace(\\\" ;\\\",\\\";\\\")\\n\\n all_values_split = [i.split(\\\";\\\") for i in original_column]\\n flat = [i for sublist in all_values_split for i in sublist]\\n trim = [i.strip() for i in flat]\\n trim = [i for i in trim if len(i)>0]\\n unique = list(set(trim))\\n if \\\"!\\\" in unique:\\n unique.remove(\\\"!\\\")\\n unique.sort()\\n value_map = []\\n quantipy_values = []\\n for k,item in enumerate(unique):\\n value_map.append((k,item))\\n quantipy_values.append({'text':{self.meta()['lib']['default text']:item},'value':k})\\n original_column = original_column.str.replace(\\\";\\\" + re.escape(item) + \\\";\\\",\\\";\\\" + str(k) + \\\";\\\")\\n original_column = original_column.str.replace(\\\"; \\\",\\\";\\\")\\n # remove the ;! !; we placed at the beginning and end of each string\\n original_column = original_column.str.replace(\\\"!;\\\",\\\"\\\")\\n original_column = original_column.str.replace(\\\"!\\\",\\\"\\\")\\n self._meta['columns'][name]['values'] = quantipy_values\\n self._meta['columns'][name]['type'] = 'delimited set'\\n self._data[name] = original_column\",\n \"def _load_protein():\\n data_file = os.path.join(data_dir, \\\"protein/CASP.csv\\\")\\n data = pd.read_csv(data_file, sep=\\\",\\\")\\n X = data.values[:, 1:]\\n y = data.values[:, 0]\\n return X, y\",\n \"def CSV(id_poke):\\r\\n poke = [] #creer une liste vide\\r\\n with open('BDD/pokemon.csv') as csv_file: #ouvre le fichier pokemon.csv\\r\\n csv_reader = csv.reader(csv_file, delimiter=',') #place les lignes du csv dans une variable\\r\\n for row in csv_reader: #parcours des lignes du csv\\r\\n if row[0] == str(id_poke): #si l'id de la ligne = id du pokemon\\r\\n poke = list(row) #variable = ligne correspondante dans le csv\\r\\n return(poke) #retourne une liste avec les caracteristiques du poke\\r\",\n \"def getById(self, ids):\\n\\t\\tproteins = []\\n\\t\\tids = [ids] if isinstance(ids, str) else ids\\n\\t\\tfor id in ids:\\n\\t\\t\\turl = self.composeQueryUrl({'query': id, 'format':'xml'})\\n\\t\\t\\tr = requests.get(url)\\n\\t\\t\\t\\n\\t\\t\\tif len(r.text) > 0:\\n\\t\\t\\t\\tprotein = self.convertXmlToProtein(r.text)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprotein = None\\n\\t\\t\\tproteins.append(protein)\\n\\t\\t\\t\\n\\t\\treturn proteins\",\n \"def getIDs():\",\n \"def get_pids_formatted(self, site: str) -> List[str]:\\n try:\\n self._cursor.execute(f\\\"SELECT productIdStr FROM {site}\\\")\\n except sqlite3.OperationalError:\\n raise sqlite3.OperationalError(f\\\"Table '{site}' does not exist. You can create it by the `create_table_safe` method.\\\")\\n rows: List[Tuple[int]] = self._cursor.fetchall()\\n return [row[0] for row in rows]\",\n \"def makePeptideOutputList(self, protein, peptide):\\n attributeList = self.pcssRunner.pfa.getColumnSortedOutputAttributes()\\n outputList = []\\n for attribute in attributeList:\\n if (attribute.attributeType == \\\"protein\\\"):\\n outputList.append(attribute.getProteinValue(protein))\\n else:\\n outputList.append(attribute.getPeptideValue(peptide))\\n return outputList\",\n \"def updateImportList(self):\\n\\t\\tids_new = self.ids\\n\\t\\tids_list = []\\n\\n\\t\\tif not os.path.exists(ids_file):\\n\\t\\t\\twith open(ids_file, 'a') as ids:\\n\\t\\t\\t\\tpass\\n\\n\\t\\twith open(ids_file, \\\"rb\\\") as ids:\\n\\t\\t\\tids_reader = csv.reader(ids)\\n\\t\\t\\tfor row in ids_reader:\\n\\t\\t\\t\\tids_list.append(row[0])\\n\\n\\t\\tids_new = set(ids_new) - set(ids_list)\\n\\n\\t\\twith open(ids_file, \\\"a\\\") as ids:\\n\\t\\t\\tids_writer = csv.writer(ids)\\n\\t\\t\\tfor idx in ids_new:\\n\\t\\t\\t\\tids_writer.writerow( str(idx) )\\n\\n\\t\\tself.ids = ids_new\",\n \"def select_unique_ids(self):\\n utk = self.metadata\\n utk_ids = []\\n for gg in set(utk['gender']):\\n for rg in set(utk['race']):\\n for ag in set(utk['age']):\\n try:\\n intersection_ids = list(utk[np.logical_and(utk['gender'] == gg,\\n np.logical_and(utk['race'] == rg,\\n utk['age'] == ag))]['filename'])\\n if len(intersection_ids) <= CAP:\\n utk_ids += intersection_ids\\n else:\\n x = list(np.random.choice(intersection_ids, CAP, replace=False))\\n utk_ids += x\\n\\n except:\\n continue\\n self.unique_ids = utk_ids\\n return utk_ids\",\n \"def _get_set_pairs(uprow, types):\\n pairs = []\\n for key, val in uprow.items():\\n pairs.append(\\\"{0}={1}\\\".format(key, _for_pgsql(val, types[key])))\\n return \\\", \\\".join(pairs)\",\n \"def get_unique_tags(df):\\n tags = []\\n\\n for index, row in df.iterrows():\\n tags = list(set(tags + ast.literal_eval(row.tags)))\\n\\n pdb.set_trace()\",\n \"def from_csv_line(line):\\r\\n return line.strip().split(',')\",\n \"def get_first_id(lines):\\r\\n result = set()\\r\\n for line in lines:\\r\\n if line.startswith('>'):\\r\\n result.add(line[1:].split()[0])\\r\\n return result\",\n \"def preset_ids(self):\\r\\n\\r\\n return map(lambda item: item[0], self.preset_items())\",\n \"def extract_protein(fileReport, INFO, PROTEIN_FUNCTION):\\n\\n\\tprint \\\"\\\\n#################\\\"\\n\\tprint \\\"# Protein extraction\\\"\\n\\tprint \\\"#################\\\\n\\\"\\n\\n\\treport_table = np.loadtxt(fileReport, dtype='string')\\n\\tnumber_prot = report_table.shape[0]\\n\\tindex_remove = []\\n\\n\\tfor index in xrange(number_prot):\\n\\t\\tif report_table[index][4] in PROTEIN_FUNCTION :\\n\\t\\t\\tsystem_number = report_table[index][7].split('_')[-1]\\n\\n\\t\\t\\tif int(system_number) > 1 :\\n\\t\\t\\t\\treport_table[index][1] = \\\"_\\\".join(report_table[index][1].split('_')[:-1])+\\\"_\\\"+system_number\\n\\t\\t\\telse:\\n\\t\\t\\t\\treport_table[index][1] = \\\"_\\\".join(report_table[index][1].split('_')[:-1])\\n\\t\\telse :\\n\\t\\t\\tindex_remove.append(index)\\n\\n\\tnp.savetxt(os.path.join(INFO, \\\"remove_report.seq\\\"), report_table[np.array(index_remove),:], delimiter=\\\"\\\\t\\\", fmt=\\\"%s\\\")\\n\\treport_table = np.delete(report_table, index_remove, axis=0)\\n\\tnumber_remove_protein = len(index_remove)\\n\\n\\tprint \\\"There are {} proteins remove during this operation because they are not in the dictionnary\\\".format(number_remove_protein)\\n\\n\\t# NOTE NC_XXXXXX[_numero de systeme si deux systemes trouvés]_nomSysteme_D_nomProteine\\n\\tnew_name = [report_table[i][1]+'_'+report_table[i][6]+'_D_'+\\\"_\\\".join(report_table[i][4].split('_')[1:]) for i in xrange(report_table.shape[0])]\\n\\n\\treturn report_table[:,0].tolist(), new_name, report_table[:,4].tolist()\",\n \"def read_data(filename, use):\\r\\n with open(os.path.join(os.getcwd(), filename)) as csvfile:\\r\\n read_csv = csv.reader(csvfile, delimiter=',')\\r\\n if use == 'exp':\\r\\n data = set()\\r\\n for row in read_csv:\\r\\n data.add(tuple(row))\\r\\n elif use == 'field':\\r\\n data = {}\\r\\n for row in read_csv:\\r\\n data[row[0]] = int(row[1])\\r\\n return data\",\n \"def getTransListSet(self, filePath):\\n transListSet = []\\n with open(filePath, 'r') as file:\\n reader = csv.reader(file, delimiter=',')\\n for line in reader:\\n transListSet.append(set(line)) \\n return transListSet\",\n \"def getPersonIDs(cohort, **kargs):\\n def read_ids(fpath):\\n fname = os.path.basename(fpath) \\n assert fname.find('.id') > 0\\n assert os.path.exists(fpath), 'Invalid input: %s' % fpath\\n df = pd.read_csv(fpath, sep=sep, header=0, index_col=False, error_bad_lines=True)\\n assert id_field in df.columns, 'Invalid ID field: %s | header=%s' % (id_field, df.columns.values)\\n return df[id_field].values\\n\\n # cohort_name = kargs['cohort']\\n sep = kargs.get('sep', ',')\\n basedir = inputdir = kargs.get('inputdir', seqparams.getCohortDir(cohort=cohort))\\n fname = seqparams.getIDFile(cohort, **kargs)\\n fpath = os.path.join(basedir, fname)\\n id_field = kargs.get('id_field', 'person_id')\\n\\n return read_ids(fpath)\",\n \"def get_apids(config):\\n csv_info = get_csv_info(config)\\n apids = []\\n for line in csv_info:\\n if int(line['apid']) not in apids:\\n apids.append(int(line['apid']))\\n return apids\",\n \"def load_uniprot(filepath):\\n print('Loading uniprot dataset')\\n with open(filepath) as handle:\\n uniprot = [r for r in SeqIO.parse(handle, 'swiss')]\\n repeated_seqs = set(seq for seq, count in Counter(u._seq._data for u in uniprot).items() if count > 1)\\n return uniprot, repeated_seqs\",\n \"def _convert_ids(self, ids):\\n ids_list_int = []\\n\\n for id_ in ids:\\n if not self._validate_identifier(id_):\\n raise PhabfiveDataException(f\\\"Identifier '{id_}' is not valid\\\")\\n\\n id_ = id_.replace(\\\"P\\\", \\\"\\\")\\n # constraints takes int\\n id_ = int(id_)\\n ids_list_int.append(id_)\\n\\n return ids_list_int\",\n \"def convert2int(self,seq_pep):\\n\\t\\treturn [self.aminoacids.index(pep) for pep in seq_pep]\",\n \"def get_ids(corpus):\\n corpusids = []\\n for chunk in corpus:\\n for _id in chunk.keys():\\n corpusids.append(_id)\\n return corpusids\",\n \"def get_seqs(in_fpath):\\n f = open(in_fpath, 'r')\\n csvread = csv.reader(f)\\n seqs = [str(row) for row in csvread]\\n seq1 = re.sub('[^A-Z]+', \\\"\\\", seqs[0])\\n seq2 = re.sub('[^A-Z]+', \\\"\\\", seqs[1])\\n return seq1, seq2\",\n \"def convert_to_ids(self, vocab):\\n for data_set in [self.train_set, self.dev_set, self.test_set]:\\n if data_set is None:\\n continue\\n for sample in data_set:\\n sample['question_token_ids'] = vocab.convert_to_ids(sample['question_tokens'])\\n for passage in sample['passages']:\\n passage['passage_token_ids'] = vocab.convert_to_ids(passage['passage_tokens'])\",\n \"def readInputFile(self, proteinFastaFile):\\n fh = open(proteinFastaFile, 'r')\\n fastaIterator = SeqIO.FastaIO.FastaIterator(fh)\\n pcssProteins = []\\n \\n for seqRecord in fastaIterator:\\n \\n pcssProtein = self.parseFastaHeader(seqRecord)\\n pcssProtein.setProteinSequence(seqRecord.seq)\\n pcssPeptideList = self.parseFastaSequence(seqRecord)\\n pcssProtein.setPeptides(pcssPeptideList)\\n\\n pcssProteins.append(pcssProtein)\\n \\n log.info(\\\"PeptideImporter: read %s proteins from input file\\\" % len(pcssProteins))\\n fh.close()\\n return pcssProteins\",\n \"def get_fasta_sequence_ids(fasta):\\n if not os.path.exists(fasta) or (not os.path.isfile(fasta)):\\n raise FileNotFoundError(fasta)\\n seq_ids = set()\\n with open(fasta, \\\"r\\\") as f:\\n # 'fasta' is https://biopython.org/wiki/SeqIO file type.\\n for record in SeqIO.parse(f, \\\"fasta\\\"):\\n seq_ids.add(record.id)\\n return seq_ids\",\n \"def ptb_nomenclature(infilename):\\n istream = open(infilename)\\n V = set([])\\n for line in istream:\\n V.update(line.split())\\n istream.close()\\n return V\",\n \"def get_all_customer_ids_from_table(table):\\n return {row[CUSTOMER_ID] for row in table}\",\n \"def seqids_from_otu_to_seqid(otu_to_seqid):\\r\\n return set(flatten(otu_to_seqid.values()))\",\n \"def list_of_gene_IDs_and_symbols_from_file(input_seq_file):\\n print(\\\"Find entrezgene IDs for reporter genes in RNAseq run\\\")\\n lines = []\\n with open(input_seq_file, 'U') as input_seq_file:\\n next(input_seq_file)\\n for line in input_seq_file:\\n new_line = line.strip().split('\\\\t')[0]\\n new_line = re.sub('\\\"', '', new_line) # inputs contained quotes\\n lines.append(new_line)\\n\\n query_list = pd.Series(data=lines).tolist()\\n\\n print(\\\"length of query list: \\\", len(query_list))\\n return query_list\",\n \"def find_all_ids(rows):\\r\\n lines = []\\r\\n road_list=['ML']\\r\\n# road_list=['ML','HV', 'FR']\\r\\n for row in rows:\\r\\n strings=string.split(row,'\\\\n')[1:]\\r\\n for stringI in strings:\\r\\n tokens=string.split(stringI,'\\\\t')\\r\\n if len(tokens)>1:\\r\\n if tokens[11] in road_list:\\r\\n try:\\r\\n lines.append([int(tokens[0]), float(tokens[7]), tokens[2], [float(tokens[8]), float(tokens[9])], int(tokens[1])])\\r\\n except ValueError:\\r\\n print 'bad tokens: ', tokens\\r\\n continue\\r\\n print lines\\r\\n return lines\",\n \"def gene_to_protein(gene: str, intrones: Union[str, Collection[str]]) -> str:\\n intrones = intrones if not isinstance(intrones, str) else (intrones,)\\n for introne in intrones:\\n gene = gene.replace(introne, \\\"\\\")\\n return dna_to_protein(gene)\",\n \"def _decode_v1(self, line: str) -> Set[str]:\\n\\n result = set()\\n\\n local_line = line.strip()\\n\\n if local_line.startswith(\\\"||\\\") and (\\n local_line.endswith(\\\"^\\\") or local_line.endswith(\\\"$\\\")\\n ):\\n local_line = local_line.replace(\\\"||\\\", \\\"\\\", 1)\\n\\n if local_line.endswith(\\\"^\\\"):\\n local_line = \\\"\\\".join(local_line.rsplit(\\\"^\\\", 1))\\n elif local_line.endswith(\\\"$\\\"):\\n local_line = \\\"\\\".join(local_line.rsplit(\\\"$\\\", 1))\\n\\n result.update(self._decode_multiple_subject(local_line))\\n\\n return {x for x in result if \\\".\\\" in x}\",\n \"def get_rsids(input_file: str) -> list:\\n\\n column_names: list = [\\\"rsid\\\", \\\"chr\\\"]\\n # catching the error if the file does not have the column names\\n try:\\n rsid_file: pd.DataFrame = pd.read_csv(input_file, usecols=column_names)\\n except KeyError:\\n print(\\\"The expected header was not found within the file\\\")\\n print(\\n \\\"Please ensure that the file has at least two columns: 'rsid' and 'chr'\\\"\\n )\\n sys.exit(1)\\n\\n rsid_list: list = rsid_file.rsid.values.tolist()\\n chr_list: list = rsid_file[\\\"chr\\\"].values.tolist()\\n\\n total_rsid_list: list = list(zip(rsid_list, chr_list))\\n\\n return total_rsid_list\",\n \"def get_pubmed_ids(self):\\n return self.pmids\",\n \"def get_value_set(self, tag_pattern=None, normalise=False):\\n value_set = set([])\\n if tag_pattern:\\n tag_pattern = TagPattern.parse(tag_pattern)\\n for row in self:\\n if tag_pattern:\\n new_values = row.get_all(tag_pattern)\\n else:\\n new_values = row.values\\n if normalise:\\n new_values = [hxl.datatypes.normalise(s) for s in new_values]\\n else:\\n new_values = [hxl.datatypes.normalise_space(s) for s in new_values]\\n value_set.update(new_values)\\n return value_set\",\n \"def get_person_ids(self) -> np.ndarray:\\n return self.person_ids\",\n \"def manual_uniprot_mapping(self, gene_to_uniprot_dict, outdir=None, set_as_representative=True):\\n for g, u in tqdm(gene_to_uniprot_dict.items()):\\n g = str(g)\\n gene = self.genes.get_by_id(g)\\n\\n try:\\n uniprot_prop = gene.protein.load_uniprot(uniprot_id=u,\\n outdir=outdir, download=True,\\n set_as_representative=set_as_representative)\\n except HTTPError as e:\\n log.error('{}, {}: unable to complete web request'.format(g, u))\\n print(e)\\n continue\\n\\n log.info('Completed manual ID mapping --> UniProt. See the \\\"df_uniprot_metadata\\\" attribute for a summary dataframe.')\",\n \"def get_all_ids(self):\\r\\n return self.__person_repository.get_all_ids()\",\n \"def primary(self):\\n return Seq(''.join([r.aa for r in self.residues]), protein_alphabet)\",\n \"def get_uniqueZIP(df):\\n return df.ZIP.unique().tolist()\",\n \"def get_unique_semantic_labels() -> Set[int]:\\n idxs = set()\\n data = SUNRGBDTrainDataset(True)\\n for i in range(len(data)):\\n idxs.update([x.item() for x in t.unique(data[i][1])])\\n return idxs\",\n \"def get_all_customer_ids():\\n table = data_manager.get_table_from_file(\\\"sales/sales.csv\\\")\\n return get_all_customer_ids_from_table(table)\",\n \"def produce_protein_interaction_dict (inPath, outPath): \\n PPIs = pd.read_table(inPath, sep=\\\"\\\\t\\\")\\n proteins = set(PPIs[[\\\"Protein_1\\\", \\\"Protein_2\\\"]].values.flatten())\\n proteinPartners = {}\\n for protein in proteins:\\n partners = set(PPIs.loc[(PPIs[[\\\"Protein_1\\\", \\\"Protein_2\\\"]]==protein).any(1),\\n [\\\"Protein_1\\\", \\\"Protein_2\\\"]].values.flatten()) - {protein}\\n if sum((PPIs[[\\\"Protein_1\\\", \\\"Protein_2\\\"]]==protein).all(1)) > 0:\\n partners.add(protein)\\n proteinPartners[protein] = partners\\n with open(outPath, 'wb') as fOut:\\n pickle.dump(proteinPartners, fOut)\",\n \"def _get_genes(self, genes: Union[str, List[str]]) -> List[str]:\\n if isinstance(genes, str):\\n up = pd.read_table(genes, header=None, comment=\\\"#\\\", dtype=str)\\n ups= up.values.astype(str)\\n ups = list(np.squeeze(ups))\\n elif isinstance(genes, (list, tuple)):\\n ups = genes\\n else:\\n raise Exception(\\\"genes must be filepath, list or tuple\\\")\\n # filter genes\\n ups_new = [str(i) for i in ups if str(i) in self.genes]\\n\\n if len(ups_new) < 1: \\n raise Exception(\\\"No genes found. Please input proper Entrez id\\\")\\n return ups_new\",\n \"def ids(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"ids\\\")\",\n \"def ids(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"ids\\\")\",\n \"def get_all_identifiers(self, cmpd_rows_df):\\n\\n num_rows = cmpd_rows_df.shape[0]\\n # Get all the identifiers for a single PiMP compound (could be one but want this as list).\\n identifiers = []\\n for i in range(0, (num_rows)):\\n new_id = cmpd_rows_df.iloc[i]['identifier']\\n identifiers.append(new_id)\\n\\n # Take one of the rows for this compound, add identifiers and save in the final df.\\n\\n return identifiers\",\n \"def ent_ids(self) -> Tuple[Optional[str], ...]:\\n keys = set(self.fuzzy_patterns.keys())\\n keys.update(self.regex_patterns.keys())\\n all_ent_ids = set()\\n\\n for k in keys:\\n if self.ent_id_sep in k:\\n _, ent_id = self._split_label(k)\\n all_ent_ids.add(ent_id)\\n all_ent_ids_tuple = tuple(all_ent_ids)\\n return all_ent_ids_tuple\",\n \"def get_user_id(file_path: str, column: int, foreign_import=False) -> list:\\n data = pd.read_csv(file_path, sep=',', header=None)\\n\\n if foreign_import:\\n data.dropna(how='all', inplace=True)\\n return data[0].values\\n\\n else:\\n data = data.loc[data[column].isna()]\\n data.dropna(how='all', inplace=True)\\n return data[1].values\",\n \"def __preprocess_line(line):\\n return [int(element) for element in line.lstrip().rstrip().split()] # preprocess the input line\",\n \"def get_primary_dids(self, rows):\\n\\n\\t\\tprimary_dids = {}\\n\\t\\tfor row in rows:\\n\\t\\t\\t(account_number, phone_number) = (int(row[0]), row[1])\\n\\t\\t\\tif primary_dids.has_key(account_number):\\n\\t\\t\\t\\tprimary_dids[account_number].append(phone_number)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprimary_dids[account_number] = [phone_number]\\n\\n\\t\\treturn primary_dids\",\n \"def parse_fasta_use_bio(file_name):\\n pro_id_list = []\\n for seq_record in SeqIO.parse(file_name, \\\"fasta\\\"):\\n tmp_list = seq_record.id.strip('\\\\n').split('|')\\n pro_id_list.append(tmp_list[1])\\n # break\\n\\n return pro_id_list\",\n \"def test_get_sam_ids(self):\\r\\n map_file = StringIO.StringIO(\\\"\\\"\\\"#SampleID\\tCountry\\tAgeYears\\tFamily\\tAgeCat\\r\\n h208A.1\\tMalawi\\t0.032854209\\th208\\tChild\\r\\n h301A.1\\tMalawi\\t0.05\\th301\\tChild\\r\\n h301B.1\\tMalawi\\t0.05\\th301\\tChild\\r\\n USinfTw20.1\\tUSA\\t0.083333333\\tUSinfTw20\\tChild\\r\\n USinfTw20.2\\tUSA\\t0.083333333\\tUSinfTw20\\tChild\\r\\n USinfTw1.1\\tUSA\\t0.083333333\\tUSinfTw1\\tChild\\r\\n h10M\\tMalawi\\t26\\th10\\tAdult\\r\\n h68M\\tMalawi\\t26\\th68\\tAdult\\r\\n TS25\\tUSA\\t26\\tUSts9\\tAdult\\r\\n TS26\\tUSA\\t26\\tUSts9\\tAdult\\\"\\\"\\\")\\r\\n\\r\\n map_data, map_header, comments = parse_mapping_file(map_file)\\r\\n colorby = 'Country'\\r\\n cat = 'USA'\\r\\n primary_state = 'AgeCat:Child'\\r\\n ids1, ids2 = get_sam_ids(map_data, map_header, colorby, cat,\\r\\n primary_state, secondary_state=None)\\r\\n self.assertEqual(set(ids1),\\r\\n set(['USinfTw20.1', 'USinfTw20.2', 'USinfTw1.1']))\\r\\n self.assertEqual(set(ids2), set(['TS25', 'TS26']))\",\n \"def _translate_line_to_pid_pair(self, line):\",\n \"def get_training_ids(mydb):\\n\\treturn list(mydb.fetch_table(table_name='training_set',field_names=['CaseId']).CaseId)\",\n \"def __sub_set_from_linescsv(self, csv_path):\\n # gather line ids\\n ids = []\\n with open(csv_path, 'r') as f_csv:\\n reader = csv.reader(f_csv, delimiter=' ')\\n for line_id in reader:\\n ids.append(line_id[0])\\n # create sub-set based on the indices\\n sub_set = self.__line_id_subset(ids=ids)\\n return sub_set\",\n \"def get_plate_ids(self) -> Union[List[int], None]:\\n if self.imported is not True:\\n logging.error(f'File {self.file_path} has not been imported')\\n return None\\n else:\\n print(\\\"time to get some IDs\\\")\\n q = self.conn.getQueryService()\\n print(q)\\n params = Parameters()\\n path_query = str(self.file_path).strip('/')\\n print(f\\\"path query: f{path_query}\\\")\\n params.map = {\\\"cpath\\\": rstring(path_query)}\\n print(params)\\n results = q.projection(\\n \\\"SELECT DISTINCT p.id FROM Plate p\\\"\\n \\\" JOIN p.plateAcquisitions pa\\\"\\n \\\" JOIN pa.wellSample ws\\\"\\n \\\" JOIN ws.image i\\\"\\n \\\" JOIN i.fileset fs\\\"\\n \\\" JOIN fs.usedFiles u\\\"\\n \\\" WHERE u.clientPath=:cpath\\\",\\n params,\\n self.conn.SERVICE_OPTS\\n )\\n print(results)\\n self.plate_ids = [r[0].val for r in results]\\n return self.plate_ids\",\n \"def select_unique_ids(self):\\n adience = self.metadata\\n adi_ids = []\\n for gg in set(adience['gender']):\\n for ag in set(adience['age_group']):\\n try:\\n idx = np.logical_and(adience['gender'] == gg,adience['age_group'] == ag)\\n intersection_ids = list(adience[idx]['user_id'] +\\n '/coarse_tilt_aligned_face.' +\\n adience[idx]['face_id'].astype(str) +\\n '.' + adience[idx]['original_image'])\\n if len(intersection_ids) <= CAP:\\n adi_ids += intersection_ids\\n else:\\n x = list(np.random.choice(intersection_ids, CAP, replace=False))\\n adi_ids += x\\n\\n except:\\n continue\\n self.unique_ids = adi_ids\\n return adi_ids\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6303952","0.62645626","0.60780895","0.57484424","0.552927","0.552591","0.53634834","0.5353858","0.53358835","0.53217846","0.5320453","0.52818024","0.523921","0.52312315","0.5158253","0.5154796","0.5145234","0.512992","0.51164055","0.51120037","0.51053476","0.5094574","0.50788367","0.50773203","0.50724185","0.50573474","0.50474846","0.50357217","0.502745","0.50239253","0.49810487","0.4974038","0.49542442","0.4951266","0.4943189","0.493838","0.4921381","0.49085376","0.49075264","0.48950768","0.48934028","0.48752823","0.48596147","0.48494652","0.48465288","0.4833989","0.48189968","0.48176083","0.47760615","0.4775347","0.47649205","0.47647777","0.4761444","0.4758507","0.4757925","0.47523287","0.47400036","0.47394893","0.47390175","0.47334632","0.4728489","0.47276905","0.47194874","0.47167665","0.47112867","0.4705087","0.4702553","0.46981382","0.4695745","0.46939537","0.469284","0.46921507","0.46876106","0.46829155","0.46798596","0.46759072","0.46751243","0.4674667","0.4674431","0.46701863","0.4664654","0.4660921","0.46587056","0.4655391","0.46513617","0.46441674","0.46386623","0.46386623","0.46315593","0.46290407","0.46280113","0.4625966","0.46246374","0.46240214","0.46233562","0.46227118","0.46222013","0.4613658","0.46105897","0.45839995"],"string":"[\n \"0.6303952\",\n \"0.62645626\",\n \"0.60780895\",\n \"0.57484424\",\n \"0.552927\",\n \"0.552591\",\n \"0.53634834\",\n \"0.5353858\",\n \"0.53358835\",\n \"0.53217846\",\n \"0.5320453\",\n \"0.52818024\",\n \"0.523921\",\n \"0.52312315\",\n \"0.5158253\",\n \"0.5154796\",\n \"0.5145234\",\n \"0.512992\",\n \"0.51164055\",\n \"0.51120037\",\n \"0.51053476\",\n \"0.5094574\",\n \"0.50788367\",\n \"0.50773203\",\n \"0.50724185\",\n \"0.50573474\",\n \"0.50474846\",\n \"0.50357217\",\n \"0.502745\",\n \"0.50239253\",\n \"0.49810487\",\n \"0.4974038\",\n \"0.49542442\",\n \"0.4951266\",\n \"0.4943189\",\n \"0.493838\",\n \"0.4921381\",\n \"0.49085376\",\n \"0.49075264\",\n \"0.48950768\",\n \"0.48934028\",\n \"0.48752823\",\n \"0.48596147\",\n \"0.48494652\",\n \"0.48465288\",\n \"0.4833989\",\n \"0.48189968\",\n \"0.48176083\",\n \"0.47760615\",\n \"0.4775347\",\n \"0.47649205\",\n \"0.47647777\",\n \"0.4761444\",\n \"0.4758507\",\n \"0.4757925\",\n \"0.47523287\",\n \"0.47400036\",\n \"0.47394893\",\n \"0.47390175\",\n \"0.47334632\",\n \"0.4728489\",\n \"0.47276905\",\n \"0.47194874\",\n \"0.47167665\",\n \"0.47112867\",\n \"0.4705087\",\n \"0.4702553\",\n \"0.46981382\",\n \"0.4695745\",\n \"0.46939537\",\n \"0.469284\",\n \"0.46921507\",\n \"0.46876106\",\n \"0.46829155\",\n \"0.46798596\",\n \"0.46759072\",\n \"0.46751243\",\n \"0.4674667\",\n \"0.4674431\",\n \"0.46701863\",\n \"0.4664654\",\n \"0.4660921\",\n \"0.46587056\",\n \"0.4655391\",\n \"0.46513617\",\n \"0.46441674\",\n \"0.46386623\",\n \"0.46386623\",\n \"0.46315593\",\n \"0.46290407\",\n \"0.46280113\",\n \"0.4625966\",\n \"0.46246374\",\n \"0.46240214\",\n \"0.46233562\",\n \"0.46227118\",\n \"0.46222013\",\n \"0.4613658\",\n \"0.46105897\",\n \"0.45839995\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7984387"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":813,"numItemsPerPage":100,"numTotalItems":95772,"offset":81300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE3MTQyMSwianRpIjoiOWJjNzcyODYtZmU0NS00MDk1LTg5OWQtZTMzYjhkMWQwMzZjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYxNzUwMjEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.COn3A2TE37rCDZOleY8a8xO62cKOCvdz_FXyTlGIA94DtpicpYuXdLcW78zXFh9QmaO3EV7Opww_np9fiS-YAQ","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 |
|---|---|---|---|---|---|---|
initializes two dictionaries and poplulates them based on f and u options | def data_from_sc_file(axes, f, uf, true_max):
f_combo_dict = collections.defaultdict(list)
uf_combo_dict = collections.defaultdict(list)
max_x = -10000
max_y = -10000
min_x = 10000
min_y = 10000
for fileType in [uf, f]:
for i, item in enumerate(fileType):
with open(item)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, uplid, ufid, initial_options=None):\n self._uplid = uplid\n self._ufid = ufid\n if initial_options:\n self.results = copy.deepcopy(initial_options)\n else:\n self.results = {}",
"def create_dicts(self):\n \n # remove this string from ... | [
"0.6001208",
"0.573551",
"0.5644616",
"0.55272007",
"0.5479403",
"0.5444485",
"0.53790003",
"0.5347614",
"0.5330056",
"0.5307087",
"0.53021747",
"0.5300067",
"0.52843934",
"0.5281411",
"0.5255877",
"0.52503407",
"0.52025026",
"0.51949894",
"0.51933396",
"0.5174729",
"0.517343... | 0.0 | -1 |
makes pdf of plots one plot for each A[09]_P[09] | def gen_plots(uf_dict, f_dict, min_x, max_x, min_y, max_y, axes, name, histogram, total):
with PdfPages(name) as pdf:
total_xuf = []
total_yuf = []
total_xf = []
total_yf = []
for entry in uf_dict:
print 'Making plot for ' + entry
xuf, yuf = zip(*uf_di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def three_PDF_plots(res=200,table_exts=[''],**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n GR = glo.global_results()\n\n fig, axs = plt.subplots(3, sharex='col',\\\n figsize=(8,15),facecolor='w',\\\n ... | [
"0.6920849",
"0.6908201",
"0.65688",
"0.65637594",
"0.6536395",
"0.6448138",
"0.63382226",
"0.6292123",
"0.62799263",
"0.6146602",
"0.60787",
"0.60698056",
"0.6053234",
"0.6007661",
"0.59270525",
"0.5922574",
"0.59107745",
"0.5870086",
"0.5869896",
"0.5864736",
"0.58501446",
... | 0.6363685 | 6 |
create axes variable and calls previous functions | def main(x_axis, y_axis, filtered, unfiltered, name, histogram, total, true_max):
axes = [x_axis, y_axis, 'description']
uf_dict, f_dict, min_x, max_x, min_y, max_y = data_from_sc_file(axes, filtered, unfiltered, true_max)
gen_plots(uf_dict, f_dict, min_x, max_x, min_y, max_y, axes, name, histogram, total) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _InitAxes( self ):\n self.ax = self.fig.add_subplot( 111 )",
"def set_axes(self, a):\r\n self.axes = a",
"def _set_axes(self):\n self += helper.line(stroke=\"black\", x1=self.__dict__['x'], x2=self.__dict__['x'], y1=0, y2=self.__dict__['y']*2)\n self += helper.line(stroke=\"... | [
"0.72655743",
"0.720131",
"0.6918141",
"0.68311334",
"0.679241",
"0.6699963",
"0.664389",
"0.66430366",
"0.6629697",
"0.64951944",
"0.6493893",
"0.640936",
"0.63702965",
"0.6354702",
"0.63313186",
"0.627019",
"0.6240899",
"0.61389935",
"0.6125609",
"0.61182207",
"0.61009276",... | 0.0 | -1 |
Handle Ctrl+C signal to stop tests prematurely. | def setUp(self):
installHandler() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ctrl_c(u_boot_console):\n\n u_boot_console.kill(signal.SIGINT)\n assert(u_boot_console.validate_exited())",
"def ctrl_c(signum, frame):\n global shutdown_event\n raise SystemExit('\\nCancelling...')",
"def signal_handler(self, signal, frame):\n logger.info('CTRL+C pressed')\n ... | [
"0.78095275",
"0.7525858",
"0.74915695",
"0.7404281",
"0.7362504",
"0.7248646",
"0.72433",
"0.7132667",
"0.6990136",
"0.67509204",
"0.6646828",
"0.65553516",
"0.6463469",
"0.6379708",
"0.6324134",
"0.63064283",
"0.6285658",
"0.6277192",
"0.6226058",
"0.621547",
"0.6188076",
... | 0.0 | -1 |
Loads a data file into a list of `InputBatch`s | def convert_examples_to_features(
instruction,
example,
max_seq_length,
tokenizer,
cls_token_at_end=False,
cls_token="[CLS]",
cls_token_segment_id=1,
sep_token="[SEP]",
sep_token_extra=False,
pad_on_left=False,
pad_token=0,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LoadBatch(filename):",
"def load_batch(fpath, label_key='labels'):\n f = open(fpath, 'rb')\n if sys.version_info < (3,):\n d = cPickle.load(f)\n else:\n d = cPickle.load(f, encoding='bytes')\n # decode utf8\n d_decoded = {}\n for k, v in d.items():\n d_d... | [
"0.7338933",
"0.70891196",
"0.6814439",
"0.6681668",
"0.66754794",
"0.66753507",
"0.665879",
"0.6644234",
"0.6614464",
"0.6594897",
"0.6594897",
"0.6543476",
"0.65322834",
"0.6483556",
"0.6473474",
"0.64684963",
"0.6405395",
"0.6392082",
"0.63900834",
"0.6372264",
"0.63704264... | 0.0 | -1 |
Logs function calls to stdout | def logged(fn):
def wrapped(*args, **kwargs):
retval = fn(*args, **kwargs)
log_tpl = "%s called with arguments: %s %s \n\tReturning %s"
print(log_tpl % (fn.__name__,
args,
kwargs,
retval))
return retval
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_stdout(self, function):\n return function()",
"def logger(func):\r\n print(f'Executing {func.__name__}...')\r\n func()\r\n print(f'Ending the {func.__name__}...')",
"def generic_log(function_name, args):\n print(\"*\" * 100)\n print(\"function: \" + function_name + \"()\")\n pr... | [
"0.7681532",
"0.7327888",
"0.7242137",
"0.719633",
"0.7189399",
"0.7079442",
"0.70589966",
"0.7017228",
"0.70044196",
"0.69920015",
"0.6939595",
"0.670841",
"0.66977406",
"0.66969466",
"0.66775495",
"0.6635336",
"0.66174144",
"0.6613684",
"0.66000116",
"0.65987974",
"0.659479... | 0.6759477 | 11 |
Testing a pylint fix | def increment(x): # pylint: disable=invalid-name
return x + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lint(self):\n raise NotImplementedError()",
"def lint():\n load_env_vars('dev')\n from tools.static_code_analysis import Lint\n pylint = Lint()\n score = pylint.run_test()\n pylint.create_badge(score)",
"def lint_py_check_per_line(_repo, cf):\n with open(cf.name, \"r\", encoding = ... | [
"0.7094025",
"0.6981076",
"0.6923023",
"0.6833203",
"0.6684813",
"0.66347957",
"0.66322243",
"0.65936655",
"0.6580039",
"0.65503883",
"0.64925385",
"0.64903754",
"0.64746773",
"0.64408034",
"0.6434844",
"0.64206004",
"0.64191663",
"0.6411161",
"0.6410546",
"0.6397726",
"0.639... | 0.0 | -1 |
Rewriting to pass rather than disable pylint | def inc_num(num):
return num + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lint(self):\n raise NotImplementedError()",
"def main() -> None:\n\n # Load the declared uses of \"pylint: disable\".\n with open(YAML_ENFORCEMENT_FILE) as f:\n pylint_disable_declarations = yaml.safe_load(f)\n\n processed_pylint_disable_declarations = sorted(\n [\n P... | [
"0.64607275",
"0.6234269",
"0.59665763",
"0.5953127",
"0.5942634",
"0.5873758",
"0.5856863",
"0.5841048",
"0.58382",
"0.5826286",
"0.57664883",
"0.5751458",
"0.5749924",
"0.57362413",
"0.5734928",
"0.57117605",
"0.5707746",
"0.5617214",
"0.56088495",
"0.56088495",
"0.56088495... | 0.0 | -1 |
Return an array of arguments to pass to Project.objects.get_[drafted|proposed|active|completed]. | def get_filter_args(self):
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def qargs(self):\n return self._qargs",
"def args(self) -> List[str]:\n return self.__args",
"def flags(self) -> list[\"ProjectCommandFlag\"]:\n _args: list[Arg] = []\n _ctx = self._select(\"flags\", _args)\n _ctx = ProjectCommandFlag(_ctx)._select_multiple(\n _des... | [
"0.6088531",
"0.6021877",
"0.60157776",
"0.60130185",
"0.5944683",
"0.5944683",
"0.5944683",
"0.59235483",
"0.5874959",
"0.58742183",
"0.58395976",
"0.5834433",
"0.57406074",
"0.5681138",
"0.5674505",
"0.56381595",
"0.56236935",
"0.5571274",
"0.5564734",
"0.55310535",
"0.5531... | 0.54357314 | 46 |
Log the user in and redirect them to the supplied next page. | def form_valid(self, form):
auth_login(self.request, form.get_user())
if self.request.session.get('payment'):
Payment.objects.filter(id=self.request.session['payment']).update(
user_id=self.request.user.revolvuserprofile, entrant_id=self.request.user.revolvuserprofile)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n cont = self.request_string('continue', default=\"/\")\n self.redirect(users.create_login_url(cont))",
"def login():\n next_url = request.form.get(\"next\", None)\n\n if current_app.config[\"USE_SAML\"]:\n if next_url:\n return redirect(url_for(\"auth.saml\"... | [
"0.7510935",
"0.7494407",
"0.7422873",
"0.7347584",
"0.7279795",
"0.72309744",
"0.72068155",
"0.70927584",
"0.70770127",
"0.7053909",
"0.6991852",
"0.6965986",
"0.69090754",
"0.6893353",
"0.6883574",
"0.6871099",
"0.6870212",
"0.6865512",
"0.6861322",
"0.6859293",
"0.6858111"... | 0.0 | -1 |
View handle unsubscribe email update | def unsubscribe(request, action):
data = {}
if action and action.lower() == 'updates':
user_profile = request.user.revolvuserprofile
user_profile.subscribed_to_repayment_notifications = False
user_profile.save()
data = {'msg': "You have successfully unsubscribed"}
elif action... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unsubscribe(self, request):\n email = self.cleaned_data.get('email')\n subscriber = Subscriber.objects.get(email=email, mailing_list=self.mailing_list)\n subscriber.unsubscribe(request)",
"def unsubscribe(request):\n user = None\n if request.user.is_authenticated:\n user = r... | [
"0.78642935",
"0.7602228",
"0.72869647",
"0.7270269",
"0.70092016",
"0.6895412",
"0.68678045",
"0.67447734",
"0.66946137",
"0.6653949",
"0.66412675",
"0.65861225",
"0.65249825",
"0.65249825",
"0.65249825",
"0.65249825",
"0.65249825",
"0.64214385",
"0.62963414",
"0.62464833",
... | 0.7462505 | 2 |
View handle my social connection page | def social_connection(request):
backend_map = {'facebook': {'name': 'facebook', 'connected': False,
'dc_url': reverse('social:disconnect', kwargs={'backend': 'facebook'})},
'google': {'name': 'google-oauth2', 'connected': False,
'dc_ur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def facebook_connect(request, template='socialregistration/facebook.html',\n extra_context=dict()):\n # for facebook the login is done in JS, so by the time it hits our view here there is no redirect step. Look for the querystring values and use that instead of worrying about session.\n connect_object = g... | [
"0.6379492",
"0.62844723",
"0.619812",
"0.61603844",
"0.6102585",
"0.6102585",
"0.5913831",
"0.5828857",
"0.5814265",
"0.58000904",
"0.5722415",
"0.5700442",
"0.5674649",
"0.56717813",
"0.56276107",
"0.5617314",
"0.5616013",
"0.56157875",
"0.5579581",
"0.55725545",
"0.5561613... | 0.75818175 | 0 |
Export financial report Excel from the admin side. | def export_xlsx(request):
import openpyxl
try:
from openpyxl.cell import get_column_letter
except ImportError:
from openpyxl.utils import get_column_letter
from_date = request.GET.get('from_date')
to_date = request.GET.get('to_date')
search = request.GET.get('search_value') or '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export(self):\n\n rpt_date = datetime.now()\n filename = 'bushfire_report_{}.xls'.format(rpt_date.strftime('%d%b%Y'))\n response = HttpResponse(content_type='application/vnd.ms-excel')\n response['Content-Disposition'] = 'attachment; filename=' + filename\n\n book = Workbook(... | [
"0.74944603",
"0.7453464",
"0.74425185",
"0.74420345",
"0.74178195",
"0.74111104",
"0.73946965",
"0.7328942",
"0.729512",
"0.7261714",
"0.6878788",
"0.6865229",
"0.67143226",
"0.66296583",
"0.6595517",
"0.6570733",
"0.6570733",
"0.6454679",
"0.6449948",
"0.64201456",
"0.63465... | 0.62886864 | 22 |
Export financial report CSV from the admin side. | def export_repayment_csv(request):
import csv
from django.utils.encoding import smart_str
# response = HttpResponse(content_type='text/csv')
# response['Content-Disposition'] = 'attachment; filename=Repayment_report.csv'
from_date = request.GET.get('from_date')
to_date = request.GET.get('to_date... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dlCsvReport(self):\r\n requestElems = {'xf': 'csv'}\r\n requestElems.update(self.getReportConfig())\r\n \r\n csvdata = self.sendRequest(self.reportFormURL, self.fileOpener,\r\n requestElems, 'POST').read()\r\n\r\n self.writeExportFile('csv', ... | [
"0.7379921",
"0.73224705",
"0.7103962",
"0.68414193",
"0.6666803",
"0.66631263",
"0.6570242",
"0.6528814",
"0.65245694",
"0.64698297",
"0.6458403",
"0.64346254",
"0.6426312",
"0.63806766",
"0.6376845",
"0.6372116",
"0.6359299",
"0.6348953",
"0.6324408",
"0.63181615",
"0.63142... | 0.65966964 | 6 |
Export financial report Excel from the admin side. | def export_repayment_xlsx(request):
import openpyxl
try:
from openpyxl.cell import get_column_letter
except ImportError:
from openpyxl.utils import get_column_letter
from_date = request.GET.get('from_date')
to_date = request.GET.get('to_date')
search = request.GET.get('search_va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export(self):\n\n rpt_date = datetime.now()\n filename = 'bushfire_report_{}.xls'.format(rpt_date.strftime('%d%b%Y'))\n response = HttpResponse(content_type='application/vnd.ms-excel')\n response['Content-Disposition'] = 'attachment; filename=' + filename\n\n book = Workbook(... | [
"0.7495683",
"0.7454717",
"0.7443899",
"0.7443692",
"0.741883",
"0.7412455",
"0.73961747",
"0.7330415",
"0.7296676",
"0.72633135",
"0.6880631",
"0.686647",
"0.67169285",
"0.66300696",
"0.6596857",
"0.65736467",
"0.65736467",
"0.64546067",
"0.64511687",
"0.64222556",
"0.634818... | 0.60136884 | 37 |
Views thats renders news sources to the home page | def homepage():
general_news=get_sources('general')
business_news=get_sources('business')
sports_news=get_sources('sports')
return render_template('sources.html',general=general_news, business=business_news, sports=sports_news) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index():\n entertainment_news = get_sources('entertainment')\n fashion_news = get_sources('fashion')\n title = 'Vnews'\n return render_template('index.html', title=title, fashion=fashion_news, entertainment=entertainment_news)",
"def home_page_view(request):\n\n\t# Set the variable jse_articles t... | [
"0.75373346",
"0.7415982",
"0.7415839",
"0.73056453",
"0.72505605",
"0.7163801",
"0.71547955",
"0.7132932",
"0.7081197",
"0.7004573",
"0.6854891",
"0.6817566",
"0.6759091",
"0.6715063",
"0.67048156",
"0.66193694",
"0.65456355",
"0.6536079",
"0.65282154",
"0.6526098",
"0.65229... | 0.8323401 | 0 |
View that would return news articles | def NewsArticles():
health_articles = get_articles('health')
education_articles = get_articles('technology')
return render_template('articles.html',health=health_articles, tech =education_articles) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def news(request):\n articles = News.objects.all()\n return render(request, 'news.html', {\"articles\": articles})",
"def newsfeed(request):\n article_list = Article.objects.order_by('published_date')\n context = {'article_list': article_list}\n return render(request, 'sacms/newsfeed.html', contex... | [
"0.8422911",
"0.7939385",
"0.7903623",
"0.7807585",
"0.7735028",
"0.7547046",
"0.7498529",
"0.7439669",
"0.743487",
"0.74265945",
"0.7382276",
"0.7278104",
"0.72469956",
"0.7242258",
"0.71915346",
"0.71299",
"0.70865196",
"0.707854",
"0.70623153",
"0.70585346",
"0.7006468",
... | 0.8291898 | 1 |
function that returns the searched articles | def articleSearch(article_name):
search_article_name = article_name.split("")
search_name_format = "+".join(search_article_name)
searched_articles = search_articles(search_name_format)
return render_template('search.html',articles = searched_articles) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_news(request):\n try:\n query_string = ''\n if request.GET['search_text'].strip() != '':\n query_string = '&title='+request.GET['search_text']\n response = requests.get(APIURL + '/articles/?format=json'+query_string)\n parser = json.loads(response.content)\n ... | [
"0.7186117",
"0.6988905",
"0.6960163",
"0.6941734",
"0.6911264",
"0.67364365",
"0.67003137",
"0.66531736",
"0.66310287",
"0.65921223",
"0.65345204",
"0.6490673",
"0.637851",
"0.63575894",
"0.62927914",
"0.6282196",
"0.62599754",
"0.6258574",
"0.6252506",
"0.6247338",
"0.62282... | 0.7510673 | 0 |
Returns the size or number of bytes of the memory module. | def getSize(self) -> int:
return len(self.mem) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSize(self):\n return self.bf.memory()",
"def get_total_memory_size(self):\n return self.drt_manager.get_total_memory_size()",
"def memsize(self):\n return self.xlist(\"get-memsize\")[1][0] * 1024",
"def size_bytes(self):\n size_words = self.size_words()\n if size_words is None:\... | [
"0.7623135",
"0.75418335",
"0.7527066",
"0.7176314",
"0.7151762",
"0.713853",
"0.7124511",
"0.7107852",
"0.70797235",
"0.7068928",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
"0.7054791",
... | 0.76415974 | 0 |
Write the passed bytes to address according to size. | def write(self, address: int, value: bytearray):
for i, val in enumerate(value):
self.mem[address+i] = value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeto_mem(self, addr: int, memaddr: int, buf: bytearray, *,\n addrsize: int = 8) -> None:\n ...",
"def writeto_mem(self, addr: int, memaddr: int, buf: bytes, /, *, addrsize: int = 8) -> None:",
"def writeto_mem(self, addr: int, memaddr: int, buf: bytes, /, *, addrsize: int = 8) ... | [
"0.71228886",
"0.70063406",
"0.70063406",
"0.67409784",
"0.6658709",
"0.643035",
"0.643035",
"0.6348352",
"0.61561",
"0.6151975",
"0.6115056",
"0.60978895",
"0.5946713",
"0.5898338",
"0.5872255",
"0.5842872",
"0.58293104",
"0.5800161",
"0.5792666",
"0.5690916",
"0.5675088",
... | 0.6465555 | 5 |
Read address as byte | def read(self, address: int) -> bytes:
return bytearray() + self.mem[address] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_byte(self, addr):\n raise NotImplementedError()",
"def getByte(self, addr: ghidra.program.model.address.Address) -> int:\n ...",
"def getByte(self, address: ghidra.program.model.address.Address) -> int:\n ...",
"def read_io_byte(self, address):\n return self.io.read(self.... | [
"0.79302216",
"0.7713162",
"0.7697147",
"0.761327",
"0.748351",
"0.70024586",
"0.6997179",
"0.68077",
"0.66201454",
"0.6584616",
"0.6535146",
"0.6512226",
"0.6469606",
"0.64672464",
"0.6434506",
"0.6429342",
"0.6408556",
"0.64030266",
"0.640144",
"0.6396575",
"0.63943136",
... | 0.71491694 | 5 |
Determine if something is a valid date | def valid_date(datestring):
try:
datetime.strptime(datestring, '%Y-%m-%d')
return True
except ValueError as e:
logger.info('not a valid date: ' + e)
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_date(date):\n try:\n datetime.strptime(date, '%Y-%m-%d')\n return True\n except (ValueError, TypeError):\n return False",
"def valid_date(date):\n try:\n parser.parse(date)\n return True\n except ValueError:\n return False",
"def _validate(self... | [
"0.83130693",
"0.82549554",
"0.8185626",
"0.8185626",
"0.8160542",
"0.8100614",
"0.8053466",
"0.7889536",
"0.7841571",
"0.7813753",
"0.78100455",
"0.7789335",
"0.7765769",
"0.7746488",
"0.7712737",
"0.76385385",
"0.76328814",
"0.75903636",
"0.75843525",
"0.75314015",
"0.75030... | 0.7633652 | 16 |
Retrieve the total portfolio value on a given data | def portfolio_value_on_date(date):
if valid_date(date):
try:
with open(folder + 'portfolio_balance.json', encoding='utf-8') as read_file:
data = json.loads(read_file.read(),
object_pairs_hook=OrderedDict)
return data[date]['daily... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPortfolioValue(self, start_t, t):\n sum_tmp=0\n for item in self.portfolio.keys():\n if \"DJI_\" in item:\n t_tmp=datetime.strftime(pd.date_range(end=t,periods=1,freq='B')[0],'%Y-%m-%d')\n price=universe.get_price_in_currency(item,t_tmp,'CAD')\n ... | [
"0.7542487",
"0.71289545",
"0.6666174",
"0.6338905",
"0.621734",
"0.6212121",
"0.61951506",
"0.61915606",
"0.6184136",
"0.61756456",
"0.61362153",
"0.6114087",
"0.61008483",
"0.61008483",
"0.609102",
"0.60624725",
"0.6047102",
"0.60127",
"0.60063684",
"0.59936106",
"0.5979917... | 0.0 | -1 |
Retrieve the net gain percentage in total value of portfolio at the end of the backtest | def net_gain_loss_percentage():
try:
with open(folder + 'portfolio_balance.json', encoding='utf-8') as read_file:
data = json.loads(read_file.read(),
object_pairs_hook=OrderedDict)
net_gain_loss = data['final_portfolio'] / portfolio_value
lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_profit(self):",
"def percentageChange(self):\n try:\n curPrice = self.dailyData[-1].currentPrice\n closePrice = self.historicData[-1].closePrice\n except IndexError: # Just return zero when no historic or dailyData is available yet\n return 0.0\n return (curPrice... | [
"0.65579927",
"0.61883414",
"0.61835027",
"0.6162108",
"0.6050546",
"0.6048661",
"0.599609",
"0.59796023",
"0.59576464",
"0.5940993",
"0.5906892",
"0.59037197",
"0.58747596",
"0.58715194",
"0.58649564",
"0.5861075",
"0.5859904",
"0.5809884",
"0.5800906",
"0.5783402",
"0.57765... | 0.67480105 | 0 |
Maximum percentage drawdown experienced in the backtest | def max_drawdown():
try:
with open(folder + 'portfolio_balance.json', encoding='utf-8') as read_file:
data = json.loads(read_file.read(),
object_pairs_hook=OrderedDict)
def daily_price():
""" Record daily volume in a generator """
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def worst_score(self):\r\n pass",
"def max_drawdown(returns):\n\n if returns.size < 1:\n return np.nan\n\n df_cum_rets = cum_returns(returns, starting_value=100)\n cum_max_return = df_cum_rets.cummax()\n\n return df_cum_rets.sub(cum_max_return).div(cum_max_return).min()",
"def lifetim... | [
"0.71471363",
"0.6878528",
"0.6755007",
"0.6686075",
"0.66709054",
"0.66709054",
"0.66709054",
"0.66709054",
"0.6585306",
"0.65748173",
"0.65741765",
"0.6546233",
"0.64815825",
"0.6458119",
"0.64326763",
"0.6413706",
"0.6378952",
"0.6353532",
"0.63428664",
"0.63250977",
"0.63... | 0.64852077 | 12 |
Record daily volume in a generator | def daily_price():
for item in data:
if valid_date(item):
yield data[item]['daily_value'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_volume(self):",
"def volumes(interval,symbol):\n\ttoday = datetime.utcnow()\n\tcurrent_time = today.time()\n\tdaily_start_time = dtime(3,45)\n\tdaily_end_time = dtime(10,15)\n\tvolume_indicator = {} \n\tstart_timestamp = 0\n\tend_timestamp = 0\n\tif current_time < daily_start_time:\n\t\tyesterday = tod... | [
"0.6108419",
"0.59582704",
"0.5658194",
"0.5645627",
"0.55301887",
"0.55294275",
"0.54440314",
"0.5385878",
"0.5381963",
"0.53462917",
"0.5296795",
"0.52559656",
"0.523488",
"0.522695",
"0.5211046",
"0.5203205",
"0.5200433",
"0.5195768",
"0.51814336",
"0.51171595",
"0.5100563... | 0.53965396 | 7 |
Gets the gradient for the consecutive pairs objective | def getGradient_Doc(obj_options, cur_scores,this_example, user_rel=1.0, user_bias = 0.0, user_scale = 1.0):
this_gradient = {}
bias_grad = 0.0
for doc in this_example.all_items:
this_score = this_example.scored_items[doc]
cur_score = cur_scores[doc]
grad_ch = float(user_rel * (this_score - (user_bias+c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self):\n result = np.zeros(len(self.variables))\n result[self.bivariateGradInd] = (self.shape-1)/self.variable - self.rate\n return result",
"def gradient(self):\n gradients = [func.gradient for func in self.functionals]\n return DiagonalOperator(*gradients)",
"d... | [
"0.6889948",
"0.68456626",
"0.6809678",
"0.67814624",
"0.672531",
"0.6724598",
"0.6713636",
"0.6646971",
"0.6624539",
"0.65632606",
"0.655551",
"0.6551338",
"0.6533211",
"0.65029466",
"0.649771",
"0.6495591",
"0.64946824",
"0.6491155",
"0.6485481",
"0.64754087",
"0.64624405",... | 0.0 | -1 |
Convert the image labels to be integers between [0, num classes) | def format_labels(image_labels):
label_values = list(set(image_labels.values()))
label_values.sort()
condensed_image_labels = dict([(image_id, label_values.index(label))
for image_id, label in image_labels.iteritems()])
new_id_to_original_id_map = dict([[label_values.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_labels(self, labels):\n # Fallback:\n # return self.encoder.transform(labels)\n classes = list(self.classes_())\n return [classes.index(label) for label in labels]",
"def transform_labels(self, labels):\n # Fallback:\n # return self.encoder.transform(label... | [
"0.7265107",
"0.7265107",
"0.72633547",
"0.71937054",
"0.716316",
"0.7154364",
"0.6947604",
"0.69361037",
"0.6895001",
"0.6748562",
"0.6731259",
"0.67226684",
"0.6717959",
"0.67108655",
"0.6666883",
"0.66271544",
"0.6606274",
"0.6592733",
"0.65913206",
"0.65601665",
"0.655136... | 0.0 | -1 |
Load in a dataset (that has been saved in the CUB Format) and store in a format to be written to the tfrecords file | def format_dataset(dataset_path, image_path_prefix):
image_paths = load_image_paths(dataset_path, image_path_prefix)
image_sizes = load_image_sizes(dataset_path)
image_bboxes = load_bounding_box_annotations(dataset_path)
image_parts = load_part_annotations(dataset_path)
image_labels, new_label_to_o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_tfrecord():\n\n record_path = os.path.join(FLAGS.dataset_dir, \"records\")\n if not os.path.isdir(record_path):\n os.makedirs(record_path)\n\n ####### Path Definition #######\n img_path = \"data/traindata/ccmpred/\"\n ss3_path = \"data/traindata/ss3/\"\n pdb_path = \"data/traind... | [
"0.66734815",
"0.6458906",
"0.6237943",
"0.6151958",
"0.6116849",
"0.60779786",
"0.60597104",
"0.6046932",
"0.60377866",
"0.60268456",
"0.5986152",
"0.59571415",
"0.59430844",
"0.59256035",
"0.5916913",
"0.59109616",
"0.59093267",
"0.5883883",
"0.58668107",
"0.58454967",
"0.5... | 0.0 | -1 |
Take `images_per_class` from the train dataset and create a validation set. | def create_validation_split(train_data, fraction_per_class=0.1, shuffle=True):
subset_train_data = []
val_data = []
val_label_counts = {}
class_labels = [i['class']['label'] for i in train_data]
images_per_class = Counter(class_labels)
val_images_per_class = {label: 0 for label in images_per_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_train_validation_test_sets(path_to_json, out_dir, path_to_images,\n train_fraction=0.6,\n validation_fraction=0.2,\n test_fraction=0.2,\n do_print=False):\n assert... | [
"0.70862657",
"0.68533665",
"0.6514909",
"0.65044284",
"0.6460029",
"0.6398828",
"0.6384702",
"0.6384702",
"0.63737273",
"0.6358643",
"0.63232464",
"0.63111234",
"0.63051456",
"0.62699944",
"0.62421966",
"0.622691",
"0.6216368",
"0.61776704",
"0.61775273",
"0.6167151",
"0.616... | 0.7281224 | 0 |
Use the card to travel | def use(self):
if self.price_of_trip == 0:
print("Sorry your card has been used")
else:
self.price_of_trip -= self.price_of_trip
print("Done") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cards_to_deal(cls, context={}):\n\t\traise NotImplementedError()",
"def cards_to_deal(cls, context={}):\n\t\treturn cls.CARDS_TO_DEAL",
"def newDeal(self):\n self.card1 = Card(1, 'c')\n self.card2 = Card(4, 'd')\n self.stateLabel[\"text\"] = \"\"\n self.refreshImages()",
"def ... | [
"0.61471826",
"0.60606945",
"0.6010794",
"0.600401",
"0.59552276",
"0.59204626",
"0.5904978",
"0.5810135",
"0.5780846",
"0.57157326",
"0.56504244",
"0.5592343",
"0.5565727",
"0.5562599",
"0.5559056",
"0.553126",
"0.5528969",
"0.5528765",
"0.5516053",
"0.54957",
"0.5476267",
... | 0.5975769 | 4 |
Checks the expiration date of the card | def check(self):
validity_year = int(self.date[0:4])
validity_month = int(self.date[5:7])
validity_day = int(self.date[8:10])
if datetime.today().year > validity_year:
self.flag = False
elif datetime.today().year == validity_year:
if datetime.today().month... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_content_expiry_date(self):\n\n if self.expire_date < datetime.now():\n self.state = 'disabled'",
"def is_expired(self):\n return self.expiration_date <= self._now()",
"def clean_expiration_date(self):\n expiration_date = self.cleaned_data['expiration_date']\n if... | [
"0.7288992",
"0.71461076",
"0.71064097",
"0.6798181",
"0.6778251",
"0.6727741",
"0.67241824",
"0.6718817",
"0.6605499",
"0.65725285",
"0.6560101",
"0.6555981",
"0.6535536",
"0.6485778",
"0.6470241",
"0.647006",
"0.64549625",
"0.64269155",
"0.64255065",
"0.64250386",
"0.641015... | 0.6089248 | 43 |
Use the card to travel | def use(self):
if self.flag:
if self.credit < self.price_of_trip:
return "Your credit is not enough, please increase your credit"
else:
self.credit -= self.price_of_trip
return "Done"
else:
return "Sorry, your card has e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cards_to_deal(cls, context={}):\n\t\traise NotImplementedError()",
"def cards_to_deal(cls, context={}):\n\t\treturn cls.CARDS_TO_DEAL",
"def newDeal(self):\n self.card1 = Card(1, 'c')\n self.card2 = Card(4, 'd')\n self.stateLabel[\"text\"] = \"\"\n self.refreshImages()",
"def ... | [
"0.61515087",
"0.6064475",
"0.6013859",
"0.60078645",
"0.5976684",
"0.5960304",
"0.59248465",
"0.5909907",
"0.5814345",
"0.57855487",
"0.5720087",
"0.56538814",
"0.5597273",
"0.5570732",
"0.5567159",
"0.556194",
"0.55343103",
"0.5533306",
"0.5532688",
"0.5520193",
"0.54938835... | 0.50508463 | 97 |
Increases the credit of the card | def charge(self, other):
if self.flag:
self.credit += other
return "{} Tomans has been added to your card credit and now the credit of your card is {} Tomans".format(
other, self.credit)
else:
return "Sorry, your card has expired." | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def charge(self, other):\n self.credit += other\n print(\"{} Tomans has been added to your card credit and now the credit of your card is {} Tomans\".format(other,\n self.credit))",
"def ... | [
"0.7035775",
"0.6908582",
"0.6584606",
"0.65523666",
"0.6435155",
"0.63019294",
"0.6200756",
"0.61545724",
"0.6137888",
"0.6132437",
"0.61214805",
"0.6077653",
"0.60740805",
"0.6062242",
"0.60452324",
"0.60144305",
"0.6013067",
"0.5982951",
"0.59137625",
"0.5900946",
"0.58880... | 0.69234675 | 1 |
Increases the credit of the card | def charge(self, other):
self.credit += other
print("{} Tomans has been added to your card credit and now the credit of your card is {} Tomans".format(other,
self.credit)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def charge(self, other):\n if self.flag:\n self.credit += other\n return \"{} Tomans has been added to your card credit and now the credit of your card is {} Tomans\".format(\n other, self.credit)\n else:\n return \"Sorry, your card has expired.\"",
"... | [
"0.69234675",
"0.6908582",
"0.6584606",
"0.65523666",
"0.6435155",
"0.63019294",
"0.6200756",
"0.61545724",
"0.6137888",
"0.6132437",
"0.61214805",
"0.6077653",
"0.60740805",
"0.6062242",
"0.60452324",
"0.60144305",
"0.6013067",
"0.5982951",
"0.59137625",
"0.5900946",
"0.5888... | 0.7035775 | 0 |
Use the card to travel | def use(self):
if self.credit < self.price_of_trip:
print("Your credit is not enough, please increase your credit")
else:
self.credit -= self.price_of_trip
print("Done") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cards_to_deal(cls, context={}):\n\t\traise NotImplementedError()",
"def cards_to_deal(cls, context={}):\n\t\treturn cls.CARDS_TO_DEAL",
"def newDeal(self):\n self.card1 = Card(1, 'c')\n self.card2 = Card(4, 'd')\n self.stateLabel[\"text\"] = \"\"\n self.refreshImages()",
"def ... | [
"0.61471826",
"0.60606945",
"0.6010794",
"0.600401",
"0.5975769",
"0.59552276",
"0.59204626",
"0.5904978",
"0.5810135",
"0.5780846",
"0.57157326",
"0.56504244",
"0.5592343",
"0.5565727",
"0.5562599",
"0.5559056",
"0.553126",
"0.5528969",
"0.5528765",
"0.5516053",
"0.54957",
... | 0.5069107 | 87 |
Do something with emails messages in the folder. For the sake of this example, print some headers. | def process_mailbox(M):
rv, data = M.search(None, config.email['search'])
if rv != 'OK':
logger.info("No messages found!")
return
for num in data[0].split():
rv, data = M.fetch(num, '(RFC822)')
if rv != 'OK':
logger.error("ERROR getting message", num)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def userMessages(self, path, pattern):\n log(logging.DEBUG, \"Look for files at \" + path + \" with pattern \" + pattern)\n # if folder does not exist\n if not os.path.exists(path):\n return []\n # result message list\n message_list = []\n # retrieve file names\... | [
"0.6262737",
"0.592273",
"0.5789566",
"0.5778403",
"0.56953245",
"0.5670702",
"0.5649647",
"0.5602646",
"0.55907255",
"0.55646175",
"0.55509037",
"0.5533535",
"0.5529366",
"0.5527925",
"0.54993945",
"0.54717857",
"0.5467351",
"0.5438078",
"0.54356897",
"0.54338974",
"0.542173... | 0.612142 | 1 |
Parses one line of data in file | def vasp_file_lines(vasp_file, line_continuation=False):
vasp_file_stripped = (line.rstrip("\n") for line in vasp_file)
line_nr = 0
for line in vasp_file_stripped:
line_nr += 1
while line_continuation and line.endswith("\\"):
line = line[:-1] + next(vasp_file_stripped)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_line(self, line):\n success = self.parser.handle_line(line)\n if success:\n self.data.update()\n else:\n self.bot.log(\"didn't handle line: '{}'\".format(line))",
"def parse_line(self, line):\n raise NotImplementedError",
"def parse(cls, line):\r\n ... | [
"0.69548947",
"0.6905197",
"0.68284994",
"0.67083246",
"0.6672508",
"0.6318916",
"0.6266864",
"0.62573653",
"0.61784714",
"0.6168965",
"0.61672115",
"0.6151331",
"0.6151331",
"0.6129076",
"0.61048865",
"0.608141",
"0.6077094",
"0.60615253",
"0.6015411",
"0.6006627",
"0.600310... | 0.0 | -1 |
execute a request in the MeteoData database | def request_meteodata(request: str):
import MySQLdb
import platform
if platform.system() == "Windows":
MySQLParams = {
'host' : "192.168.5.1",
'user' : "MeteoRobot",
'passwd': "robot",
'db' : "MeteoData"
}
else:
MySQLParams = {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run_query(self):",
"def post(self, request):\n return self.execute_query()",
"def execute():",
"def query(self):\n pass",
"def query(self):",
"def query(self, **kwargs):",
"def execute_query(self, *args, **kwargs):",
"def do_request(ean):\n url = 'INSERT URL OF EAN DATABASE HERE... | [
"0.6710959",
"0.6582548",
"0.65078473",
"0.64458466",
"0.64313316",
"0.6429438",
"0.6367198",
"0.63005024",
"0.62007064",
"0.6155797",
"0.6154988",
"0.6154988",
"0.6154988",
"0.6154988",
"0.610536",
"0.6070094",
"0.6034479",
"0.6034479",
"0.6034479",
"0.6034479",
"0.5996396",... | 0.64356184 | 4 |
get the database data on the last period | def get_data(last):
Table = "ServerRoom"
filter = ""
if last == "lastone":
data = request_meteodata("SELECT * from `ServerRoom` ORDER BY id DESC LIMIT 1 ")
if len(data) == 0:
return [SensorData(datetime.datetime.now(), 0, 0)]
res = []
for d in data:
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(self, date_time):\n id_columns = ','.join([col for col in self.table_primary_keys if col not in ['EFFECTIVEDATE', 'VERSIONNO']])\n return_columns = ','.join(self.table_columns)\n with self.con:\n cur = self.con.cursor()\n cur.execute(\"DROP TABLE IF EXISTS te... | [
"0.66456187",
"0.66129696",
"0.65368724",
"0.6481614",
"0.6442516",
"0.63483286",
"0.63411635",
"0.6279019",
"0.62594837",
"0.62587345",
"0.62279445",
"0.6175993",
"0.616382",
"0.6153795",
"0.6136147",
"0.61287874",
"0.606596",
"0.6036077",
"0.6036077",
"0.60130566",
"0.59977... | 0.67294055 | 0 |
smooth the curve plotted by data | def smooth_data(data, smooth_width):
out = []
for i, dat in enumerate(data):
low = max(0, i - smooth_width)
high = min((len(data) - 1), low + 2 * smooth_width)
n = 0
s_temperature = 0
s_humidity = 0
for d in data[low:high]:
n += 1
s_tempera... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curve(self, data):\n x, y, y_smoothed = data\n\n curve_keys = ['color', 'linestyle', 'alpha', 'label']\n curve_config = self.config.filter(curve_keys, prefix='curve_')\n\n curves = self.ax.plot(x, y, **curve_config)\n\n if y_smoothed is not None:\n smoothed_color =... | [
"0.7313142",
"0.69398075",
"0.6655488",
"0.65327597",
"0.63836634",
"0.6375429",
"0.63086617",
"0.62467694",
"0.6144106",
"0.614324",
"0.6140233",
"0.6114227",
"0.6062881",
"0.60028267",
"0.5995925",
"0.5986899",
"0.59816587",
"0.596397",
"0.5943088",
"0.59140795",
"0.5877314... | 0.0 | -1 |
limit the amount of dat | def resample_data(data, entity_number):
if len(data) <= entity_number:
# not that many entity: nothing to do
return data
interval = int(len(data)/entity_number + 1)
out = []
for i, dat in enumerate(data):
if i % interval == 0:
out.append(dat)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_data(self, limit: int):",
"def limit(requestContext, seriesList, n):\n return seriesList[0:n]",
"def limit(self, limit):\n raise NotImplementedError(\"This should have been implemented.\")",
"def set_result_limit(self, data):\n self.add_payload('resultLimit', data)\n self._resu... | [
"0.7557813",
"0.6726402",
"0.6408106",
"0.6167715",
"0.6139555",
"0.6135192",
"0.60850734",
"0.60437834",
"0.5982196",
"0.59246933",
"0.58739847",
"0.58739847",
"0.58739847",
"0.58472615",
"0.5828757",
"0.5822307",
"0.5805646",
"0.57973814",
"0.57706034",
"0.57259965",
"0.572... | 0.0 | -1 |
linking credentials to devices | def main():
django.setup()
devices = NetworkDevice.objects.all()
creds = Credentials.objects.all()
std_creds = creds[0]
arista_creds = creds[1]
for a_device in devices:
if 'pynet-sw' in a_device.device_name:
a_device.credentials = arista_creds
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_credentials():",
"def __init__(self, user, password, device):\n self.user = user\n self.password = password\n self.device = device\n self.session = requests.session()\n\n # Hard-coded auth seed\n seed = \"oZ7QE6LcLJp6fiWzdqZc\"\n\n # Get auth tokens\n ... | [
"0.6891069",
"0.66422874",
"0.6202527",
"0.618294",
"0.60527545",
"0.59875023",
"0.59675354",
"0.5958228",
"0.59270346",
"0.5901835",
"0.58968145",
"0.5871899",
"0.58570117",
"0.58440846",
"0.57795954",
"0.5754165",
"0.5754151",
"0.57462233",
"0.57175606",
"0.5711669",
"0.570... | 0.6287373 | 2 |
builds a new TensorRT engine and saves it. | def get_engine(onnx_file_path, engine_file_path=""):
def build_engine():
"""Takes an ONNX file and creates a TensorRT engine to run inference with"""
with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
builder.max_w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '-v', '--verbose', action='store_true',\n help='enable verbose output (for debugging)')\n parser.add_argument(\n '-c', '--category_num', type=int,\n help='number of object categories (obsolete)')\n par... | [
"0.67849517",
"0.67617816",
"0.6362268",
"0.6190603",
"0.6143309",
"0.611478",
"0.60166395",
"0.5841629",
"0.584155",
"0.5791088",
"0.57723004",
"0.5698285",
"0.56744826",
"0.5669226",
"0.562782",
"0.5618678",
"0.5618636",
"0.56058806",
"0.5582209",
"0.557229",
"0.5519337",
... | 0.6606123 | 2 |
Takes an ONNX file and creates a TensorRT engine to run inference with | def build_engine():
with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
builder.max_workspace_size = 1 << 30 # 1GB
builder.max_batch_size = 1
builder.fp16_mode = mode_fp16
# builder.int8_mode... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_engine(onnx_file_path, engine_file_path=\"\"):\n def build_engine():\n \"\"\"Takes an ONNX file and creates a TensorRT engine to run inference with\"\"\"\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\n ... | [
"0.8031374",
"0.7831621",
"0.7261751",
"0.71062404",
"0.7080748",
"0.6950961",
"0.6506367",
"0.64999366",
"0.6419242",
"0.62066257",
"0.6092014",
"0.5996473",
"0.5924226",
"0.59063506",
"0.5795536",
"0.5773174",
"0.576665",
"0.576164",
"0.5756392",
"0.56630164",
"0.56498075",... | 0.6927419 | 6 |
Create a TensorRT engine for ONNXbased YOLOv3608 and run inference. | def main():
get_engine(onnx_file_path, engine_file_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '-v', '--verbose', action='store_true',\n help='enable verbose output (for debugging)')\n parser.add_argument(\n '-c', '--category_num', type=int,\n help='number of object categories (obsolete)')\n par... | [
"0.7478217",
"0.7159704",
"0.69230884",
"0.673915",
"0.6581398",
"0.6492738",
"0.64049906",
"0.62891704",
"0.62095827",
"0.6123898",
"0.6090181",
"0.5939654",
"0.59038186",
"0.58348006",
"0.58271414",
"0.5808182",
"0.5780439",
"0.5771464",
"0.57401353",
"0.5676676",
"0.564849... | 0.65200746 | 5 |
define tthe index function | def index():
if request.method == "POST":
# fetch the data forms
userDetails = request.form
firstname = userDetails["firstname"]
secondname = userDetails["secondname"]
foodtoeat = userDetails["foodtoeat"]
cur = mysql.connection.cursor()
cur.execute("INSERT INT... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self, x) -> int:\n pass",
"def index(self) -> int:",
"def index(self, sub) -> int:\n pass",
"def get_index(self, *args, **dargs):\n pass",
"def __index__(self, *args, **kwargs): # real signature unknown\n pass",
"def __index__(self, *args, **kwargs): # real signature unknown... | [
"0.7466199",
"0.74422425",
"0.7333869",
"0.7228359",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.7033737",
"0.69949394",
... | 0.0 | -1 |
define the users function endpoint | def users():
cur = mysql.connection.cursor()
resultValue = cur.execute("SELECT * FROM users")
if resultValue > 0:
userDetails = cur.fetchall()
return render_template("users.html", userDetails=userDetails) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user():",
"def user(request, user_id):\n raise NotImplementedError",
"def user():\n pass",
"def user(self):",
"def standard_student_endpoint(\nendpoint_name,\nrequired_values,\nmethod,\nrequest,\nfunctor): \n try:\n\n # verify method\n if request.method != method:\n ... | [
"0.6563187",
"0.6428347",
"0.63846487",
"0.6112737",
"0.60384446",
"0.5966322",
"0.58806527",
"0.58600867",
"0.58498687",
"0.5792116",
"0.5780776",
"0.57783985",
"0.5732193",
"0.56492466",
"0.56412804",
"0.5636319",
"0.56155",
"0.56095773",
"0.5585259",
"0.5577989",
"0.555347... | 0.0 | -1 |
TODO you should not call pickle directly, rather load the file into memory and submit the string to our function as defined in SemDiscUtils.py This is for test purposes only. The createCypherQueries(edgeList) will be called from SemDiscUtils.py which in turn returns a string of cypher queries | def readPickleTest():
""" edgeList1 covers this typr of question - "What is the email id of the reader who reads Batman Hush" """
edgeList1 = {'_node1': {'Name': 'Batman Hush'},
'_node2': {'Name': 'Email_Id'},
'_attrs': {'Name': 'reads1'}}
""" edgeList2 covers this t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_schema(self, cypher_file):\n if len(self.graph.nodes) > 0:\n msg = \"Cypher file specified but the graph is not empty. Aborting.\"\n raise ValueError(msg)\n cyp = open(cypher_file, 'r').read()\n self.graph.run(cyp)",
"def _load_data(self):\n with open... | [
"0.5628399",
"0.55132294",
"0.5401076",
"0.5240609",
"0.52057654",
"0.5204791",
"0.5188983",
"0.5111568",
"0.5094759",
"0.509352",
"0.5072148",
"0.5065339",
"0.5056807",
"0.5046235",
"0.50047314",
"0.49945167",
"0.4992883",
"0.4991696",
"0.49686602",
"0.4957791",
"0.4950982",... | 0.52642983 | 3 |
Extracts all types of products. | def task101(self):
self.ex("""
SELECT
a.account_id AS account_id,
pt.name AS product_type,
p.name AS product_name
FROM account AS a
RIGHT JOIN product AS p ON a.product_cd = p.product_cd
INNER JOIN product_type AS pt ON p.product_type_cd = pt.product_type_cd
ORDER BY account_id"""... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def product_types(self):\n return self._product_types",
"def build_from_products(self, products, strict_products=False):\n p_it1, p_it2 = itertools.tee(products)\n\n # 1. Collect all possible type variants. Those are already in dict as meaningful existing types\n # matches as singleto... | [
"0.688441",
"0.6707839",
"0.66763467",
"0.66484165",
"0.65424275",
"0.63596106",
"0.6307602",
"0.6232655",
"0.6128479",
"0.6125535",
"0.611501",
"0.607919",
"0.60508305",
"0.60443723",
"0.60259634",
"0.5969954",
"0.595593",
"0.5940951",
"0.59290147",
"0.5912695",
"0.5870188",... | 0.0 | -1 |
Extracts the same as in previous task but with using another join. | def task102(self):
self.ex("""
SELECT
a.account_id AS account_id,
p.name AS product_name
FROM product AS p
LEFT JOIN account AS a ON p.product_cd = a.product_cd
ORDER BY account_id;""") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task_6a(bt_df, rt_df, fg_df):\n return rt_df.join(bt_df, \"business_id\")",
"def sreduce(self, key, values, task):\n list1 = []\n found_file1 = False\n found_file2 = False\n outer_file1 = (self.outer=='left' or self.outer=='both')\n outer_file2 = (self.outer=='right' or ... | [
"0.61531043",
"0.58204305",
"0.5783453",
"0.57746005",
"0.56748706",
"0.5667666",
"0.5576084",
"0.5489864",
"0.5406213",
"0.5405063",
"0.5404756",
"0.5399502",
"0.53982985",
"0.5359601",
"0.53233653",
"0.532238",
"0.52769905",
"0.52728516",
"0.5264537",
"0.52625185",
"0.50796... | 0.0 | -1 |
Extracts customer id, product cd and individual or business customer name. | def task103(self):
self.ex("""
SELECT
a.cust_id AS customer_id,
a.product_cd AS product_cd,
concat(i.fname, ' ', i.lname) AS individual_customer_name,
b.name AS buisness_customer_name
FROM account AS a
LEFT JOIN individual AS i ON a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseCustomerInfo(self, response):\n parser = make_parser()\n prid = ParseCustomerInfo(self.ns_customer_ent)\n parser.setContentHandler(prid)\n parser.setFeature(handler.feature_namespaces, 1)\n parser.parse(StringIO.StringIO(response))\n rval = prid.getCustomerInfo()\... | [
"0.6429363",
"0.62600464",
"0.6159198",
"0.59811467",
"0.59774333",
"0.5960992",
"0.58831596",
"0.58690196",
"0.57828003",
"0.57575685",
"0.5747817",
"0.5723138",
"0.571669",
"0.57056504",
"0.567384",
"0.567384",
"0.56684715",
"0.5660668",
"0.5639587",
"0.5607663",
"0.5591218... | 0.0 | -1 |
Generates a set {1, 2, 3, ..., 100} using cross join. | def task104(self):
self.ex("""
SELECT ones.num + tens.num + 1 AS num
FROM (SELECT 1 num
UNION
SELECT 2 num
UNION
SELECT 3 num
UNION
SELECT 4 num
UNION
SELECT 5 num
UNION
SELECT 6 num
UNION
SELECT 7 num
UNION
SELECT 8 num
U... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossProduct( set1, set2):\n set1 = asarray( set1, _aformat(set1))\n set1 = reshape( set1, (-1, 3))\n set2 = asarray( set2, _aformat(set2))\n set2 = reshape( set2, (-1, 3))\n return cross( set1, set2 )",
"def cross(a, b):\n return [s + t for s in a for t in b]",
"def crossProduct4( set1, ... | [
"0.629022",
"0.59710526",
"0.5969501",
"0.5826466",
"0.57101566",
"0.5662604",
"0.5608783",
"0.5603874",
"0.55706143",
"0.5552218",
"0.5518106",
"0.5492818",
"0.54695106",
"0.5463395",
"0.5386702",
"0.53221595",
"0.5283778",
"0.5282577",
"0.5275992",
"0.5268177",
"0.5267994",... | 0.5506208 | 11 |
Renvoyer le contexte d'affichage du template | def get_context(self):
from scoop.editorial.models import Excerpt
identifier = self.value
# Vérifier que l'image existe
try:
excerpt = Excerpt.objects.get(name=identifier)
except Excerpt.DoesNotExist:
excerpt = None
return {'excerpt': excerpt} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def in_context(self):\n pass",
"def render( context, *args, **kwargs ):",
"def context(self) -> CONTEXT:",
"def get_context_data(self, *args, **kwargs):\n \n context = super().get_context_data(**kwargs) \n \n # Daten an Backend senden.\n serverAntwort = datenAnBacken... | [
"0.68644655",
"0.6756904",
"0.6574579",
"0.6454107",
"0.6420507",
"0.6420507",
"0.6420507",
"0.6420507",
"0.6420507",
"0.6420507",
"0.63759226",
"0.635479",
"0.63513696",
"0.62880975",
"0.62545836",
"0.62505394",
"0.6236864",
"0.61906767",
"0.6188532",
"0.61761904",
"0.617282... | 0.57212514 | 75 |
Renvoyer le chemin du template d'affichage | def get_template_name(self):
base = super(ExcerptInline, self).get_template_name()[0]
path = "editorial/%s" % base
return path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Template(Fenetre_largeur,Fenetre_hauteur):\r\n li= Select_ligne(\"Nombre de lignes: \",Fenetre_largeur,Fenetre_hauteur)\r\n nom=\"Template\"\r\n fich=\"Template\"\r\n version=0\r\n while Path(\"stages/\"+fich+\".txt\").is_file() == True:\r\n version+=1\r\n fich=nom+str(version)\r\n... | [
"0.6391667",
"0.6280781",
"0.6133017",
"0.60334784",
"0.5994215",
"0.5985893",
"0.59521735",
"0.5860931",
"0.58261806",
"0.5753843",
"0.57103914",
"0.56576955",
"0.5623416",
"0.5602326",
"0.55988973",
"0.5591306",
"0.5576477",
"0.55760825",
"0.5563358",
"0.55583566",
"0.55569... | 0.0 | -1 |
Attempt to solve the problem... | def problem_52():
for number in xrange(1, 123456789):
sorted_num = ''.join(sorted(str(number)))
if len([value for value in xrange(2, 7)
if ''.join(sorted(str((value * number)))) == sorted_num]) == 5:
return number | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def solve(self):\n ...",
"def solve(self):\n pass",
"def solve(self):\n pass",
"def problem_298():\n pass",
"def solution(s):",
"def solve(self):\n raise NotImplementedError(\"This method needs to be implemented.\")",
"def exercise_b2_106():\r\n p... | [
"0.7730392",
"0.75410193",
"0.7307096",
"0.7307096",
"0.70221806",
"0.6674096",
"0.6412365",
"0.6365025",
"0.6341411",
"0.6314549",
"0.6289291",
"0.6278359",
"0.62118804",
"0.616413",
"0.61261684",
"0.612467",
"0.6122574",
"0.611507",
"0.60840267",
"0.60686123",
"0.6067139",
... | 0.0 | -1 |
Initialize melon order attributes. | def __init__(self, species, qty, order_type, tax):
self.species = species
self.qty = qty
self.shipped = False
self.order_type = order_type
self.tax = tax | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._order_list = []",
"def __init__(self, *args, **kwargs):\n self._orders = None\n super().__init__(*args, **kwargs)",
"def __init__(self):\n self.orders = {}",
"def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.mu... | [
"0.6708174",
"0.662357",
"0.65577954",
"0.6431638",
"0.6348181",
"0.63275594",
"0.61550564",
"0.6137234",
"0.6117595",
"0.6087555",
"0.6017396",
"0.5979355",
"0.59747034",
"0.59043527",
"0.5896923",
"0.588143",
"0.5866107",
"0.5865401",
"0.5861821",
"0.5853268",
"0.5838351",
... | 0.55245596 | 56 |
Calculate price, including tax. | def get_total(self):
base_price = 5
if self.species == "Christmas melon":
base_price = base_price * 1.5
total = (1 + self.tax) * self.qty * base_price
if self.order_type == "international" and self.qty>10:
total += 3
return total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_price(self):\n\n cargo_weight = self.cargo.weight\n tax_rate = Decimal(0.18)\n\n untaxed_total = Decimal(cargo_weight) * Decimal(self.price_per_unit_weight)\n\n total_price = (untaxed_total * tax_rate) + untaxed_total\n\n return total_price",
"def calculate_total_... | [
"0.77471083",
"0.763973",
"0.7035976",
"0.6969799",
"0.6841924",
"0.6784742",
"0.6764191",
"0.6706861",
"0.6700252",
"0.66708153",
"0.6621594",
"0.6610665",
"0.6608133",
"0.6603047",
"0.66002357",
"0.659871",
"0.6580778",
"0.6561078",
"0.655176",
"0.65358806",
"0.65206593",
... | 0.6566887 | 17 |
Record the fact than an order has been shipped. | def mark_shipped(self):
self.shipped = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mark_shipped(self):\n\n self.shipped = True\n # moved from DomesticMelonOrder",
"def action_ship_create(self):\n res = super(SaleOrder, self).action_ship_create()\n for sale_order in self:\n if sale_order.invoiced:\n sale_order.picking_ids.write({'x_is_pa... | [
"0.73743325",
"0.651005",
"0.62031525",
"0.6028882",
"0.5751929",
"0.5704558",
"0.5638554",
"0.56364393",
"0.563631",
"0.5605549",
"0.5555828",
"0.554914",
"0.54631656",
"0.54229397",
"0.5364435",
"0.53255874",
"0.5321269",
"0.5310086",
"0.53069085",
"0.5291062",
"0.52815145"... | 0.6596032 | 8 |
Lists genomes present in selected reference databases (ensembl, phytozome, refseq) | def list_reference_genomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.list_reference_genomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_genomes():\n genome_list = yaml.load(open(script_dir + \"/utils/genomes.yaml\",\"r\"))\n print(\"\")\n print(\"\\033[1m%-30s\\t%-30s\\033[0m\" % (\"Reference Name\", \"Location\"))\n for k,v in genome_list.items():\n print(\"%-30s\\t%-30s\" % (k, v))\n print(\"\")",
"def load_refge... | [
"0.72052234",
"0.6681579",
"0.65693146",
"0.6492775",
"0.6463348",
"0.64268726",
"0.60308814",
"0.59824353",
"0.5938681",
"0.5849946",
"0.5805375",
"0.5713854",
"0.5712395",
"0.5681238",
"0.56560886",
"0.56373715",
"0.5536142",
"0.5521856",
"0.5500701",
"0.5477903",
"0.546699... | 0.7649514 | 0 |
Lists genomes loaded into KBase from selected reference sources (ensembl, phytozome, refseq) | def list_loaded_genomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.list_loaded_genomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_reference_genomes(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.list_reference_genomes',\n [params], self._service_ver, context)",
"def list_genomes():\n genome_list = yaml.load(open(script_dir + \"/utils/genomes.yaml\",\"r\"))\n ... | [
"0.7379342",
"0.6987427",
"0.6913297",
"0.68597585",
"0.6310048",
"0.62025315",
"0.6013068",
"0.6001058",
"0.5765435",
"0.5684875",
"0.5651807",
"0.5620138",
"0.5543948",
"0.54923236",
"0.54544765",
"0.5449119",
"0.540734",
"0.5391047",
"0.5391047",
"0.5370194",
"0.5368396",
... | 0.6714616 | 4 |
Lists genomes indexed in SOLR | def list_solr_genomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.list_solr_genomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_genomes_in_solr(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.index_genomes_in_solr',\n [params], self._service_ver, context)",
"def list_genomes():\n genome_list = yaml.load(open(script_dir + \"/utils/genomes.yaml\",\"r\"))\n ... | [
"0.6830845",
"0.65424156",
"0.60664916",
"0.606512",
"0.60501164",
"0.58641434",
"0.5826815",
"0.5826815",
"0.58215374",
"0.58214",
"0.57476413",
"0.56885886",
"0.568328",
"0.5639871",
"0.5536571",
"0.54968697",
"0.549255",
"0.5483767",
"0.545044",
"0.5449478",
"0.5432765",
... | 0.6747959 | 1 |
Index specified genomes in SOLR from KBase workspace | def index_genomes_in_solr(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.index_genomes_in_solr',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_index():\n for site in get_sites():\n text = read_site(site)\n while text == False:\n text = read_site(site) # keep attempting to read until successful\n index_site(site, text)",
"def build_index():\n for site in get_sites():\n text = read_site(site)\n ... | [
"0.6265813",
"0.6265813",
"0.6139362",
"0.61347544",
"0.6121336",
"0.6064185",
"0.60180306",
"0.5999387",
"0.5975277",
"0.596837",
"0.5914677",
"0.5905104",
"0.5903449",
"0.58965874",
"0.5834955",
"0.58183974",
"0.5724497",
"0.57202715",
"0.5687734",
"0.5682116",
"0.5679189",... | 0.72983086 | 0 |
Lists taxa loaded into KBase for a given workspace | def list_loaded_taxa(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.list_loaded_taxa',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_solr_taxa(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.list_solr_taxa',\n [params], self._service_ver, context)",
"def get_taxonomy_results(verbose=False):\n if verbose:\n pprint(taxonomy_results)\n return taxonomy_resu... | [
"0.5854104",
"0.5630706",
"0.5523026",
"0.5359899",
"0.5303297",
"0.52729064",
"0.5272661",
"0.52519345",
"0.52469647",
"0.5236552",
"0.52222174",
"0.5208818",
"0.5188408",
"0.5179878",
"0.51560634",
"0.5141281",
"0.51307255",
"0.5109015",
"0.51087105",
"0.5079378",
"0.503626... | 0.5544073 | 2 |
Lists taxa indexed in SOLR | def list_solr_taxa(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.list_solr_taxa',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_taxa_in_solr(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.index_taxa_in_solr',\n [params], self._service_ver, context)",
"def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, d... | [
"0.6509729",
"0.6357868",
"0.62683314",
"0.60519195",
"0.5974132",
"0.5915071",
"0.591159",
"0.5772863",
"0.5712139",
"0.56651306",
"0.5592324",
"0.556518",
"0.55518234",
"0.554848",
"0.55198777",
"0.55016136",
"0.54998034",
"0.5499193",
"0.5472442",
"0.5457834",
"0.543946",
... | 0.6861536 | 0 |
Loads specified taxa into KBase workspace and indexes in SOLR on demand | def load_taxa(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.load_taxa',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_taxa_in_solr(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.index_taxa_in_solr',\n [params], self._service_ver, context)",
"def load_tas_lookup():\n logger.info('Loading TAS')\n load_tas()",
"def list_solr_taxa(self, params, ... | [
"0.6498204",
"0.5891013",
"0.57397306",
"0.5648463",
"0.55865234",
"0.54691",
"0.525066",
"0.52232873",
"0.5206583",
"0.5182996",
"0.5106142",
"0.5098938",
"0.50653493",
"0.5048019",
"0.501896",
"0.50153154",
"0.50048745",
"0.49948743",
"0.49922657",
"0.49847096",
"0.49776623... | 0.6328378 | 1 |
Index specified taxa in SOLR from KBase workspace | def index_taxa_in_solr(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.index_taxa_in_solr',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reindex_subcomponent_taxa():\n pass",
"def index_siteroot(context):\n portal = getSite()\n portal.reindexObject()",
"def index_fobj(fobj):\n doc = fileobject_to_dict(fobj)\n if doc is not None:\n #print doc\n SOLR.add(doc)\n else:\n pass",
"def search(terms):\n ... | [
"0.6358017",
"0.6279029",
"0.6045649",
"0.5848363",
"0.5843543",
"0.579074",
"0.57332224",
"0.5654865",
"0.5615632",
"0.55991507",
"0.5592114",
"0.5569687",
"0.556002",
"0.54822147",
"0.54292715",
"0.5420272",
"0.536411",
"0.5358117",
"0.5352065",
"0.5331198",
"0.5322685",
... | 0.71712476 | 0 |
Loads specified genomes into KBase workspace and indexes in SOLR on demand | def load_genomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.load_genomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index_genomes_in_solr(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.index_genomes_in_solr',\n [params], self._service_ver, context)",
"def load_refgenomes(self, params, context=None):\n return self._client.call_method(\n ... | [
"0.6626249",
"0.60957223",
"0.60924673",
"0.60247797",
"0.59353334",
"0.5797676",
"0.56434065",
"0.55891055",
"0.5580639",
"0.5580639",
"0.55667996",
"0.5544847",
"0.5504955",
"0.54986495",
"0.5482139",
"0.5481608",
"0.545993",
"0.54438055",
"0.5425209",
"0.53886104",
"0.5387... | 0.66491956 | 0 |
Loads NCBI RefSeq genomes into KBase workspace with or without SOLR indexing | def load_refgenomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.load_refgenomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_genomes(self, params, context=None):\n return self._client.call_method(\n 'ReferenceDataManager.load_genomes',\n [params], self._service_ver, context)",
"def index_gcis(gcis_url, es_url, index, alias, dump_dir):\n conn = get_es_conn(es_url, index, alias)\n refList = ge... | [
"0.6063036",
"0.5841345",
"0.58144426",
"0.5734855",
"0.54659575",
"0.5403981",
"0.5402181",
"0.5332247",
"0.5307035",
"0.5291659",
"0.5222015",
"0.5217969",
"0.5209188",
"0.5207623",
"0.5170394",
"0.51697093",
"0.5144679",
"0.5139786",
"0.51380336",
"0.51057464",
"0.50968397... | 0.61688125 | 0 |
Updates the loaded genomes in KBase for the specified source databases | def update_loaded_genomes(self, params, context=None):
return self._client.call_method(
'ReferenceDataManager.update_loaded_genomes',
[params], self._service_ver, context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gbf_pub_update():\r\n LOG.info(\"Start: Update datasets in RLIDGeo warehouse.\")\r\n month_stamps = [\r\n datetime.date.today().strftime(\"%Y_%m\"),\r\n (\r\n datetime.date.today().replace(day=1)\r\n - datetime.timedelta(days=1)\r\n ).strftime(\"%Y_%m\"),\r\n ... | [
"0.59036124",
"0.57262635",
"0.5505454",
"0.5471788",
"0.5454221",
"0.53054446",
"0.5293783",
"0.52560055",
"0.51999205",
"0.5191524",
"0.51797444",
"0.51658607",
"0.515508",
"0.5140619",
"0.5138678",
"0.5115914",
"0.5101359",
"0.5012815",
"0.49987558",
"0.49879158",
"0.49756... | 0.6448755 | 0 |
Tests start of authentication (incoming auth req) and receiving auth response. | def test_entire_flow(self, context):
responses.add(responses.POST,
"https://graph.facebook.com/v2.5/oauth/access_token",
body=json.dumps({"access_token": "qwerty",
"token_type": "bearer",
"e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_authentication_required(self):\n self.auth.validate_token_request(self.request)\n self.mock_validator.client_authentication_required.assert_called_once_with(self.request)",
"def test_authflow(self):\n response = self.client.post('/auth/signup/', {\n ... | [
"0.69330895",
"0.6900142",
"0.6677716",
"0.6526462",
"0.6523139",
"0.6522858",
"0.65209544",
"0.65144455",
"0.6500772",
"0.6499939",
"0.6493193",
"0.64686173",
"0.63993716",
"0.6384796",
"0.6383272",
"0.6357318",
"0.63483596",
"0.6325268",
"0.63151926",
"0.6314975",
"0.630289... | 0.5979925 | 68 |
Apply a mapping of namevaluepairs to a template. | def apply(self, mapping):
mapping = {name: self.str(value, tolerant=self.tolerant)
for name, value in mapping.items()
if value is not None or self.tolerant}
if self.tolerant:
return self.template.safe_substitute(mapping)
return self.template.su... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_template(template: dict, input_: dict) -> None:\n for k, v in template.items():\n config_val = input_.get(k)\n\n if isinstance(v, dict) and k != 'NullHandler':\n map_template(v, input_)\n\n if config_val:\n template[k] = config_val.upper() if k == 'level' else ... | [
"0.6347333",
"0.6122666",
"0.5724706",
"0.55872214",
"0.5524677",
"0.5517751",
"0.549768",
"0.5487899",
"0.53845775",
"0.530882",
"0.5244786",
"0.52417064",
"0.5239383",
"0.5211652",
"0.5148122",
"0.51388305",
"0.51228106",
"0.51005185",
"0.5080841",
"0.5061058",
"0.50332797"... | 0.6634928 | 0 |
Test case for create_nas_share_by_nas | def test_create_nas_share_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_test_nas_share(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_update_nas_share_by_nas(self):\n pass",
"def test_index_nas_shares_by_nas(self):\n pass",
"def test_show_nas_share(self):\n ... | [
"0.87092817",
"0.8525568",
"0.8476073",
"0.8432505",
"0.811207",
"0.8111951",
"0.79742056",
"0.7967393",
"0.7931208",
"0.7835071",
"0.7778211",
"0.7645673",
"0.7638049",
"0.75317097",
"0.7366997",
"0.7344222",
"0.7333957",
"0.7017911",
"0.6752469",
"0.66835386",
"0.65300155",... | 0.95934916 | 0 |
Test case for destroy_nas_share | def test_destroy_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_destroy_nas_share_by_nas(self):\n pass",
"def test_destroy_nas_share_by_pool(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_update_nas_share(self):\n pass",
"def test_update_nas_share_by_nas(... | [
"0.9389554",
"0.8792524",
"0.76362747",
"0.75515646",
"0.7297889",
"0.7273542",
"0.7258762",
"0.7239002",
"0.71278036",
"0.71259034",
"0.71167296",
"0.7033105",
"0.6955307",
"0.6797405",
"0.67879903",
"0.67438823",
"0.6702528",
"0.669155",
"0.6557659",
"0.6553244",
"0.6280817... | 0.95384085 | 0 |
Test case for destroy_nas_share_by_nas | def test_destroy_nas_share_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_destroy_nas_share(self):\n pass",
"def test_destroy_nas_share_by_pool(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_update_nas_share_by_nas(self):\n pass",
"def test_dashboards_v2_delete_sha... | [
"0.9417224",
"0.8834285",
"0.7744262",
"0.758655",
"0.75549483",
"0.7326083",
"0.7300899",
"0.7292167",
"0.72800195",
"0.71851236",
"0.71172214",
"0.70820516",
"0.69532496",
"0.690352",
"0.67362416",
"0.6723919",
"0.67131734",
"0.67035735",
"0.6650557",
"0.6545809",
"0.640851... | 0.9542495 | 0 |
Test case for destroy_nas_share_by_pool | def test_destroy_nas_share_by_pool(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_destroy_nas_share(self):\n pass",
"def test_destroy_nas_share_by_nas(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_mount_status_nas_share_by_pool(self):\n pass",
"def test_test_nas_... | [
"0.87827253",
"0.87459147",
"0.7914171",
"0.76246",
"0.75718844",
"0.7118149",
"0.7093812",
"0.708217",
"0.68163544",
"0.6781625",
"0.67124707",
"0.66831726",
"0.6607139",
"0.65762645",
"0.6470638",
"0.64604396",
"0.6458959",
"0.64408374",
"0.6336116",
"0.62824637",
"0.624967... | 0.9630253 | 0 |
Test case for index_nas_shares | def test_index_nas_shares(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_nas_shares_by_nas(self):\n pass",
"def test_index_nas_shares_by_pool(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_test_nas_share... | [
"0.9408521",
"0.8480369",
"0.7828743",
"0.77089137",
"0.76689196",
"0.7658634",
"0.7639658",
"0.7374224",
"0.73682296",
"0.71836025",
"0.70449203",
"0.69670975",
"0.677711",
"0.675877",
"0.670886",
"0.6664895",
"0.6502741",
"0.6135646",
"0.60962385",
"0.5956307",
"0.5926037",... | 0.93974316 | 1 |
Test case for index_nas_shares_by_nas | def test_index_nas_shares_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_nas_shares(self):\n pass",
"def test_index_nas_shares_by_pool(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_update_nas_share_by_nas(self):\n pass",
"def test_test_result_nas_sha... | [
"0.91021",
"0.85721266",
"0.7744076",
"0.7691755",
"0.7667866",
"0.766065",
"0.7447273",
"0.71588457",
"0.7131582",
"0.70934236",
"0.7039851",
"0.6991671",
"0.67114615",
"0.65478647",
"0.6541465",
"0.63235873",
"0.62416536",
"0.6241281",
"0.60786486",
"0.607121",
"0.5646648",... | 0.95178986 | 0 |
Test case for index_nas_shares_by_pool | def test_index_nas_shares_by_pool(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_nas_shares_by_nas(self):\n pass",
"def test_index_nas_shares(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_mount_status_nas_share_by_pool(self):\n pass",
"def test_destroy_nas... | [
"0.84751886",
"0.8132446",
"0.80617833",
"0.80411273",
"0.74651307",
"0.707621",
"0.6979327",
"0.68828",
"0.6788973",
"0.6761283",
"0.6760841",
"0.6421319",
"0.6332053",
"0.6197863",
"0.601423",
"0.59699273",
"0.578675",
"0.5785175",
"0.5685915",
"0.56655633",
"0.5647678",
... | 0.9608631 | 0 |
Test case for mount_status_nas_share | def test_mount_status_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mount_status_nas_share_by_nas(self):\n pass",
"def test_mount_status_nas_share_by_pool(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_show_nas_share(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_show_nas_share_by_... | [
"0.9339884",
"0.86251044",
"0.7847734",
"0.77573013",
"0.7702383",
"0.75028086",
"0.7351555",
"0.73283494",
"0.7200713",
"0.69585705",
"0.68284434",
"0.68067634",
"0.6647951",
"0.65063286",
"0.6441414",
"0.6424272",
"0.6211882",
"0.59345067",
"0.5869384",
"0.5858923",
"0.5856... | 0.94080406 | 0 |
Test case for mount_status_nas_share_by_nas | def test_mount_status_nas_share_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mount_status_nas_share(self):\n pass",
"def test_mount_status_nas_share_by_pool(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_show_nas_share(sel... | [
"0.9223469",
"0.8762923",
"0.8201179",
"0.81886965",
"0.8143352",
"0.8128441",
"0.7978966",
"0.7839654",
"0.7666999",
"0.7568727",
"0.72756267",
"0.72689754",
"0.718854",
"0.70526314",
"0.70140773",
"0.6603129",
"0.6567966",
"0.64892024",
"0.62469953",
"0.6022947",
"0.5962818... | 0.94895434 | 0 |
Test case for mount_status_nas_share_by_pool | def test_mount_status_nas_share_by_pool(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mount_status_nas_share_by_nas(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_mount_status_nas_share(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_index_nas_shares_by_pool(self):\n pass",
"def test_destr... | [
"0.85433346",
"0.84213686",
"0.8400509",
"0.81344026",
"0.76243025",
"0.75721836",
"0.7563653",
"0.7507107",
"0.7303699",
"0.72915065",
"0.7267744",
"0.6979238",
"0.69425905",
"0.66233706",
"0.6539754",
"0.6512662",
"0.63295096",
"0.631071",
"0.6240405",
"0.61339945",
"0.6002... | 0.9529886 | 0 |
Test case for show_nas_share | def test_show_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_show_nas_share_by_nas(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_mount_status_nas_share_by... | [
"0.9303875",
"0.85624135",
"0.84599024",
"0.8404861",
"0.8154698",
"0.80376023",
"0.7731183",
"0.75881684",
"0.74865353",
"0.74834853",
"0.73471814",
"0.7230511",
"0.7218506",
"0.7175002",
"0.6964021",
"0.66760683",
"0.64869213",
"0.6413816",
"0.6327175",
"0.6229252",
"0.6192... | 0.94518304 | 0 |
Test case for show_nas_share_by_nas | def test_show_nas_share_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_show_nas_share(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_mount_status_nas_share_by_nas(se... | [
"0.9115962",
"0.8672631",
"0.83680737",
"0.83024406",
"0.81769687",
"0.7848348",
"0.7818351",
"0.7816461",
"0.74024487",
"0.737524",
"0.73302305",
"0.72978896",
"0.7211219",
"0.71098095",
"0.6981241",
"0.69681144",
"0.66827077",
"0.6341193",
"0.633762",
"0.631773",
"0.6093063... | 0.94415253 | 0 |
Test case for show_nas_share_by_pool | def test_show_nas_share_by_pool(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_show_nas_share_by_nas(self):\n pass",
"def test_mount_status_nas_share_by_pool(self):\n pass",
"def test_show_nas_share(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_index_nas_shares_by_pool(self):\n pass",
"def test_destroy_nas_s... | [
"0.838688",
"0.82205",
"0.82004833",
"0.81190896",
"0.8064236",
"0.76910836",
"0.7640043",
"0.7465289",
"0.7388782",
"0.7017174",
"0.6918035",
"0.68557525",
"0.6643733",
"0.65673494",
"0.65449506",
"0.652991",
"0.6403193",
"0.6230861",
"0.61453474",
"0.5764217",
"0.56883866",... | 0.9581628 | 0 |
Test case for test_nas_share | def test_test_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_test_result_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_show_nas_share(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_mount_status_nas_share_by_nas(self):\n pass",
"def test_update_nas_share_b... | [
"0.93370456",
"0.93197984",
"0.9103192",
"0.90562487",
"0.887185",
"0.87910056",
"0.876829",
"0.85913104",
"0.8434087",
"0.8427662",
"0.8250264",
"0.8236316",
"0.8182762",
"0.81814677",
"0.81565195",
"0.76892686",
"0.7569769",
"0.73527855",
"0.69095725",
"0.68744296",
"0.6867... | 0.9618386 | 0 |
Test case for test_result_nas_share | def test_test_result_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_test_nas_share(self):\n pass",
"def test_show_nas_share_by_nas(self):\n pass",
"def test_show_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_mount_status_nas_share_by_nas(self):\n pass",
"def test_update_nas_share_by_nas(s... | [
"0.87205005",
"0.8468603",
"0.84374386",
"0.84110034",
"0.81306785",
"0.80009717",
"0.79637134",
"0.795491",
"0.7851127",
"0.7800759",
"0.77983934",
"0.7788885",
"0.75479025",
"0.73223394",
"0.73046243",
"0.72120965",
"0.6860787",
"0.6632178",
"0.64907837",
"0.6297669",
"0.62... | 0.957169 | 0 |
Test case for update_nas_share | def test_update_nas_share(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_nas_share_by_nas(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_destroy_nas_share_by_... | [
"0.94022584",
"0.8667093",
"0.82092834",
"0.8034242",
"0.79996043",
"0.77217346",
"0.76853245",
"0.76770335",
"0.7653774",
"0.7644211",
"0.7401856",
"0.7383217",
"0.73583794",
"0.718956",
"0.7073682",
"0.69962233",
"0.6705802",
"0.658027",
"0.64904004",
"0.6448504",
"0.636371... | 0.9529857 | 0 |
Test case for update_nas_share_by_nas | def test_update_nas_share_by_nas(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_nas_share(self):\n pass",
"def test_update_nas_share_by_pool(self):\n pass",
"def test_create_nas_share_by_nas(self):\n pass",
"def test_test_nas_share(self):\n pass",
"def test_test_result_nas_share(self):\n pass",
"def test_index_nas_shares_by_nas(self... | [
"0.92568874",
"0.868185",
"0.8243654",
"0.8035217",
"0.79071957",
"0.7904033",
"0.7861192",
"0.7808969",
"0.75646436",
"0.75128955",
"0.749248",
"0.7425515",
"0.71185464",
"0.7093589",
"0.70677394",
"0.70360464",
"0.6987904",
"0.6672082",
"0.6565424",
"0.65342563",
"0.6251355... | 0.95343274 | 0 |
Test case for update_nas_share_by_pool | def test_update_nas_share_by_pool(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_nas_share_by_nas(self):\n pass",
"def test_update_nas_share(self):\n pass",
"def test_index_nas_shares_by_pool(self):\n pass",
"def test_show_nas_share_by_pool(self):\n pass",
"def test_destroy_nas_share_by_pool(self):\n pass",
"def test_mount_status_nas... | [
"0.8472414",
"0.83880275",
"0.82184863",
"0.8195564",
"0.81169623",
"0.80361986",
"0.74852073",
"0.74578637",
"0.7348537",
"0.7070271",
"0.7059347",
"0.70257837",
"0.6890321",
"0.68191767",
"0.68162924",
"0.6728974",
"0.6446969",
"0.6397714",
"0.6347254",
"0.616938",
"0.60866... | 0.96373075 | 0 |
For evaluating vhb we extract labels for vhb instead of sao2 | def preprocess_vhb(batch, nr_samples=None, snr=None,
magnification=None, bands_to_sortout=None):
X, y = preprocess2(batch, nr_samples, snr,
magnification, bands_to_sortout)
return X, y["vhb"].values | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels_b_v(self):\n return self._labels_b_v",
"def labels_b_v_all(self):\n return self._labels_b_v_all",
"def _make_vbenf_label(chain_parts):\n\n # toy label for development: run simple and dijet independently.\n # simple makes Et cuts on two jets. Independently (sharing possible)\n # of jet... | [
"0.67501473",
"0.6568259",
"0.6314509",
"0.62052965",
"0.59897834",
"0.59897834",
"0.5946092",
"0.59377635",
"0.58991873",
"0.5809695",
"0.5798361",
"0.5797039",
"0.57916325",
"0.57773614",
"0.57766294",
"0.5765343",
"0.57443243",
"0.57443243",
"0.5742162",
"0.57366246",
"0.5... | 0.5693916 | 25 |
Our standard method to evaluate the data. It will fill a DataFrame df which saves the errors for each evaluated setup | def evaluate_data(df_train, w_train, df_test, w_test,
evaluation_setups=None, preprocessing=None):
if evaluation_setups is None:
evaluation_setups = standard_evaluation_setups
if preprocessing is None:
preprocessing = preprocess
if ("weights" in df_train) and df_train["weig... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_df(self, df):\n ## Check invariant; model inputs must be subset of df columns\n var_diff = set(self.var).difference(set(df.columns))\n if len(var_diff) != 0:\n raise ValueError(\n \"Model inputs not a subset of given columns;\\n\"\n + \"mis... | [
"0.65705955",
"0.61609674",
"0.61391914",
"0.61067426",
"0.60614115",
"0.60162455",
"0.60003746",
"0.59906065",
"0.59698033",
"0.5951393",
"0.5951041",
"0.5949095",
"0.5932602",
"0.5929731",
"0.59138703",
"0.58937687",
"0.5890896",
"0.5842125",
"0.58418965",
"0.582007",
"0.58... | 0.7769943 | 0 |
Returns roman equivalent to an arabic | def to_roman(an_arabic):
result = ""
for level, symbol in [(1000,"M"),
(900,"CM"),
(500,"D"),
(400,"CD"),
(100,"C"),
(90,"XC"),
(50,"L"),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def arabic_to_roman_replace(test_word):\n arabic_word = test_word\n\n \"\"\"\n testWord = \"دَرْس\"\n print(testWord, sep=\" \")\n \"\"\"\n\n # converting into roman characters\n print()\n roman_characters = \"\"\n for letter in arabic_word:\n #print(letter)\n if letter in ... | [
"0.779442",
"0.74281687",
"0.7296251",
"0.7257054",
"0.67278147",
"0.67266434",
"0.6697449",
"0.6658061",
"0.66198784",
"0.65114695",
"0.6464905",
"0.64380807",
"0.639312",
"0.63480544",
"0.6299207",
"0.62872094",
"0.62515366",
"0.62329185",
"0.6206833",
"0.62048817",
"0.6163... | 0.8043565 | 0 |
Creates some B words for every pair, with the following constraints | def create_B_words(path_to_pairs,
path_to_librispeech_text,
path_to_phonemes,
path_save,
freq_sim,
len_sim,
edit_sim):
for i in range(len(path_to_pairs)):
pairs = []
dic_cl_eq =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_pairs_of_words(word_list):\n def pair_words(word_list, i, j, connector):\n return word_list[i] + connector + word_list[j]\n pairs = []\n n = len(word_list)\n for i in range(n-1):\n for j in range(i+1, n):\n pairs.append(pair_words(word_list, i, j, ' '))\n ... | [
"0.6379959",
"0.6285808",
"0.6200078",
"0.61135346",
"0.6090671",
"0.6088368",
"0.6056059",
"0.60499376",
"0.6005667",
"0.5910683",
"0.59056056",
"0.590162",
"0.5847353",
"0.58410585",
"0.5787261",
"0.5781655",
"0.5771898",
"0.57667893",
"0.57136333",
"0.5706423",
"0.56973606... | 0.6256183 | 2 |
We call new, when we want to apply the pipeline to something unrelated | def new(self):
self.interesting_mask = None
self.previous_lines = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_own_pipeline() -> Pipeline:\n nn_pipeline = None\n\n nn_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('tfidf', TfidfTransformer()),\n ('clf', MLPClassifier()) \n ])\n \n return nn_pipeline",
"def pipeline(self) -> Pipeline:\n if self._to_pipeline is None... | [
"0.6718284",
"0.6605446",
"0.64793473",
"0.63921684",
"0.6358232",
"0.63030565",
"0.6258657",
"0.62482244",
"0.6221897",
"0.62135386",
"0.62027407",
"0.61847925",
"0.6180768",
"0.61727595",
"0.61503994",
"0.6145696",
"0.61375916",
"0.6078692",
"0.6036495",
"0.60242677",
"0.60... | 0.0 | -1 |
Helper method that calls ``tokenizer.batch_encode`` if possible, and if not, falls back to calling ``tokenizer.encode`` for each input. | def tokenize(self, inputs):
if hasattr(self.tokenizer, "batch_encode"):
return self.tokenizer.batch_encode(inputs)
else:
return [self.tokenizer.encode(x) for x in inputs] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode(batch, tokenizer):\n return tokenizer.batch_encode_plus(batch['sentence'], padding='max_length')",
"def _batch_encode(self, text: List[str]) -> List[List[str]]:\n token_ids: List[List[int]] = self.bert_model.batch_encode([t.strip() for t in text])\n tokens_ids_str: List[List[str]] = [... | [
"0.7312299",
"0.62325454",
"0.62248653",
"0.62079835",
"0.61744493",
"0.60844237",
"0.60585696",
"0.5993476",
"0.59909976",
"0.59304714",
"0.5894535",
"0.5890986",
"0.5826842",
"0.5709089",
"0.57029486",
"0.5684606",
"0.56439316",
"0.56439316",
"0.55587023",
"0.55517715",
"0.... | 0.71921265 | 1 |
parses the command line args for options/parameters | def parse_options(self):
parser = argparse.ArgumentParser()
parser.add_argument(
"-i",
"--input_csv",
type=str,
help="Input CSV path(s)",
required=True,
nargs="+",
)
parser.add_argument(
"-o", "--output_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet... | [
"0.80873114",
"0.7811934",
"0.77932054",
"0.77715003",
"0.77535075",
"0.76733726",
"0.7649569",
"0.7641751",
"0.7631887",
"0.75946397",
"0.7534283",
"0.7530792",
"0.7495356",
"0.7490417",
"0.7487174",
"0.74836403",
"0.7483276",
"0.7483084",
"0.7479624",
"0.7477241",
"0.747385... | 0.0 | -1 |
distinguishes one vs. many unified input csv files and either sets the single csv as input, or merges all csvs and sets the merged csv as input. | def set_input_csv(self):
if len(self["input_csv"]) > 1:
raise Exception("You must only specify *one* unified CSV file!")
self.csv_path = self["input_csv"][0]
print("Using input file", self.csv_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_directory_csv(d_in, d_out, target_column, merge_columns):\n\n INPUT_FILES = grab_files(\"*.csv\", d_in)\n\n if not INPUT_FILES:\n logger.warning(\"No matching CSV files found, exiting\")\n exit(2)\n\n for f_csv in INPUT_FILES:\n f_csv_out = os.path.join(d_out, os.path.basen... | [
"0.65366405",
"0.63891923",
"0.63422674",
"0.61547923",
"0.6103674",
"0.6021459",
"0.5971792",
"0.5885629",
"0.58756024",
"0.58568597",
"0.58556205",
"0.57153285",
"0.5673784",
"0.56549925",
"0.563907",
"0.5638952",
"0.56366646",
"0.56365585",
"0.56354904",
"0.5634072",
"0.56... | 0.7068569 | 0 |
Finds and notes decoys that share their sequence with a target PSM. Also counts the number of targets and decoys to get a quick estimate of how many positive/negative training examples can be "claimed". | def find_shitty_decoys(self):
target_seqs = set()
decoy_seqs = set()
with open(self.csv_path, "r") as f:
reader = csv.DictReader(f)
sorted_reader = sorted(
reader,
reverse=self["bigger_scores_better"],
key=lambda d: float(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_target(self):\n tally = {}\n for obj in self.target:\n tally[obj] = 0\n\n ind = 0\n for label in self.labelList:\n filename = self.pathLabel + label\n f = open(filename, 'r')\n content = f.read().split('\\n')\n for line in... | [
"0.59328616",
"0.54016626",
"0.53880644",
"0.53279763",
"0.5304748",
"0.5270805",
"0.52698284",
"0.52169853",
"0.5192627",
"0.5187703",
"0.5163138",
"0.5144442",
"0.5137317",
"0.51321214",
"0.5109379",
"0.5109379",
"0.5092773",
"0.5085388",
"0.5081025",
"0.50582725",
"0.50424... | 0.60678124 | 0 |
Turns the unified CSV column "Protein ID" into a set of all protein IDs. | def parse_protein_ids(csv_field, sep="<|>"):
clean = csv_field.replace("decoy_", "").strip()
prot_id_set = set(clean.split(sep))
return prot_id_set | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_award_ids (self, column):\n raw = self[column]\n vals = map (lambda x:x.strip(), raw.split(','))\n # return list (set (vals))\n return vals\n\n if 0:\n # truncated = filter (None, map (lambda x: len(x)>5 and x[-5:] or None, vals))\n truncated = filte... | [
"0.6303952",
"0.62645626",
"0.60780895",
"0.57484424",
"0.552927",
"0.552591",
"0.53634834",
"0.5353858",
"0.53358835",
"0.53217846",
"0.5320453",
"0.52818024",
"0.523921",
"0.52312315",
"0.5158253",
"0.5154796",
"0.5145234",
"0.512992",
"0.51164055",
"0.51120037",
"0.5105347... | 0.7984387 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.