def create_mongo_sink(topic, collection):
data = {
'name': f'mongo-sink-{topic}',
'config': {
'connector.class': 'com.mongodb.kafka.connect.MongoSinkConnector',
'tasks.max': 1,
'topics': topic,
'connection.uri': mongo_url,
'database': mongo_db_name,
'collection': collection,
'key.converter': 'org.apache.kafka.connect.storage.StringConverter',
'value.converter': 'io.confluent.connect.json.JsonSchemaConverter',
'value.converter.schema.registry.url': schema_registry_url,
'value.converter.schemas.enable': True,
'errors.tolerance': 'all',
'errors.log.enable': 'true',
'errors.log.include.messages': 'true',
'errors.deadletterqueue.topic.name': f'dlq.mongo.{mongo_db_name}.{collection}',
'errors.deadletterqueue.context.headers.enable': 'true',
'errors.deadletterqueue.topic.replication.factor': 1,
},
}
httpx.delete(f'{kafka_connect_url}/connectors/mongo-sink-{topic}')
res = httpx.post(f'{kafka_connect_url}/connectors', json=data)
print(res.json())
res.raise_for_status()
async def api_delete_accounts():
admin_access_token = await api_access_token(admin_login_name,
admin_password)
admin_auth_header = api_auth_header(admin_access_token)
for user in await api_get_users():
if user['role'] == 'admin':
continue
httpx.delete(api_url + '/accounts/' + user['account_id'],
headers=admin_auth_header)
async def test_asset_bad_requests(async_client, batch_client, httpd):
""""""
_, logs = batch_client
# Add a dataset, version, and default asset
dataset = "test_bad_requests"
version = "v1.1.1"
_ = await create_default_asset(dataset,
version,
async_client=async_client,
execute_batch_jobs=False)
# Flush requests list so we're starting fresh
httpx.delete(f"http://localhost:{httpd.server_port}")
# Try adding a non-default raster tile set asset with an extra field "foo"
asset_payload = {
"asset_type": "Raster tile set",
"is_managed": True,
"foo": "foo", # The extra field
"creation_options": {
"data_type": "uint16",
"pixel_meaning": "gfw_fid",
"grid": "90/27008",
"resampling": "nearest",
"overwrite": True,
"subset": "90N_000E",
},
}
create_asset_resp = await async_client.post(
f"/dataset/{dataset}/{version}/assets", json=asset_payload)
resp_json = create_asset_resp.json()
assert resp_json["status"] == "failed"
assert resp_json["message"] == [{
"loc": ["body", "foo"],
"msg": "extra fields not permitted",
"type": "value_error.extra",
}]
# Try adding a non-default raster tile set asset missing the
# "creation_options" field (and toss the extra "foo" field from before)
del asset_payload["foo"]
del asset_payload["creation_options"]
create_asset_resp = await async_client.post(
f"/dataset/{dataset}/{version}/assets", json=asset_payload)
resp_json = create_asset_resp.json()
assert resp_json["status"] == "failed"
assert resp_json["message"] == [{
"loc": ["body", "creation_options"],
"msg": "field required",
"type": "value_error.missing",
}]
def delete_file(
repo: Optional[str],
package: Optional[str],
version: Optional[str],
filename: Optional[str],
):
username, header = get_auth_header_and_username()
if not username:
return
if not repo:
repo = repositories.select_from_available_repo(subject=username)
if not package:
package = packages_core.select_from_available_packages(
subject=username, repo=repo)
if not version:
version = select_from_available_versions(subject=username,
repo=repo,
package=package,
filename=filename)
if not filename:
filename = select_from_available_files(subject=username,
repo=repo,
package=package,
version=version)
print_message(f"Deleting file {filename} version {version}")
url = get_url(f"/{username}/{repo}/{package}/{version}/{filename}")
password = typer.prompt("Password", hide_input=True)
response = httpx.delete(url=url,
auth=httpx.BasicAuth(username=username,
password=password))
response_handler(response=response, return_model=FileDeleteResponseModel)
return
def load_vocab(vocab: Path, guri):
authdetails = None
try:
authdetails = (os.environ["DB_USERNAME"], os.environ["DB_PASSWORD"])
except:
pass
context = "{}/rdf4j-server/repositories/{}/statements?context=<{}>".format(RDF4JSERVER, REPO, quote_plus(guri))
r = httpx.delete(
# "http://"+os.environ["VOCAB_HOST"] + "/rdf4j-server/repositories/ogc-na" ,
context,
auth=authdetails
)
# print ( r.status_code )
r = httpx.post(
#"http://"+os.environ["VOCAB_HOST"] + "/rdf4j-server/repositories/ogc-na" ,
context,
params={"graph": guri },
headers={"Content-Type": "application/x-turtle;charset=UTF-8"},
content=open(vocab, "rb").read(),
auth= authdetails
)
assert 200 <= r.status_code <= 300, "Status code was {}".format(r.status_code)
# add_to_vocab_index(vocab, get_graph_uri_for_vocab(vocab))
return context
async def test_delete_a_skill_as_an_admin():
await api_delete_skills()
admin_headers = await api_admin_auth_headers()
r = api_create_skill('python', admin_headers)
skill_id = r.json()['id']
r = httpx.delete(api_url + '/skills/' + skill_id, headers=admin_headers)
assert r.status_code == 204
def test_rabbitmq_chained(self):
# trigger queue create
resp = httpx.post(MGMT + '/async/producers/chain2-on-demand',
verify=False)
resp.raise_for_status()
resp = httpx.post(MGMT + '/async/producers/chain2-reactive',
verify=False)
resp.raise_for_status()
# TODO: make it detect the moment when queues are created
time.sleep(10) # wait for consumers to subscribe
# clean the log
resp = httpx.delete(MGMT + '/async/consumers/chain2-validating',
verify=False)
resp.raise_for_status()
resp = httpx.post(MGMT + '/async/producers/chain2-on-demand',
verify=False)
resp.raise_for_status()
for _ in range(30):
resp = httpx.get(MGMT + '/async/consumers/chain2-validating',
verify=False)
resp.raise_for_status()
msgs = resp.json()['log']['entries']
if not msgs:
time.sleep(1)
continue
self.assertEqual(1, len(msgs))
break
else:
self.fail("Did not capture the message")
def delete_notification(*, client: Client, id: str) -> bool:
url = "{}/v0b/notifications/{id}".format(client.base_url, id=id)
response = httpx.delete(url=url, headers=client.get_headers())
if response.status_code == 204:
return True
raise ApiResponseError(code=response.status_code, detail=response.json())
def _test_traffic_log(self, root):
self.test_urlencoded() # ensure httpx are there
# clear log
resp = httpx.delete(root + '/traffic-log', verify=False)
json = self._valid_har(resp)
self.assertFalse(json['log']['entries'])
self.assertFalse(json['log']['_enabled'])
# enable log
resp = httpx.post(root + '/traffic-log',
data={"enable": "true"},
verify=False)
resp.raise_for_status()
# check
resp = httpx.get(root + '/traffic-log', verify=False)
json = self._valid_har(resp)
self.assertFalse(json['log']['entries'])
self.assertTrue(json['log']['_enabled'])
# make httpx
self.test_multipart()
# fetch log
resp = httpx.get(root + '/traffic-log', verify=False)
json = self._valid_har(resp)
self.assertTrue(json['log']['entries'])
# disable log
resp = httpx.post(root + '/traffic-log',
data={"enable": "false"},
verify=False)
resp.raise_for_status()
# clear
resp = httpx.delete(root + '/traffic-log', verify=False)
resp.raise_for_status()
self.test_urlencoded() # ensure httpx are made
# validate cleared
resp = httpx.get(root + '/traffic-log', verify=False)
json = self._valid_har(resp)
self.assertFalse(json['log']['entries'])
self.assertFalse(json['log']['_enabled'])
def test_create_deployment():
resp = httpx.post(
f"{URL}/deployments/hdoupe/ccc-widget/",
json={
"tag": "fix-iframe-link3",
"deployment_name": "test"
},
)
assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}"
now = datetime.now()
max_wait = 120
success = False
while (datetime.now() - now).seconds < max_wait:
resp = httpx.get(f"{URL}/deployments/hdoupe/ccc-widget/test/")
assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}"
data = resp.json()
print(resp, data)
if (data["deployment"]["ready"] and data["svc"]["ready"]
and data["ingressroute"]["ready"]):
print(data)
success = True
break
time.sleep(1)
if not success:
raise Exception(
f"Deployment not ready in less than {max_wait} seconds: {data}")
server = Server(
project=PROJECT,
owner="hdoupe",
title="ccc-widget",
tag="fix-iframe-link3",
model_config=ModelConfig(PROJECT, CS_URL),
callable_name="dash",
deployment_name="test",
namespace="default",
incluster=False,
)
assert server.ready_stats() == data
resp = httpx.delete(f"{URL}/deployments/hdoupe/ccc-widget/test/")
assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}"
assert resp.json() == {
"deployment": {
"deleted": True
},
"svc": {
"deleted": True
},
"ingressroute": {
"deleted": True
},
}
def delete(self, endpoint, status_code=200, **kwargs):
if "auth" not in kwargs and self._authorized:
kwargs.update(auth=self.creds)
logger.info(f"Getting {endpoint}...")
r = requests.delete(self.url + endpoint, **kwargs)
logger.info("done")
assert r.status_code == status_code, (r.status_code, status_code,
r.text)
return r
async def test_http_methods(client):
async with respx.mock:
url = "https://foo.bar"
route = respx.get(url, path="/") % 404
respx.post(url, path="/").respond(200)
respx.post(url, path="/").respond(201)
respx.put(url, path="/").respond(202)
respx.patch(url, path="/").respond(500)
respx.delete(url, path="/").respond(204)
respx.head(url, path="/").respond(405)
respx.options(url, path="/").respond(status_code=501)
respx.request("GET", url, path="/baz/").respond(status_code=204)
url += "/"
response = httpx.get(url)
assert response.status_code == 404
response = await client.get(url)
assert response.status_code == 404
response = httpx.get(url + "baz/")
assert response.status_code == 204
response = await client.get(url + "baz/")
assert response.status_code == 204
response = httpx.post(url)
assert response.status_code == 201
response = await client.post(url)
assert response.status_code == 201
response = httpx.put(url)
assert response.status_code == 202
response = await client.put(url)
assert response.status_code == 202
response = httpx.patch(url)
assert response.status_code == 500
response = await client.patch(url)
assert response.status_code == 500
response = httpx.delete(url)
assert response.status_code == 204
response = await client.delete(url)
assert response.status_code == 204
response = httpx.head(url)
assert response.status_code == 405
response = await client.head(url)
assert response.status_code == 405
response = httpx.options(url)
assert response.status_code == 501
response = await client.options(url)
assert response.status_code == 501
assert route.called is True
assert respx.calls.call_count == 8 * 2
def delete_object_and_orgfuncs(uuid: str,
mox_base: str,
object_type: str,
dry_run: bool = False):
assert object_type in ("bruger", "organisationenhed")
rel = "tilknyttedebrugere" if object_type == "bruger" else "tilknyttedeenheder"
response = httpx.get(
f"{mox_base}/organisation/organisationfunktion?{rel}={uuid}")
response.raise_for_status()
org_funcs = response.json()["results"][0]
if dry_run:
return org_funcs
for org_func_uuid in org_funcs:
r = httpx.delete(
f"{mox_base}/organisation/organisationfunktion/{org_func_uuid}")
r.raise_for_status()
r = httpx.delete(f"{mox_base}/organisation/{object_type}/{uuid}")
r.raise_for_status()
def delete_record(msgs):
if msgs:
option = int(input("choose the option: ")) if len(msgs) > 1 else 0
msg = msgs[option]
if httpx.delete(f'{base_url}/{msg["id"]}',
headers=headers).json()['success']:
print('Deleted')
logger.info(f'DELETED | {eval(req_msg)}')
else:
print(f'Record not found: {name}')
def test_fallback(self):
resp = httpx.delete(SRV7 + '/sub/__admin/unhandled')
resp.raise_for_status()
resp = httpx.post(SRV7 + '/sub/__admin/unhandled', json=True)
resp.raise_for_status()
resp = httpx.get(SRV7 + '/')
self.assertEqual(200, resp.status_code)
self.assertEqual("no fallback", resp.text)
resp = httpx.get(
SRV7 + '/Changelog.html') # '/parameterized1/fallback/subval'
self.assertEqual(200, resp.status_code)
resp = httpx.get(SRV7 + '/img/logo.png')
self.assertEqual(200, resp.status_code)
self.assertEqual('image/png', resp.headers.get('content-type'))
resp = httpx.get(SRV7 + '/not-exists')
self.assertEqual(404, resp.status_code)
resp = httpx.get(SRV7 + '/sub/__admin/unhandled')
resp.raise_for_status()
exp = {
'services': [{
'endpoints': [{
'method': 'GET',
'path': '/Changelog.html',
'response': {
'status': 200
}
}, {
'method': 'GET',
'path': '/not-exists',
'response': {
'status': 404
}
}],
'name':
'Service with fallback',
'port':
8007
}]
}
rdata = resp.json()
endps = rdata['services'][0]['endpoints']
self.assertIn('<html', endps[0]['response'].pop('body'))
endps[1]['response'].pop('body')
endps[0]['response'].pop('headers')
endps[1]['response'].pop('headers')
self.assertEqual(exp, rdata)
resp = httpx.post(SRV7 + '/sub/__admin/unhandled', json=False)
resp.raise_for_status()
def test_resources_global(self):
resp = httpx.get(MGMT + '/resources', verify=False)
resp.raise_for_status()
files = resp.json()['files']
logging.info("Files: %s", files)
self.assertIn('subdir/empty_schema.json', files)
self.assertIn('cors.html', files)
self.assertIn('subdir/image.png', files)
self.assertNotIn('/etc/hosts', files)
self.assertEqual(len(files), len(set(files)))
for file in files: # test that all files reported can be read and written
resp = httpx.get(MGMT + '/resources?path=%s' % file, verify=False)
resp.raise_for_status()
resp = httpx.post(MGMT + '/resources',
files={file: resp.content},
verify=False)
resp.raise_for_status()
resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False)
resp.raise_for_status()
self.assertIn('<html ', resp.text)
orig_content = resp.text
resp = httpx.delete(MGMT + '/resources?path=cors.html', verify=False)
resp.raise_for_status()
with self.assertRaises(httpx.HTTPError):
resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False)
resp.raise_for_status()
marker = "<!-- %s -->" % time.time()
resp = httpx.post(MGMT + '/resources',
files={"cors.html": orig_content + marker},
verify=False)
resp.raise_for_status()
resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False)
resp.raise_for_status()
self.assertTrue(resp.text.endswith(marker))
resp = httpx.post(MGMT + '/resources',
files={"cors.html": orig_content},
verify=False)
resp.raise_for_status()
with self.assertRaises(httpx.HTTPError):
resp = httpx.get(MGMT + '/resources?path=/etc/hosts', verify=False)
resp.raise_for_status()
with self.assertRaises(httpx.HTTPError):
resp = httpx.get(MGMT + '/resources?path=__init__.py',
verify=False)
resp.raise_for_status()
def delete_repo(repo: Optional[str], is_operation_confirmed: Optional[bool] = False):
username, headers = get_auth_header_and_username()
if not username:
return
if not repo:
repo = select_from_available_repo(subject=username)
if not is_operation_confirmed and not is_operation_confirm():
return
url: str = get_url(f"/repo/{username}/{repo}")
response = httpx.delete(url=url, headers=headers)
return response_handler(response, RepoDeleteResponseModel)
def DeleteRole(RoleID: str):
r = httpx.delete(
'https://discord.com/api/{}/guilds/{}/roles/{}'.format(api, guild, RoleID),
proxies=getProxyDict(),
headers=headers
)
if r.status_code in [200, 201, 204]:
util.log('[!]', 'Deleted {}{}'.format(Fore.LIGHTCYAN_EX, RoleID))
elif r.status_code == 429:
util.log('[!]', 'Ratelimited for {}{}'.format(Fore.LIGHTCYAN_EX, r.json()['retry_after']))
DeleteChannel(ChannelID)
return(True)
def update_labels(github_event_data: dict,
release_info: typing.Optional[ReleaseInfo]):
labels_to_add = {"bot:has-release-file"}
labels_to_remove: typing.Set[str] = set()
new_release_label = None
if release_info is None:
labels_to_remove = labels_to_add
labels_to_add = set()
else:
new_release_label = f"bot:release-type-{release_info.change_type.value}"
labels_to_add.add(new_release_label)
labels_url = get_labels_link(github_event_data)
current_labels_url_by_name = {
label["name"]: label["url"]
for label in github_event_data["pull_request"]["labels"]
}
current_labels = set(current_labels_url_by_name.keys())
release_labels_to_remove = [
label for label in current_labels
if label.startswith("bot:release-type-") and label != new_release_label
]
labels_to_remove.update(release_labels_to_remove)
print("current_labels", current_labels, "labels_to_remove",
labels_to_remove)
if not current_labels.issuperset(labels_to_add):
request = httpx.post(
labels_url,
headers={"Authorization": f"token {GITHUB_TOKEN}"},
json={"labels": list(labels_to_add)},
)
if request.status_code >= 400:
print(request.text)
print(request.status_code)
if current_labels.issuperset(labels_to_remove):
for label in labels_to_remove:
request = httpx.delete(
current_labels_url_by_name[label],
headers={"Authorization": f"token {GITHUB_TOKEN}"},
)
if request.status_code >= 400:
print(request.text)
print(request.status_code)
def sync_detailed(
*,
client: Client,
conn_id: str,
) -> Response[ConnectionModuleResponse]:
kwargs = _get_kwargs(
client=client,
conn_id=conn_id,
)
response = httpx.delete(**kwargs, )
return _build_response(response=response)
def delete_device(
mac_address: str,
is_operation_confirmed: bool = False,
) -> None:
username, header = get_auth_header_and_username()
if not username:
return
if not is_operation_confirmed and not is_operation_confirm():
return
url = get_url(f"/devices/{mac_address}")
response = httpx.delete(url=url, headers=header)
response_handler(response=response, return_model=DeviceDeleteResponseModel)
def sync_detailed(
*,
client: Client,
name: str,
) -> Response[Union[ApiResponse, None]]:
kwargs = _get_kwargs(
client=client,
name=name,
)
response = httpx.delete(**kwargs, )
return _build_response(response=response)
def sync_detailed(
*,
client: AuthenticatedClient,
name: str,
) -> Response[Union[None, ErrorMessage, ErrorMessage, HTTPValidationError]]:
kwargs = _get_kwargs(
client=client,
name=name,
)
response = httpx.delete(**kwargs, )
return _build_response(response=response)
def sync_detailed(
*,
client: AuthenticatedClient,
id: int,
) -> Response[None]:
kwargs = _get_kwargs(
client=client,
id=id,
)
response = httpx.delete(**kwargs, )
return _build_response(response=response)
def delete(self,
payload: typing.Any = None,
endpoint: str = "") -> httpx.Response:
r = httpx.delete(
url=f"{self.url}{endpoint}",
auth=self.auth,
params=payload,
timeout=self.timeout,
)
if self.debug:
print(f"DELETE {r.url}")
print(json.dumps(r.json(), indent=4, sort_keys=True))
if r.is_error:
r.raise_for_status()
return r
async def test_http_methods(client):
async with respx.HTTPXMock() as httpx_mock:
url = "https://foo.bar/"
m = httpx_mock.get(url, status_code=404)
httpx_mock.post(url, status_code=201)
httpx_mock.put(url, status_code=202)
httpx_mock.patch(url, status_code=500)
httpx_mock.delete(url, status_code=204)
httpx_mock.head(url, status_code=405)
httpx_mock.options(url, status_code=501)
response = httpx.get(url)
assert response.status_code == 404
response = await client.get(url)
assert response.status_code == 404
response = httpx.post(url)
assert response.status_code == 201
response = await client.post(url)
assert response.status_code == 201
response = httpx.put(url)
assert response.status_code == 202
response = await client.put(url)
assert response.status_code == 202
response = httpx.patch(url)
assert response.status_code == 500
response = await client.patch(url)
assert response.status_code == 500
response = httpx.delete(url)
assert response.status_code == 204
response = await client.delete(url)
assert response.status_code == 204
response = httpx.head(url)
assert response.status_code == 405
response = await client.head(url)
assert response.status_code == 405
response = httpx.options(url)
assert response.status_code == 501
response = await client.options(url)
assert response.status_code == 501
assert m.called is True
assert httpx_mock.stats.call_count == 7 * 2
def terminate_filtered_employees(dry_run):
settings = load_settings()
filter_ids = settings.get("integrations.opus.units.filter_ids", [])
mox_base = settings.get("mox.base", "localhost:8080")
latest_date, opus_dump = opus_helpers.get_latest_dump()
file_diffs = opus_helpers.file_diff(None, opus_dump)
# Get every id of filtered units
all_ids = opus_helpers.find_all_filtered_ids(opus_dump, filter_ids)
# find all engagements to a filtered unit in latest opus-file
filtered_employees = list(
filter(lambda emp: emp.get("orgUnit") in all_ids,
file_diffs["employees"]))
diff = OpusDiffImport(latest_date, ad_reader=None, employee_mapping={})
# Check if any engagements exist that should have been filtered
eng_info = [
diff._find_engagement(e["@id"], "Engagement", present=False)
for e in filtered_employees
]
eng_info = list(filter(lambda x: x is not None, eng_info))
if dry_run:
print(
f"There are {len(eng_info)} engagements that should have been terminated."
)
return eng_info
for eng_uuid in tqdm(eng_info, desc="Deleting filtered engagements"):
r = httpx.delete(
f"{mox_base}/organisation/organisationfunktion/{eng_uuid}")
r.raise_for_status()
# Check users in MO - if no engagements are left then delete the user and all details to it.
user_cprs = set(map(opus_helpers.read_cpr, filtered_employees))
users = [diff.helper.read_user(user_cpr=cpr) for cpr in user_cprs]
users = filter(lambda x: x, users)
user_uuids = set(map(itemgetter("uuid"), users))
user_engagements = {
user_uuid: diff.helper.read_user_engagements(user_uuid, read_all=True)
for user_uuid in user_uuids
}
delete_users = dict(filter(lambda x: x[1] == [], user_engagements.items()))
for user_uuid in tqdm(delete_users,
desc="Deleting users with no other engagements"):
delete_object_and_orgfuncs(uuid=user_uuid,
mox_base=mox_base,
object_type="bruger",
dry_run=dry_run)
def DeleteChannel(ChannelID: str) -> bool:
try:
r = httpx.delete(
'https://discord.com/api/{}/channels/{}'.format(api, ChannelID),
#proxies=getProxyDict(),
headers=headers
)
if r.status_code in [200, 201, 204]:
util.log('[!]', 'Deleted {}{}'.format(Fore.LIGHTCYAN_EX, ChannelID))
elif r.status_code == 429:
util.log('[!]', 'Ratelimited for {}{}'.format(Fore.LIGHTCYAN_EX, r.json()['retry_after']))
NukeFunctions.DeleteChannel(ChannelID)
return(True)
except:
return(NukeFunctions.DeleteChannel(ChannelID))
async def remove_schema_by_id(schema_id: str) -> None:
"""Remove schema from trust registry by id
Args:
actor_id (str): identifier of the schema to remove
Raises:
TrustRegistryException: If an error occurred while removing the schema
"""
remove_response = httpx.delete(
f"{TRUST_REGISTRY_URL}/registry/schemas/{schema_id}")
if remove_response.is_error:
raise TrustRegistryException(
f"Error removing schema from trust registry: {remove_response.text}",
remove_response.status_code,
)
def stop_run(
*,
client: "AuthenticatedClient",
auto_test_id: "int",
run_id: "int",
extra_parameters: Mapping[str, str] = None,
) -> Union[None, ]:
"""Delete an AutoTest run, this makes it possible to edit the AutoTest.
This also clears the rubric categories filled in by the AutoTest."""
url = "{}/api/v1/auto_tests/{autoTestId}/runs/{runId}".format(
client.base_url, autoTestId=auto_test_id, runId=run_id)
headers: Dict[str, Any] = client.get_headers()
params: Dict[str, Any] = {
"no_course_in_assignment": "true",
"no_role_name": "true",
"no_assignment_in_case": "true",
"extended": "true",
}
if extra_parameters:
params.update(extra_parameters)
response = httpx.delete(
url=url,
headers=headers,
params=params,
)
if response_code_matches(response.status_code, 204):
return None
if response_code_matches(response.status_code, 400):
raise BaseError.from_dict(cast(Dict[str, Any], response.json()))
if response_code_matches(response.status_code, 409):
raise BaseError.from_dict(cast(Dict[str, Any], response.json()))
if response_code_matches(response.status_code, 401):
raise BaseError.from_dict(cast(Dict[str, Any], response.json()))
if response_code_matches(response.status_code, 403):
raise BaseError.from_dict(cast(Dict[str, Any], response.json()))
if response_code_matches(response.status_code, "5XX"):
raise BaseError.from_dict(cast(Dict[str, Any], response.json()))
else:
raise ApiResponseError(response=response)
