qwak-core 0.4.278__py3-none-any.whl → 0.5.19__py3-none-any.whl

frogml_storage/authentication/login/_login_cli.py

@@ -1,239 +0,0 @@
-from typing import List, Optional, Union
-
-import typer
-
-from frogml_storage.utils import assemble_artifact_url, join_url
-from frogml_storage.authentication.login._login_command import run as run_login
-from frogml_storage.authentication.models import AuthConfig, LoginArguments
-from frogml_storage.authentication.utils import (
-    get_frogml_configuration,
-    parse_cli_config_server,
-    read_jfrog_cli_config,
-)
-from frogml_storage.authentication.utils import (
-    get_list_of_servers_from_config,
-    login_input_checks,
-    is_login_without_params,
-)
-from frogml_storage.constants import CONFIG_FILE_PATH, JFROG_CLI_CONFIG_FILE_PATH
-
-
-def login(
-    url: Optional[str],
-    username: Optional[str],
-    password: Optional[str],
-    token: Optional[str],
-    anonymous: Optional[bool],
-    is_interactive: Optional[bool],
-) -> bool:
-    if anonymous is None:
-        anonymous = False
-    if is_login_without_params(url, username, password, token, anonymous):
-        if not is_interactive:
-            return __login_by_frogml_configuration_file_flow()
-        else:
-            return __interactive_flow()
-    elif login_input_checks(url, username, password, token, anonymous):
-        url = assemble_artifact_url(url)
-        return __login_by_command_line_params(url, username, password, token, anonymous)
-    else:
-        typer.echo(
-            f"{__get_failed_reason(url, username, password, token, anonymous)}Login failed"
-        )
-        return False
-
-
-def __get_failed_reason(
-    url: Optional[str],
-    username: Optional[str],
-    password: Optional[str],
-    token: Optional[str],
-    anonymous: Optional[bool],
-) -> str:
-    details = ""
-    if url is None:
-        details += "Url is required.\n"
-    if token is not None and (
-        any(params is not None for params in [username, password])
-    ):
-        details += "Token is specified when username/password is specified.\n"
-    if anonymous is True and any(
-        params is not None for params in [username, password, token]
-    ):
-        details += "Anonymous is specified with authentication details.\n"
-    if username is None and password is not None:
-        details += "Username is required when password is specified.\n"
-    elif username is not None and password is None:
-        details += "Password is required when username is specified.\n"
-    return details
-
-
-def __run_interactive_mode() -> Union[LoginArguments, None]:
-    jfrog_cli_config = read_jfrog_cli_config()
-
-    if jfrog_cli_config is not None:
-        jfrog_cli_servers = get_list_of_servers_from_config(jfrog_cli_config)
-        if jfrog_cli_servers is not None and len(jfrog_cli_servers) > 0:
-            login_method_id = typer.prompt(
-                f"Please select from the following options:\n"  # nosec B608
-                f"1.Login by jfrog-cli configuration file: {JFROG_CLI_CONFIG_FILE_PATH}\n"
-                f"2.Connecting to a new server\n"
-            )
-
-            while (
-                not login_method_id.isdigit()
-                or int(login_method_id) > 2
-                or int(login_method_id) <= 0
-            ):
-                login_method_id = typer.prompt(
-                    "Bad Input. Choose your preferred login option"
-                )
-
-            login_method_id = int(login_method_id)
-            if login_method_id == 1:
-                return __prompt_jfrog_cli_configuration_list(
-                    jfrog_cli_config, jfrog_cli_servers
-                )
-
-        return __prompt_manual_details()
-
-    return None
-
-
-def __prompt_manual_details() -> Union[LoginArguments, None]:
-    login_args = LoginArguments()
-    login_args.artifactory_url = typer.prompt("Enter artifactory base url")
-
-    if login_args.artifactory_url is not None:
-        login_args.artifactory_url = join_url(login_args.artifactory_url, "artifactory")
-
-    auth_options = ["Username and Password", "Access Token", "Anonymous Access"]
-    authentication_types = ""
-    for index, item in enumerate(auth_options):
-        authentication_types += f"{index}: {item} \n"
-    selected_auth_type = typer.prompt(
-        f"Choose your preferred authentication option:\n{authentication_types}"
-    )
-    while (
-        not selected_auth_type.isdigit()
-        or int(selected_auth_type) >= len(auth_options)
-        or int(selected_auth_type) < 0
-    ):
-        selected_auth_type = typer.prompt(
-            "Bad Input. Choose your preferred authentication"
-        )
-    selected_auth_type = int(selected_auth_type)
-    if selected_auth_type == 0:
-        return __prompt_username_password(login_args)
-    elif selected_auth_type == 1:
-        return __prompt_access_token(login_args)
-    elif selected_auth_type == 2:
-        login_args.isAnonymous = True
-        return login_args
-    return None
-
-
-def __prompt_username_password(login_args: LoginArguments) -> LoginArguments:
-    username = typer.prompt("Enter JFrog user name")
-    password = typer.prompt("Enter JFrog password", hide_input=True)
-    login_args.username = username
-    login_args.password = password
-    return login_args
-
-
-def __prompt_access_token(login_args: LoginArguments) -> LoginArguments:
-    token = typer.prompt("Enter JFrog access token", hide_input=True)
-    login_args.access_token = token
-    return login_args
-
-
-def __prompt_jfrog_cli_configuration_list(
-    jfrog_cli_config: dict, jfrog_cli_servers: List[str]
-) -> Union[LoginArguments, None]:
-    list_server_options = ""
-    for index, item in enumerate(jfrog_cli_servers):
-        list_server_options += f"{index}: {item}\n"
-    server_index_cli_conf = typer.prompt(
-        f"Found the following servers in your JFrog CLI configuration, "
-        f"choose one of the following:\n{list_server_options}"
-    )
-    while (
-        not server_index_cli_conf.isdigit()
-        or int(server_index_cli_conf) < 0
-        or int(server_index_cli_conf) >= len(jfrog_cli_servers)
-    ):
-        server_index_cli_conf = typer.prompt(
-            "Invalid choice. Please choose a number from the list"
-        )
-    server_index_cli_conf = int(server_index_cli_conf)
-    typer.echo(f"{jfrog_cli_servers[server_index_cli_conf]} was chosen")
-    servers = jfrog_cli_config.get("servers")
-    if servers is not None:
-        return parse_cli_config_server(servers[server_index_cli_conf])
-    else:
-        raise ValueError("No servers found in the JFrog CLI configuration.")
-
-
-def __execute_login(auth_config: AuthConfig, anonymous: bool) -> bool:
-    if run_login(auth_config, anonymous):
-        success_message = "Logged in successfully"
-        if auth_config.artifactory_url is not None:
-            success_message += (
-                f" to: {auth_config.artifactory_url.replace('/artifactory', '')}"
-            )
-        typer.echo(success_message)
-        return True
-    else:
-        typer.echo("Failed to login, bad authentication")
-        return False
-
-
-def __login_by_frogml_configuration_file_flow() -> bool:
-    login_args = get_frogml_configuration()
-    auth_config = None
-    if login_args is not None:
-        typer.echo(
-            f"Using existing frogml authentication config file: {CONFIG_FILE_PATH}"
-        )
-        auth_config = AuthConfig(
-            artifactory_url=login_args.artifactory_url,
-            user=login_args.username,
-            password=login_args.password,
-            access_token=login_args.access_token,
-        )
-
-    if (
-        auth_config is not None
-        and login_args is not None
-        and __execute_login(auth_config, login_args.isAnonymous)
-    ):
-        return True
-
-    return __interactive_flow()
-
-
-def __interactive_flow() -> bool:
-    login_args = __run_interactive_mode()
-    if login_args is not None:
-        auth_config = AuthConfig(
-            artifactory_url=login_args.artifactory_url,
-            user=login_args.username,
-            password=login_args.password,
-            access_token=login_args.access_token,
-        )
-        return __execute_login(auth_config, login_args.isAnonymous)
-    return False
-
-
-def __login_by_command_line_params(
-    url: str,
-    username: Optional[str],
-    password: Optional[str],
-    token: Optional[str],
-    anonymous: Optional[bool],
-) -> bool:
-    anonymous_value = anonymous if anonymous is not None else False
-    auth_config = AuthConfig(
-        artifactory_url=url, user=username, password=password, access_token=token
-    )
-    return __execute_login(auth_config, anonymous_value)

