huggingface-hub 0.21.4__py3-none-any.whl → 0.22.0rc0__py3-none-any.whl

huggingface_hub/inference/_generated/types/text_generation.py

@@ -0,0 +1,161 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import List, Literal, Optional
+
+from .base import BaseInferenceType
+
+
+@dataclass
+class TextGenerationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Text Generation
+    """
+
+    best_of: Optional[int] = None
+    """The number of sampling queries to run. Only the best one (in terms of total logprob) will
+    be returned.
+    """
+    decoder_input_details: Optional[bool] = None
+    """Whether or not to output decoder input details"""
+    details: Optional[bool] = None
+    """Whether or not to output details"""
+    do_sample: Optional[bool] = None
+    """Whether to use logits sampling instead of greedy decoding when generating new tokens."""
+    max_new_tokens: Optional[int] = None
+    """The maximum number of tokens to generate."""
+    repetition_penalty: Optional[float] = None
+    """The parameter for repetition penalty. A value of 1.0 means no penalty. See [this
+    paper](https://hf.co/papers/1909.05858) for more details.
+    """
+    return_full_text: Optional[bool] = None
+    """Whether to prepend the prompt to the generated text."""
+    seed: Optional[int] = None
+    """The random sampling seed."""
+    stop_sequences: Optional[List[str]] = None
+    """Stop generating tokens if a member of `stop_sequences` is generated."""
+    temperature: Optional[float] = None
+    """The value used to modulate the logits distribution."""
+    top_k: Optional[int] = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: Optional[float] = None
+    """If set to < 1, only the smallest set of most probable tokens with probabilities that add
+    up to `top_p` or higher are kept for generation.
+    """
+    truncate: Optional[int] = None
+    """Truncate input tokens to the given size."""
+    typical_p: Optional[float] = None
+    """Typical Decoding mass. See [Typical Decoding for Natural Language
+    Generation](https://hf.co/papers/2202.00666) for more information
+    """
+    watermark: Optional[bool] = None
+    """Watermarking with [A Watermark for Large Language Models](https://hf.co/papers/2301.10226)"""
+
+
+@dataclass
+class TextGenerationInput(BaseInferenceType):
+    """Inputs for Text Generation inference"""
+
+    inputs: str
+    """The text to initialize generation with"""
+    parameters: Optional[TextGenerationParameters] = None
+    """Additional inference parameters"""
+    stream: Optional[bool] = None
+    """Whether to stream output tokens"""
+
+
+TextGenerationFinishReason = Literal["length", "eos_token", "stop_sequence"]
+
+
+@dataclass
+class TextGenerationPrefillToken(BaseInferenceType):
+    id: int
+    logprob: float
+    text: str
+    """The text associated with that token"""
+
+
+@dataclass
+class TextGenerationOutputToken(BaseInferenceType):
+    """Generated token."""
+
+    id: int
+    special: bool
+    """Whether or not that token is a special one"""
+    text: str
+    """The text associated with that token"""
+    logprob: Optional[float] = None
+
+
+@dataclass
+class TextGenerationOutputSequenceDetails(BaseInferenceType):
+    finish_reason: "TextGenerationFinishReason"
+    generated_text: str
+    """The generated text"""
+    generated_tokens: int
+    """The number of generated tokens"""
+    prefill: List[TextGenerationPrefillToken]
+    tokens: List[TextGenerationOutputToken]
+    """The generated tokens and associated details"""
+    seed: Optional[int] = None
+    """The random seed used for generation"""
+    top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None
+    """Most likely tokens"""
+
+
+@dataclass
+class TextGenerationOutputDetails(BaseInferenceType):
+    """When enabled, details about the generation"""
+
+    finish_reason: "TextGenerationFinishReason"
+    """The reason why the generation was stopped."""
+    generated_tokens: int
+    """The number of generated tokens"""
+    prefill: List[TextGenerationPrefillToken]
+    tokens: List[TextGenerationOutputToken]
+    """The generated tokens and associated details"""
+    best_of_sequences: Optional[List[TextGenerationOutputSequenceDetails]] = None
+    """Details about additional sequences when best_of is provided"""
+    seed: Optional[int] = None
+    """The random seed used for generation"""
+    top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None
+    """Most likely tokens"""
+
+
+@dataclass
+class TextGenerationOutput(BaseInferenceType):
+    """Outputs for Text Generation inference"""
+
+    generated_text: str
+    """The generated text"""
+    details: Optional[TextGenerationOutputDetails] = None
+    """When enabled, details about the generation"""
+
+
+@dataclass
+class TextGenerationStreamDetails(BaseInferenceType):
+    """Generation details. Only available when the generation is finished."""
+
+    finish_reason: "TextGenerationFinishReason"
+    """The reason why the generation was stopped."""
+    generated_tokens: int
+    """The number of generated tokens"""
+    seed: int
+    """The random seed used for generation"""
+
+
+@dataclass
+class TextGenerationStreamOutput(BaseInferenceType):
+    """Text Generation Stream Output"""
+
+    token: TextGenerationOutputToken
+    """Generated token."""
+    details: Optional[TextGenerationStreamDetails] = None
+    """Generation details. Only available when the generation is finished."""
+    generated_text: Optional[str] = None
+    """The complete generated text. Only available when the generation is finished."""
+    index: Optional[int] = None
+    """The token index within the stream. Optional to support older clients that omit it."""

huggingface_hub/inference/_generated/types/text_to_audio.py

@@ -0,0 +1,105 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union
+
+from .base import BaseInferenceType
+
+
+EarlyStoppingEnum = Literal["never"]
+
+
+@dataclass
+class TextToAudioGenerationParameters(BaseInferenceType):
+    """Parametrization of the text generation process
+    Ad-hoc parametrization of the text generation process
+    """
+
+    do_sample: Optional[bool] = None
+    """Whether to use sampling instead of greedy decoding when generating new tokens."""
+    early_stopping: Optional[Union[bool, "EarlyStoppingEnum"]] = None
+    """Controls the stopping condition for beam-based methods."""
+    epsilon_cutoff: Optional[float] = None
+    """If set to float strictly between 0 and 1, only tokens with a conditional probability
+    greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+    3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+    Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+    """
+    eta_cutoff: Optional[float] = None
+    """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+    float strictly between 0 and 1, a token is only considered if it is greater than either
+    eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+    term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+    the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+    See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+    for more details.
+    """
+    max_length: Optional[int] = None
+    """The maximum length (in tokens) of the generated text, including the input."""
+    max_new_tokens: Optional[int] = None
+    """The maximum number of tokens to generate. Takes precedence over maxLength."""
+    min_length: Optional[int] = None
+    """The minimum length (in tokens) of the generated text, including the input."""
+    min_new_tokens: Optional[int] = None
+    """The minimum number of tokens to generate. Takes precedence over maxLength."""
+    num_beam_groups: Optional[int] = None
+    """Number of groups to divide num_beams into in order to ensure diversity among different
+    groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+    """
+    num_beams: Optional[int] = None
+    """Number of beams to use for beam search."""
+    penalty_alpha: Optional[float] = None
+    """The value balances the model confidence and the degeneration penalty in contrastive
+    search decoding.
+    """
+    temperature: Optional[float] = None
+    """The value used to modulate the next token probabilities."""
+    top_k: Optional[int] = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: Optional[float] = None
+    """If set to float < 1, only the smallest set of most probable tokens with probabilities
+    that add up to top_p or higher are kept for generation.
+    """
+    typical_p: Optional[float] = None
+    """Local typicality measures how similar the conditional probability of predicting a target
+    token next is to the expected conditional probability of predicting a random token next,
+    given the partial text already generated. If set to float < 1, the smallest set of the
+    most locally typical tokens with probabilities that add up to typical_p or higher are
+    kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+    """
+    use_cache: Optional[bool] = None
+    """Whether the model should use the past last key/values attentions to speed up decoding"""
+
+
+@dataclass
+class TextToAudioParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Text To Audio
+    """
+
+    generate: Optional[TextToAudioGenerationParameters] = None
+    """Parametrization of the text generation process"""
+
+
+@dataclass
+class TextToAudioInput(BaseInferenceType):
+    """Inputs for Text To Audio inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: Optional[TextToAudioParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class TextToAudioOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Audio task"""
+
+    audio: Any
+    """The generated audio waveform."""
+    sampling_rate: Any
+    text_to_audio_output_sampling_rate: Optional[float] = None
+    """The sampling rate of the generated audio waveform."""

huggingface_hub/inference/_generated/types/text_to_image.py

@@ -0,0 +1,57 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+from .base import BaseInferenceType
+
+
+@dataclass
+class TextToImageTargetSize(BaseInferenceType):
+    """The size in pixel of the output image"""
+
+    height: int
+    width: int
+
+
+@dataclass
+class TextToImageParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Text To Image
+    """
+
+    guidance_scale: Optional[float] = None
+    """For diffusion models. A higher guidance scale value encourages the model to generate
+    images closely linked to the text prompt at the expense of lower image quality.
+    """
+    negative_prompt: Optional[List[str]] = None
+    """One or several prompt to guide what NOT to include in image generation."""
+    num_inference_steps: Optional[int] = None
+    """For diffusion models. The number of denoising steps. More denoising steps usually lead to
+    a higher quality image at the expense of slower inference.
+    """
+    scheduler: Optional[str] = None
+    """For diffusion models. Override the scheduler with a compatible one"""
+    target_size: Optional[TextToImageTargetSize] = None
+    """The size in pixel of the output image"""
+
+
+@dataclass
+class TextToImageInput(BaseInferenceType):
+    """Inputs for Text To Image inference"""
+
+    inputs: str
+    """The input text data (sometimes called "prompt\""""
+    parameters: Optional[TextToImageParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class TextToImageOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Image task"""
+
+    image: Any
+    """The generated image"""

huggingface_hub/inference/_generated/types/token_classification.py

@@ -0,0 +1,53 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, List, Literal, Optional
+
+from .base import BaseInferenceType
+
+
+TokenClassificationAggregationStrategy = Literal["none", "simple", "first", "average", "max"]
+
+
+@dataclass
+class TokenClassificationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Token Classification
+    """
+
+    aggregation_strategy: Optional["TokenClassificationAggregationStrategy"] = None
+    """The strategy used to fuse tokens based on model predictions"""
+    ignore_labels: Optional[List[str]] = None
+    """A list of labels to ignore"""
+    stride: Optional[int] = None
+    """The number of overlapping tokens between chunks when splitting the input text."""
+
+
+@dataclass
+class TokenClassificationInput(BaseInferenceType):
+    """Inputs for Token Classification inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: Optional[TokenClassificationParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class TokenClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Token Classification task"""
+
+    label: Any
+    score: float
+    """The associated score / probability"""
+    end: Optional[int] = None
+    """The character position in the input where this group ends."""
+    entity_group: Optional[str] = None
+    """The predicted label for that group of tokens"""
+    start: Optional[int] = None
+    """The character position in the input where this group begins."""
+    word: Optional[str] = None
+    """The corresponding text"""

huggingface_hub/inference/_generated/types/translation.py

@@ -0,0 +1,46 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, Dict, Literal, Optional
+
+from .base import BaseInferenceType
+
+
+TranslationGenerationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"]
+
+
+@dataclass
+class TranslationGenerationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Text2text Generation
+    """
+
+    clean_up_tokenization_spaces: Optional[bool] = None
+    """Whether to clean up the potential extra spaces in the text output."""
+    generate_parameters: Optional[Dict[str, Any]] = None
+    """Additional parametrization of the text generation algorithm"""
+    truncation: Optional["TranslationGenerationTruncationStrategy"] = None
+    """The truncation strategy to use"""
+
+
+@dataclass
+class TranslationInput(BaseInferenceType):
+    """Inputs for Translation inference
+    Inputs for Text2text Generation inference
+    """
+
+    inputs: str
+    """The input text data"""
+    parameters: Optional[TranslationGenerationParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class TranslationOutput(BaseInferenceType):
+    """Outputs of inference for the Translation task"""
+
+    translation_text: str
+    """The translated text."""

huggingface_hub/inference/_generated/types/video_classification.py

@@ -0,0 +1,47 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, Literal, Optional
+
+from .base import BaseInferenceType
+
+
+ClassificationOutputTransform = Literal["sigmoid", "softmax", "none"]
+
+
+@dataclass
+class VideoClassificationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Video Classification
+    """
+
+    frame_sampling_rate: Optional[int] = None
+    """The sampling rate used to select frames from the video."""
+    function_to_apply: Optional["ClassificationOutputTransform"] = None
+    num_frames: Optional[int] = None
+    """The number of sampled frames to consider for classification."""
+    top_k: Optional[int] = None
+    """When specified, limits the output to the top K most probable classes."""
+
+
+@dataclass
+class VideoClassificationInput(BaseInferenceType):
+    """Inputs for Video Classification inference"""
+
+    inputs: Any
+    """The input video data"""
+    parameters: Optional[VideoClassificationParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class VideoClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Video Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

huggingface_hub/inference/_generated/types/visual_question_answering.py

@@ -0,0 +1,53 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from .base import BaseInferenceType
+
+
+@dataclass
+class VisualQuestionAnsweringInputData(BaseInferenceType):
+    """One (image, question) pair to answer"""
+
+    image: Any
+    """The image."""
+    question: Any
+    """The question to answer based on the image."""
+
+
+@dataclass
+class VisualQuestionAnsweringParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Visual Question Answering
+    """
+
+    top_k: Optional[int] = None
+    """The number of answers to return (will be chosen by order of likelihood). Note that we
+    return less than topk answers if there are not enough options available within the
+    context.
+    """
+
+
+@dataclass
+class VisualQuestionAnsweringInput(BaseInferenceType):
+    """Inputs for Visual Question Answering inference"""
+
+    inputs: VisualQuestionAnsweringInputData
+    """One (image, question) pair to answer"""
+    parameters: Optional[VisualQuestionAnsweringParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class VisualQuestionAnsweringOutputElement(BaseInferenceType):
+    """Outputs of inference for the Visual Question Answering task"""
+
+    label: Any
+    score: float
+    """The associated score / probability"""
+    answer: Optional[str] = None
+    """The answer to the question"""

huggingface_hub/inference/_generated/types/zero_shot_classification.py

@@ -0,0 +1,56 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import List, Optional
+
+from .base import BaseInferenceType
+
+
+@dataclass
+class ZeroShotClassificationInputData(BaseInferenceType):
+    """The input text data, with candidate labels"""
+
+    candidate_labels: List[str]
+    """The set of possible class labels to classify the text into."""
+    text: str
+    """The text to classify"""
+
+
+@dataclass
+class ZeroShotClassificationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Zero Shot Classification
+    """
+
+    hypothesis_template: Optional[str] = None
+    """The sentence used in conjunction with candidateLabels to attempt the text classification
+    by replacing the placeholder with the candidate labels.
+    """
+    multi_label: Optional[bool] = None
+    """Whether multiple candidate labels can be true. If false, the scores are normalized such
+    that the sum of the label likelihoods for each sequence is 1. If true, the labels are
+    considered independent and probabilities are normalized for each candidate.
+    """
+
+
+@dataclass
+class ZeroShotClassificationInput(BaseInferenceType):
+    """Inputs for Zero Shot Classification inference"""
+
+    inputs: ZeroShotClassificationInputData
+    """The input text data, with candidate labels"""
+    parameters: Optional[ZeroShotClassificationParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class ZeroShotClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Zero Shot Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

huggingface_hub/inference/_generated/types/zero_shot_image_classification.py

@@ -0,0 +1,51 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+from .base import BaseInferenceType
+
+
+@dataclass
+class ZeroShotImageClassificationInputData(BaseInferenceType):
+    """The input image data, with candidate labels"""
+
+    candidate_labels: List[str]
+    """The candidate labels for this image"""
+    image: Any
+    """The image data to classify"""
+
+
+@dataclass
+class ZeroShotImageClassificationParameters(BaseInferenceType):
+    """Additional inference parameters
+    Additional inference parameters for Zero Shot Image Classification
+    """
+
+    hypothesis_template: Optional[str] = None
+    """The sentence used in conjunction with candidateLabels to attempt the text classification
+    by replacing the placeholder with the candidate labels.
+    """
+
+
+@dataclass
+class ZeroShotImageClassificationInput(BaseInferenceType):
+    """Inputs for Zero Shot Image Classification inference"""
+
+    inputs: ZeroShotImageClassificationInputData
+    """The input image data, with candidate labels"""
+    parameters: Optional[ZeroShotImageClassificationParameters] = None
+    """Additional inference parameters"""
+
+
+@dataclass
+class ZeroShotImageClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Zero Shot Image Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""