gcore 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

gcore/types/streaming/ai_task_get_response.py

@@ -0,0 +1,313 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .ai_task import AITask
+from ..._models import BaseModel
+
+__all__ = [
+    "AITaskGetResponse",
+    "AITaskGetResponseProcessingTime",
+    "AITaskGetResponseResult",
+    "AITaskGetResponseResultAIResultsTranscribe",
+    "AITaskGetResponseResultAIResultsTranscribeSubtitle",
+    "AITaskGetResponseResultAIResultsContentmoderationSport",
+    "AITaskGetResponseResultAIResultsContentmoderationSportFrame",
+    "AITaskGetResponseResultAIResultsContentmoderationWeapon",
+    "AITaskGetResponseResultAIResultsContentmoderationWeaponFrame",
+    "AITaskGetResponseResultAIResultsContentmoderationNsfw",
+    "AITaskGetResponseResultAIResultsContentmoderationNsfwFrame",
+    "AITaskGetResponseResultAIResultsContentmoderationHardnudity",
+    "AITaskGetResponseResultAIResultsContentmoderationHardnudityFrame",
+    "AITaskGetResponseResultAIResultsContentmoderationSoftnudity",
+    "AITaskGetResponseResultAIResultsContentmoderationSoftnudityFrame",
+    "AITaskGetResponseResultAIResultsContentmoderationCasm",
+    "AITaskGetResponseResultAIResultsContentmoderationCasmFrame",
+    "AITaskGetResponseResultAIResultsFailure",
+]
+
+
+class AITaskGetResponseProcessingTime(BaseModel):
+    completed_at: Optional[str] = None
+    """Video processing end time. Format is date time in ISO 8601"""
+
+    started_at: Optional[str] = None
+    """Video processing start time. Format is date time in ISO 8601"""
+
+    total_time_sec: Optional[float] = None
+    """Duration of video processing in seconds"""
+
+
+class AITaskGetResponseResultAIResultsTranscribeSubtitle(BaseModel):
+    end_time: Optional[str] = None
+    """End time of the phrase, when it ends in the video. Format is "HH:mm:ss.fff"."""
+
+    start_time: Optional[str] = None
+    """Start time of the phrase when it is heard in the video.
+
+    Format is "HH:mm:ss.fff".
+    """
+
+    text: Optional[str] = None
+    """A complete phrase that sounds during a specified period of time."""
+
+
+class AITaskGetResponseResultAIResultsTranscribe(BaseModel):
+    concatenated_text: Optional[str] = None
+    """Full text of the analyzed video. The value is unstructured, unformatted text."""
+
+    languages: Optional[List[str]] = None
+    """An array of language codes that were discovered and/or used in transcription.
+
+    If the audio or subtitle language was explicitly specified in the initial
+    parameters, it will be copied here. For automatic detection the identified
+    languages will be displayed here. Also please note that for multilingual audio,
+    the first 5 languages are displayed in order of frequency of use.
+    """
+
+    speech_detected: Optional[bool] = None
+    """
+    Determines whether speech was detected or not. Please note: If the task is in
+    "SUCCESS" status and speech was not found in the entire file, then "false" will
+    be indicated here and the `subtitles` field will be empty.
+    """
+
+    subtitles: Optional[List[AITaskGetResponseResultAIResultsTranscribeSubtitle]] = None
+    """An array of phrases divided into time intervals, in the format "json".
+
+    Suitable when you need to display the result in chronometric form, or transfer
+    the text for further processing.
+    """
+
+    vtt_content: Optional[str] = FieldInfo(alias="vttContent", default=None)
+    """Auto generated subtitles in WebVTT format."""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationSportFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the activity"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where activity was found"""
+
+    label: Optional[str] = None
+    """Type of detected activity"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationSport(BaseModel):
+    detection_results: Optional[
+        List[
+            Literal[
+                "archery",
+                "arm wrestling",
+                "playing badminton",
+                "playing baseball",
+                "basketball dunk",
+                "bowling",
+                "boxing punch",
+                "boxing speed bag",
+                "catching or throwing baseball",
+                "catching or throwing softball",
+                "cricket",
+                "curling",
+                "disc golfing",
+                "dodgeball",
+                "fencing",
+                "football",
+                "golf chipping",
+                "golf driving",
+                "golf putting",
+                "hitting baseball",
+                "hockey stop",
+                "ice skating",
+                "javelin throw",
+                "juggling soccer ball",
+                "kayaking",
+                "kicking field goal",
+                "kicking soccer ball",
+                "playing cricket",
+                "playing field hockey",
+                "playing ice hockey",
+                "playing kickball",
+                "playing lacrosse",
+                "playing ping pong",
+                "playing polo",
+                "playing squash or racquetball",
+                "playing tennis",
+                "playing volleyball",
+                "pole vault",
+                "riding a bike",
+                "riding or walking with horse",
+                "roller skating",
+                "rowing",
+                "sailing",
+                "shooting goal (soccer)",
+                "skateboarding",
+                "skiing",
+            ]
+        ]
+    ] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationSportFrame]] = None
+
+    sport_detected: Optional[bool] = None
+    """A boolean value whether any sports were detected"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationWeaponFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the object"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where object was found"""
+
+    label: Optional[str] = None
+    """Type of detected object"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationWeapon(BaseModel):
+    detection_results: Optional[List[Literal["gun", "heavy weapon", "knife"]]] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationWeaponFrame]] = None
+
+    weapon_detected: Optional[bool] = None
+    """A boolean value whether any weapon was detected"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationNsfwFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the object"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where object was found"""
+
+    label: Optional[str] = None
+    """Type of detected object"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationNsfw(BaseModel):
+    detection_results: Optional[List[Literal["nsfw"]]] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationNsfwFrame]] = None
+
+    nsfw_detected: Optional[bool] = None
+    """A boolean value whether any Not Safe For Work content was detected"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationHardnudityFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the object"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where object was found"""
+
+    label: Optional[str] = None
+    """Type of detected object"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationHardnudity(BaseModel):
+    detection_results: Optional[
+        List[
+            Literal[
+                "ANUS_EXPOSED",
+                "BUTTOCKS_EXPOSED",
+                "FEMALE_BREAST_EXPOSED",
+                "FEMALE_GENITALIA_EXPOSED",
+                "MALE_BREAST_EXPOSED",
+                "MALE_GENITALIA_EXPOSED",
+            ]
+        ]
+    ] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationHardnudityFrame]] = None
+
+    porn_detected: Optional[bool] = None
+    """A boolean value whether any nudity was detected"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationSoftnudityFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the object"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where object was found"""
+
+    label: Optional[str] = None
+    """Type of detected object"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationSoftnudity(BaseModel):
+    detection_results: Optional[
+        List[
+            Literal[
+                "ANUS_COVERED",
+                "ANUS_EXPOSED",
+                "ARMPITS_COVERED",
+                "ARMPITS_EXPOSED",
+                "BELLY_COVERED",
+                "BELLY_EXPOSED",
+                "BUTTOCKS_COVERED",
+                "BUTTOCKS_EXPOSED",
+                "FACE_FEMALE",
+                "FACE_MALE",
+                "FEET_COVERED",
+                "FEET_EXPOSED",
+                "FEMALE_BREAST_COVERED",
+                "FEMALE_BREAST_EXPOSED",
+                "FEMALE_GENITALIA_COVERED",
+                "FEMALE_GENITALIA_EXPOSED",
+                "MALE_BREAST_EXPOSED",
+                "MALE_GENITALIA_EXPOSED",
+            ]
+        ]
+    ] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationSoftnudityFrame]] = None
+
+    porn_detected: Optional[bool] = None
+    """A boolean value whether any nudity and other body part was detected"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationCasmFrame(BaseModel):
+    confidence: Optional[float] = None
+    """Percentage of probability of identifying the object"""
+
+    frame_number: Optional[int] = FieldInfo(alias="frame-number", default=None)
+    """Video frame number where object was found"""
+
+    label: Optional[str] = None
+    """Type of detected object"""
+
+
+class AITaskGetResponseResultAIResultsContentmoderationCasm(BaseModel):
+    child_pornography_detected: Optional[bool] = None
+    """A boolean value whether child pornography was detected"""
+
+    detection_results: Optional[List[Literal["0-2", "3-9", "10-19"]]] = None
+
+    frames: Optional[List[AITaskGetResponseResultAIResultsContentmoderationCasmFrame]] = None
+
+
+class AITaskGetResponseResultAIResultsFailure(BaseModel):
+    error: str
+
+
+AITaskGetResponseResult: TypeAlias = Union[
+    AITaskGetResponseResultAIResultsTranscribe,
+    AITaskGetResponseResultAIResultsContentmoderationSport,
+    AITaskGetResponseResultAIResultsContentmoderationWeapon,
+    AITaskGetResponseResultAIResultsContentmoderationNsfw,
+    AITaskGetResponseResultAIResultsContentmoderationHardnudity,
+    AITaskGetResponseResultAIResultsContentmoderationSoftnudity,
+    AITaskGetResponseResultAIResultsContentmoderationCasm,
+    AITaskGetResponseResultAIResultsFailure,
+]
+
+
+class AITaskGetResponse(AITask):
+    processing_time: Optional[AITaskGetResponseProcessingTime] = None
+
+    result: Optional[AITaskGetResponseResult] = None

