qwak-core 0.4.265__py3-none-any.whl → 0.4.266__py3-none-any.whl

frogml_storage/authentication/_authentication_utils.py

@@ -0,0 +1,259 @@
+import http
+import json
+import os
+from typing import Optional, Tuple, Union
+
+import requests
+from requests.auth import AuthBase, HTTPBasicAuth
+
+from frogml_storage._artifactory_api import ArtifactoryApi
+from frogml_storage._log_config import logger
+from frogml_storage._utils import BearerAuth, EmptyAuth, join_url
+from frogml_storage.authentication.models._auth_config import AuthConfig
+from frogml_storage.cli.models._cli_login_arguments import LoginArguments
+from frogml_storage.constants import (
+    CONFIG_FILE_PATH,
+    FROG_ML_CONFIG_ACCESS_TOKEN,
+    FROG_ML_CONFIG_ARTIFACTORY_URL,
+    FROG_ML_CONFIG_PASSWORD,
+    FROG_ML_CONFIG_USER,
+    JF_ACCESS_TOKEN,
+    JF_URL,
+    JFROG_CLI_CONFIG_ACCESS_TOKEN,
+    JFROG_CLI_CONFIG_ARTIFACTORY_URL,
+    JFROG_CLI_CONFIG_FILE_PATH,
+    JFROG_CLI_CONFIG_PASSWORD,
+    JFROG_CLI_CONFIG_URL,
+    JFROG_CLI_CONFIG_USER,
+    SERVER_ID,
+)
+
+
+def read_jfrog_cli_config() -> Union[dict, None]:
+    try:
+        with open(JFROG_CLI_CONFIG_FILE_PATH, "r") as file:
+            config_data = json.load(file)
+            return config_data
+    except FileNotFoundError:
+        logger.debug("JFrog cli config file was not found.")
+        return None
+    except json.JSONDecodeError as e:
+        print(f"JFrog cli config file is not a valid JSON {e}.")
+        return None
+
+
+def read_frogml_config() -> Union[dict, None]:
+    try:
+        with open(CONFIG_FILE_PATH, "r") as file:
+            config_data = json.load(file)
+            return config_data
+    except FileNotFoundError:
+        logger.debug("FrogMl config file was not found.")
+        return None
+    except json.JSONDecodeError as e:
+        print(f"FrogMl config file is not a valid JSON {e}.")
+        return None
+
+
+def parse_cli_config_server(server_config: dict) -> Union[LoginArguments, None]:
+    login_args = LoginArguments()
+    login_args.server_id = server_config.get(SERVER_ID)
+
+    if JFROG_CLI_CONFIG_ARTIFACTORY_URL in server_config:
+        login_args.artifactory_url = server_config.get(JFROG_CLI_CONFIG_ARTIFACTORY_URL)
+    elif (
+        JFROG_CLI_CONFIG_URL in server_config
+        and server_config.get(JFROG_CLI_CONFIG_URL) is not None
+    ):
+        login_args.artifactory_url = join_url(
+            server_config[JFROG_CLI_CONFIG_URL], "artifactory"
+        )
+    else:
+        logger.debug(
+            "Invalid JFrog CLI file, expected either artifactoryUrl or url in jfrog cli config file"
+        )
+        return None
+
+    if JFROG_CLI_CONFIG_ACCESS_TOKEN in server_config:
+        login_args.access_token = server_config.get(JFROG_CLI_CONFIG_ACCESS_TOKEN)
+    elif (
+        JFROG_CLI_CONFIG_USER in server_config
+        and JFROG_CLI_CONFIG_PASSWORD in server_config
+    ):
+        login_args.username = server_config.get(JFROG_CLI_CONFIG_USER)
+        login_args.password = server_config.get(JFROG_CLI_CONFIG_PASSWORD)
+    else:
+        logger.debug(
+            "Expected either accessToken or user/password in jfrog cli config file"
+        )
+        return None
+
+    return login_args
+
+
+def get_frogml_configuration() -> Union[LoginArguments, None]:
+    frog_ml_config = read_frogml_config()
+    if (
+        frog_ml_config is not None
+        and frog_ml_config.get("servers") is not None
+        and len(frog_ml_config["servers"]) > 0
+    ):
+        server_config = frog_ml_config["servers"][0]
+        login_args = LoginArguments()
+        if FROG_ML_CONFIG_ARTIFACTORY_URL in server_config:
+            login_args.artifactory_url = server_config.get(
+                FROG_ML_CONFIG_ARTIFACTORY_URL
+            )
+        else:
+            logger.debug(
+                "Invalid FrogMl authentication file, expected either artifactory_url in FrogMl authentication file"
+            )
+            return None
+
+        if FROG_ML_CONFIG_ACCESS_TOKEN in server_config:
+            login_args.access_token = server_config.get(FROG_ML_CONFIG_ACCESS_TOKEN)
+        elif (
+            FROG_ML_CONFIG_USER in server_config
+            and FROG_ML_CONFIG_PASSWORD in server_config
+        ):
+            login_args.username = server_config.get(FROG_ML_CONFIG_USER)
+            login_args.password = server_config.get(FROG_ML_CONFIG_PASSWORD)
+        elif (
+            FROG_ML_CONFIG_USER in server_config
+            and FROG_ML_CONFIG_PASSWORD not in server_config
+            or (
+                FROG_ML_CONFIG_USER not in server_config
+                and FROG_ML_CONFIG_PASSWORD in server_config
+            )
+        ):
+            logger.debug(
+                "Invalid FrogMl authentication file, username or password is missing in FrogMl authentication file"
+            )
+            return None
+        elif (
+            login_args.username is None
+            and login_args.password is None
+            and login_args.access_token is None
+        ):
+            login_args.isAnonymous = True
+        return login_args
+    else:
+        return None
+
+
+def get_encrypted_password(
+    auth_config: AuthConfig, auth_token: AuthBase
+) -> Optional[str]:
+    try:
+        response = ArtifactoryApi(
+            auth_config.artifactory_url, auth_token
+        ).encrypt_password()
+        if response.status_code != http.HTTPStatus.OK:
+            logger.debug(
+                f"Expected {http.HTTPStatus.OK} status but got {response.status_code} "
+                f"when using url {auth_config.artifactory_url}"
+            )
+            print("Error while trying to encrypt password.")
+            return None
+        return response.text
+    except requests.exceptions.RequestException as e:
+        print(f"Error while trying to encrypt password: {e}.")
+        return None
+
+
+def save_auth_config(auth_config: AuthConfig) -> None:
+    file_content: dict[str, list] = {}
+    file_content.setdefault("servers", []).append(auth_config.to_json())
+    os.makedirs(os.path.dirname(CONFIG_FILE_PATH), exist_ok=True)
+    with open(CONFIG_FILE_PATH, "w") as file:
+        json.dump(file_content, file, indent=2)
+
+
+def get_credentials(auth_config: Optional[AuthConfig] = None) -> Tuple[str, AuthBase]:
+    if not __should_use_file_auth(auth_config):
+        __validate_credentials(auth_config)
+        return __auth_config_to_auth_tuple(auth_config)
+    logger.debug(
+        "Login configuration not supplied, attempting to find environment variables"
+    )
+
+    if __should_use_environment_variables():
+        return get_environment_variables()
+
+    logger.debug(
+        "Environment variables not supplied, attempting to load configuration from file"
+    )
+
+    if os.path.exists(CONFIG_FILE_PATH):
+        return __read_credentials_from_file(CONFIG_FILE_PATH)
+    raise ValueError(
+        f"Configuration were not provided and configuration file not found in {CONFIG_FILE_PATH},"
+        f" either pass configuration in the constructor, add env variables or create the configuration file by "
+        f"running `frogml login`"
+    )
+
+
+def __should_use_environment_variables() -> bool:
+    return os.getenv("JF_URL") is not None
+
+
+def get_environment_variables() -> Tuple[str, AuthBase]:
+    auth_config: AuthConfig = AuthConfig(
+        artifactory_url=os.getenv(JF_URL),
+        access_token=os.getenv(JF_ACCESS_TOKEN),
+    )
+
+    return __auth_config_to_auth_tuple(auth_config)
+
+
+def __should_use_file_auth(credentials: Optional[AuthConfig] = None) -> bool:
+    return credentials is None or (
+        credentials.artifactory_url is None
+        and credentials.user is None
+        and credentials.password is None
+        and credentials.access_token is None
+    )
+
+
+def __validate_credentials(credentials: Optional[AuthConfig]) -> None:
+    if credentials is None:
+        raise ValueError("Credentials must be provided.")
+    if credentials.artifactory_url is None:
+        raise ValueError("Credentials must contain artifactory url.")
+    return None
+
+
+def __read_credentials_from_file(file_path: str) -> Tuple[str, AuthBase]:
+    try:
+        with open(file_path, "r") as file:
+            config_content: dict = json.load(file)
+            servers = config_content.get("servers")
+            if servers is None or len(servers) == 0:
+                raise ValueError(
+                    "Configuration file was found but it's empty, failing authentication"
+                )
+            server = servers[0]
+            return __auth_config_to_auth_tuple(AuthConfig.from_dict(server))
+    except json.JSONDecodeError:
+        raise ValueError(f"Error when reading {file_path}, please recreate the file.")
+
+
+def __auth_config_to_auth_tuple(
+    auth_config: Optional[AuthConfig],
+) -> Tuple[str, AuthBase]:
+
+    if auth_config is None:
+        raise ValueError("No authentication configuration provided")
+
+    auth: AuthBase = EmptyAuth()
+    if auth_config.access_token is not None:
+        auth = BearerAuth(auth_config.access_token)
+    elif auth_config.user is not None and auth_config.password is not None:
+        auth = HTTPBasicAuth(auth_config.user, auth_config.password)
+    elif auth_config.user is not None or auth_config.password is not None:
+        raise ValueError("User and password must be provided together")
+
+    if auth_config.artifactory_url is None:
+        raise ValueError("No artifactory URL provided")
+
+    return auth_config.artifactory_url, auth

