better names for commands

Author: samuelcolvin

pydantic_ai_slim/pydantic_ai/_agent_graph.py

@@ -608,7 +608,7 @@ async def process_function_tools(  # noqa C901
         elif mcp_tool := await _tool_from_mcp_server(call.tool_name, ctx):
             if stub_function_tools:
                 # TODO(Marcelo): We should add coverage for this part of the code.
-                output_parts.append(  # pragma: not covered
+                output_parts.append(  # pragma: no cover
                     _messages.ToolReturnPart(
                         tool_name=call.tool_name,
                         content='Tool not executed - a final result was already processed.',
@@ -730,7 +730,7 @@ async def _tool_from_mcp_server(
     async def run_tool(ctx: RunContext[DepsT], **args: Any) -> Any:
         # There's no normal situation where the server will not be running at this point, we check just in case
         # some weird edge case occurs.
-        if not server.is_running:  # pragma: not covered
+        if not server.is_running:  # pragma: no cover
             raise exceptions.UserError(f'MCP server is not running: {server}')
         result = await server.call_tool(tool_name, args)
         return result

pydantic_ai_slim/pydantic_ai/_cli.py

@@ -165,7 +165,7 @@ def cli(args_list: Sequence[str] | None = None) -> int:
     session: PromptSession[Any] = PromptSession(history=FileHistory(str(history)))
     try:
         return asyncio.run(run_chat(session, stream, cli_agent, console, code_theme))
-    except KeyboardInterrupt:  # pragma: not covered
+    except KeyboardInterrupt:  # pragma: no cover
         return 0
 
 
@@ -177,7 +177,7 @@ async def run_chat(session: PromptSession[Any], stream: bool, agent: Agent, cons
         try:
             auto_suggest = CustomAutoSuggest(['/markdown', '/multiline', '/exit'])
             text = await session.prompt_async('pai ➤ ', auto_suggest=auto_suggest, multiline=multiline)
-        except (KeyboardInterrupt, EOFError):  # pragma: not covered
+        except (KeyboardInterrupt, EOFError):  # pragma: no cover
             return 0
 
         if not text.strip():
@@ -191,7 +191,7 @@ async def run_chat(session: PromptSession[Any], stream: bool, agent: Agent, cons
         else:
             try:
                 messages = await ask_agent(agent, text, stream, console, code_theme, messages)
-            except CancelledError:  # pragma: not covered
+            except CancelledError:  # pragma: no cover
                 console.print('[dim]Interrupted[/dim]')
 
 
@@ -233,7 +233,7 @@ def __init__(self, special_suggestions: list[str] | None = None):
         super().__init__()
         self.special_suggestions = special_suggestions or []
 
-    def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:  # pragma: not covered
+    def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:  # pragma: no cover
         # Get the suggestion from history
         suggestion = super().get_suggestion(buffer, document)
 
@@ -284,5 +284,5 @@ def handle_slash_command(
     return None, multiline
 
 
-def app():  # pragma: not covered
+def app():  # pragma: no cover
     sys.exit(cli())

pydantic_ai_slim/pydantic_ai/_utils.py

@@ -182,7 +182,7 @@ async def async_iter_groups() -> AsyncIterator[list[T]]:
 
     try:
         yield async_iter_groups()
-    finally:  # pragma: not covered
+    finally:  # pragma: no cover
         # after iteration if a tasks still exists, cancel it, this will only happen if an error occurred
         if task:
             task.cancel('Cancelling due to error in iterator')

pydantic_ai_slim/pydantic_ai/agent.py

@@ -269,7 +269,7 @@ def __init__(
         self.name = name
         self.model_settings = model_settings
 
-        if 'result_type' in _deprecated_kwargs:  # pragma: not covered
+        if 'result_type' in _deprecated_kwargs:  # pragma: no cover
             if output_type is not str:
                 raise TypeError('`result_type` and `output_type` cannot be set at the same time.')
             warnings.warn('`result_type` is deprecated, use `output_type` instead', DeprecationWarning)
@@ -282,20 +282,20 @@ def __init__(
         self._deps_type = deps_type
 
         self._deprecated_result_tool_name = _deprecated_kwargs.get('result_tool_name')
-        if self._deprecated_result_tool_name is not None:  # pragma: not covered
+        if self._deprecated_result_tool_name is not None:  # pragma: no cover
             warnings.warn(
                 '`result_tool_name` is deprecated, use `output_type` with `ToolOutput` instead',
                 DeprecationWarning,
             )
 
         self._deprecated_result_tool_description = _deprecated_kwargs.get('result_tool_description')
-        if self._deprecated_result_tool_description is not None:  # pragma: not covered
+        if self._deprecated_result_tool_description is not None:  # pragma: no cover
             warnings.warn(
                 '`result_tool_description` is deprecated, use `output_type` with `ToolOutput` instead',
                 DeprecationWarning,
             )
         result_retries = _deprecated_kwargs.get('result_retries')
-        if result_retries is not None:  # pragma: not covered
+        if result_retries is not None:  # pragma: no cover
             if output_retries is not None:
                 raise TypeError('`output_retries` and `result_retries` cannot be set at the same time.')
             warnings.warn('`result_retries` is deprecated, use `max_result_retries` instead', DeprecationWarning)
@@ -432,7 +432,7 @@ async def main():
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
 
-        if 'result_type' in _deprecated_kwargs:  # pragma: not covered
+        if 'result_type' in _deprecated_kwargs:  # pragma: no cover
             if output_type is not str:
                 raise TypeError('`result_type` and `output_type` cannot be set at the same time.')
             warnings.warn('`result_type` is deprecated, use `output_type` instead.', DeprecationWarning)
@@ -583,7 +583,7 @@ async def main():
         model_used = self._get_model(model)
         del model
 
-        if 'result_type' in _deprecated_kwargs:  # pragma: not covered
+        if 'result_type' in _deprecated_kwargs:  # pragma: no cover
             if output_type is not str:
                 raise TypeError('`result_type` and `output_type` cannot be set at the same time.')
             warnings.warn('`result_type` is deprecated, use `output_type` instead.', DeprecationWarning)
@@ -810,7 +810,7 @@ def run_sync(
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
 
-        if 'result_type' in _deprecated_kwargs:  # pragma: not covered
+        if 'result_type' in _deprecated_kwargs:  # pragma: no cover
             if output_type is not str:
                 raise TypeError('`result_type` and `output_type` cannot be set at the same time.')
             warnings.warn('`result_type` is deprecated, use `output_type` instead.', DeprecationWarning)
@@ -926,7 +926,7 @@ async def main():
             if frame := inspect.currentframe():  # pragma: no branch
                 self._infer_name(frame.f_back)
 
-        if 'result_type' in _deprecated_kwargs:  # pragma: not covered
+        if 'result_type' in _deprecated_kwargs:  # pragma: no cover
             if output_type is not str:
                 raise TypeError('`result_type` and `output_type` cannot be set at the same time.')
             warnings.warn('`result_type` is deprecated, use `output_type` instead.', DeprecationWarning)
@@ -1741,7 +1741,7 @@ def _traceparent(self, *, required: Literal[False]) -> str | None: ...
     def _traceparent(self) -> str: ...
     def _traceparent(self, *, required: bool = True) -> str | None:
         traceparent = self._graph_run._traceparent(required=False)  # type: ignore[reportPrivateUsage]
-        if traceparent is None and required:  # pragma: not covered
+        if traceparent is None and required:  # pragma: no cover
             raise AttributeError('No span was created for this agent run')
         return traceparent
 
@@ -1765,7 +1765,7 @@ def next_node(
             return next_node
         if _agent_graph.is_agent_node(next_node):
             return next_node
-        raise exceptions.AgentRunError(f'Unexpected node type: {type(next_node)}')  # pragma: not covered
+        raise exceptions.AgentRunError(f'Unexpected node type: {type(next_node)}')  # pragma: no cover
 
     @property
     def result(self) -> AgentRunResult[OutputDataT] | None:
@@ -1907,7 +1907,7 @@ def _traceparent(self, *, required: Literal[False]) -> str | None: ...
     @overload
     def _traceparent(self) -> str: ...
     def _traceparent(self, *, required: bool = True) -> str | None:
-        if self._traceparent_value is None and required:  # pragma: not covered
+        if self._traceparent_value is None and required:  # pragma: no cover
             raise AttributeError('No span was created for this agent run')
         return self._traceparent_value
 

pydantic_ai_slim/pydantic_ai/mcp.py

@@ -308,7 +308,7 @@ async def client_streams(
         self,
     ) -> AsyncIterator[
         tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
-    ]:  # pragma: not covered
+    ]:  # pragma: no cover
         async with sse_client(
             url=self.url, headers=self.headers, timeout=self.timeout, sse_read_timeout=self.sse_read_timeout
         ) as (read_stream, write_stream):

pydantic_ai_slim/pydantic_ai/messages.py

@@ -81,7 +81,7 @@ class VideoUrl:
     """Type identifier, this is available on all parts as a discriminator."""
 
     @property
-    def media_type(self) -> VideoMediaType:  # pragma: no cover
+    def media_type(self) -> VideoMediaType:  # pragma: lax no cover
         """Return the media type of the video, based on the url."""
         if self.url.endswith('.mkv'):
             return 'video/x-matroska'
@@ -308,7 +308,7 @@ def _video_format(media_type: str) -> VideoFormat:
         return 'wmv'
     elif media_type == 'video/3gpp':
         return 'three_gp'
-    else:  # pragma: not covered
+    else:  # pragma: no cover
         raise ValueError(f'Unknown video media type: {media_type}')
 
 

pydantic_ai_slim/pydantic_ai/models/__init__.py

@@ -294,7 +294,7 @@ async def request_stream(
         raise NotImplementedError(f'Streamed requests not supported by this {self.__class__.__name__}')
         # yield is required to make this a generator for type checking
         # noinspection PyUnreachableCode
-        yield  # pragma: not covered
+        yield  # pragma: no cover
 
     def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
         """Customize the request parameters for the model.

pydantic_ai_slim/pydantic_ai/models/_json_schema.py

@@ -43,7 +43,7 @@ def walk(self) -> JsonSchema:
         if not self.prefer_inlined_defs and self.defs:
             handled['$defs'] = {k: self._handle(v) for k, v in self.defs.items()}
 
-        elif self.recursive_refs:  # pragma: not covered
+        elif self.recursive_refs:  # pragma: no cover
             # If we are preferring inlined defs and there are recursive refs, we _have_ to use a $defs+$ref structure
             # We try to use whatever the original root key was, but if it is already in use,
             # we modify it to avoid collisions.
@@ -70,7 +70,7 @@ def _handle(self, schema: JsonSchema) -> JsonSchema:
                     break  # recursive ref can't be unpacked
                 self.refs_stack += (key,)
                 def_schema = self.defs.get(key)
-                if def_schema is None:  # pragma: not covered
+                if def_schema is None:  # pragma: no cover
                     raise UserError(f'Could not find $ref definition for {key}')
                 schema = def_schema
 
@@ -153,8 +153,8 @@ def _simplify_nullable_union(cases: list[JsonSchema]) -> list[JsonSchema]:
                 new_schema = deepcopy(non_null_schema)
                 new_schema['nullable'] = True
                 return [new_schema]
-            else:  # pragma: not covered
+            else:  # pragma: no cover
                 # they are both null, so just return one of them
                 return [cases[0]]
 
-        return cases  # pragma: not covered
+        return cases  # pragma: no cover

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -374,7 +374,7 @@ async def _map_user_prompt(
                             source=PlainTextSourceParam(data=response.text, media_type=item.media_type, type='text'),
                             type='document',
                         )
-                    else:  # pragma: not covered
+                    else:  # pragma: no cover
                         raise RuntimeError(f'Unsupported media type: {item.media_type}')
                 else:
                     raise RuntimeError(f'Unsupported content type: {type(item)}')

pydantic_ai_slim/pydantic_ai/models/bedrock.py

@@ -396,7 +396,7 @@ async def _map_messages(
                         )
                     elif isinstance(part, RetryPromptPart):
                         # TODO(Marcelo): We need to add a test here.
-                        if part.tool_name is None:  # pragma: not covered
+                        if part.tool_name is None:  # pragma: no cover
                             bedrock_messages.append({'role': 'user', 'content': [{'text': part.model_response()}]})
                         else:
                             assert part.tool_call_id is not None
@@ -475,7 +475,7 @@ async def _map_user_prompt(part: UserPromptPart, document_count: Iterator[int])
                         )
                         video: VideoBlockTypeDef = {'format': format, 'source': {'bytes': response.content}}
                         content.append({'video': video})
-                elif isinstance(item, AudioUrl):  # pragma: not covered
+                elif isinstance(item, AudioUrl):  # pragma: no cover
                     raise NotImplementedError('Audio is not supported yet.')
                 else:
                     assert_never(item)

pydantic_ai_slim/pydantic_ai/models/cohere.py

@@ -289,9 +289,9 @@ def _map_usage(response: ChatResponse) -> usage.Usage:
                 details['input_tokens'] = int(u.billed_units.input_tokens)
             if u.billed_units.output_tokens:
                 details['output_tokens'] = int(u.billed_units.output_tokens)
-            if u.billed_units.search_units:  # pragma: not covered
+            if u.billed_units.search_units:  # pragma: no cover
                 details['search_units'] = int(u.billed_units.search_units)
-            if u.billed_units.classifications:  # pragma: not covered
+            if u.billed_units.classifications:  # pragma: no cover
                 details['classifications'] = int(u.billed_units.classifications)
 
         request_tokens = int(u.tokens.input_tokens) if u.tokens and u.tokens.input_tokens else None

pydantic_ai_slim/pydantic_ai/models/gemini.py

@@ -236,7 +236,7 @@ async def _make_request(
             if (frequency_penalty := model_settings.get('frequency_penalty')) is not None:
                 generation_config['frequency_penalty'] = frequency_penalty
             if (thinkingConfig := model_settings.get('gemini_thinking_config')) is not None:
-                generation_config['thinking_config'] = thinkingConfig  # pragma: not covered
+                generation_config['thinking_config'] = thinkingConfig  # pragma: no cover
             if (gemini_safety_settings := model_settings.get('gemini_safety_settings')) is not None:
                 request_data['safetySettings'] = gemini_safety_settings
         if generation_config:
@@ -820,7 +820,7 @@ def transform(self, schema: JsonSchema) -> JsonSchema:
         schema.pop('title', None)
         schema.pop('default', None)
         schema.pop('$schema', None)
-        if (const := schema.pop('const', None)) is not None:  # pragma: not covered
+        if (const := schema.pop('const', None)) is not None:  # pragma: no cover
             # Gemini doesn't support const, but it does support enum with a single value
             schema['enum'] = [const]
         schema.pop('discriminator', None)
@@ -832,7 +832,7 @@ def transform(self, schema: JsonSchema) -> JsonSchema:
         schema.pop('exclusiveMinimum', None)
 
         type_ = schema.get('type')
-        if 'oneOf' in schema and 'type' not in schema:  # pragma: not covered
+        if 'oneOf' in schema and 'type' not in schema:  # pragma: no cover
             # This gets hit when we have a discriminated union
             # Gemini returns an API error in this case even though it says in its error message it shouldn't...
             # Changing the oneOf to an anyOf prevents the API error and I think is functionally equivalent
@@ -856,7 +856,7 @@ def transform(self, schema: JsonSchema) -> JsonSchema:
             for item in prefix_items:
                 if item not in unique_items:
                     unique_items.append(item)
-            if len(unique_items) > 1:  # pragma: not covered
+            if len(unique_items) > 1:  # pragma: no cover
                 schema['items'] = {'anyOf': unique_items}
             elif len(unique_items) == 1:
                 schema['items'] = unique_items[0]

pydantic_ai_slim/pydantic_ai/models/groq.py

@@ -350,9 +350,9 @@ def _map_user_prompt(part: UserPromptPart) -> chat.ChatCompletionUserMessagePara
                         content.append(chat.ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
                     else:
                         raise RuntimeError('Only images are supported for binary content in Groq.')
-                elif isinstance(item, DocumentUrl):  # pragma: not covered
+                elif isinstance(item, DocumentUrl):  # pragma: no cover
                     raise RuntimeError('DocumentUrl is not supported in Groq.')
-                else:  # pragma: not covered
+                else:  # pragma: no cover
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
 
         return chat.ChatCompletionUserMessageParam(role='user', content=content)

pydantic_ai_slim/pydantic_ai/models/instrumented.py

@@ -238,7 +238,7 @@ def model_attributes(model: Model):
         if base_url := model.base_url:
             try:
                 parsed = urlparse(base_url)
-            except Exception:  # pragma: not covered
+            except Exception:  # pragma: no cover
                 pass
             else:
                 if parsed.hostname:

pydantic_ai_slim/pydantic_ai/models/mistral.py

@@ -408,7 +408,7 @@ def _get_python_type(cls, value: dict[str, Any]) -> str:
         if value_type == 'object':
             additional_properties = value.get('additionalProperties', {})
             if isinstance(additional_properties, bool):
-                return 'bool'  # pragma: not covered
+                return 'bool'  # pragma: no cover
             additional_properties_type = additional_properties.get('type')
             if (
                 additional_properties_type in SIMPLE_JSON_TYPE_MAPPING
@@ -520,7 +520,7 @@ def _map_user_prompt(self, part: UserPromptPart) -> MistralUserMessage:
                     raise RuntimeError('DocumentUrl is not supported in Mistral.')
                 elif isinstance(item, VideoUrl):
                     raise RuntimeError('VideoUrl is not supported in Mistral.')
-                else:  # pragma: not covered
+                else:  # pragma: no cover
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
         return MistralUserMessage(content=content)
 
@@ -680,7 +680,7 @@ def _map_content(content: MistralOptionalNullable[MistralContent]) -> str | None
         output = content
 
     # Note: Check len to handle potential mismatch between function calls and responses from the API. (`msg: not the same number of function class and responses`)
-    if output and len(output) == 0:  # pragma: not covered
+    if output and len(output) == 0:  # pragma: no cover
         output = None
 
     return output