cgcsdk 0.8.5__tar.gz → 0.8.7__tar.gz

{cgcsdk-0.8.5/cgcsdk.egg-info → cgcsdk-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cgcsdk
-Version: 0.8.5
+Version: 0.8.7
 Summary: Comtegra GPU Cloud REST API client
 Author: Comtegra AI Team
 Author-email: ai@comtegra.pl

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/.env

@@ -7,4 +7,4 @@ CONFIG_FILE_NAME = cfg.json
 TMP_DIR = .tmp
 RELEASE = 0
 MAJOR_VERSION = 8
-MINOR_VERSION = 5
+MINOR_VERSION = 7

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+## 0.8.7
+
+Release on May 23, 2023.
+
+* hotfix: development changed .env file making it broken for new users
+
+## 0.8.6
+
+Release on May 19, 2023.
+
+* added get_redis_client_async() for RedisConnector
+* get_redis_access() - async_client: bool, new parameter
+* new command: cgc context switch [number]
+  * switch between user contexts
+* new command: cgc context list
+  * list all configuration files
+* updated command: cgc register
+  * allow to have multiple user contexts
+* increased timeout for requests to 30 sec
+
 ## 0.8.5
 
 Release on Apr 21, 2023.

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/cgc.py

@@ -15,6 +15,7 @@ from cgc.commands.cgc_cmd import (
     cgc_status,
     sending_telemetry_permission,
     resource_events,
+    context_group,
 )
 from cgc.utils.version_control import check_version, _get_version
 from cgc.utils.click_group import CustomGroup
@@ -28,6 +29,7 @@ def cli():
 
 
 cli.add_command(debug_group)
+cli.add_command(context_group)
 cli.add_command(auth_register)
 cli.add_command(api_keys_group)
 cli.add_command(volume_group)

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/commands/auth/__init__.py

@@ -8,3 +8,8 @@ class AuthCommandException(ResponseException):
 class NoNamespaceInConfig(AuthCommandException):
     def __init__(self) -> None:
         super().__init__(f"Namespace not readable from config file.")
+
+
+class NoConfigFileFound(AuthCommandException):
+    def __init__(self) -> None:
+        super().__init__(f"Config does not exists.")

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/commands/auth/auth_cmd.py

@@ -7,12 +7,16 @@ from cgc.commands.auth.auth_responses import (
 from cgc.commands.auth.auth_utils import (
     auth_create_api_key_with_save,
 )
-
 from cgc.utils.prepare_headers import get_url_and_prepare_headers_register
 from cgc.utils.cryptography import rsa_crypto
 from cgc.utils.click_group import CustomCommand, CustomGroup
 from cgc.utils.requests_helper import call_api, EndpointTypes
 from cgc.utils.response_utils import retrieve_and_validate_response_send_metric
+from cgc.utils import (
+    check_if_config_exist,
+    require_confirm_loop,
+    find_first_available_config_name,
+)
 
 
 @click.group("api-keys", cls=CustomGroup, hidden=True)
@@ -24,9 +28,9 @@ def api_keys_group():
 
 
 @click.command("register", cls=CustomCommand)
-@click.option("--user_id", "-u", "user_id", prompt=True)
-@click.option("--access_key", "-k", "access_key", prompt=True)
-def auth_register(user_id: str, access_key: str):
+# @click.option("--user_id", "-u", "user_id", prompt=True)
+# @click.option("--access_key", "-k", "access_key", prompt=True)
+def auth_register(config_filename: str = "cfg.json"):
     """Register a user in system using user id and access key.\n
     Enabling/Disabling Telemetry sending is available, if set to yes CGC will send
     usage metrics for application improvements purposes.
@@ -40,6 +44,13 @@ def auth_register(user_id: str, access_key: str):
     :type telemetry_sending: bool
     """
 
+    if check_if_config_exist(config_filename):
+        click.echo("Already registered.")
+        require_confirm_loop("Do you want to add new context?")
+        config_filename = find_first_available_config_name()
+
+    user_id = input("User ID: ")
+    access_key = input("Access key: ")
     url, headers = get_url_and_prepare_headers_register(user_id, access_key)
     metric = "auth.register"
     pub_key_bytes, priv_key_bytes = rsa_crypto.key_generate_pair()
@@ -56,6 +67,7 @@ def auth_register(user_id: str, access_key: str):
             retrieve_and_validate_response_send_metric(__res, metric, False),
             user_id,
             priv_key_bytes,
+            config_filename,
         )
     )
 

