dnastack-client-library 3.1.138__py3-none-any.whl → 3.1.144__py3-none-any.whl

dnastack/__init__.py

@@ -1,5 +1,5 @@
-from dnastack.client.collections.client import CollectionServiceClient
-from dnastack.client.data_connect import DataConnectClient
-from dnastack.client.drs import DrsClient
-from dnastack.client.models import ServiceEndpoint
-from dnastack.context.helper import use
+from dnastack.client.collections.client import CollectionServiceClient  # noqa: F401
+from dnastack.client.data_connect import DataConnectClient  # noqa: F401
+from dnastack.client.drs import DrsClient  # noqa: F401
+from dnastack.client.models import ServiceEndpoint  # noqa: F401
+from dnastack.context.helper import use  # noqa: F401

dnastack/__main__.py

@@ -10,6 +10,7 @@ from dnastack.cli.commands.config import config_command_group
 from dnastack.cli.commands.config.contexts import contexts_command_group, ContextCommandHandler
 from dnastack.cli.commands.dataconnect import data_connect_command_group
 from dnastack.cli.commands.drs import drs_command_group
+from dnastack.cli.commands.explorer.commands import explorer_command_group
 from dnastack.cli.commands.publisher import publisher_command_group
 from dnastack.cli.commands.workbench import workbench_command_group
 from dnastack.cli.core.command import formatted_command
@@ -106,6 +107,9 @@ dnastack.add_command(publisher_command_group)
 # noinspection PyTypeChecker
 dnastack.add_command(workbench_command_group)
 
+# noinspection PyTypeChecker
+dnastack.add_command(explorer_command_group)
+
 
 if __name__ == "__main__":
     dnastack.main(prog_name=APP_NAME)

dnastack/alpha/app/workbench.py

@@ -171,7 +171,7 @@ class Workbench:
 			if not r.has_failed() and not r.was_canceled():
 				try:
 					self.cancel_run(run_status.run_id)
-				except Exception as rex:
+				except Exception:
 					bad_run_ids.append(run_status.run_id)
 		if(len(bad_run_ids) > 0):
 			raise WorkbenchRunException("Could not cancel all runs in batch "+batch_id+".  Run IDs: "+"\n".join(bad_run_ids), run_ids=bad_run_ids)
@@ -196,10 +196,10 @@ class Workbench:
 			if this_runs_state.has_failed():
 				batch_error_message = batch_error_message + "\nRun {run_id} failed with status {run_state}".format(run_id=run.run_id, run_state=run.state)
 			elif this_runs_state.was_canceled():
-				batch_error_message = batch_error_message + "\nRun {run_id} was canceled".format(run_id=run.run_id, run_state=run.state)
+				batch_error_message = batch_error_message + "\nRun {run_id} was canceled".format(run_id=run.run_id, )
 			elif batch_error_message == "":
 				if current_unanimous_state is None:
-					current_unanimous_state = RunStatus(run.state);
+					current_unanimous_state = RunStatus(run.state)
 				elif current_unanimous_state != this_runs_state:
 					current_unanimous_state = RunStatus.UNKNOWN
 
@@ -315,7 +315,6 @@ class Workbench:
 		for task_log in run.task_logs:
 			if task_log.name == task_name:
 				return self.stream_task_log(run_id=run, task_id=task_log.task_id, log_type=log_type, max_bytes=max_bytes)
-				return self._get_ewes_client().stream_task_logs(run_id=run, task_id=task_log.task_id, log_type=logtype, max_bytes=max_bytes)
 
 	def stream_task_log(self, run: Union[ExtendedRun, str], task_id: str, log_type: LogType, max_bytes: Optional[int] = None) -> Iterable[bytes]:
 		return self._get_ewes_client().stream_task_logs(run_id=run, task_id=task_id, log_type=log_type, max_bytes=max_bytes)

dnastack/alpha/client/wes/client.py

@@ -313,12 +313,12 @@ class WesClient(BaseServiceClient):
 
     def get_service_info(self):
         with self.create_http_session() as session:
