def get(cls, username: str, password: str) -> "DeveloperToken": response = requests.post( "https://iam.ebrains.eu/auth/realms/hbp/protocol/openid-connect/token", auth=('developer', ''), data={ "username": username, "password": password, "grant_type": "password", }, ) print( f"Get DevToken response:\n:{json.dumps(response.json(), indent=4)}" ) response.raise_for_status() payload = ensureJsonObject(response.json()) return DeveloperToken( access_token=ensureJsonString(payload.get("access_token")), expires_in=ensureJsonInt(payload.get("expires_in")), not_before_policy=ensureJsonInt(payload.get("not-before-policy")), refresh_expires_in=ensureJsonInt( payload.get("refresh_expires_in")), refresh_token=ensureJsonString(payload.get("refresh_token")), scope=ensureJsonString(payload.get("scope")), token_type=ensureJsonString(payload.get("token_type")), )
def from_json_data(cls, data: JsonValue) -> "Color": data_dict = ensureJsonObject(data) return Color( r=np.uint8(ensureJsonInt(data_dict.get("r", 0))), g=np.uint8(ensureJsonInt(data_dict.get("g", 0))), b=np.uint8(ensureJsonInt(data_dict.get("b", 0))), )
def from_json_value(cls, value: JsonValue) -> "JobResources": value_obj = ensureJsonObject(value) return JobResources( Memory=Memory.from_json_value(value_obj.get("Memory")), Runtime=Seconds(ensureJsonInt(value_obj.get("Runtime"))), CPUs=ensureJsonInt(value_obj.get("CPUs")), Nodes=ensureJsonInt(value_obj.get("Nodes")), CPUsPerNode=ensureJsonInt(value_obj.get("CPUsPerNode")), Reservation=ensureJsonString(value_obj.get("Reservation")), )
def wait_until_jobs_completed(workflow: PixelClassificationWorkflow, timeout: float = 50): wait_time = 0.5 while timeout > 0: export_status: JsonObject = workflow.export_applet._get_json_state() jobs = ensureJsonArray(export_status["jobs"]) for job in jobs: job_obj = ensureJsonObject(job) num_args = ensureJsonInt(job_obj["num_args"]) num_completed_steps = ensureJsonInt(job_obj["num_completed_steps"]) if num_completed_steps < num_args: print(f"Jobs not done yet. Waiting...") time.sleep(wait_time) timeout -= wait_time break else: return raise TimeoutError("Waiting on jobs timed out!")
def from_json_value(cls, value: JsonValue) -> "BucketObject": value_dict = ensureJsonObject(value) return BucketObject( hash_=ensureJsonString(value_dict.get("hash")), last_modified=datetime.fromisoformat( ensureJsonString(value_dict.get("last_modified"))), bytes_=ensureJsonInt(value_dict.get("bytes")), name=PurePosixPath(ensureJsonString(value_dict.get("name"))), content_type=ensureJsonString(value_dict.get("content_type")), )
def from_json_value(cls, data: JsonValue): data_dict = ensureJsonObject(data) return PrecomputedChunksInfo( type_=ensureJsonString(data_dict.get("type")), data_type=np.dtype(ensureJsonString(data_dict.get("data_type"))), #type: ignore num_channels=ensureJsonInt(data_dict.get("num_channels")), scales=tuple( PrecomputedChunksScale.from_json_value(raw_scale) for raw_scale in ensureJsonArray(data_dict.get("scales")) ) )
def from_json_value(cls, value: JsonValue) -> "PrecomputedChunksScaleSink": value_obj = ensureJsonObject(value) return PrecomputedChunksScaleSink( filesystem=JsonableFilesystem.from_json_value( value_obj.get("filesystem")), info_dir=PurePosixPath(ensureJsonString( value_obj.get("info_dir"))), scale=PrecomputedChunksScale.from_json_value( value_obj.get("scale")), dtype=np.dtype(ensureJsonString(value_obj.get("dtype"))), num_channels=ensureJsonInt(value_obj.get("num_channels")))
def from_json_value(cls, data: JsonValue): data_dict = ensureJsonObject(data) type_ = ensureJsonString(data_dict.get("type")) if type_ != "image": raise ValueError(f"Bad 'type' marker value: {type_}") return PrecomputedChunksInfo( type_=type_, data_type=np.dtype(ensureJsonString(data_dict.get("data_type"))), num_channels=ensureJsonInt(data_dict.get("num_channels")), scales=tuple( PrecomputedChunksScale.from_json_value(raw_scale) for raw_scale in ensureJsonArray(data_dict.get("scales"))))
def get(cls, *, client_id: str, client_secret: str) -> "ServiceToken": response = requests.post( "https://iam.ebrains.eu/auth/realms/hbp/protocol/openid-connect/token", auth=('developer', ''), data={ "client_id": client_id, "client_secret": client_secret, "scope": "email profile team group clb.wiki.read clb.wiki.write", #FIXME "grant_type": "client_credentials", }, ) print(f"Get ServiceToken response:\n:{json.dumps(response.json(), indent=4)}") response.raise_for_status() payload = ensureJsonObject(response.json()) return ServiceToken( access_token=ensureJsonString(payload.get("access_token")), expires_in=ensureJsonInt(payload.get("expires_in")), not_before_policy=ensureJsonInt(payload.get("not-before-policy")), refresh_expires_in=ensureJsonInt(payload.get("refresh_expires_in")), scope=ensureJsonString(payload.get("scope")), token_type=ensureJsonString(payload.get("token_type")), )
def from_json_data(cls, data: JsonValue) -> "Bzip2Compressor": return Bzip2Compressor(blockSize=ensureJsonInt( ensureJsonObject(data).get("blockSize", 9)))
def from_json_data(cls, data: JsonValue) -> "GzipCompressor": return GzipCompressor( level=ensureJsonInt(ensureJsonObject(data).get("level", 1)))
def from_json_data(cls, data: JsonValue) -> "XzCompressor": return XzCompressor( preset=ensureJsonInt(ensureJsonObject(data).get("preset")))
def from_json_value(cls, value: JsonValue) -> "OidcClient": value_obj = ensureJsonObject(value) raw_rootUrl = ensureJsonString(value_obj.get("rootUrl")) rootUrl = Url.parse(raw_rootUrl) if rootUrl is None: rootUrl = Url.parse( raw_rootUrl + "/") # it's possible to register a rootUrl without a path -.- assert rootUrl is not None redirectUris: List[Url] = [] for raw_redirect_uri in ensureJsonStringArray( value_obj.get("redirectUris")): try: redirect_uri = Url.parse(raw_redirect_uri) assert redirect_uri is not None redirectUris.append(redirect_uri) except ValueError: uri = rootUrl.joinpath( PurePosixPath(raw_redirect_uri) ) # FIXME: do leading slashes mean root here too? redirectUris.append(uri) baseUrl = Url.parse(ensureJsonString(value_obj.get("baseUrl"))) assert baseUrl is not None return OidcClient( alwaysDisplayInConsole=ensureJsonBoolean( value_obj.get("alwaysDisplayInConsole")), baseUrl=baseUrl, bearerOnly=ensureJsonBoolean(value_obj.get("bearerOnly")), clientAuthenticatorType=ensureJsonString( value_obj.get("clientAuthenticatorType")), clientId=ensureJsonString(value_obj.get("clientId")), consentRequired=ensureJsonBoolean( value_obj.get("consentRequired")), defaultClientScopes=ensureJsonStringArray( value_obj.get("defaultClientScopes")), description=ensureJsonString(value_obj.get("description")), directAccessGrantsEnabled=ensureJsonBoolean( value_obj.get("directAccessGrantsEnabled")), enabled=ensureJsonBoolean(value_obj.get("enabled")), frontchannelLogout=ensureJsonBoolean( value_obj.get("frontchannelLogout")), fullScopeAllowed=ensureJsonBoolean( value_obj.get("fullScopeAllowed")), id=ensureJsonString(value_obj.get("id")), implicitFlowEnabled=ensureJsonBoolean( value_obj.get("implicitFlowEnabled")), name=ensureJsonString(value_obj.get("name")), nodeReRegistrationTimeout=ensureJsonInt( value_obj.get("nodeReRegistrationTimeout")), notBefore=ensureJsonInt(value_obj.get("notBefore")), optionalClientScopes=set( Scope.from_json_value(s) for s in ensureJsonArray( value_obj.get("optionalClientScopes"))), protocol=ensureJsonString(value_obj.get("protocol")), publicClient=ensureJsonBoolean(value_obj.get("publicClient")), redirectUris=tuple(redirectUris), registrationAccessToken=ensureJsonString( value_obj.get("registrationAccessToken")), rootUrl=rootUrl, secret=ensureJsonString(value_obj.get("secret")), serviceAccountsEnabled=ensureJsonBoolean( value_obj.get("serviceAccountsEnabled")), standardFlowEnabled=ensureJsonBoolean( value_obj.get("standardFlowEnabled")), surrogateAuthRequired=ensureJsonBoolean( value_obj.get("surrogateAuthRequired")), webOrigins=ensureJsonStringArray(value_obj.get("webOrigins")), )
def from_json_value(cls, value: JsonValue) -> "PrecomputedChunksScale5D": value_obj = ensureJsonObject(value) raw_scale = PrecomputedChunksScale.from_json_value(value) return PrecomputedChunksScale5D.from_raw_scale(raw_scale, num_channels=ensureJsonInt(value_obj.get("num_channels")))
async def spawn_session(self, ebrains_login: EbrainsLogin, request: web.Request) -> web.Response: raw_payload = await request.content.read() try: payload_dict = ensureJsonObject( json.loads(raw_payload.decode('utf8'))) session_duration = Minutes( ensureJsonInt(payload_dict.get("session_duration_minutes"))) except Exception: return web.json_response({"error": "Bad payload"}, status=400) session_id = uuid.uuid4() quota: NodeSeconds = NodeSeconds(100 * 60 * 60) #FIXME user_info = await ebrains_login.user_token.get_userinfo( self.http_client_session) if user_info.sub != uuid.UUID( "bdca269c-f207-4cdb-8b68-a562e434faed"): #FIXME return web.json_response( {"error": "This user can't allocate sessions yet"}, status=400) if user_info.sub not in self.session_user_locks: self.session_user_locks[user_info.sub] = asyncio.Lock() async with self.session_user_locks[user_info.sub]: this_months_jobs_result = await self.session_launcher.get_jobs( starttime=datetime.today().replace(day=1)) if isinstance(this_months_jobs_result, Exception): print( f"Could not get session information:\n{this_months_jobs_result}\n", file=sys.stderr) return web.json_response( {"error": "Could get session information"}, status=500) for job in this_months_jobs_result: if not job.belongs_to(user_info=user_info): continue if job.is_running(): return web.json_response( {"error": "Already running a session"}, status=400) quota = NodeSeconds(quota - job.duration * job.num_nodes) if quota <= 0: #FIXME return web.json_response({"error": "Out of quota"}, status=400) session_result = await self.session_launcher.launch( user_info=user_info, time=Minutes(min(quota, session_duration)), ebrains_user_token=ebrains_login.user_token, session_id=session_id, ) if isinstance(session_result, Exception): print(f"Could not create compute session:\n{session_result}", file=sys.stderr) return web.json_response( {"error": "Could not create compute session"}, status=500) return web.json_response( { "id": str(session_id), "url": self._make_session_url(session_id).raw, }, )