cgcsdk-0.8.7/cgc/commands/auth/auth_responses.py

@@ -0,0 +1,35 @@
+import shutil
+import os
+
+from cgc.commands.auth import auth_utils
+from cgc.utils.consts.env_consts import TMP_DIR, get_config_file_name
+from cgc.utils.config_utils import get_config_path, save_to_config
+from cgc.utils.message_utils import key_error_decorator_for_helpers
+
+
+@key_error_decorator_for_helpers
+def auth_register_response(response, user_id, priv_key_bytes, config_filename) -> str:
+    TMP_DIR_PATH = os.path.join(get_config_path(), TMP_DIR)
+    unzip_dir, namespace = auth_utils.save_and_unzip_file(response)
+    aes_key, password = auth_utils.get_aes_key_and_password(unzip_dir, priv_key_bytes)
+
+    os.environ["CONFIG_FILE_NAME"] = config_filename
+    save_to_config(
+        user_id=user_id, password=password, aes_key=aes_key, namespace=namespace
+    )
+    auth_utils.auth_create_api_key_with_save()
+    shutil.rmtree(TMP_DIR_PATH)
+    # config.json
+    if config_filename == "config.json":
+        return f"Register successful! You can now use the CLI. Saved data to:{os.path.join(get_config_path(),config_filename)}\n\
+        Consider backup this file. It stores data accessible only to you with which you can access CGC platform."
+    return f"New context created successfully! \nNew config file saved to: {os.path.join(get_config_path(),config_filename)}\n\
+Consider backup this file. It stores data accessible only to you with which you can access CGC platform.\n \n\
+To switch context use \ncgc context switch"
+
+
+@key_error_decorator_for_helpers
+def login_successful_response():
+    return f"Successfully logged in, created new API key pair.\n\
+                Saved data to: {os.path.join(get_config_path(), get_config_file_name())}.\n\
+                Consider backup this file. It stores data accessible only to you with which you can access CGC platform."

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/commands/auth/auth_utils.py

