snapctl 0.39.3__py3-none-any.whl → 0.41.0__py3-none-any.whl

snapctl/commands/game.py

@@ -1,13 +1,14 @@
 """
   Snapend CLI commands
 """
-from typing import Union, Dict
+from typing import Union
 import requests
 from requests.exceptions import RequestException
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
     SNAPCTL_GAME_CREATE_ERROR, SNAPCTL_GAME_ENUMERATE_ERROR, \
-    HTTP_ERROR_DUPLICATE_GAME_NAME, SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR
+    HTTP_ERROR_DUPLICATE_GAME_NAME, SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, \
+    HTTP_ERROR_GAME_LIMIT_REACHED, SNAPCTL_GAME_CREATE_LIMIT_ERROR
 from snapctl.utils.helper import snapctl_error, snapctl_success
 
 
@@ -18,11 +19,12 @@ class Game:
     SUBCOMMANDS = ['create', 'enumerate']
 
     def __init__(
-            self, subcommand: str, base_url: str, api_key: Union[str, None], name: Union[str, None]
+            self, *, subcommand: str, base_url: str, api_key: Union[str, None],
+            name: Union[str, None] = None
     ) -> None:
         self.subcommand: str = subcommand
         self.base_url: str = base_url
-        self.api_key: str = api_key
+        self.api_key: Union[str, None] = api_key
         self.name: Union[str, None] = name
         # Validate input
         self.validate_input()
@@ -33,18 +35,22 @@ class Game:
         """
         # Check API Key and Base URL
         if not self.api_key or self.base_url == '':
-            snapctl_error("Missing API Key.", SNAPCTL_INPUT_ERROR)
+            snapctl_error(
+                message="Missing API Key.", code=SNAPCTL_INPUT_ERROR)
         # Check subcommand
         if not self.subcommand in Game.SUBCOMMANDS:
-            snapctl_error("Invalid command. Valid commands are" +
-                          f"{', '.join(Game.SUBCOMMANDS)}.",
-                          SNAPCTL_INPUT_ERROR)
+            snapctl_error(
+                message="Invalid command. Valid commands are" +
+                f"{', '.join(Game.SUBCOMMANDS)}.",
+                code=SNAPCTL_INPUT_ERROR)
         # Check sdk-download commands
         if self.subcommand == 'create':
             if self.name is None or self.name == '':
-                snapctl_error("Missing game name.", SNAPCTL_INPUT_ERROR)
+                snapctl_error(
+                    message="Missing game name.",
+                    code=SNAPCTL_INPUT_ERROR)
 
-    def create(self) -> bool:
+    def create(self, no_exit: bool = False) -> bool:
         """
           Create a game
         """
@@ -67,19 +73,31 @@ class Game:
             )
             if res.ok:
                 snapctl_success(
-                    f"Game {self.name} create successful", progress)
+                    message=f"Game {self.name} create successful",
+                    progress=progress, no_exit=no_exit)
+                return
             response_json = res.json()
             if "api_error_code" in response_json and "message" in response_json:
+                if response_json['api_error_code'] == HTTP_ERROR_GAME_LIMIT_REACHED:
+                    snapctl_error(
+                        message=f"Game {self.name} already exists.",
+                        code=SNAPCTL_GAME_CREATE_LIMIT_ERROR, progress=progress)
                 if response_json['api_error_code'] == HTTP_ERROR_DUPLICATE_GAME_NAME:
-                    snapctl_error(f"Game {self.name} already exists.",
-                                  SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, progress)
+                    snapctl_error(
+                        message=f"Game {self.name} already exists.",
+                        code=SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, progress=progress)
             snapctl_error(
-                f'Server error: {response_json}', SNAPCTL_GAME_CREATE_ERROR, progress)
+                message=f'Server error: {response_json}',
+                code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
         except RequestException as e:
-            snapctl_error(f"Exception: Unable to download the SDK {e}",
-                          SNAPCTL_GAME_CREATE_ERROR, progress)
-        snapctl_error('Failed to create game.',
-                      SNAPCTL_GAME_CREATE_ERROR, progress)
+            snapctl_error(
+                message=f"Exception: Unable to download the SDK {e}",
+                code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Failed to create game.',
+            code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
 
     def enumerate(self) -> bool:
         """
