devstack-cli 11.0.254__tar.gz → 12.0.0__tar.gz

{devstack_cli-11.0.254/src/devstack_cli.egg-info → devstack_cli-12.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devstack-cli
-Version: 11.0.254
+Version: 12.0.0
 Summary: Command-line access to Cloud Development Environments (CDEs) created by Cloudomation DevStack
 Author-email: Stefan Mückstein <stefan@cloudomation.com>
 Project-URL: Homepage, https://cloudomation.com/

{devstack_cli-11.0.254 → devstack_cli-12.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devstack-cli"
-version = "11.0.254"
+version = "12.0.0"
 authors = [
     { name="Stefan Mückstein", email="stefan@cloudomation.com" },
 ]

{devstack_cli-11.0.254 → devstack_cli-12.0.0}/src/cli.py

@@ -34,6 +34,7 @@ import rich.logging
 import rich.markup
 import rich.pretty
 import rich.progress
+import rich.table
 import watchdog.events
 import watchdog.observers
 import yarl
@@ -237,11 +238,12 @@ class Cli:
         self.password: typing.Optional[str] = None
         self.session: typing.Optional[aiohttp.ClientSession] = None
         self.workspace_url: typing.Optional[yarl.URL] = None
+        self.user_info: typing.Optional[dict] = None
         self.sync_task: typing.Optional[asyncio.Task] = None
         self.port_forwarding_task: typing.Optional[asyncio.Task] = None
         self.logs_task: typing.Optional[asyncio.Task] = None
         self.exit_stack: typing.Optional[contextlib.AsyncExitStack] = None
-        self.cdes: typing.List[dict] = []
+        self.cdes: typing.Dict[str, dict] = {}
         self.cde: typing.Optional[dict] = None
         self.cde_type: typing.Optional[dict] = None
         self.ssh_client: typing.Optional[paramiko.SSHClient] = None
@@ -358,7 +360,7 @@ class Cli:
         parser.add_argument(
             '--maximum-uptime-hours',
             type=int,
-            help='the number of hours before an CDE is automatically stopped',
+            help='deprecated. accepted to not break backwards compatibility, please set `devstack_default_maximum_uptime_hours` metadata value on your user.',
         )
         parser.add_argument(
             '-n', '--cde-name',
@@ -484,6 +486,59 @@ class Cli:
             self.loop.remove_reader(sys.stdin)
             termios.tcsetattr(self._fd, termios.TCSADRAIN, self._tcattr)
 
+    async def _migrate_maximum_uptime_hours(self: 'Cli') -> None:
+        assert self.session is not None
+        assert self.workspace_url is not None
+        assert self.user_info is not None
+        assert self.config is not None
+        response = await self.session.get(
+            url=self.workspace_url / 'api/latest/record_metadata',
+            params={
+                'filter': json.dumps({
+                    'and': [
+                        {
+                            'field': 'record_id',
+                            'op': 'eq',
+                            'value': self.user_info['identity_id'],
+                        },
+                        {
+                            'field': 'key',
+                            'op': 'eq',
+                            'value': 'devstack_default_maximum_uptime_hours',
+                        },
+                    ],
+                }),
+                'fields': 'record_id,key,data,id',
+                'plain': 'True',
+            },
+        )
+        if not response.ok:
+            raise InitializationError('Failed to get devstack_default_maximum_uptime_hours metadata')
+        maximum_uptime_hours_value = await response.json()
+        if len(maximum_uptime_hours_value) > 0:
+            if not isinstance(maximum_uptime_hours_value[0]['data'], (str, int)):
+                response = await self.session.delete(url=self.workspace_url / 'api/latest/record_metadata' / maximum_uptime_hours_value[0]['id'])
+                if not response.ok:
+                    raise InitializationError(f'Failed to delete invalid metadata: {response.reason} ({response.status}):\n{await response.text()}')
+                logger.warning('Deleted invalid metadata: %s', maximum_uptime_hours_value[0]['id'])
+            else:
+                if int(self.config['global']['maximum_uptime_hours']) != int(maximum_uptime_hours_value[0]['data']):
+                    logger.warning('"maximum_uptime_hours" is deprecated and set, while the metadata key `devstack_default_maximum_uptime_hours` is also set, which will be used.')
+                return
+        logger.info('Migrating maximum_uptime_hours to Cloudomation metadata')
+        response = await self.session.post(
+            url=self.workspace_url / 'api/latest/record_metadata',
+            json={
+                'record_id': self.user_info['identity_id'],
+                'key': 'devstack_default_maximum_uptime_hours',
+                'data': int(self.config['global']['maximum_uptime_hours']),
+            },
+        )
+        if not response.ok:
+            raise InitializationError(f'Failed to migrate maximum_uptime_hours: {response.reason} ({response.status}):\n{await response.text()}')
+        del self.config['global']['maximum_uptime_hours']
+
+
     async def _load_global_config(self: 'Cli') -> None:
         self.config_file = pathlib.Path(os.path.expandvars(self.args.config_file))
         self.config_file.parent.mkdir(parents=True, exist_ok=True)  # make sure the config directory exists
@@ -496,6 +551,8 @@ class Cli:
                 config_str = await f.read()
             self.config.read_string(config_str, source=self.config_file)
         self.config.setdefault('global', {})
+        self.config['global'].setdefault('source_directory_template', '$HOME/{folder}')
+        self.config['global'].setdefault('output_directory_template', '$HOME/{folder}-output')
 
         workspace_url = self.args.workspace_url or self.config['global'].get('workspace_url')
         if not workspace_url:
@@ -513,18 +570,6 @@ class Cli:
             self.password = self._console_input(f'Enter your password to authenticate "{user_name}" to {workspace_url}: ', password=True)
         self.twofa_code = self._console_input('Enter a current two-factor authentication code (if enabled): ', password=True)
 
-        maximum_uptime_hours = self.args.maximum_uptime_hours or self.config['global'].get('maximum_uptime_hours')
-        if not maximum_uptime_hours:
-            while True:
-                maximum_uptime_hours = self._console_input('How many hours should an CDE remain started until it is automatically stopped: ', prefill='8')
-                try:
-                    int(maximum_uptime_hours)
-                except ValueError:
-                    logger.error('"%s" is not a valid number', maximum_uptime_hours)  # noqa: TRY400
-                else:
-                    break
-        self.config['global']['maximum_uptime_hours'] = maximum_uptime_hours
-
         await self._write_config_file()
 
     async def _write_config_file(self: 'Cli') -> None:
@@ -578,6 +623,9 @@ class Cli:
         logger.info('Logged in to Cloudomation workspace')
         json_logger.debug(json.dumps(self.user_info, indent=4, sort_keys=True))
 
+        if 'maximum_uptime_hours' in self.config['global']:
+            await self._migrate_maximum_uptime_hours()
+
         response = await self.session.get(
             url=self.workspace_url / 'api/latest/object_template/cde-type',
             params={
@@ -590,6 +638,18 @@ class Cli:
         logger.debug('The "cde-type" object template')
         json_logger.debug(json.dumps(self.cde_type_template, indent=4, sort_keys=True))
 
+        response = await self.session.get(
+            url=self.workspace_url / 'api/latest/object_template/cde-snapshot',
+            params={
+                'by': 'name',
+            },
+        )
+        if response.status != 200:
+            raise InitializationError(f'Failed to fetch "cde-snapshot" object template: {response.reason} ({response.status}):\n{await response.text()}\nIs the "DevStack" bundle installed?')
+        self.cde_snapshot_template = (await response.json())['object_template']
+        logger.debug('The "cde-snapshot" object template')
+        json_logger.debug(json.dumps(self.cde_snapshot_template, indent=4, sort_keys=True))
+
         response = await self.session.get(
             url=self.workspace_url / 'api/latest/object_template/cde',
             params={
@@ -619,6 +679,28 @@ class Cli:
         logger.debug('The "cde-type" custom objects')
         json_logger.debug(json.dumps(self.cde_types, indent=4, sort_keys=True))
 
+        response = await self.session.get(
+            url=self.workspace_url / 'api/latest/custom_object',
+            params={
+                'filter': json.dumps({
+                    'and': [
+                        {
+                            'field': 'object_template_id',
+                            'op': 'eq',
+                            'value': self.cde_snapshot_template['id'],
+                        },
+                    ],
+                }),
+                'plain': 'true',
+            },
+        )
+        if response.status != 200:
+            raise InitializationError(f'Failed to fetch "cde-snapshot" custom objects: {response.reason} ({response.status}):\n{await response.text()}')
+        self.cde_snapshots = await response.json()
+        self.cde_snapshots.sort(key=lambda cde_snapshot: cde_snapshot['name'])
+        logger.debug('The "cde-snapshot" custom objects')
+        json_logger.debug(json.dumps(self.cde_snapshots, indent=4, sort_keys=True))
+
         # logger.info('Using configuration of CDE "%s"', self.cde_name)
         # json_logger.debug(json.dumps(self.cde_config, indent=4, sort_keys=True))
 
@@ -642,7 +724,10 @@ class Cli:
             table.add_section()
             table.add_row('', '== CDE selection ==')
         for i, cde in enumerate(self.cdes.values(), start=1):
-            cde_type = await self._get_cde_type_of_cde(cde)
+            cde_snapshot = await self._get_cde_snapshot_of_cde(cde)
+            if not cde_snapshot:
+                continue
+            cde_type = await self._get_cde_type_of_cde_snapshot(cde_snapshot)
             if not cde_type:
                 continue
             cde_type_name = cde_type['name']
@@ -822,24 +907,31 @@ class Cli:
                 self.sftp_client.close()
                 self.sftp_client = None
 
+    async def _get_cde_type_of_cde_snapshot(self: 'Cli', cde_snapshot: dict) -> typing.Optional[dict]:
+        try:
+            cde_type = next(cde_type for cde_type in self.cde_types if cde_type['id'] == cde_snapshot['value']['cde-type'])
+        except StopIteration:
+            logger.error('CDE type ID "%s" not found', cde_snapshot['value']['cde-type'])  # noqa: TRY400
+            return None
+        return cde_type
 
-    async def _get_cde_type_of_cde(self: 'Cli', cde: dict) -> typing.Optional[dict]:
+    async def _get_cde_snapshot_of_cde(self: 'Cli', cde: dict) -> typing.Optional[dict]:
         if cde['exists_remotely']:
             try:
-                cde_type = next(cde_type for cde_type in self.cde_types if cde_type['id'] == cde['value']['cde-type'])
+                cde_snapshot = next(cde_snapshot for cde_snapshot in self.cde_snapshots if cde_snapshot['id'] == cde['value']['cde-snapshot'])
             except StopIteration:
-                logger.error('CDE type ID "%s" not found', cde['value']['cde-type'])  # noqa: TRY400
+                logger.error('CDE snapshot ID "%s" not found', cde['value']['cde-snapshot'])  # noqa: TRY400
                 return None
         elif cde['exists_locally']:
             try:
-                cde_type = next(cde_type for cde_type in self.cde_types if cde_type['name'] == cde['cde_type'])
+                cde_snapshot = next(cde_snapshot for cde_snapshot in self.cde_snapshots if cde_snapshot['name'] == cde.get('cde_snapshot'))
             except StopIteration:
-                logger.error('CDE type "%s" not found', cde['cde_type'])  # noqa: TRY400
+                logger.error('CDE snapshot "%s" not found', cde.get('cde_snapshot'))  # noqa: TRY400
                 return None
         else:
             logger.error('CDE does not exist')
             return None
-        return cde_type
+        return cde_snapshot
 
     async def _process_args(self: 'Cli') -> None:
         if self.args.cde_name:
@@ -936,32 +1028,60 @@ class Cli:
 
     async def _create_cde(self: 'Cli') -> None:
         logger.info('Creating new CDE')
-        table = rich.table.Table(title='CDE types')
+
+        response = await self.session.get(
+            url=self.workspace_url / 'api/latest/custom_object',
+            params={
+                'filter': json.dumps({
+                    'and': [
+                        {
+                            'field': 'object_template_id',
+                            'op': 'eq',
+                            'value': self.cde_snapshot_template['id'],
+                        },
+                        {
+                            'field': 'provisioning_state',
+                            'op': 'eq',
+                            'value': 'READY',
+                        },
+                    ],
+                }),
+                'plain': 'true',
+            },
+        )
+        if response.status != 200:
+            raise InitializationError(f'Failed to fetch "cde-snapshot" custom objects: {response.reason} ({response.status}):\n{await response.text()}')
+        self.cde_snapshots = await response.json()
+        self.cde_snapshots.sort(key=lambda cde_snapshot: cde_snapshot['name'])
+        logger.debug('The "cde-snapshot" custom objects')
+        json_logger.debug(json.dumps(self.cde_snapshots, indent=4, sort_keys=True))
+
+        table = rich.table.Table(title='CDE snapshots')
         table.add_column('Key', style='cyan bold')
         table.add_column('Name')
         table.add_column('Description')
-        for i, cde_type in enumerate(self.cde_types, start=1):
-            table.add_row(str(i), cde_type['name'], cde_type['description'])
-        table.add_row('ESC', 'Cancel')
+        table.add_column('Status')
+        for i, cde_snapshot in enumerate(self.cde_snapshots, start=1):
+            table.add_row(str(i), cde_snapshot['name'], cde_snapshot['description'], cde_snapshot['provisioning_state'])
+        #table.add_row('ESC', 'Cancel')
         rich.print(table)
-        logger.info('Choose a CDE type (1-%d):', len(self.cde_types))
-        key_press = await self.key_queue.get()
-        if key_press == chr(27):
-            logger.warning('Aborting')
-            return
+        cde_snapshot_index = self._console_input(f'Choose a CDE snapshot (1-{len(self.cde_snapshots)}): ')
         try:
-            cde_type = self.cde_types[int(key_press)-1]
+            cde_snapshot = self.cde_snapshots[int(cde_snapshot_index)-1]
         except (IndexError, ValueError):
-            logger.error('Invalid choice "%s"', key_press)  # noqa: TRY400
+            logger.error('Invalid choice "%s"', cde_snapshot_index)  # noqa: TRY400
+            return
+        if cde_snapshot['provisioning_state'] != 'READY':
+            logger.error('CDE snapshot "%s" is not ready', cde_snapshot['name'])
             return
-        cde_name = self._console_input('Choose a name for your CDE: ', prefill=f"{self.user_info['name']}-{cde_type['name']}")
-        await self._create_cde_api_call(cde_name, cde_type['id'])
+        cde_name = self._console_input('Choose a name for your CDE: ', prefill=f"{self.user_info['name']}-{cde_snapshot['name']}")
+        await self._create_cde_api_call(cde_name, cde_snapshot['id'])
         await self._update_cde_list()
         await self._select_cde(cde_name)
+        if self.cde['status'] == 'not configured':
+            await self._configure_cde(silent=True)
 
-    async def _create_cde_api_call(self: 'Cli', cde_name: str, cde_type_id: str) -> None:
-        maximum_uptime_hours = int(self.config['global'].get('maximum_uptime_hours', '8'))
-        stop_at = (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=maximum_uptime_hours)).isoformat()
+    async def _create_cde_api_call(self: 'Cli', cde_name: str, cde_snapshot_id: str) -> None:
         try:
             response = await self.session.post(
                 url=self.workspace_url / 'api/latest/custom_object',
@@ -969,10 +1089,9 @@ class Cli:
                     'name': cde_name,
                     'object_template_id': self.cde_template['id'],
                     'value': {
-                        'cde-type': cde_type_id,
+                        'cde-snapshot': cde_snapshot_id,
                         'user': self.user_info['identity_id'],
                         'feature-branch-mapping': None,
-                        'stop-at': stop_at,
                     },
                 },
                 params={
@@ -985,18 +1104,28 @@ class Cli:
         if response.status != 200:
             logger.error('Failed to create CDE: %s (%s):\n%s', response.reason, response.status, await response.text())
             return
+        response_json = await response.json()
+        if response_json['id'] in { c['id'] for c in self.cdes.values() if 'id' in c}:
+            logger.warning('Did not create a new CDE since a CDE with the name you chose already exists')
 
     async def _select_cde(self: 'Cli', cde_name: str, *, quiet: bool = False) -> None:
         if self.cde is not None and self.cde['name'] != cde_name and self.ssh_client is not None:
             await self._disconnect_cde()
         try:
             self.cde = self.cdes[cde_name]
-        except IndexError:
+        except KeyError:
             logger.error('Cannot select CDE "%s". No such CDE', cde_name)  # noqa: TRY400
             return
         if not quiet:
             logger.info('Selecting "%s" CDE', self.cde_name)
-        self.cde_type = await self._get_cde_type_of_cde(self.cde)
+        self.cde_snapshot = await self._get_cde_snapshot_of_cde(self.cde)
+        if not self.cde_snapshot:
+            logger.error('Cannot select CDE "%s". No such CDE snapshot', cde_name)  # noqa: TRY400
+            return
+        self.cde_type = await self._get_cde_type_of_cde_snapshot(self.cde_snapshot)
+        if not self.cde_type:
+            logger.error('Cannot select CDE "%s". No such CDE type', cde_name)  # noqa: TRY400
+            return
         self.config['global']['last_cde_name'] = self.cde_name
         await self._write_config_file()
 
@@ -1022,8 +1151,10 @@ class Cli:
         elif self.cde['status'] == 'connected':
             await self._disconnect_cde()
         else:
-            logger.error('CDE is not running. Cannot connect.')
-            return
+            await self._start_cde()
+            await self._wait_running()
+            # logger.error('CDE is not running. Cannot connect.')
+            # return
 
     async def _connect_cde(self: 'Cli') -> None:
         logger.info('Connecting to CDE')
@@ -1077,7 +1208,7 @@ class Cli:
         self.known_hosts_file = None
         logger.debug('Disconnected from CDE')
 
-    async def _configure_cde(self: 'Cli') -> None:
+    async def _configure_cde(self: 'Cli', *, silent: bool = False) -> None:
         await self._update_cde_list()
         if not self.cde:
             logger.error('No CDE is selected. Cannot configure CDE.')
@@ -1087,17 +1218,26 @@ class Cli:
             logger.info('Creating new configuration for CDE "%s".', self.cde_name)
             self.config[cde_config_key] = {
                 'cde_type': self.cde_type['name'],
+                'cde_snapshot': self.cde_snapshot['name'],
             }
-        source_directory = self._console_input(
-            f'Choose a local directory where the sources of the "{self.cde_name}" CDE will be stored: ',
-            prefill=self.config[cde_config_key].get('source_directory', f'$HOME/{self.cde_type["name"].replace(" ", "-")}'),
-        )
+        default_source_directory = self.config['global']['source_directory_template'].format(folder=self.cde_type['name'].replace(' ', '-'))
+        if silent:
+            source_directory = default_source_directory
+        else:
+            source_directory = self._console_input(
+                f'Choose a local directory where the sources of the "{self.cde_name}" CDE will be stored: ',
+                prefill=self.config[cde_config_key].get('source_directory', default_source_directory),
+            )
         self.config[cde_config_key]['source_directory'] = source_directory
         while True:
-            output_directory = self._console_input(
-                f'Choose a local directory where the outputs of the "{self.cde_name}" CDE will be stored: ',
-                prefill=self.config[cde_config_key].get('output_directory', f'$HOME/{self.cde_type["name"].replace(" ", "-")}-output'),
-            )
+            default_output_directory = self.config['global']['output_directory_template'].format(folder=self.cde_type['name'].replace(' ', '-'))
+            if silent:
+                output_directory = default_output_directory
+            else:
+                output_directory = self._console_input(
+                    f'Choose a local directory where the outputs of the "{self.cde_name}" CDE will be stored: ',
+                    prefill=self.config[cde_config_key].get('output_directory', default_output_directory),
+                )
             if (
                     _is_relative_to(source_directory, output_directory)
                     or _is_relative_to(output_directory, source_directory)
@@ -1106,18 +1246,6 @@ class Cli:
             else:
                 break
         self.config[cde_config_key]['output_directory'] = output_directory
-        while True:
-            maximum_uptime_hours = self._console_input(
-                'How many hours should this CDE remain started until it is automatically stopped: ',
-                prefill=self.config['global'].get('maximum_uptime_hours', '8'),
-            )
-            try:
-                int(maximum_uptime_hours)
-            except ValueError:
-                logger.error('"%s" is not a valid number', maximum_uptime_hours)  # noqa: TRY400
-            else:
-                break
-        self.config[cde_config_key]['maximum_uptime_hours'] = maximum_uptime_hours
 
         await self._write_config_file()
         logger.info('CDE "%s" configured.', self.cde_name)
@@ -1157,15 +1285,12 @@ class Cli:
             self.ssh_client = None
 
     async def _start_cde_api_call(self: 'Cli') -> None:
-        maximum_uptime_hours = int(self.config['global'].get('maximum_uptime_hours', '8'))
-        stop_at = (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=maximum_uptime_hours)).isoformat()
         try:
             response = await self.session.patch(
                 url=self.workspace_url / 'api/latest/custom_object' / self.cde['id'],
                 json={
                     'value': {
                         'is-running': True,
-                        'stop-at': stop_at,
                     },
                 },
             )
@@ -1199,19 +1324,21 @@ class Cli:
             logger.error('No CDE is selected. Cannot delete CDE.')
             return
         logger.info('Deleting CDE "%s"', self.cde_name)
-        try:
-            response = await self.session.delete(
-                url=self.workspace_url / 'api/latest/custom_object' / self.cde['id'],
-                params={
-                    'permanently': 'true',
-                },
-            )
-        except (aiohttp.ClientError, aiohttp.ClientResponseError) as ex:
-            logger.error('Failed to delete CDE: %s', str(ex))  # noqa: TRY400
-            return
-        if response.status != 204:
-            logger.error('Failed to delete CDE: %s (%s)', response.reason, response.status)
-            return
+        if self.cde['exists_remotely']:
+            try:
+                response = await self.session.delete(
+                    url=self.workspace_url / 'api/latest/custom_object' / self.cde['id'],
+                    params={
+                        'permanently': 'true',
+                        'wait': 'false',
+                    },
+                )
+            except (aiohttp.ClientError, aiohttp.ClientResponseError) as ex:
+                logger.error('Failed to delete CDE: %s', str(ex))  # noqa: TRY400
+                return
+            if response.status != 204:
+                logger.error('Failed to delete CDE: %s (%s)', response.reason, response.status)
+                return
         if self.sync_task:
             self.sync_task.cancel()
             self.sync_task = None
@@ -1224,7 +1351,9 @@ class Cli:
         if self.ssh_client is not None:
             self.ssh_client.close()
             self.ssh_client = None
-
+        self.config.remove_section(f'cde.{self.cde_name}')
+        self.config['global'].pop('last_cde_name', None)
+        await self._write_config_file()
     #####
     ##### PORT FORWARDING
     #####
@@ -1240,11 +1369,11 @@ class Cli:
             logger.error('No CDE is selected. Cannot start port forwarding.')
             return
         if not self.is_cde_running:
-            logger.error('CDE is not running. Cannot start port forwarding.')
-            return
+            await self._start_cde()
+            await self._wait_running()
+            await self._connect_cde()
         if self.ssh_client is None:
-            logger.error('Not connected to CDE. Cannot start port forwarding.')
-            return
+            await self._connect_cde()
         self.port_forwarding_task = asyncio.create_task(self._bg_port_forwarding())
 
     async def _stop_port_forwarding(self: 'Cli') -> None:
@@ -1347,7 +1476,7 @@ class Cli:
             logger.info('Starting file sync')
             try:
                 await self._init_local_cache()
-            except OSError as ex:
+            except Exception as ex:
                 logger.error('Failed to initialize local cache: %s', str(ex))  # noqa: TRY400
                 return
             filesystem_event_queue = asyncio.Queue()
@@ -1757,8 +1886,7 @@ class Cli:
             logger.error('CDE is not running. Cannot follow logs.')
             return
         if self.ssh_client is None:
-            logger.error('Not connected to CDE. Cannot follow logs.')
-            return
+            await self._connect_cde()
         self.logs_task = asyncio.create_task(self._bg_logs())
 
     async def _stop_logs(self: 'Cli') -> None:
@@ -1803,8 +1931,7 @@ class Cli:
             logger.error('CDE is not running. Cannot open terminal.')
             return
         if self.ssh_client is None:
-            logger.error('Not connected to CDE. Cannot open terminal.')
-            return
+            await self._connect_cde()
         while True:
             logger.info('Opening interactive terminal (press CTRL+D or enter "exit" to close)')
             await self._reset_keyboard()

{devstack_cli-11.0.254 → devstack_cli-12.0.0/src/devstack_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devstack-cli
-Version: 11.0.254
+Version: 12.0.0
 Summary: Command-line access to Cloud Development Environments (CDEs) created by Cloudomation DevStack
 Author-email: Stefan Mückstein <stefan@cloudomation.com>
 Project-URL: Homepage, https://cloudomation.com/

devstack_cli-12.0.0/src/version.py

@@ -0,0 +1,9 @@
+"""
+constants, set by build
+"""
+
+MAJOR = '12'
+BRANCH_NAME = 'release-12'
+BUILD_DATE = '2026-08-19-223353'
+SHORT_SHA = '7b791d7'
+VERSION = '12+release-12.2026-08-19-223353.7b791d7'

devstack_cli-11.0.254/src/version.py

@@ -1,9 +0,0 @@
-"""
-constants, set by build
-"""
-
-MAJOR = '11'
-BRANCH_NAME = 'release-11'
-BUILD_DATE = '2026-06-22-023906'
-SHORT_SHA = '000400e'
-VERSION = '11+release-11.2026-06-22-023906.000400e'