@@ -76,7 +76,6 @@ def save_and_unzip_file(res: requests.Response) -> str:
     """
     zip_file = res.headers.get("content-disposition").split('"')[1]
     namespace = zip_file.split("---")[-1].split(".")[0]
-    save_to_config(namespace=namespace)
 
     if not os.path.isdir(TMP_DIR_PATH):
         os.makedirs(TMP_DIR_PATH)
@@ -87,7 +86,7 @@ def save_and_unzip_file(res: requests.Response) -> str:
     unzip_dir = zip_file_path[:-4]
     shutil.unpack_archive(zip_file_path, unzip_dir)
 
-    return unzip_dir
+    return unzip_dir, namespace
 
 
 def get_aes_key_and_password(unzip_dir: str, priv_key_bytes: bytes):

cgcsdk-0.8.7/cgc/commands/cgc_cmd.py

@@ -0,0 +1,117 @@
+import click
+import json
+
+from cgc.commands.cgc_cmd_responses import cgc_status_response
+from cgc.commands.resource.resource_cmd import resource_delete
+from cgc.utils.requests_helper import call_api, EndpointTypes
+from cgc.utils.click_group import CustomCommand, CustomGroup
+from cgc.utils.prepare_headers import get_api_url_and_prepare_headers
+from cgc.utils.response_utils import retrieve_and_validate_response_send_metric
+from cgc.telemetry.basic import telemetry_permission_set
+from cgc.commands.compute.compute_responses import compute_logs_response
+from cgc.commands.auth.auth_cmd import auth_register
+from cgc.utils import set_environment_data, check_if_config_exist, list_all_config_files
+from cgc.commands.cgc_helpers import table_of_user_context_files
+from cgc.utils.config_utils import config_path
+
+
+@click.command("rm", cls=CustomCommand)
+@click.argument("name", type=click.STRING)
+def cgc_rm(name: str):
+    """
+    Delete an app in user namespace
+    """
+    resource_delete(name)
+
+
+@click.command("events", cls=CustomCommand)
+@click.argument("app_name", type=click.STRING)
+def resource_events(app_name: str):
+    """Get events of given app"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/get_pod_events"
+    metric = "resource.events"
+    __payload = {"name": app_name}
+    __res = call_api(
+        request=EndpointTypes.get,
+        url=url,
+        headers=headers,
+        data=json.dumps(__payload),
+    )
+    click.echo(
+        compute_logs_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )
+
+
+@click.command("status", cls=CustomCommand)
+def cgc_status():
+    """Lists available and used resources"""
+    api_url, headers = get_api_url_and_prepare_headers()
+    url = f"{api_url}/v1/api/resource/status"
+    metric = "resource.status"
+    __res = call_api(
+        request=EndpointTypes.get,
+        url=url,
+        headers=headers,
+    )
+    click.echo(
+        cgc_status_response(retrieve_and_validate_response_send_metric(__res, metric))
+    )
+
+
+@click.command("telemetry", cls=CustomCommand)
+def sending_telemetry_permission():
+    """Changing permission for sending telemetry"""
+
+    click.echo(
+        f"Sending telemetry is now {'enabled' if telemetry_permission_set() else 'disabled'}"
+    )
+
+
+@click.group(name="context", cls=CustomGroup)
+def context_group():
+    """
+    Switch between namespaces (contexts) that are at your disposal.
+    """
+
+
+@context_group.command("switch", cls=CustomCommand)
+@click.argument("number", type=click.INT)
+# @click.pass_context
+def switch_context(number: int):
+    """Set which namespace config should be used. After switching context your next command will be run in given namespace that corresponds to user namespace"""
+    file_name = f"{number}.json" if number > 1 else "cfg.json"
+
+    if not check_if_config_exist(file_name):
+        click.echo("Selected context does not exist.")
+        click.echo("To get all available contexts use:")
+        click.echo("cgc context list")
+        exit(0)
+        # user_id = input("User ID: ")
+        # access_key = input("Access key: ")
+        # ctx.invoke(
+        #     auth_register,
+        #     user_id=user_id,
+        #     access_key=access_key,
+        #     config_filename=file_name,
+        # )
+    set_environment_data("CONFIG_FILE_NAME", file_name)
+    click.echo(f"Context file changed to: {file_name}")
+
+
+@context_group.command("list", cls=CustomCommand)
+def list_context():
+    """List all namespaces available to you"""
+    click.echo(table_of_user_context_files(list_all_config_files()))
+
+
+@context_group.command("folder", cls=CustomCommand)
+def folder_of_contexts():
+    """Check location of config files in case that you need to export them."""
+    click.echo(f"All config files are located: {config_path}")
+    click.echo(
+        "If you'd like to use them on a different machine just copy all the files to corresponding folder."
+    )
+    click.echo(
+        "You can check location of that folder on different machine with the same command."
+    )

cgcsdk-0.8.7/cgc/commands/cgc_helpers.py

