From 5da1b4f81ec2d852aa520308c5bc12a70b972557 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 19 Oct 2025 02:11:52 +0000 Subject: [PATCH] style: apply pre-commit fixes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 🤖 Applied by @github-actions bot via pre-commit workflow --- docs/static/llama-stack-spec.html | 8 +-- docs/static/llama-stack-spec.yaml | 76 +++++++++++---------- docs/static/stainless-llama-stack-spec.html | 8 +-- docs/static/stainless-llama-stack-spec.yaml | 76 +++++++++++---------- 4 files changed, 88 insertions(+), 80 deletions(-) diff --git a/docs/static/llama-stack-spec.html b/docs/static/llama-stack-spec.html index 413e4f23e..55decda0b 100644 --- a/docs/static/llama-stack-spec.html +++ b/docs/static/llama-stack-spec.html @@ -492,7 +492,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -521,7 +521,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -539,7 +539,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -561,7 +561,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } diff --git a/docs/static/llama-stack-spec.yaml b/docs/static/llama-stack-spec.yaml index 93e51de6a..751e4892f 100644 --- a/docs/static/llama-stack-spec.yaml +++ b/docs/static/llama-stack-spec.yaml @@ -354,26 +354,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: include @@ -396,26 +397,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: limit @@ -429,26 +431,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: order @@ -465,26 +468,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` deprecated: false diff --git a/docs/static/stainless-llama-stack-spec.html b/docs/static/stainless-llama-stack-spec.html index 858f20725..5db44e356 100644 --- a/docs/static/stainless-llama-stack-spec.html +++ b/docs/static/stainless-llama-stack-spec.html @@ -492,7 +492,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -521,7 +521,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -539,7 +539,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } @@ -561,7 +561,7 @@ { "type": "object", "title": "NotGiven", - "description": "A sentinel singleton class used to distinguish omitted keyword arguments from those passed in with the value None (which may have different behavior).\nFor example:\n\n```py\ndef get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...\n\n\nget(timeout=1) # 1s timeout\nget(timeout=None) # No timeout\nget() # Default timeout behavior, which may not be statically known at the method definition.\n```" + "description": "For parameters with a meaningful None value, we need to distinguish between the user explicitly passing None, and the user not passing the parameter at all.\nUser code shouldn't need to use not_given directly.\n\nFor example:\n\n```py\ndef create(timeout: Timeout | None | NotGiven = not_given): ...\n\n\ncreate(timeout=1) # 1s timeout\ncreate(timeout=None) # No timeout\ncreate() # Default timeout behavior\n```" } ] } diff --git a/docs/static/stainless-llama-stack-spec.yaml b/docs/static/stainless-llama-stack-spec.yaml index 886549dbc..4c90d5670 100644 --- a/docs/static/stainless-llama-stack-spec.yaml +++ b/docs/static/stainless-llama-stack-spec.yaml @@ -357,26 +357,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: include @@ -399,26 +400,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: limit @@ -432,26 +434,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` - name: order @@ -468,26 +471,27 @@ paths: - type: object title: NotGiven description: >- - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different - behavior). + For parameters with a meaningful None value, we need to distinguish + between the user explicitly passing None, and the user not passing + the parameter at all. + + User code shouldn't need to use not_given directly. + For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: - ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout + create(timeout=1) # 1s timeout - get(timeout=None) # No timeout + create(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known - at the method definition. + create() # Default timeout behavior ``` deprecated: false