frogml_storage/authentication/models/_auth_config.py

@@ -0,0 +1,70 @@
+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/cli/_frogml_cli.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+from frogml_storage.cli._login_cli import login as prompt_login
+
+app = typer.Typer(add_completion=False)
+
+
+@app.command("login")
+def login(
+    url: Annotated[Optional[str], typer.Option(help="Artifactory base url")] = None,
+    username: Annotated[Optional[str], typer.Option(help="The user's username")] = None,
+    password: Annotated[Optional[str], typer.Option(help="The user's password")] = None,
+    token: Annotated[
+        Optional[str], typer.Option(help="Access token to authenticate")
+    ] = None,
+    anonymous: Annotated[
+        bool, typer.Option(help="Run login as anonymous user")
+    ] = False,
+    interactive: Annotated[
+        bool, typer.Option(help="Login with interactive flow")
+    ] = False,
+) -> None:
+    # url_value = url if url is not None else ""
+    prompt_login(url, username, password, token, anonymous, interactive)
+
+
+@app.callback()
+def callback():
+    pass
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

frogml_storage/cli/_login_cli.py

@@ -0,0 +1,240 @@
+from typing import List, Optional, Union
+
+import typer
+
+from frogml_storage._utils import assemble_artifact_url, join_url
+from frogml_storage.authentication._authentication_utils import (
+    get_frogml_configuration,
+    parse_cli_config_server,
+    read_jfrog_cli_config,
+)
+from frogml_storage.authentication.models._auth_config import AuthConfig
+from frogml_storage.cli.commands._login_command import run as run_login
+from frogml_storage.cli.models._cli_login_arguments import LoginArguments
+from frogml_storage.cli.utils._cli_utils import get_list_of_servers_from_config
+from frogml_storage.cli.utils._login_checks_utility import (
+    is_login_command_without_params,
+    login_input_checks,
+)
+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_command_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/cli/commands/_login_command.py

@@ -0,0 +1,74 @@
+import http
+from typing import Optional
+
+import requests
+from requests.auth import AuthBase, HTTPBasicAuth
+
+from frogml_storage._artifactory_api import ArtifactoryApi
+from frogml_storage._log_config import logger
+from frogml_storage._utils import BearerAuth, EmptyAuth
+from frogml_storage.authentication._authentication_utils import (
+    get_encrypted_password,
+    save_auth_config,
+)
+from frogml_storage.authentication.models._auth_config import AuthConfig
+from frogml_storage.cli.utils._login_checks_utility import (
+    is_access_token_login,
+    is_anonymous_login,
+    is_username_password_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}.")
+    finally:
+        return success