@@ -0,0 +1,33 @@
+from typing import List
+from cgc.utils import quick_sort
+from cgc.utils.config_utils import read_from_cfg
+from tabulate import tabulate
+
+
+def table_of_user_context_files(config_files: List[str]):
+    # print tabulate of: [context NR | namespace | user_id]
+    headers = ["Context No.", "Namespace", "User ID"]
+    contexts = []
+    contexts_nrs = []
+    for file in config_files:
+        file_context = []
+        file_context.append(
+            int(file.split(".")[0]) if file != "cfg.json" else 1
+        )  # should never throw exception with good config_file list
+        contexts_nrs.append(file_context[0])
+        file_data = read_from_cfg(None, file)
+        values_to_read = ["namespace", "user_id"]
+        for k in values_to_read:
+            try:
+                value = file_data[k]
+            except KeyError:
+                value = None
+            file_context.append(value)
+        contexts.append(file_context)
+
+    contexts_nrs_sorted = quick_sort(contexts_nrs)
+    contexts_sorted = []
+    for context in contexts_nrs_sorted:
+        contexts_sorted.append(contexts[contexts_nrs.index(context)])
+
+    return tabulate(contexts_sorted, headers=headers)

cgcsdk-0.8.7/cgc/sdk/redis.py

@@ -0,0 +1,88 @@
+from redis.asyncio import redis as redis_async
+import redis
+
+
+class RedisConnector:
+    redis_client_async = None
+    redis_client = None
+
+    def __init__(
+        self, host: str, password: str = None, decode_responses: bool = False
+    ) -> None:
+        self._host = host
+        assert type(host) is str
+        "host must be a str containing redis app name"
+        self._password = password
+        self._decode_responses = decode_responses
+
+    def connect(self, async_client: bool = False):
+        while True:
+            try:
+                if not async_client:
+                    self.redis_client = redis.Redis(
+                        host=self._host,
+                        port=6379,
+                        password=self._password,
+                        decode_responses=self._decode_responses,
+                    )
+                else:
+                    self.redis_client_async = redis_async.Redis(
+                        host=self._host,
+                        port=6379,
+                        password=self._password,
+                        decode_responses=self._decode_responses,
+                    )
+                print(f"Connected to Redis: {self._host}")
+                break
+            except (redis.ConnectionError,) as e:
+                print(f"Redis connection error: {e}")
+                print(f"retrying to connect...")
+
+    def get_redis_client(self):
+        if self.redis_client is None:
+            self.connect()
+        return self.redis_client
+
+    def get_redis_client_async(self):
+        if self.redis_client_async is None:
+            self.connect(async_client=True)
+        return self.redis_client_async
+
+
+def get_redis_access(
+    app_name: str,
+    password: str,
+    decode_responses: bool = False,
+    restart: bool = False,
+    async_client=False,
+):
+    global _redis_access
+    global _redis_access_async
+
+    def init_access(async_client=False):
+        global _redis_access
+        global _redis_access_async
+
+        if not async_client:
+            _redis_access = RedisConnector(
+                host=app_name, password=password, decode_responses=decode_responses
+            )
+        else:
+            _redis_access_async = RedisConnector(
+                host=app_name, password=password, decode_responses=decode_responses
+            )
+
+    try:
+        if not async_client:
+            if not isinstance(_redis_access, RedisConnector) or restart:
+                init_access()
+        else:
+            if not isinstance(_redis_access_async, RedisConnector) or restart:
+                init_access(True)
+    except NameError:
+        if not async_client:
+            init_access()
+        else:
+            init_access(True)
+        pass
+    return _redis_access if async_client else _redis_access_async

cgcsdk-0.8.7/cgc/utils/__init__.py