-            response = session.get(urljoin(self.endpoint.url, f'service-info'))
+            response = session.get(urljoin(self.endpoint.url, 'service-info'))
             return response.json()
 
     def get_runs(self, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[_Run]:
         # GET /runs
-        return ResultIterator(RunListLoader(initial_url=urljoin(self.endpoint.url, f'runs'),
+        return ResultIterator(RunListLoader(initial_url=urljoin(self.endpoint.url, 'runs'),
                                             page_size=page_size,
                                             page_token=page_token,
                                             http_session=self.create_http_session()))

dnastack/cli/commands/config/endpoints.py

@@ -470,7 +470,7 @@ class EndpointCommandHandler:
 
                 node = e.parent or obj
 
-                self.__logger.debug(f'__repair_path: LOOP: ***** Broken Path Detected *****')
+                self.__logger.debug('__repair_path: LOOP: ***** Broken Path Detected *****')
                 self.__logger.debug(f'__repair_path: LOOP: type(e.parent) => {type(e.parent).__name__}')
                 self.__logger.debug(f'__repair_path: LOOP: e.parent => {e.parent}')
                 self.__logger.debug(f'__repair_path: LOOP: last_visited_node => {last_visited_node}')
@@ -478,10 +478,10 @@ class EndpointCommandHandler:
                 annotation = node.__annotations__[last_visited_node]
 
                 if hasattr(node, last_visited_node) and getattr(node, last_visited_node):
-                    self.__logger.debug(f'__repair_path: LOOP: No repair')
+                    self.__logger.debug('__repair_path: LOOP: No repair')
                 elif str(annotation).startswith('typing.Union[') or str(annotation).startswith("typing.Optional["):
                     # Dealing with Union/Optional
-                    self.__logger.debug(f'__repair_path: LOOP: Handling union and optional')
+                    self.__logger.debug('__repair_path: LOOP: Handling union and optional')
                     self.__logger.debug(f'__repair_path: LOOP: annotation.__args__ => {annotation.__args__}')
                     self.__initialize_default_value(node, last_visited_node, annotation.__args__[0])
                 else:
@@ -512,11 +512,11 @@ class EndpointCommandHandler:
             setattr(node, property_name, annotation())
 
     def __get_place_holder(self, cls):
-        if cls == str:
+        if cls is str:
             return ''
-        elif cls == int or cls == float:
+        elif cls is int or cls is float:
             return 0
-        elif cls == bool:
+        elif cls is bool:
             return False
         else:
             raise NotImplementedError(cls)
@@ -592,7 +592,7 @@ class EndpointCommandHandler:
                 while ref_path:
                     property_name = ref_path.pop(0)
                     local_reference = local_reference[property_name]
-            except KeyError as e:
+            except KeyError:
                 raise RuntimeError(f'The reference {reference_url} for the configuration is undefined.')
             return self.__resolve_json_reference(local_reference, root)
 

dnastack/cli/commands/explorer/commands.py

@@ -0,0 +1,21 @@
+from dnastack.cli.commands.explorer.questions.commands import init_questions_commands
+from dnastack.cli.core.group import formatted_group
+
+
+@formatted_group("explorer")
+def explorer_command_group():
+    """Commands for working with Explorer federated questions"""
+    pass
+
+
+@formatted_group("questions")
+def questions_command_group():
+    """Commands for working with federated questions"""
+    pass
+
+
+# Initialize questions subcommands
+init_questions_commands(questions_command_group)
+
+# Register questions group under explorer
+explorer_command_group.add_command(questions_command_group)

dnastack/cli/commands/explorer/questions/commands.py

@@ -0,0 +1,168 @@
+from typing import Optional
+
+import click
+from click import Group
+
+from dnastack.cli.commands.explorer.questions.utils import (
+    get_explorer_client,
+    parse_collections_argument,
+    validate_question_parameters,
+    handle_question_results_output
+)
+from dnastack.cli.core.command import formatted_command
+from dnastack.cli.core.command_spec import ArgumentSpec, CONTEXT_ARG, SINGLE_ENDPOINT_ID_ARG, ArgumentType, RESOURCE_OUTPUT_ARG, DATA_OUTPUT_ARG
+from dnastack.cli.helpers.iterator_printer import show_iterator
+from dnastack.common.json_argument_parser import JsonLike, parse_and_merge_arguments
+from dnastack.common.logger import get_logger
+from dnastack.common.tracing import Span
+
+logger = get_logger(__name__)
+
+
+def init_questions_commands(group: Group):
+    @formatted_command(
+        group=group,
+        name='list',
+        specs=[
+            RESOURCE_OUTPUT_ARG,
+            CONTEXT_ARG,
+            SINGLE_ENDPOINT_ID_ARG,
+        ]
+    )
+    def list_questions(output: str, context: Optional[str], endpoint_id: Optional[str]):
+        """List all available federated questions"""
+        trace = Span()
+        client = get_explorer_client(context=context, endpoint_id=endpoint_id, trace=trace)
+        questions_iter = client.list_federated_questions(trace=trace)
+        
+        # Convert to list and pass to show_iterator
+        questions = list(questions_iter)
+        
+        # For JSON/YAML output, show the raw question objects
+        # No need for table formatting as show_iterator handles it
+        show_iterator(
+            output_format=output,
+            iterator=questions,
+            transform=lambda q: q.dict()
+        )
+
+    @formatted_command(
+        group=group,
+        name='describe',
+        specs=[
+            ArgumentSpec(
+                name='question_id',
+                arg_type=ArgumentType.POSITIONAL,
+                help='The ID of the question to describe',
+                required=True
+            ),
+            RESOURCE_OUTPUT_ARG,
+            CONTEXT_ARG,
+            SINGLE_ENDPOINT_ID_ARG,
+        ]
+    )
+    def describe_question(question_id: str, output: str, context: Optional[str], endpoint_id: Optional[str]):
+        """Get detailed information about a federated question"""
+        trace = Span()
+        client = get_explorer_client(context=context, endpoint_id=endpoint_id, trace=trace)
+        question = client.describe_federated_question(question_id, trace=trace)
+        
+        # Use show_iterator for consistent output handling
+        show_iterator(
+            output_format=output,
+            iterator=[question],  # Single item as list
+            transform=lambda q: q.dict()
+        )
+
+    @formatted_command(
+        group=group,
+        name='ask',
+        specs=[
+            ArgumentSpec(
+                name='question_name',
+                arg_names=['--question-name'],
+                help='The name/ID of the question to ask',
+                required=True
+            ),
+            ArgumentSpec(
+                name='args',
+                arg_names=['--param'],
+                help='Question parameters in key=value format (can be used multiple times)',
+                type=JsonLike,
+                multiple=True
+            ),
+            ArgumentSpec(
+                name='collections',
+                arg_names=['--collections'],
+                help='Comma-separated list of collection IDs to query (default: all collections for the question)'
+            ),
+            ArgumentSpec(
+                name='output_file',
+                arg_names=['--output-file'],
+                help='Output file path for results'
+            ),
+            DATA_OUTPUT_ARG,
+            CONTEXT_ARG,
+            SINGLE_ENDPOINT_ID_ARG,
+        ]
+    )
+    def ask_question(
+        question_name: str,
+        args: tuple,
+        collections: Optional[str],
+        output_file: Optional[str],
+        output: str,
+        context: Optional[str],
+        endpoint_id: Optional[str]
+    ):
+        """Ask a federated question with the provided parameters"""
+        trace = Span()
+        client = get_explorer_client(context=context, endpoint_id=endpoint_id, trace=trace)
+        
+        # Parse collections if provided
+        collection_ids = parse_collections_argument(collections)
+        
+        # Parse arguments
+        inputs = {}
+        if args:
+            # When multiple=True with JsonLike, we get a tuple of JsonLike objects
+            if isinstance(args, tuple):
+                for arg in args:
+                    parsed_args = arg.parsed_value() if hasattr(arg, 'parsed_value') else parse_and_merge_arguments(arg)
+                    inputs.update(parsed_args)
+            else:
+                # Single JsonLike object
+                parsed_args = args.parsed_value() if hasattr(args, 'parsed_value') else parse_and_merge_arguments(args)
+                inputs.update(parsed_args)
+        
+        # Get question details for validation
+        question = client.describe_federated_question(question_name, trace=trace)
+        
+        # Validate parameters
+        try:
+            inputs = validate_question_parameters(inputs, question)
+        except ValueError as e:
+            click.echo(f"Error: {e}", err=True)
+            raise click.Abort()
+        
+        if collection_ids is not None:
+            # Validate collection IDs exist in question
+            available_ids = {col.id for col in question.collections}
+            invalid_ids = [cid for cid in collection_ids if cid not in available_ids]
+            if invalid_ids:
+                click.echo(f"Error: Invalid collection IDs for this question: {', '.join(invalid_ids)}", err=True)
+                raise click.Abort()
+        
+        # Execute the question
+        results_iter = client.ask_federated_question(
+            question_id=question_name,
+            inputs=inputs,
+            collections=collection_ids,
+            trace=trace
+        )
+        
+        # Collect results
+        results = list(results_iter)
+        
+        # Output results
+        handle_question_results_output(results, output_file, output)

dnastack/cli/commands/explorer/questions/tables.py

@@ -0,0 +1,142 @@
+from typing import List, Dict, Any
+from dnastack.client.explorer.models import FederatedQuestion
+
+
+def format_question_list_table(questions: List[FederatedQuestion]) -> List[Dict[str, Any]]:
+    """
+    Format a list of federated questions for table display.
+    
+    Args:
+        questions: List of FederatedQuestion objects
+        
+    Returns:
+        List[Dict[str, Any]]: Formatted table data
+    """
+    table_data = []
+    
+    for question in questions:
+        row = {
+            'ID': question.id,
+            'Name': question.name,
+            'Description': question.description,
+            'Parameters': len(question.params),
+            'Collections': len(question.collections),
+            'Required Params': len([p for p in question.params if p.required])
+        }
+        table_data.append(row)
+    
+    return table_data
+
+
+def format_question_detail_table(question: FederatedQuestion) -> Dict[str, Any]:
+    """
+    Format a single federated question for detailed display.
+    
+    Args:
+        question: FederatedQuestion object
+        
+    Returns:
+        Dict[str, Any]: Formatted question details
+    """
+    # Format parameters
+    params_info = []
+    for param in question.params:
+        param_info = {
+            'Name': param.name,
+            'Type': param.input_type,
+            'Required': 'Yes' if param.required else 'No',
+            'Description': param.description or '',
+            'Default': param.default_value or ''
+        }
+        
+        # Add dropdown values if available
+        if param.values and param.input_subtype == "DROPDOWN":
+            values_list = param.values.split('\n')
+            param_info['Choices'] = ', '.join(values_list[:3]) + ('...' if len(values_list) > 3 else '')
+        
+        params_info.append(param_info)
+    
+    # Format collections
+    collections_info = []
+    for col in question.collections:
+        col_info = {
+            'ID': col.id,
+            'Name': col.name,
+            'Slug': col.slug,
+            'Question ID': col.question_id
+        }
+        collections_info.append(col_info)
+    
+    return {
+        'question': {
+            'ID': question.id,
+            'Name': question.name,
+            'Description': question.description
+        },
+        'parameters': params_info,
+        'collections': collections_info
+    }
+
+
+def format_question_results_table(results: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Format question query results for table display.
+    
+    Args:
+        results: List of result dictionaries
+        
+    Returns:
+        List[Dict[str, Any]]: Formatted table data
+    """
+    if not results:
+        return []
+    
+    # For complex nested results, we'll flatten them
+    formatted_results = []
+    
+    for result in results:
+        # If result is already flat, use as-is
+        if all(not isinstance(v, (dict, list)) for v in result.values()):
+            formatted_results.append(result)
+        else:
+            # Flatten complex nested structures
+            flattened = _flatten_dict(result)
+            formatted_results.append(flattened)
+    
+    return formatted_results
+
+
+def _flatten_dict(d: Dict[str, Any], parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
+    """
+    Flatten a nested dictionary.
+    
+    Args:
+        d: Dictionary to flatten
+        parent_key: Parent key prefix
+        sep: Separator for nested keys
+        
+    Returns:
+        Dict[str, Any]: Flattened dictionary
+    """
+    items = []
+    
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        
+        if isinstance(v, dict):
+            items.extend(_flatten_dict(v, new_key, sep=sep).items())
+        elif isinstance(v, list):
+            if v and isinstance(v[0], dict):
+                # For lists of dicts, create separate entries
+                for i, item in enumerate(v):
+                    if isinstance(item, dict):
+                        items.extend(_flatten_dict(item, f"{new_key}[{i}]", sep=sep).items())
+                    else:
+                        items.append((f"{new_key}[{i}]", item))
+            else:
+                # For simple lists, join with commas
+                items.append((new_key, ', '.join(str(x) for x in v)))
+        else:
+            items.append((new_key, v))
+    
+    return dict(items)