@@ -101,11 +119,17 @@ class Game:
             )
             response_json = res.json()
             if res.ok and 'games' in response_json:
-                snapctl_success(response_json['games'], progress)
-            snapctl_error('Unable to enumerate games.',
-                          SNAPCTL_GAME_ENUMERATE_ERROR, progress)
+                snapctl_success(
+                    message=response_json['games'], progress=progress)
+            snapctl_error(
+                message='Unable to enumerate games.',
+                code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
         except RequestException as e:
-            snapctl_error(f"Exception: Unable to update your snapend {e}",
-                          SNAPCTL_GAME_ENUMERATE_ERROR, progress)
-        snapctl_error('Failed to enumerate games.',
-                      SNAPCTL_GAME_ENUMERATE_ERROR, progress)
+            snapctl_error(
+                message=f"Exception: Unable to update your snapend {e}",
+                code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Failed to enumerate games.',
+            code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)

snapctl/commands/generate.py

@@ -28,9 +28,9 @@ class Generate:
     }
 
     def __init__(
-        self, subcommand: str, base_url: str, api_key: Union[str, None],
-        category: Union[str, None],
-        out_path: Union[str, None]
+        self, *, subcommand: str, base_url: str, api_key: Union[str, None],
+        category: Union[str, None] = None,
+        out_path: Union[str, None] = None
     ) -> None:
         self.subcommand: str = subcommand
         self.base_url: str = base_url