@@ -0,0 +1,113 @@
+from typing import List
+from os import listdir
+from os.path import isfile, join
+from cgc.utils.config_utils import config_path
+from operator import is_not
+from functools import partial
+from random import randrange
+
+from cgc.utils.consts.env_consts import ENV_FILE_PATH
+from cgc.utils.config_utils import read_from_cfg
+from cgc.commands.auth import NoConfigFileFound
+
+
+def require_confirm_loop(message: str):
+    while True:
+        answer = input(f"{message} (Y/N): ").lower()
+        if answer in ("y", "yes"):
+            break
+        if answer in ("n", "no"):
+            exit(0)
+
+
+def quick_sort(collection: list) -> list:
+    """A pure Python implementation of quick sort algorithm
+
+    :param collection: a mutable collection of comparable items
+    :return: the same collection ordered by ascending
+
+    Examples:
+    >>> quick_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+    >>> quick_sort([])
+    []
+    >>> quick_sort([-2, 5, 0, -45])
+    [-45, -2, 0, 5]
+    """
+    if len(collection) < 2:
+        return collection
+    pivot_index = randrange(len(collection))  # Use random element as pivot
+    pivot = collection[pivot_index]
+    greater: list[int] = []  # All elements greater than pivot
+    lesser: list[int] = []  # All elements less than or equal to pivot
+
+    for element in collection[:pivot_index]:
+        (greater if element > pivot else lesser).append(element)
+
+    for element in collection[pivot_index + 1 :]:
+        (greater if element > pivot else lesser).append(element)
+
+    return [*quick_sort(lesser), pivot, *quick_sort(greater)]
+
+
+def set_environment_data(variable: str, value: str):
+    """Set variable to .env file
+
+    :return: new value
+    :rtype: str
+    """
+    f = open(file=ENV_FILE_PATH, mode="r")
+    replaced_content = f.read()
+    replaced_content = replaced_content.splitlines()
+    f.close()
+    for i, line in enumerate(replaced_content):
+        splitted = line.split(" ")
+        if splitted[0] == variable.upper():
+            replaced_content[i] = line.replace(splitted[2], value)
+            with open(file=ENV_FILE_PATH, mode="w") as f:
+                f.write("\n".join(replaced_content))
+            break
+    else:
+        with open(file=ENV_FILE_PATH, mode="a") as f:
+            f.write(f"\n{variable.upper()} = {value}")
+
+    return value
+
+
+def find_first_available_config_name() -> str:
+    increment = 2
+    while True:
+        filename = f"{increment}.json"
+        try:
+            read_from_cfg(None, filename)
+            increment += 1
+        except NoConfigFileFound:
+            break
+    return filename
+
+
+def check_if_config_exist(filename: str) -> bool:
+    try:
+        read_from_cfg(None, filename)
+    except NoConfigFileFound:
+        return False
+    return True
+
+
+def list_all_config_files() -> List[str]:
+    only_files = [f for f in listdir(config_path) if isfile(join(config_path, f))]
+
+    def only_json_file(filename: str):
+        return filename if filename.endswith(".json") else None
+
+    def cgc_config_file(filename: str):
+        filename_prefix = filename.split(".")[0]
+        try:
+            int(filename_prefix)
+            return filename
+        except ValueError:
+            if filename_prefix == "cfg":
+                return filename
+
+    json_files = list(filter(partial(is_not, None), map(only_json_file, only_files)))
+    return list(filter(partial(is_not, None), map(cgc_config_file, json_files)))

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/config_utils.py

@@ -3,11 +3,9 @@ import os
 import sys
 import click
 
-from cgc.commands.auth import NoNamespaceInConfig
+from cgc.commands.auth import NoNamespaceInConfig, NoConfigFileFound
 from cgc.utils.message_utils import prepare_error_message
-from cgc.utils.consts.env_consts import (
-    CONFIG_FILE_NAME,
-)
+from cgc.utils.consts.env_consts import get_config_file_name
 
 
 def get_config_path():
@@ -32,7 +30,6 @@ def get_config_path():
 
 
 config_path = get_config_path()
-user_config_file = os.path.join(config_path, CONFIG_FILE_NAME)
 
 
 def save_to_config(**kwargs):
@@ -44,6 +41,7 @@ def save_to_config(**kwargs):
     :type kwargs: dict
     """
     read_cfg = {}
+    user_config_file = os.path.join(config_path, get_config_file_name())
     if not os.path.isdir(config_path):
         os.makedirs(config_path)
     try:
@@ -57,7 +55,7 @@ def save_to_config(**kwargs):
         json.dump(final_cfg, f)
 
 
-def read_from_cfg(key: str):
+def read_from_cfg(key: str, filename=None):
     """Function to read a single value from config
 
     :param key: key name to read the value from config