gcore/types/streaming/ai_task_list_params.py

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["AITaskListParams"]
+
+
+class AITaskListParams(TypedDict, total=False):
+    date_created: str
+    """Time when task was created. Datetime in ISO 8601 format."""
+
+    limit: int
+    """Number of results to return per page."""
+
+    ordering: Literal["task_id", "status", "task_name", "started_at"]
+    """
+    Which field to use when ordering the results: `task_id`, status, and
+    `task_name`. Sorting is done in ascending (ASC) order. If parameter is omitted
+    then "`started_at` DESC" is used for ordering by default.
+    """
+
+    page: int
+    """Page to view from task list, starting from 1"""
+
+    search: str
+    """
+    This is an field for combined text search in the following fields: `task_id`,
+    `task_name`, status, and `task_data`. Both full and partial searches are
+    possible inside specified above fields. For example, you can filter tasks of a
+    certain category, or tasks by a specific original file. Example:
+
+    - To filter tasks of Content Moderation NSFW method:
+      `GET /streaming/ai/tasks?search=nsfw`
+    - To filter tasks of processing video from a specific origin:
+      `GET /streaming/ai/tasks?search=s3.eu-west-1.amazonaws.com`
+    """
+
+    status: Literal["FAILURE", "PENDING", "RECEIVED", "RETRY", "REVOKED", "STARTED", "SUCCESS"]
+    """Task status"""
+
+    task_id: str
+    """The task unique identifier to fiund"""
+
+    task_name: Literal["transcription", "content-moderation"]
+    """Type of the AI task.
+
+    Reflects the original API method that was used to create the AI task.
+    """

