cloudos-cli 2.93.0__tar.gz → 2.93.1__tar.gz

{cloudos_cli-2.93.0 → cloudos_cli-2.93.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudos_cli
-Version: 2.93.0
+Version: 2.93.1
 Summary: Python package for interacting with the Lifebit Platform
 Home-page: https://github.com/lifebit-ai/cloudos-cli
 Author: David Piñeyro

cloudos_cli-2.93.1/cloudos_cli/_version.py

@@ -0,0 +1 @@
+__version__ = '2.93.1'

{cloudos_cli-2.93.0 → cloudos_cli-2.93.1}/cloudos_cli/interactive_session/cli.py

@@ -29,7 +29,9 @@ from cloudos_cli.interactive_session.interactive_session import (
     format_stop_success_output,
     poll_session_termination,
     build_resume_payload,
-    fetch_interactive_session_page
+    fetch_interactive_session_page,
+    APP_SESSION_TYPES,
+    build_app_filtered_page_fetcher
 )
 from cloudos_cli.configure.configure import with_profile_config, CLOUDOS_URL
 from cloudos_cli.utils.cli_helpers import pass_debug_to_subcommands
@@ -223,11 +225,16 @@ def list_sessions(ctx,
         sessions = result.get('sessions', [])
         pagination_metadata = result.get('pagination_metadata', None)
 
-        # Create callback function for fetching additional pages
-        def fetch_page(page_num):
-            return fetch_interactive_session_page(
-                cl, workspace_id, page_num, limit, filter_status, filter_only_mine, archived, verify_ssl
-            )
+        # Create callback function for fetching additional pages.
+        # App sessions must be filtered here too so that navigating to
+        # next/prev pages via interactive pagination never re-introduces them.
+        fetch_page = build_app_filtered_page_fetcher(
+            cl, workspace_id, limit, filter_status, filter_only_mine, archived, verify_ssl
+        )
+
+        # Filter out app sessions (awsCustomSession / azureCustomSession) — not supported via API key
+        # Client-side filter; the API has no type-exclusion parameter
+        sessions = [s for s in sessions if s.get('interactiveSessionType') not in APP_SESSION_TYPES]
 
         # Handle empty results
         if len(sessions) == 0:

{cloudos_cli-2.93.0 → cloudos_cli-2.93.1}/cloudos_cli/interactive_session/interactive_session.py

@@ -57,6 +57,9 @@ def validate_instance_type(instance_type, execution_platform='aws'):
     return True, None
 
 
+APP_SESSION_TYPES = frozenset({'awsCustomSession', 'azureCustomSession'})
+
+
 def _map_session_type_to_friendly_name(session_type):
     """Map internal session type names to user-friendly display names.
 
@@ -83,7 +86,9 @@ def _map_session_type_to_friendly_name(session_type):
         'azureSpark': 'Spark',
         'awsRStudio': 'RStudio',  # Handle both capitalizations
         'azureRStudio': 'RStudio',
-        'awsWindowsSession': 'Windows'
+        'awsWindowsSession': 'Windows',
+        'awsCustomSession': 'App',
+        'azureCustomSession': 'App'
     }
     return type_mapping.get(session_type, session_type)
 
@@ -251,50 +256,95 @@ def create_interactive_session_list_table(sessions, pagination_metadata=None, se
     if len(sessions) == 0:
         console.print('[yellow]No interactive sessions found.[/yellow]')
         return
-    # Prepare rows data
-    rows = []
-    for session in sessions:
-        row_data = []
-        for col_name in columns_to_show:
-            if col_name not in all_columns:
-                continue
-            col_config = all_columns[col_name]
-            accessor = col_config['accessor']
-            # Extract value from session object
-            value = _get_nested_value(session, accessor)
-            # Format the value
-            formatted_value = _format_session_field(col_name, value)
-            row_data.append(formatted_value)
-        rows.append(row_data)
-
-    # Interactive pagination - use API pagination metadata if available
+    # ------------------------------------------------------------------
+    # Row-builder helper (keeps column-mapping in one place)
+    # ------------------------------------------------------------------
+    def _build_rows(sess_list):
+        result = []
+        for sess in sess_list:
+            row_data = []
+            for col_name in columns_to_show:
+                if col_name not in all_columns:
+                    continue
+                col_config = all_columns[col_name]
+                value = _get_nested_value(sess, col_config['accessor'])
+                row_data.append(_format_session_field(col_name, value))
+            result.append(row_data)
+        return result
+
+    # ------------------------------------------------------------------
+    # Pagination state
+    # ------------------------------------------------------------------
     if pagination_metadata:
-        # Server-side pagination
+        # Server-side pagination with fill-buffer.
+        # The server page may contain app-session types that are filtered
+        # client-side, leaving fewer than page_size rows.  We keep a
+        # carry_forward buffer and silently fetch ahead so that every
+        # virtual page is exactly page_size rows (or fewer only on the
+        # very last page).
         current_api_page = pagination_metadata.get('page', 1)
-        total_sessions = pagination_metadata.get('count', len(sessions))
-        total_pages = pagination_metadata.get('totalPages', 1)
+        total_sessions   = pagination_metadata.get('count', len(sessions))
+        total_pages      = pagination_metadata.get('totalPages', 1)
+
+        carry_forward            = list(sessions)   # fetched but not yet shown
+        last_fetched_server_page = current_api_page
+        virtual_page_history     = []               # for "prev" navigation
+
+        def _top_up():
+            """Silently fetch ahead until carry_forward >= page_size or exhausted."""
+            nonlocal last_fetched_server_page, total_pages
+            if not fetch_page_callback:
+                return
+            while (len(carry_forward) < page_size
+                   and last_fetched_server_page < total_pages):
+                try:
+                    extra = fetch_page_callback(last_fetched_server_page + 1)
+                    carry_forward.extend(extra.get('sessions', []))
+                    meta = extra.get('pagination_metadata', {})
+                    total_pages = meta.get('totalPages', total_pages)
+                    last_fetched_server_page += 1
+                except Exception:
+                    break
+
+        # Fill the first virtual page
+        _top_up()
+        current_page_sessions = carry_forward[:page_size]
+        del carry_forward[:page_size]
+
     else:
-        # Client-side pagination (fallback)
-        current_api_page = 0
-        total_sessions = len(sessions)
-        total_pages = (len(sessions) + page_size - 1) // page_size if len(sessions) > 0 else 1
-    show_error = None  # Track error messages to display
+        # Client-side pagination (all sessions already in memory)
+        current_api_page         = 0
+        total_sessions           = len(sessions)
+        total_pages              = (len(sessions) + page_size - 1) // page_size if sessions else 1
+        current_page_sessions    = None   # unused in client-side path
+        carry_forward            = []
+        last_fetched_server_page = 0
+        virtual_page_history     = []
+
+    virtual_page_num = 1
+    show_error = None   # Track error messages to display
+
     while True:
-        # For client-side pagination, start/end are indices into the local rows array
-        # For server-side pagination, we use the API page directly
+        # ---- Build display rows for the current virtual page ----------------
+        if fetch_page_callback and pagination_metadata:
+            page_rows = _build_rows(current_page_sessions)
+        else:
+            all_rows  = _build_rows(sessions)
+            start     = current_api_page * page_size
+            page_rows = all_rows[start:start + page_size]
+
+        # ---- Determine navigation availability ------------------------------
         if fetch_page_callback and pagination_metadata:
-            # Server-side pagination - sessions list contains current page data
-            page_rows = rows[:]  # All rows are from current page
+            has_next = bool(carry_forward) or last_fetched_server_page < total_pages
+            has_prev = bool(virtual_page_history)
         else:
-            # Client-side pagination
-            start = current_api_page * page_size
-            end = start + page_size
-            page_rows = rows[start:end]
-        # Clear console first
+            has_next = (current_api_page + 1) * page_size < len(sessions)
+            has_prev = current_api_page > 0
+        show_nav = has_next or has_prev
+
+        # ---- Render table --------------------------------------------------
         console.clear()
-        # Create table
         table = Table(title='Interactive Sessions')
-        # Add columns to table
         for col_name in columns_to_show:
             if col_name not in all_columns:
                 continue
@@ -304,100 +354,86 @@ def create_interactive_session_list_table(sessions, pagination_metadata=None, se
                 style=col_config.get('style', 'white'),
                 no_wrap=col_config.get('no_wrap', False)
             )
-        # Add rows to table
         for row in page_rows:
             table.add_row(*row)
-        # Print table
         console.print(table)
-        # Display pagination info
-        console.print(f"\n[cyan]Total sessions:[/cyan] {total_sessions}")
-        if total_pages > 1:
-            console.print(f"[cyan]Page:[/cyan] {current_api_page} of {total_pages}")
-            console.print(f"[cyan]Sessions on this page:[/cyan] {len(page_rows)}")
 
-        # Show error message if any
+        # ---- Pagination info ------------------------------------------------
+        # Sessions on this page is always the exact post-filter count.
+        # The virtual page number counts only pages with at least one session.
+        if show_nav:
+            page_display = virtual_page_num if (fetch_page_callback and pagination_metadata) else current_api_page + 1
+            console.print(f"\n[cyan]Page:[/cyan] {page_display}")
+        elif not pagination_metadata:
+            # Client-side, single page: total is exact
+            console.print(f"\n[cyan]Total sessions:[/cyan] {total_sessions}")
+        console.print(f"[cyan]Sessions on this page:[/cyan] {len(page_rows)}")
+        if fetch_page_callback and pagination_metadata:
+            console.print("[yellow]Note: total page count is not available from the CLI for interactive sessions. This feature will be ready soon.[/yellow]")
+
+        # ---- Error message --------------------------------------------------
         if show_error:
             console.print(show_error)
-            show_error = None  # Reset error after displaying
-        # Show pagination controls
-        if total_pages > 1:
-            # Check if we're in an interactive environment
+            show_error = None
+
+        # ---- Navigation controls -------------------------------------------
+        if show_nav:
             if not sys.stdin.isatty():
-                console.print("\n[yellow]Note: Pagination not available in non-interactive mode. Showing page 1 of {0}.[/yellow]".format(total_pages))
+                page_display = virtual_page_num if (fetch_page_callback and pagination_metadata) else current_api_page + 1
+                console.print(f"\n[yellow]Note: Pagination not available in non-interactive mode. Showing page {page_display}.[/yellow]")
                 console.print("[yellow]Run in an interactive terminal to navigate through all pages.[/yellow]")
                 break
             console.print(f"\n[bold cyan]n[/] = next, [bold cyan]p[/] = prev, [bold cyan]q[/] = quit")
-            # Get user input for navigation
             try:
                 choice = input(">>> ").strip().lower()
             except (EOFError, KeyboardInterrupt):
-                # Handle non-interactive environments or user interrupt
                 console.print("\n[yellow]Pagination interrupted.[/yellow]")
                 break
+
             if choice in ("q", "quit"):
                 break
+
             elif choice in ("n", "next"):
-                if current_api_page < total_pages:
-                    # Try to fetch the next page
-                    if fetch_page_callback:
-                        try:
-                            next_page_data = fetch_page_callback(current_api_page + 1)
-                            sessions = next_page_data.get('sessions', [])
-                            pagination_metadata = next_page_data.get('pagination_metadata', {})
-                            current_api_page = pagination_metadata.get('page', current_api_page + 1)
-                            total_pages = pagination_metadata.get('totalPages', total_pages)                          
-                            # Rebuild rows for the new page
-                            rows = []
-                            for session in sessions:
-                                row_data = []
-                                for col_name in columns_to_show:
-                                    if col_name not in all_columns:
-                                        continue
-                                    col_config = all_columns[col_name]
-                                    accessor = col_config['accessor']
-                                    value = _get_nested_value(session, accessor)
-                                    formatted_value = _format_session_field(col_name, value)
-                                    row_data.append(formatted_value)
-                                rows.append(row_data)
-                        except Exception as e:
-                            show_error = f"[red]Error fetching next page: {str(e)}[/red]"
+                if fetch_page_callback and pagination_metadata:
+                    if carry_forward or last_fetched_server_page < total_pages:
+                        virtual_page_history.append(current_page_sessions[:])
+                        _top_up()
+                        if carry_forward:
+                            current_page_sessions = carry_forward[:page_size]
+                            del carry_forward[:page_size]
+                            virtual_page_num += 1
+                        else:
+                            virtual_page_history.pop()
+                            show_error = "[yellow]No more sessions found.[/yellow]"
                     else:
-                        current_api_page += 1
+                        show_error = "[red]Already on the last page.[/red]"
                 else:
-                    show_error = "[red]Invalid choice. Already on the last page.[/red]"
+                    if has_next:
+                        current_api_page += 1
+                    else:
+                        show_error = "[red]Already on the last page.[/red]"
+
             elif choice in ("p", "prev"):
-                if current_api_page > 1:
-                    # Try to fetch the previous page
-                    if fetch_page_callback:
-                        try:
-                            prev_page_data = fetch_page_callback(current_api_page - 1)
-                            sessions = prev_page_data.get('sessions', [])
-                            pagination_metadata = prev_page_data.get('pagination_metadata', {})
-                            current_api_page = pagination_metadata.get('page', current_api_page - 1)
-                            total_pages = pagination_metadata.get('totalPages', total_pages)
-                            # Rebuild rows for the new page
-                            rows = []
-                            for session in sessions:
-                                row_data = []
-                                for col_name in columns_to_show:
-                                    if col_name not in all_columns:
-                                        continue
-                                    col_config = all_columns[col_name]
-                                    accessor = col_config['accessor']
-                                    value = _get_nested_value(session, accessor)
-                                    formatted_value = _format_session_field(col_name, value)
-                                    row_data.append(formatted_value)
-                                rows.append(row_data)
-                        except Exception as e:
-                            show_error = f"[red]Error fetching previous page: {str(e)}[/red]"
+                if fetch_page_callback and pagination_metadata:
+                    if virtual_page_history:
+                        # Return current sessions to the front of carry_forward,
+                        # then restore the previous virtual page from history.
+                        carry_forward[:0] = current_page_sessions
+                        current_page_sessions = virtual_page_history.pop()
+                        virtual_page_num -= 1
                     else:
-                        current_api_page -= 1
+                        show_error = "[red]Already on the first page.[/red]"
                 else:
-                    show_error = "[red]Invalid choice. Already on the first page.[/red]"
+                    if has_prev:
+                        current_api_page -= 1
+                    else:
+                        show_error = "[red]Already on the first page.[/red]"
+
             else:
                 show_error = "[red]Invalid choice. Please enter 'n' (next), 'p' (prev), or 'q' (quit).[/red]"
+
         else:
-            # Only one page, no need for input, just exit
+            # Single page or no sessions left — nothing to navigate
             break
 
 
@@ -1851,3 +1887,48 @@ def fetch_interactive_session_page(cl, workspace_id, page_num, limit, filter_sta
         include_archived=archived,
         verify=verify_ssl
     )
+
+
+def build_app_filtered_page_fetcher(cl, workspace_id, limit, filter_status, filter_only_mine, archived, verify_ssl):
+    """Return a page-fetch callback that strips app-type sessions from each page.
+
+    The returned callable is intended for use as the ``fetch_page_callback``
+    argument of :func:`create_interactive_session_list_table`.  It fetches a
+    page via :func:`fetch_interactive_session_page` and removes any session
+    whose ``interactiveSessionType`` belongs to :data:`APP_SESSION_TYPES`
+    before returning, ensuring app sessions never appear in the interactive
+    table even when the user navigates to subsequent pages.
+
+    Parameters
+    ----------
+    cl : Cloudos
+        API client instance.
+    workspace_id : str
+        Team/workspace identifier.
+    limit : int
+        Page size.
+    filter_status : tuple or None
+        Status values to pass to the API filter.
+    filter_only_mine : bool
+        Restrict results to the authenticated user's sessions.
+    archived : bool
+        Include archived sessions.
+    verify_ssl : bool or str
+        SSL verification setting.
+
+    Returns
+    -------
+    callable
+        A function ``fetch_page(page_num: int) -> dict`` that returns the API
+        response dict with app sessions already removed from ``"sessions"``.
+    """
+    def fetch_page(page_num):
+        page_result = fetch_interactive_session_page(
+            cl, workspace_id, page_num, limit, filter_status, filter_only_mine, archived, verify_ssl
+        )
+        page_result['sessions'] = [
+            s for s in page_result.get('sessions', [])
+            if s.get('interactiveSessionType') not in APP_SESSION_TYPES
+        ]
+        return page_result
+    return fetch_page

{cloudos_cli-2.93.0 → cloudos_cli-2.93.1}/cloudos_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudos_cli
-Version: 2.93.0
+Version: 2.93.1
 Summary: Python package for interacting with the Lifebit Platform
 Home-page: https://github.com/lifebit-ai/cloudos-cli
 Author: David Piñeyro

{cloudos_cli-2.93.0 → cloudos_cli-2.93.1}/tests/test_interactive_session/test_list_sessions.py

@@ -245,6 +245,155 @@ class TestInteractiveSessionAPIMethod:
             cl.get_interactive_session_list('test_team', limit=150)
 
 
+class TestAppSessionFilter:
+    """Tests for client-side app-session filtering."""
+
+    @patch('cloudos_cli.interactive_session.cli.Cloudos')
+    @patch('cloudos_cli.configure.configure.ConfigurationProfile.load_profile_and_validate_data')
+    def test_app_sessions_are_filtered_out(self, mock_config, mock_cloudos):
+        """list_sessions CLI must exclude awsCustomSession and azureCustomSession from its output."""
+        runner = CliRunner()
+        mock_config.return_value = {}
+        mock_cloudos_instance = mock.MagicMock()
+        mock_cloudos.return_value = mock_cloudos_instance
+        mock_cloudos_instance.get_interactive_session_list.return_value = {
+            'sessions': [
+                {'_id': 'aaa', 'name': 'Jupyter', 'status': 'running',
+                 'interactiveSessionType': 'awsJupyterNotebook',
+                 'resources': {'instanceType': 'c5.xlarge'}, 'totalCostInUsd': 0.0},
+                {'_id': 'bbb', 'name': 'MyApp', 'status': 'running',
+                 'interactiveSessionType': 'awsCustomSession',
+                 'resources': {'instanceType': 'c5.xlarge'}, 'totalCostInUsd': 0.0},
+                {'_id': 'ccc', 'name': 'AzureApp', 'status': 'running',
+                 'interactiveSessionType': 'azureCustomSession',
+                 'resources': {'instanceType': 'c5.xlarge'}, 'totalCostInUsd': 0.0},
+            ],
+            'pagination_metadata': {'count': 3, 'page': 1, 'limit': 10, 'totalPages': 1}
+        }
+
+        with runner.isolated_filesystem():
+            result = runner.invoke(run_cloudos_cli, [
+                'interactive-session', 'list',
+                '--apikey', 'test_key',
+                '--cloudos-url', 'http://test.com',
+                '--workspace-id', 'test_team',
+                '--output-format', 'json',
+            ])
+
+            assert result.exit_code == 0, result.output
+            with open('interactive_sessions_list.json') as f:
+                saved_sessions = json.load(f)
+
+        saved_ids = {s['_id'] for s in saved_sessions}
+        assert 'aaa' in saved_ids, "Regular session must be kept"
+        assert 'bbb' not in saved_ids, "awsCustomSession must be filtered out"
+        assert 'ccc' not in saved_ids, "azureCustomSession must be filtered out"
+        assert len(saved_sessions) == 1
+
+    def test_app_session_types_constant_contains_expected_values(self):
+        """APP_SESSION_TYPES must contain exactly the two app session type strings."""
+        from cloudos_cli.interactive_session.interactive_session import APP_SESSION_TYPES
+
+        assert len(APP_SESSION_TYPES) == 2, (
+            f"APP_SESSION_TYPES must have exactly 2 entries, got {len(APP_SESSION_TYPES)}: {APP_SESSION_TYPES}"
+        )
+        assert 'awsCustomSession' in APP_SESSION_TYPES
+        assert 'azureCustomSession' in APP_SESSION_TYPES
+
+    def test_regular_sessions_not_filtered(self):
+        """Regular session types must pass through the filter unchanged."""
+        from cloudos_cli.interactive_session.interactive_session import APP_SESSION_TYPES
+
+        regular_types = [
+            'awsJupyterNotebook', 'azureJupyterNotebook',
+            'awsVSCode', 'azureVSCode',
+            'awsRstudio', 'azureRstudio',
+            'awsSpark', 'awsWindowsSession',
+        ]
+        for t in regular_types:
+            assert t not in APP_SESSION_TYPES, f"{t} should not be filtered out"
+
+
+class TestBuildAppFilteredPageFetcher:
+    """Tests for build_app_filtered_page_fetcher, the factory used as fetch_page_callback."""
+
+    @patch('cloudos_cli.interactive_session.interactive_session.fetch_interactive_session_page')
+    def test_filters_app_sessions_from_page(self, mock_fetch):
+        """App sessions must be removed from the returned sessions list."""
+        from cloudos_cli.interactive_session.interactive_session import build_app_filtered_page_fetcher
+        from unittest.mock import MagicMock
+
+        mock_fetch.return_value = {
+            'sessions': [
+                {'_id': 'aaa', 'interactiveSessionType': 'awsJupyterNotebook'},
+                {'_id': 'bbb', 'interactiveSessionType': 'awsCustomSession'},
+                {'_id': 'ccc', 'interactiveSessionType': 'azureCustomSession'},
+            ],
+            'pagination_metadata': {'count': 3, 'page': 2, 'totalPages': 3}
+        }
+
+        cl = MagicMock()
+        fetcher = build_app_filtered_page_fetcher(cl, 'ws1', 10, None, False, False, True)
+        result = fetcher(2)
+
+        mock_fetch.assert_called_once_with(cl, 'ws1', 2, 10, None, False, False, True)
+        returned_ids = {s['_id'] for s in result['sessions']}
+        assert 'aaa' in returned_ids, "Regular session must be kept"
+        assert 'bbb' not in returned_ids, "awsCustomSession must be filtered"
+        assert 'ccc' not in returned_ids, "azureCustomSession must be filtered"
+
+    @patch('cloudos_cli.interactive_session.interactive_session.fetch_interactive_session_page')
+    def test_passes_all_params_to_api(self, mock_fetch):
+        """Factory closure must forward every captured parameter to fetch_interactive_session_page."""
+        from cloudos_cli.interactive_session.interactive_session import build_app_filtered_page_fetcher
+        from unittest.mock import MagicMock
+
+        mock_fetch.return_value = {'sessions': [], 'pagination_metadata': {}}
+
+        cl = MagicMock()
+        fetcher = build_app_filtered_page_fetcher(cl, 'ws1', 20, ('running',), True, False, True)
+        fetcher(5)
+
+        mock_fetch.assert_called_once_with(cl, 'ws1', 5, 20, ('running',), True, False, True)
+
+    @patch('cloudos_cli.interactive_session.interactive_session.fetch_interactive_session_page')
+    def test_keeps_all_regular_sessions(self, mock_fetch):
+        """Non-app session types must be returned unchanged."""
+        from cloudos_cli.interactive_session.interactive_session import build_app_filtered_page_fetcher
+        from unittest.mock import MagicMock
+
+        regular_sessions = [
+            {'_id': 'j1', 'interactiveSessionType': 'awsJupyterNotebook'},
+            {'_id': 'v1', 'interactiveSessionType': 'awsVSCode'},
+            {'_id': 'r1', 'interactiveSessionType': 'awsRstudio'},
+        ]
+        mock_fetch.return_value = {
+            'sessions': regular_sessions,
+            'pagination_metadata': {'count': 3, 'page': 1, 'totalPages': 1}
+        }
+
+        cl = MagicMock()
+        fetcher = build_app_filtered_page_fetcher(cl, 'ws1', 10, None, False, False, True)
+        result = fetcher(1)
+
+        assert len(result['sessions']) == 3
+
+    @patch('cloudos_cli.interactive_session.interactive_session.fetch_interactive_session_page')
+    def test_pagination_metadata_preserved(self, mock_fetch):
+        """pagination_metadata from the API response must be returned intact."""
+        from cloudos_cli.interactive_session.interactive_session import build_app_filtered_page_fetcher
+        from unittest.mock import MagicMock
+
+        expected_meta = {'count': 10, 'page': 3, 'totalPages': 5}
+        mock_fetch.return_value = {'sessions': [], 'pagination_metadata': expected_meta}
+
+        cl = MagicMock()
+        fetcher = build_app_filtered_page_fetcher(cl, 'ws1', 10, None, False, False, True)
+        result = fetcher(3)
+
+        assert result['pagination_metadata'] == expected_meta
+
+
 if __name__ == '__main__':
     pytest.main([__file__, '-v'])
 

cloudos_cli-2.93.0/cloudos_cli/_version.py

@@ -1 +0,0 @@
-__version__ = '2.93.0'