def search_repo(
name: Optional[str], description: Optional[str]
) -> RepoSearchResponseModel:
url: str = get_url(f"/search/repos")
params = {"name": name, "desc": description}
response = httpx.get(url=url, params=params)
return response_handler(response=response, return_with_out_model=True)
def file_upload(repo: Optional[str], package: Optional[str], version: str,
filename: 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)
file_path: str = filename
if os.path.isabs(file_path):
filename = os.path.basename(file_path)
url = get_url(f"/content/{username}/{repo}/{package}/{version}/{filename}")
try:
with open(file_path, "br") as file:
data = file.read()
headers = {
"x-bintray-publish": "1",
"content-type": "application/octet-stream",
"x-bintray-override": "1",
}
headers.update(header)
password = typer.prompt("Password", hide_input=True)
response = httpx.put(
url=url,
data=data,
headers=headers,
auth=httpx.BasicAuth(username=username, password=password),
)
response_handler(response=response, return_with_out_model=True)
except Exception as e:
print_error(f"{e.args[0]}")
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 update_version(
repo: Optional[str],
package: Optional[str],
version: Optional[str],
is_operation_confirmed: Optional[bool] = False,
):
username, headers = get_auth_header_and_username()
if not username:
return
if not repo:
repo = repositories_core.select_from_available_repo(subject=username)
if not package:
package = packages_core.select_from_available_packages(
subject=username, repo=repo)
if not version:
version = files_core.select_from_available_versions(subject=username,
repo=repo,
package=package,
filename=None)
body = pydantic_to_prompt(model=VersionUpdateBodyModel)
if not is_operation_confirmed and not is_operation_confirm():
return
url = get_url(f"/packages/{username}/{repo}/{package}/versions/{version}")
response = httpx.patch(url=url, json=body.dict(), headers=headers)
response_handler(response=response, return_with_out_model=True)
def get_version_for_file(subject: str, repo: Optional[str], file_path: str):
if not repo:
repo = repositories_core.select_from_available_repo(subject=subject)
url = get_url(f"/file_version/{subject}/{repo}/{file_path}")
response = httpx.get(url=url)
return response_handler(response=response,
return_model=VersionGetFileVersionResponseModel)
def get_device_list() -> None:
username, header = get_auth_header_and_username()
if not username:
return
url = get_url("/devices/")
response = httpx.get(url=url, headers=header)
response = response_handler(response=response, print_field="data")
def get_package_file(
subject: str,
repo: Optional[str],
package: Optional[str],
version: Optional[str],
include_unpublished: int,
is_internal_call: bool = False,
):
if not repo:
repo = repositories.select_from_available_repo(subject=subject)
if not package:
package = packages_core.select_from_available_packages(subject=subject,
repo=repo)
if not version:
version = select_from_available_versions(subject=subject,
repo=repo,
package=package,
filename=None)
url = get_url(
f"/packages/{subject}/{repo}/{package}/versions/{version}/files")
params = {}
params.update({"include_unpublished": include_unpublished})
response = httpx.get(url=url, params=params)
if is_internal_call and response.status_code != 200:
return None
if not is_internal_call:
response_handler(response=response, return_with_out_model=True)
else:
return response.json()
def file_download(
subject: str,
repo: Optional[str],
package: Optional[str],
version: Optional[str],
file_name: Optional[str],
path_to_save: str,
):
if not repo:
repo = repositories.select_from_available_repo(subject=subject)
if not package:
package = packages_core.select_from_available_packages(subject=subject,
repo=repo)
if not version:
version = select_from_available_versions(subject=subject,
repo=repo,
package=package,
filename=file_name)
if not file_name:
file_name = select_from_available_files(subject=subject,
repo=repo,
package=package,
version=version)
url = get_url(f"/{subject}/{repo}/{package}/{version}/{file_name}")
response = httpx.get(url=url)
if response.status_code == 200:
path = os.path.join(path_to_save, file_name)
with open(path, "bw") as file:
file.write(response.content)
print_message(f"file saved to {path}")
else:
print_error(response.text)
def add_device() -> None:
username, header = get_auth_header_and_username()
if not username:
return
url = get_url("/devices/")
body = pydantic_to_prompt(model=CreateDeviceModel)
response = httpx.post(url=url, json=body.dict(), headers=header)
response_handler(response=response, return_model=DeviceCreateResponseModel)
def get_repos(subject: str, is_internal_call: bool = False) -> dict:
url: str = get_url(f"/repos/{subject}")
response = httpx.get(url=url)
if not is_internal_call:
response_handler(response=response, return_with_out_model=True)
exit(0)
return response.json()
def create_repo():
username, headers = get_auth_header_and_username()
if not username:
return
body = pydantic_to_prompt(model=RepoCreateBodyModel)
url: str = get_url(f"/repos/{username}/{body.name}")
response = httpx.post(url=url, json=body.dict(), headers=headers)
response_handler(response, RepoCreateResponseModel)
def get_users_scope(users_username: str):
username, headers = get_auth_header_and_username()
if not username:
exit(1)
url = get_url(f"/v1/authorization/user/{users_username}/scopes/get")
response = httpx.get(url=url, headers=headers)
response_handler(response=response,
return_model=UsersScopesGetResponseModel)
def get_device(mac_address: str) -> None:
username, header = get_auth_header_and_username()
if not username:
return
url = get_url(f"/devices/{mac_address}")
response = httpx.get(url=url, headers=header)
response_handler(response=response,
return_model=DeviceOutModel,
print_field="data")
def create_package(repo: Optional[str]):
username, headers = get_auth_header_and_username()
if not username:
return
if not repo:
repo = repositories_core.select_from_available_repo(subject=username)
body = pydantic_to_prompt(model=PackageCreateBodyModel)
url = get_url(f"/packages/{username}/{repo}")
response = httpx.post(url=url, json=body.dict(), headers=headers)
return response_handler(response=response)
def get_valid_scopes():
url = get_url("/v1/authorization/scopes")
response = httpx.get(url=url)
result: ScopesGetValidResponseModel = response_handler(
response=response,
return_model=ScopesGetValidResponseModel,
print_result=False)
scopes = select_available_options_checkbox(name="Scopes",
message="Select scopes",
choices=result.valid_scopes)
return scopes["Scopes"] if scopes else []
def get_package(subject: str, package: Optional[str], repo: Optional[str],
attribute_values: int):
if not repo:
repo = repositories_core.select_from_available_repo(subject=subject)
if not package:
package = select_from_available_packages(subject=subject, repo=repo)
url = get_url(f"/packages/{subject}/{repo}/{package}")
params = {"attribute_values": attribute_values}
response = httpx.get(url=url, params=params)
return response_handler(response=response, return_model=PackageModel)
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 update_device(mac_address: str,
is_operation_confirmed: bool = False) -> None:
username, header = get_auth_header_and_username()
if not username:
return
url = get_url("/devices/{mac_address}")
body = pydantic_to_prompt(model=UpdateDeviceModel)
if not is_operation_confirmed and not is_operation_confirm():
return
response = httpx.patch(url=url, json=body.dict(), headers=header)
response_handler(response=response, return_model=DeviceModel)
def change_password(current_password: str, new_password: str):
username, headers = get_auth_header_and_username()
if not username:
return
url = get_url(f"/user/profile/security/change-password")
response = httpx.put(
url=url,
auth=httpx.BasicAuth(username=username, password=current_password),
json=UserUpdatePasswordBodyModel(new_password=new_password).dict(),
)
response_handler(response=response,
return_model=UserUpdatePasswordResponseModel)
def add_scope(users_username: str):
username, headers = get_auth_header_and_username()
if not username:
exit(1)
scopes = get_valid_scopes()
if not scopes:
print_error("No Scope has been selected!")
exit(1)
url = get_url(f"/v1/authorization/user/{users_username}/scopes/add")
body = AddUserScopesBodyModel(scopes=scopes)
response = httpx.post(url=url, headers=headers, json=body.dict())
response_handler(response=response, return_model=UserScopeAddResponseModel)
def update_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)
body = pydantic_to_prompt(model=RepoUpdateBodyModel)
if not is_operation_confirmed and not is_operation_confirm():
return
url: str = get_url(f"/repos/{username}/{repo}")
response = httpx.patch(url=url, json=body.dict(), headers=headers)
response_handler(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 register(email: str, username: str, password: str):
url: str = get_url(url=f"/user/register")
try:
body = UserRegisterBodyModel(
username=username,
email=EmailStr(email),
password=password,
)
response = httpx.post(url=url, json=body.dict())
response_handler(response=response,
return_model=UserRegisterResponseModel)
except ValidationError:
print_error("Check your inputs")
def create_version(repo: Optional[str], package: Optional[str]):
username, headers = get_auth_header_and_username()
if not username:
return
if not repo:
repo = repositories_core.select_from_available_repo(subject=username)
if not package:
package = packages_core.select_from_available_packages(
subject=username, repo=repo)
body = pydantic_to_prompt(model=VersionCreateBodyModel)
url = get_url(f"/packages/{username}/{repo}/{package}/versions")
response = httpx.post(url=url, json=body.dict(), headers=headers)
response_handler(response=response, return_with_out_model=True)
def get_latest(
subject: str,
repo: Optional[str],
package: Optional[str],
attribute_values: Optional[str] = None,
):
if not repo:
repo = repositories_core.select_from_available_repo(subject=subject)
if not package:
package = packages_core.select_from_available_packages(subject=subject,
repo=repo)
url = get_url(f"/packages/{subject}/{repo}/{package}/versions/_latest")
params = {}
if attribute_values:
params.update({"attribute_values": attribute_values})
response = httpx.get(url=url, params=params)
return response_handler(response=response, return_model=VersionModel)
def search_packages(
name: Optional[str] = None,
desc: Optional[str] = None,
subject: Optional[str] = None,
repo: Optional[str] = None,
):
url = get_url("/search/packages")
params = {}
if name:
params.update({"name": name})
if subject:
params.update({"subject": subject})
if desc:
params.update({"desc": desc})
if repo:
params.update({"repo": repo})
response = httpx.get(url=url, params=params)
return response_handler(response=response, return_with_out_model=True)
def delete_package(
repo: Optional[str],
package: Optional[str],
is_operation_confirmed: Optional[bool] = False,
):
username, headers = get_auth_header_and_username()
if not username:
exit(1)
if not repo:
repo = repositories_core.select_from_available_repo(subject=username)
if not package:
package = select_from_available_packages(subject=username, repo=repo)
if not is_operation_confirmed and not is_operation_confirm():
exit(1)
url = get_url(f"/packages/{username}/{repo}/{package}")
response = httpx.delete(url=url, headers=headers)
return response_handler(response=response,
return_model=PackageDeleteResponseModel)
def update_package(
repo: Optional[str],
package: Optional[str],
is_operation_confirmed: Optional[bool] = False,
):
username, headers = get_auth_header_and_username()
if not username:
exit(1)
if not repo:
repo = repositories_core.select_from_available_repo(subject=username)
if not package:
package = select_from_available_packages(subject=username, repo=repo)
body = pydantic_to_prompt(PackageUpdateBodyModel)
if not is_operation_confirmed and not is_operation_confirm():
exit(1)
url = get_url(f"/packages/{username}/{repo}/{package}")
response = httpx.patch(url=url, json=body.dict(), headers=headers)
response_handler(response=response)
def get_all_packages(
subject: str,
repo: Optional[str],
start_pos: Optional[int],
start_name: Optional[str],
is_internal_call: bool = False,
):
if not repo:
repo = repositories_core.select_from_available_repo(subject=subject)
url = get_url(f"/repos/{subject}/{repo}/packages")
params = {}
if start_name:
params.update({"start_name": start_name})
if start_pos:
params.update({"start_pos": start_pos})
response = httpx.get(url=url, params=params)
if not is_internal_call:
response_handler(response=response, return_with_out_model=True)
exit(0)
return response.json()
def files_search(
subject: str,
repo: Optional[str],
name: Optional[str] = None,
sha1: Optional[str] = None,
start_pos: Optional[str] = None,
create_after: Optional[datetime.datetime] = None,
):
if not repo:
repo = repositories.select_from_available_repo(subject=subject)
url = get_url(f"/search/file")
params = {"subject": subject, "repo": repo}
if name and sha1:
print_error("cant search name and sha1 at the same time")
return
if name:
params.update({"name": name})
if sha1:
params.update({"sha1": sha1})
response = httpx.get(url=url, params=params)
response_handler(response=response, return_with_out_model=True)