@@ -65,15 +63,18 @@ def read_from_cfg(key: str):
     :return: value for the provided key
     :rtype: _type_
     """
+    if filename is None:
+        filename_with_path = os.path.join(config_path, get_config_file_name())
+    else:
+        filename_with_path = os.path.join(config_path, filename)
     try:
-        f = open(user_config_file, "r+", encoding="UTF-8")
-        read_cfg = json.load(f)
-        return read_cfg[key]
+        with open(filename_with_path, "r+", encoding="UTF-8") as f:
+            read_cfg = json.load(f)
+            if key is None:
+                return read_cfg
+            return read_cfg[key]
     except FileNotFoundError:
-        if key == "namespace":
-            raise NoNamespaceInConfig()
-        print("No config file found. Please use cgc register first.")
-        sys.exit()
+        raise NoConfigFileFound()
     except KeyError:
         if key == "namespace":
             raise NoNamespaceInConfig()

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/consts/env_consts.py

@@ -36,8 +36,11 @@ else:
 
 API_PORT = os.getenv("API_PORT")
 API_URL = f"{__prefix}://{API_HOST}:{API_PORT}"
-CONFIG_FILE_NAME = os.getenv("CONFIG_FILE_NAME")
 TMP_DIR = os.getenv("TMP_DIR")
 RELEASE = int(os.getenv("RELEASE"))
 MAJOR_VERSION = int(os.getenv("MAJOR_VERSION"))
 MINOR_VERSION = int(os.getenv("MINOR_VERSION"))
+
+
+def get_config_file_name():
+    return os.getenv("CONFIG_FILE_NAME")

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/consts/message_consts.py

@@ -1,3 +1,6 @@
+CONFIG_FILE_NOT_FOUND = (
+    "Config file not found. Please register with CGC or verify user context."
+)
 UNKNOWN_ERROR = "An unknown error occurred. Please try again or contact support at support@comtegra.pl."
 TIMEOUT_ERROR = (
     "Connection timed out. Try again or contact support at support@comtegra.pl"
@@ -12,6 +15,6 @@ OUTDATED_MINOR = "There is a new release available, consider updating the applic
 OUTDATED_MAJOR = (
     "You are using outdated version of cgcsdk, please update to the latest version."
 )
-UNAUTHORIZED_ERROR = "Unauthorized. Please check your API key and secret key or contact support at support@comtegra.pl"
+UNAUTHORIZED_ERROR = "Unauthorized. Credentials provided are invalid. Contact support at support@comtegra.pl"
 DISABLED_ERROR = "Account has been disabled. If you require assistance, please contact support at support@comtegra.pl"
 ENDPOINT_DISABLED = "Endpoint is currently disabled, please try again later or contact support for additional information at support@comtegra.pl"

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/message_utils.py

@@ -1,9 +1,12 @@
+import click
+
 from colorama import Fore, Style
 from functools import wraps
 
 from cgc.commands.exceptions import ResponseException
 from cgc.telemetry.basic import increment_metric
-from cgc.utils.consts.message_consts import UNKNOWN_ERROR
+from cgc.utils.consts.message_consts import UNKNOWN_ERROR, CONFIG_FILE_NOT_FOUND
+from cgc.commands.auth import NoConfigFileFound
 
 
 def prepare_error_message(message: str) -> str:
@@ -46,6 +49,9 @@ def key_error_decorator_for_helpers(func):
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
+        except NoConfigFileFound as err:
+            click.echo(prepare_warning_message(CONFIG_FILE_NOT_FOUND))
+            exit(1)
         except (TypeError, KeyError, IndexError) as err:
             print(args, "\n", kwargs)
             increment_metric("client.parser", True)

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/prepare_headers.py

@@ -1,6 +1,7 @@
 from cgc.utils.config_utils import read_from_cfg
 from cgc.utils.consts.env_consts import API_URL, CGC_SECRET
 from cgc.commands.auth import auth_utils
+from cgc.utils.message_utils import key_error_decorator_for_helpers
 
 
 def load_user_api_keys():
@@ -12,6 +13,7 @@ def load_user_api_keys():
     return read_from_cfg("api_key"), read_from_cfg("api_secret")
 
 
+@key_error_decorator_for_helpers
 def get_api_url_and_prepare_headers():
     """Loads API_URL and user api keys into single function. Ment to be used as single point of truth for all andpoints except register - due to different Content-Type header
 