frogml_storage/authentication/login/_login_command.py

@@ -1,74 +0,0 @@
-import http
-from typing import Optional
-
-import requests
-from requests.auth import AuthBase, HTTPBasicAuth
-
-from frogml_storage.artifactory import ArtifactoryApi
-from frogml_storage.logging import logger
-from frogml_storage.authentication.models import BearerAuth, EmptyAuth
-from frogml_storage.authentication.utils import (
-    get_encrypted_password,
-    save_auth_config,
-)
-from frogml_storage.authentication.models import AuthConfig
-from frogml_storage.authentication.utils import (
-    is_username_password_login,
-    is_access_token_login,
-    is_anonymous_login,
-)
-
-
-def run(auth_config: AuthConfig, anonymous: Optional[bool] = False) -> bool:
-    if is_username_password_login(auth_config, anonymous):
-        connection_validation_result = __login_by_username_password(auth_config)
-    elif is_access_token_login(auth_config, anonymous):
-        connection_validation_result = __validate_server_connection(
-            auth_config, BearerAuth(auth_config.access_token)
-        )
-    elif is_anonymous_login(auth_config, anonymous):
-        connection_validation_result = __validate_server_connection(
-            auth_config, EmptyAuth()
-        )
-    else:
-        connection_validation_result = False
-
-    if connection_validation_result:
-        save_auth_config(auth_config)
-    return connection_validation_result
-
-
-def __login_by_username_password(auth_config: AuthConfig) -> bool:
-    if auth_config.user is not None and auth_config.password is not None:
-        auth_token = HTTPBasicAuth(auth_config.user, auth_config.password)
-        connection_validation_result = __validate_server_connection(
-            auth_config, auth_token
-        )
-        if connection_validation_result:
-            encrypted_password = get_encrypted_password(auth_config, auth_token)
-            if encrypted_password is not None:
-                auth_config.password = encrypted_password
-                return True
-    return False
-
-
-def __validate_server_connection(auth_config: AuthConfig, auth_token: AuthBase) -> bool:
-    success = False
-    try:
-        logger.debug("Attempting to ping artifactory")
-        response = ArtifactoryApi(auth_config.artifactory_url, auth_token).ping()
-        if response.status_code == http.HTTPStatus.OK:
-            success = True
-        else:
-            logger.debug(
-                f"Expected {http.HTTPStatus.OK} status but got {response.status_code} "
-                f"when using url {auth_config.artifactory_url}"
-            )
-    except requests.exceptions.ConnectionError as e:
-        logger.debug(f"Unable to connect to the provided url :{e}.")
-    except requests.exceptions.MissingSchema as e:
-        logger.debug(f"Invalid Artifactory URL provided: {e}.")
-    except requests.exceptions.RequestException as e:
-        logger.debug(f"Unexpected request exception: {e}.")
-
-    return success