@@ -63,44 +63,44 @@ class Generate:
         """
         if self.subcommand not in Generate.SUBCOMMANDS:
             snapctl_error(
-                f"Invalid command {self.subcommand}. Valid command are " +
+                message=f"Invalid command {self.subcommand}. Valid command are " +
                 f"{Generate.SUBCOMMANDS}",
-                SNAPCTL_INPUT_ERROR
+                code=SNAPCTL_INPUT_ERROR
             )
         # Check path
         if self.subcommand == 'profile':
             if self.category not in Generate.CATEGORIES['profile']:
                 snapctl_error(
-                    f"Invalid category {self.category}. Valid category are " +
+                    message=f"Invalid category {self.category}. Valid category are " +
                     f"{Generate.CATEGORIES['profile']}",
-                    SNAPCTL_INPUT_ERROR
+                    code=SNAPCTL_INPUT_ERROR
                 )
             if not self.out_path:
                 snapctl_error(
-                    "Path is required for profile generation",
-                    SNAPCTL_INPUT_ERROR
+                    message="Path is required for profile generation",
+                    code=SNAPCTL_INPUT_ERROR
                 )
         elif self.subcommand == 'credentials':
             if self.category not in Generate.CATEGORIES['credentials']:
                 snapctl_error(
-                    f"Invalid category {self.category}. Valid category are " +
+                    message=f"Invalid category {self.category}. Valid category are " +
                     f"{Generate.CATEGORIES['credentials']}",
-                    SNAPCTL_INPUT_ERROR
+                    code=SNAPCTL_INPUT_ERROR
                 )
             if not self.out_path:
                 snapctl_error(
-                    "Path is required for token generation",
-                    SNAPCTL_INPUT_ERROR
+                    message="Path is required for token generation",
+                    code=SNAPCTL_INPUT_ERROR
                 )
         # Now confirm that out-path is valid
         if self.out_path and not os.path.isdir(self.out_path):
             snapctl_error(
-                f"Invalid path {self.out_path}. Wont be able to " +
+                message=f"Invalid path {self.out_path}. Wont be able to " +
                 "store the output file",
-                SNAPCTL_INPUT_ERROR
+                code=SNAPCTL_INPUT_ERROR
             )
 
-    def byosnap_profile(self) -> None:
+    def byosnap_profile(self, no_exit: bool = False) -> None:
         """
             Generate snapser-byosnap-profile.json
         """
@@ -125,30 +125,34 @@ class Generate:
                 file_written = True
             if file_written:
                 snapctl_success(
-                    "BYOSNAP Profile generation successful. " +
+                    message="BYOSNAP Profile generation successful. " +
                     f"{Generate.BYOSNAP_PROFILE_FN} saved at {file_save_path}",
-                    progress
+                    progress=progress,
+                    no_exit=no_exit
                 )
+                return
         except (IOError, OSError) as file_error:
-            snapctl_error(f"File error: {file_error}",
-                          SNAPCTL_GENERATE_PROFILE_ERROR, progress)
+            snapctl_error(
+                message=f"File error: {file_error}",
+                code=SNAPCTL_GENERATE_PROFILE_ERROR, progress=progress)
         except json.JSONDecodeError as json_error:
-            snapctl_error(f"JSON error: {json_error}",
-                          SNAPCTL_GENERATE_PROFILE_ERROR, progress)
+            snapctl_error(
+                message=f"JSON error: {json_error}",
+                code=SNAPCTL_GENERATE_PROFILE_ERROR, progress=progress)
         snapctl_error(
-            "Failed to generate BYOSNAP Profile",
-            SNAPCTL_GENERATE_PROFILE_ERROR,
-            progress
+            message="Failed to generate BYOSNAP Profile",
+            code=SNAPCTL_GENERATE_PROFILE_ERROR,
+            progress=progress
         )
 
-    def profile(self) -> None:
+    def profile(self, no_exit: bool = False) -> None:
         """
             Generate profile
         """
         if self.category == 'byosnap':
-            self.byosnap_profile()
+            self.byosnap_profile(no_exit)
 
-    def ecr_credentials(self) -> None:
+    def ecr_credentials(self, no_exit: bool = False) -> None:
         """
             Generate credentials
         """
@@ -169,9 +173,9 @@ class Generate:
             # url|web_app_token|service_id|ecr_repo_url|ecr_repo_username|ecr_repo_token
             if token_parts is None or len(token_parts) != 4:
                 snapctl_error(
-                    "Unable to retrieve token.",
-                    SNAPCTL_GENERATE_GENERIC_ERROR,
-                    progress
+                    message="Unable to retrieve token.",
+                    code=SNAPCTL_GENERATE_GENERIC_ERROR,
+                    progress=progress
                 )
             token_details = {
                 'ecr_repo_url': token_parts[0],
@@ -191,20 +195,24 @@ class Generate:
                 file_written = True
             if file_written:
                 snapctl_success(
-                    "ECR Token generation successful. " +
+                    message="ECR Token generation successful. " +
                     f"{Generate.ECR_TOKEN_FN} saved at {file_save_path}",
-                    progress
+                    progress=progress,
+                    no_exit=no_exit
                 )
+                return
         except (IOError, OSError) as file_error:
-            snapctl_error(f"File error: {file_error}",
-                          SNAPCTL_GENERATE_CREDENTIALS_ERROR, progress)
+            snapctl_error(
+                message=f"File error: {file_error}",
+                code=SNAPCTL_GENERATE_CREDENTIALS_ERROR, progress=progress)
         except json.JSONDecodeError as json_error:
-            snapctl_error(f"JSON error: {json_error}",
-                          SNAPCTL_GENERATE_CREDENTIALS_ERROR, progress)
+            snapctl_error(
+                message=f"JSON error: {json_error}",
+                code=SNAPCTL_GENERATE_CREDENTIALS_ERROR, progress=progress)
         snapctl_error(
-            "Failed to generate Token",
-            SNAPCTL_GENERATE_CREDENTIALS_ERROR,
-            progress
+            message="Failed to generate Token",
+            code=SNAPCTL_GENERATE_CREDENTIALS_ERROR,
+            progress=progress
         )
 
     def credentials(self):