@@ -53,6 +55,7 @@ def get_url_and_headers_jwt_token():
     return url, headers
 
 
+@key_error_decorator_for_helpers
 def prepare_headers_api_key():
     """Prepares headers for create API key request.
 

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/requests_helper.py

@@ -26,7 +26,7 @@ class EndpointTypes(Enum):
 
 def _process_endpoint_kwargs(**kwargs):
     if not "timeout" in kwargs.keys():
-        kwargs["timeout"] = 10
+        kwargs["timeout"] = 30
     return kwargs
 
 

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgc/utils/response_utils.py

@@ -4,7 +4,7 @@ import pprint
 import requests
 import json
 from tabulate import tabulate
-from cgc.commands.auth import NoNamespaceInConfig
+from cgc.commands.auth import NoNamespaceInConfig, NoConfigFileFound
 from cgc.utils.message_utils import prepare_error_message
 from cgc.utils.consts.message_consts import (
     UNKNOWN_ERROR,
@@ -38,6 +38,10 @@ def retrieve_and_validate_response_send_metric(
                 metric = f"{get_namespace()}.{metric}"
         except NoNamespaceInConfig:
             metric = f"unknown-namespace.{metric}"
+        except NoConfigFileFound:
+            print("No config file found. Please use:")
+            print("cgc register")
+            metric = f"bad-client.{metric}"
 
         if response.status_code == 200:
             increment_metric(

{cgcsdk-0.8.5 → cgcsdk-0.8.7/cgcsdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cgcsdk
-Version: 0.8.5
+Version: 0.8.7
 Summary: Comtegra GPU Cloud REST API client
 Author: Comtegra AI Team
 Author-email: ai@comtegra.pl

{cgcsdk-0.8.5 → cgcsdk-0.8.7}/cgcsdk.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ cgc/server.crt
 cgc/commands/__init__.py
 cgc/commands/cgc_cmd.py
 cgc/commands/cgc_cmd_responses.py
+cgc/commands/cgc_helpers.py
 cgc/commands/exceptions.py
 cgc/commands/auth/__init__.py
 cgc/commands/auth/auth_cmd.py

cgcsdk-0.8.5/cgc/commands/auth/auth_responses.py

@@ -1,27 +0,0 @@
-import shutil
-import os
-
-from cgc.commands.auth import auth_utils
-from cgc.utils.consts.env_consts import TMP_DIR
-from cgc.utils.config_utils import get_config_path, save_to_config, user_config_file
-from cgc.utils.message_utils import key_error_decorator_for_helpers
-
-
-@key_error_decorator_for_helpers
-def auth_register_response(response, user_id, priv_key_bytes) -> str:
-    TMP_DIR_PATH = os.path.join(get_config_path(), TMP_DIR)
-    unzip_dir = auth_utils.save_and_unzip_file(response)
-    aes_key, password = auth_utils.get_aes_key_and_password(unzip_dir, priv_key_bytes)
-
-    save_to_config(user_id=user_id, password=password, aes_key=aes_key)
-    auth_utils.auth_create_api_key_with_save()
-    shutil.rmtree(TMP_DIR_PATH)
-    return f"Register successful! You can now use the CLI. Saved data to: {user_config_file}\n\
-        Consider backup this file. It stores data with which you can access CGC platform."
-
-
-@key_error_decorator_for_helpers
-def login_successful_response():
-    return f"Successfully logged in, created new API key pair.\n\
-                Saved data to: {user_config_file}.\n\
-                Consider backup this file. It stores data with which you can access CGC platform."

cgcsdk-0.8.5/cgc/commands/cgc_cmd.py

@@ -1,64 +0,0 @@
-import click
-import json
-
-from cgc.commands.cgc_cmd_responses import cgc_status_response
-from cgc.commands.resource.resource_cmd import resource_delete
-from cgc.utils.requests_helper import call_api, EndpointTypes
-from cgc.utils.click_group import CustomCommand
-from cgc.utils.prepare_headers import get_api_url_and_prepare_headers
-from cgc.utils.response_utils import retrieve_and_validate_response_send_metric
-from cgc.telemetry.basic import telemetry_permission_set
-from cgc.commands.compute.compute_responses import compute_logs_response
-
-
-@click.command("rm", cls=CustomCommand)
-@click.argument("name", type=click.STRING)
-def cgc_rm(name: str):
-    """
-    Delete an app in user namespace
-    """
-    resource_delete(name)
-
-
-@click.command("events", cls=CustomCommand)
-@click.argument("app_name", type=click.STRING)
-def resource_events(app_name: str):
-    """Get events of given app"""
-    api_url, headers = get_api_url_and_prepare_headers()
-    url = f"{api_url}/v1/api/resource/get_pod_events"
-    metric = "resource.events"
-    __payload = {"name": app_name}
-    __res = call_api(
-        request=EndpointTypes.get,
-        url=url,
-        headers=headers,
-        data=json.dumps(__payload),
-    )
-    click.echo(
-        compute_logs_response(retrieve_and_validate_response_send_metric(__res, metric))
-    )
-
-
-@click.command("status", cls=CustomCommand)
-def cgc_status():
-    """Lists available and used resources"""
-    api_url, headers = get_api_url_and_prepare_headers()
-    url = f"{api_url}/v1/api/resource/status"
-    metric = "resource.status"
-    __res = call_api(
-        request=EndpointTypes.get,
-        url=url,
-        headers=headers,
-    )
-    click.echo(
-        cgc_status_response(retrieve_and_validate_response_send_metric(__res, metric))
-    )
-
-
-@click.command("telemetry", cls=CustomCommand)
-def sending_telemetry_permission():
-    """Changing permission for sending telemetry"""
-
-    click.echo(
-        f"Sending telemetry is now {'enabled' if telemetry_permission_set() else 'disabled'}"
-    )

cgcsdk-0.8.5/cgc/sdk/redis.py

@@ -1,51 +0,0 @@
-from redis import Redis, ConnectionError
-
-
-class RedisConnector:
-    def __init__(
-        self, host: str, password: str = None, decode_responses: bool = False
-    ) -> None:
-        self._host = host
-        assert type(host) is str
-        "host must be a str containing redis app name"
-        self._password = password
-        self._decode_responses = decode_responses
-        self.connect()
-
-    def connect(self):
-        while True:
-            try:
-                self._redis_client = Redis(
-                    host=self._host,
-                    port=6379,
-                    password=self._password,
-                    decode_responses=self._decode_responses,
-                )
-                print(f"Connected to Redis: {self._host}")
-                break
-            except (ConnectionError,) as e:
-                print(f"Redis connection error: {e}")
-                print(f"retrying to connect...")
-
-    def get_redis_client(self):
-        return self._redis_client
-
-
-def get_redis_access(
-    app_name: str, password: str, decode_responses: bool = False, restart: bool = False
-):
-    global _redis_access
-
-    def init_access():
-        global _redis_access
-        _redis_access = RedisConnector(
-            host=app_name, password=password, decode_responses=decode_responses
-        )
-
-    try:
-        if not isinstance(_redis_access, RedisConnector) or restart:
-            init_access()
-    except NameError:
-        init_access()
-        pass
-    return _redis_access