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 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 get_auth_header_and_username(
) -> Optional[Tuple[Optional[str], Optional[dict]]]:
username = get_username()
token: str = keyring.get_password("pax.express", username=username)
if token:
return username, {"Authorization": f"Bearer {token}"}
print_error("Please login!")
return None, None
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 select_from_available_repo(subject: str) -> str:
repos = get_repos(subject=subject, is_internal_call=True)
if not repos:
print_error("No repository has been created!")
exit(1)
repo = select_available_options(
name="repo",
choices=[item["name"] for item in repos],
message="Select the repository",
)
if not repo:
exit(1)
return repo["repo"]
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 select_from_available_packages(subject: str, repo: str):
packages = get_all_packages(
subject=subject,
repo=repo,
is_internal_call=True,
start_pos=None,
start_name=None,
)
if not packages:
print_error("No packages has been created!")
exit(1)
package = select_available_options(
name="package",
choices=[package["name"] for package in packages],
message="Select the package",
)
if not package:
exit(1)
return package["package"]
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)
def select_from_available_files(subject: str, repo: str, package: str,
version: str):
files = get_package_file(
subject=subject,
repo=repo,
package=package,
version=version,
include_unpublished=1,
is_internal_call=True,
)
if not files:
print_error("No files have been uploaded!")
exit(1)
selected_file = select_available_options(
name="file",
message="Select the file",
choices=[item["name"] for item in files if item["version"] == version],
)
if not selected_file:
print_error("No file has been selected!")
exit(1)
return selected_file["file"]
def select_from_available_versions(subject: str, repo: str, package: str,
filename: Optional[str]) -> Optional[str]:
files = get_versions_file(
subject=subject,
package=package,
repo=repo,
include_unpublished=1,
is_internal_call=True,
)
if not files:
print_error("No versions have been created!")
exit(1)
selected_version = select_available_options(
name="version",
message="Select the version",
choices=[item["version"] for item in files] if not filename else
[item["version"] for item in files if item["name"] == filename],
)
if not selected_version:
print_error("No version has been selected!")
exit(1)
return selected_version["version"]
def login(email: str, password: str, as_admin: bool = False):
url: str = get_url(f"/user/login")
try:
data = {"username": email, "password": password}
if as_admin:
scopes = get_valid_scopes()
if not scopes:
print_error("No Scope has been selected!")
exit(1)
scopes = " ".join(scopes)
data.update({"scope": scopes})
response = httpx.post(url=url, data=data)
if response.status_code == 200:
modeled_response = UserLoginResponseModel(**response.json())
keyring.set_password("pax.express", modeled_response.username,
modeled_response.access_token)
save_username(username=modeled_response.username)
print_message(
"You have successfully logged in\nYour login will expire after [red bold]30[/] Minutes"
)
return
elif response.status_code == 406:
if response.json()["detail"].get("legal_documents"):
show_available_legal_documents_list(
filter_by_legal_document_id=response.json()["detail"].get(
"legal_documents"),
username=response.json()["detail"].get("username"),
password=password,
)
login(email=email, password=password)
pass
else:
print_error(response.text)
return
except ValidationError:
print_error("Check your inputs")
def get_username(is_logout: bool = False) -> Optional[str]:
try:
with open(pax_info_file_path, "r") as f:
info = yaml.safe_load(f)
username = info.get("username", None)
if username:
return username
else:
print_error("Please login!")
except FileNotFoundError as ex:
if not is_logout:
username = typer.prompt("Username")
# check if token exist for this username
# if token exist, save username in .pax_info
token: str = keyring.get_password("pax.express", username=username)
if token:
save_username(username)
return username
else:
print_error("Please login!")
else:
print_error("Please login!")