gcore/types/streaming/broadcast.py

@@ -0,0 +1,71 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["Broadcast"]
+
+
+class Broadcast(BaseModel):
+    name: str
+    """Broadcast name"""
+
+    ad_id: Optional[int] = None
+    """ID of ad to be displayed in a live stream.
+
+    If empty the default ad is show. If there is no default ad, no ad is shown
+    """
+
+    custom_iframe_url: Optional[str] = None
+    """Custom URL of iframe for video player to be shared via sharing button in player.
+
+    Auto generated iframe URL is provided by default
+    """
+
+    pending_message: Optional[str] = None
+    """A custom message that is shown if broadcast status is set to pending.
+
+    If empty, a default message is shown
+    """
+
+    player_id: Optional[int] = None
+    """ID of player to be used with a broadcast. If empty the default player is used"""
+
+    poster: Optional[str] = None
+    """Uploaded poster file"""
+
+    share_url: Optional[str] = None
+    """
+    Custom URL or iframe displayed in the link field when a user clicks on a sharing
+    button in player. If empty, the link field and social network sharing is
+    disabled
+    """
+
+    show_dvr_after_finish: Optional[bool] = None
+    """Regulates if a DVR record is shown once a broadcast is finished.
+
+    Has two possible values:
+
+    - **true** — record is shown
+    - **false** — record isn't shown
+
+    Default is false
+    """
+
+    status: Optional[str] = None
+    """
+    Broadcast statuses:
+     **Pending** — default “Broadcast isn’t started yet” or custom message (see `pending_message`
+    parameter) is shown, users don't see the live stream
+     **Live** — broadcast is live, and viewers can see it
+     **Paused** — “Broadcast is paused” message is shown, users don't see the live stream
+
+    **Finished** — “Broadcast is finished” message is shown, users don't see the
+    live stream
+     The users' browsers start displaying the message/stream immediately after you change
+    the broadcast status
+    """
+
+    stream_ids: Optional[List[int]] = None
+    """IDs of streams used in a broadcast"""