frogml_storage/authentication/models/__init__.py

@@ -1,3 +0,0 @@
-from ._auth_config import AuthConfig
-from ._auth import BearerAuth, EmptyAuth
-from ._login import LoginArguments

frogml_storage/authentication/models/_auth.py

@@ -1,24 +0,0 @@
-from typing import Any
-
-from requests import PreparedRequest
-from requests.auth import AuthBase
-
-
-class BearerAuth(AuthBase):
-    def __init__(self, token: str):
-        self.token: str = token
-
-    def __call__(self, r: PreparedRequest) -> PreparedRequest:
-        r.headers["Authorization"] = f"Bearer {self.token}"
-        return r
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, BearerAuth):
-            return False
-
-        return self.token == other.token
-
-
-class EmptyAuth(AuthBase):
-    def __call__(self, r: PreparedRequest) -> PreparedRequest:
-        return r

frogml_storage/authentication/models/_auth_config.py

@@ -1,70 +0,0 @@
-from typing import Optional
-
-from frogml_storage.constants import (
-    FROG_ML_CONFIG_ACCESS_TOKEN,
-    FROG_ML_CONFIG_ARTIFACTORY_URL,
-    FROG_ML_CONFIG_PASSWORD,
-    FROG_ML_CONFIG_USER,
-    SERVER_ID,
-)
-
-
-class AuthConfig(object):
-    def __init__(
-        self,
-        artifactory_url: Optional[str] = None,
-        access_token: Optional[str] = None,
-        user: Optional[str] = None,
-        password: Optional[str] = None,
-        server_id: Optional[str] = None,
-    ) -> None:
-        self.artifactory_url = artifactory_url
-        self.user = user
-        self.password = password
-        self.access_token = access_token
-        self.server_id = server_id
-
-    def to_json(self):
-        include_keys = [
-            FROG_ML_CONFIG_ARTIFACTORY_URL,
-            FROG_ML_CONFIG_USER,
-            FROG_ML_CONFIG_PASSWORD,
-            FROG_ML_CONFIG_ACCESS_TOKEN,
-            SERVER_ID,
-        ]
-        return {
-            key: getattr(self, key)
-            for key in include_keys
-            if getattr(self, key) is not None
-        }
-
-    @classmethod
-    def by_access_token(cls, artifactory_url: str, access_token: str) -> "AuthConfig":
-        return cls(
-            artifactory_url=artifactory_url,
-            access_token=access_token,
-        )
-
-    @classmethod
-    def by_basic_auth(
-        cls, artifactory_url: str, user: str, password: str
-    ) -> "AuthConfig":
-        return cls(
-            artifactory_url=artifactory_url,
-            user=user,
-            password=password,
-        )
-
-    @classmethod
-    def by_server_id(cls, server_id: str) -> "AuthConfig":
-        return cls(server_id=server_id)
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "AuthConfig":
-        return cls(
-            artifactory_url=data.get(FROG_ML_CONFIG_ARTIFACTORY_URL),
-            access_token=data.get(FROG_ML_CONFIG_ACCESS_TOKEN),
-            server_id=data.get(SERVER_ID),
-            user=data.get(FROG_ML_CONFIG_USER),
-            password=data.get(FROG_ML_CONFIG_PASSWORD),
-        )

frogml_storage/authentication/models/_login.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-
-class LoginArguments(object):
-    isAnonymous: bool = False
-    server_id: Optional[str] = None
-    username: Optional[str] = None
-    password: Optional[str] = None
-    access_token: Optional[str] = None
-    artifactory_url: Optional[str] = None
-
-    def __eq__(self, other):
-        if not isinstance(other, LoginArguments):
-            return False
-        return (
-            self.isAnonymous == other.isAnonymous
-            and self.server_id == other.server_id
-            and self.username == other.username
-            and self.password == other.password
-            and self.access_token == other.access_token
-            and self.artifactory_url == other.artifactory_url
-        )

frogml_storage/authentication/utils/__init__.py

@@ -1,17 +0,0 @@
-from ._authentication_utils import (
-    get_credentials,
-    get_frogml_configuration,
-    parse_cli_config_server,
-    read_jfrog_cli_config,
-    get_encrypted_password,
-    save_auth_config,
-    get_list_of_servers_from_config,
-    read_frogml_config,
-)
-from ._login_checks_utils import (
-    login_input_checks,
-    is_login_without_params,
-    is_username_password_login,
-    is_access_token_login,
-    is_anonymous_login,
-)