gcore/types/streaming/broadcast_create_params.py

@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Required, TypedDict
+
+__all__ = ["BroadcastCreateParams", "Broadcast"]
+
+
+class BroadcastCreateParams(TypedDict, total=False):
+    broadcast: Broadcast
+
+
+class Broadcast(TypedDict, total=False):
+    name: Required[str]
+    """Broadcast name"""
+
+    ad_id: int
+    """ID of ad to be displayed in a live stream.
+
+    If empty the default ad is show. If there is no default ad, no ad is shown
+    """
+
+    custom_iframe_url: str
+    """Custom URL of iframe for video player to be shared via sharing button in player.
+
+    Auto generated iframe URL is provided by default
+    """
+
+    pending_message: str
+    """A custom message that is shown if broadcast status is set to pending.
+
+    If empty, a default message is shown
+    """
+
+    player_id: int
+    """ID of player to be used with a broadcast. If empty the default player is used"""
+
+    poster: str
+    """Uploaded poster file"""
+
+    share_url: str
+    """
+    Custom URL or iframe displayed in the link field when a user clicks on a sharing
+    button in player. If empty, the link field and social network sharing is
+    disabled
+    """
+
+    show_dvr_after_finish: bool
+    """Regulates if a DVR record is shown once a broadcast is finished.
+
+    Has two possible values:
+
+    - **true** — record is shown
+    - **false** — record isn't shown
+
+    Default is false
+    """
+
+    status: str
+    """
+    Broadcast statuses:
+     **Pending** — default “Broadcast isn’t started yet” or custom message (see `pending_message`
+    parameter) is shown, users don't see the live stream
+     **Live** — broadcast is live, and viewers can see it
+     **Paused** — “Broadcast is paused” message is shown, users don't see the live stream
+
+    **Finished** — “Broadcast is finished” message is shown, users don't see the
+    live stream
+     The users' browsers start displaying the message/stream immediately after you change
+    the broadcast status
+    """
+
+    stream_ids: Iterable[int]
+    """IDs of streams used in a broadcast"""

gcore/types/streaming/broadcast_list_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["BroadcastListParams"]
+
+
+class BroadcastListParams(TypedDict, total=False):
+    page: int
+    """Query parameter. Use it to list the paginated content"""

gcore/types/streaming/broadcast_spectators_count.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["BroadcastSpectatorsCount"]
+
+
+class BroadcastSpectatorsCount(BaseModel):
+    spectators_count: Optional[int] = None
+    """Number of spectators at the moment"""

gcore/types/streaming/broadcast_update_params.py

@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Required, TypedDict
+
+__all__ = ["BroadcastUpdateParams", "Broadcast"]
+
+
+class BroadcastUpdateParams(TypedDict, total=False):
+    broadcast: Broadcast
+
+
+class Broadcast(TypedDict, total=False):
+    name: Required[str]
+    """Broadcast name"""
+
+    ad_id: int
+    """ID of ad to be displayed in a live stream.
+
+    If empty the default ad is show. If there is no default ad, no ad is shown
+    """
+
+    custom_iframe_url: str
+    """Custom URL of iframe for video player to be shared via sharing button in player.
+
+    Auto generated iframe URL is provided by default
+    """
+
+    pending_message: str
+    """A custom message that is shown if broadcast status is set to pending.
+
+    If empty, a default message is shown
+    """
+
+    player_id: int
+    """ID of player to be used with a broadcast. If empty the default player is used"""
+
+    poster: str
+    """Uploaded poster file"""
+
+    share_url: str
+    """
+    Custom URL or iframe displayed in the link field when a user clicks on a sharing
+    button in player. If empty, the link field and social network sharing is
+    disabled
+    """
+
+    show_dvr_after_finish: bool
+    """Regulates if a DVR record is shown once a broadcast is finished.
+
+    Has two possible values:
+
+    - **true** — record is shown
+    - **false** — record isn't shown
+
+    Default is false
+    """
+
+    status: str
+    """
+    Broadcast statuses:
+     **Pending** — default “Broadcast isn’t started yet” or custom message (see `pending_message`
+    parameter) is shown, users don't see the live stream
+     **Live** — broadcast is live, and viewers can see it
+     **Paused** — “Broadcast is paused” message is shown, users don't see the live stream
+
+    **Finished** — “Broadcast is finished” message is shown, users don't see the
+    live stream
+     The users' browsers start displaying the message/stream immediately after you change
+    the broadcast status
+    """
+
+    stream_ids: Iterable[int]
+    """IDs of streams used in a broadcast"""

gcore/types/streaming/clip.py

@@ -0,0 +1,78 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["Clip"]
+
+
+class Clip(BaseModel):
+    id: str
+    """ID of the clip"""
+
+    duration: int
+    """
+    Requested segment duration in seconds to be cut. Please, note that cutting is
+    based on the idea of instantly creating a clip, instead of precise timing. So
+    final segment may be:
+
+    - Less than the specified value if there is less data in the DVR than the
+      requested segment.
+    - Greater than the specified value, because segment is aligned to the first and
+      last key frames of already stored fragment in DVR, this way -1 and +1 chunks
+      can be added to left and right. Duration of cutted segment cannot be greater
+      than DVR duration for this stream. Therefore, to change the maximum, use
+      "`dvr_duration`" parameter of this stream.
+    """
+
+    created_at: Optional[str] = None
+    """Creation date and time. Format is date time in ISO 8601"""
+
+    expiration: Optional[int] = None
+    """
+    Expire time of the clip via a public link. Unix timestamp in seconds, absolute
+    value. This is the time how long the instant clip will be stored in the server
+    memory and can be accessed via public HLS/MP4 links. Download and/or use the
+    instant clip before this time expires. After the time has expired, the clip is
+    deleted from memory and is no longer available via the link. You need to create
+    a new segment, or use `vod_required: true` attribute. If value is omitted, then
+    expiration is counted as +3600 seconds (1 hour) to the end of the clip (i.e.
+    `unix timestamp = + + 3600`). Allowed range: 1m <= expiration <= 4h. Example:
+    `24.05.2024 14:00:00 (GMT) + 60 seconds of duration + 3600 seconds of expiration = 24.05.2024 15:01:00 (GMT) is Unix timestamp = 1716562860`
+    """
+
+    hls_master: Optional[str] = None
+    """Link to HLS .m3u8 with immediate clip.
+
+    The link retains same adaptive bitrate as in the stream for end viewers. For
+    additional restrictions, see the description of parameter "`mp4_master`".
+    """
+
+    mp4_master: Optional[str] = None
+    """Link to MP4 with immediate clip.
+
+    The link points to max rendition quality. Request of the URL can return:
+
+    - 200 OK – if the clip exists.
+    - 404 Not found – if the clip did not exist or has already ceased to exist.
+    - 425 Too early – if recording is on-going now. The file is incomplete and will
+      be accessible after start+duration time will come.
+    """
+
+    renditions: Optional[List[str]] = None
+    """List of available rendition heights"""
+
+    start: Optional[int] = None
+    """
+    Starting point of the segment to cut. Unix timestamp in seconds, absolute value.
+    Example: `24.05.2024 14:00:00 (GMT) is Unix timestamp = 1716559200` If a value
+    from the past is specified, it is used as the starting point for the segment to
+    cut. If the value is omitted, then clip will start from now.
+    """
+
+    video_id: Optional[int] = None
+    """ID of the created video if `vod_required`=true"""
+
+    vod_required: Optional[bool] = None
+    """Indicates if video needs to be stored as VOD"""