blaxel 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/integration_model.py

@@ -1,162 +0,0 @@
-from typing import Any, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="IntegrationModel")
-
-
-@_attrs_define
-class IntegrationModel:
-    """Model obtained from an external authentication provider, such as HuggingFace, OpenAI, etc...
-
-    Attributes:
-        author (Union[Unset, str]): Provider model author
-        created_at (Union[Unset, str]): Provider model created at
-        downloads (Union[Unset, int]): Provider model downloads
-        endpoint (Union[Unset, str]): Model endpoint URL
-        id (Union[Unset, str]): Provider model ID
-        library_name (Union[Unset, str]): Provider model library name
-        likes (Union[Unset, int]): Provider model likes
-        model_private (Union[Unset, str]): Is the model private
-        name (Union[Unset, str]): Provider model name
-        pipeline_tag (Union[Unset, str]): Provider model pipeline tag
-        tags (Union[Unset, list[str]]): Provider model tags
-        trending_score (Union[Unset, int]): Provider model trending score
-    """
-
-    author: Union[Unset, str] = UNSET
-    created_at: Union[Unset, str] = UNSET
-    downloads: Union[Unset, int] = UNSET
-    endpoint: Union[Unset, str] = UNSET
-    id: Union[Unset, str] = UNSET
-    library_name: Union[Unset, str] = UNSET
-    likes: Union[Unset, int] = UNSET
-    model_private: Union[Unset, str] = UNSET
-    name: Union[Unset, str] = UNSET
-    pipeline_tag: Union[Unset, str] = UNSET
-    tags: Union[Unset, list[str]] = UNSET
-    trending_score: Union[Unset, int] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        author = self.author
-
-        created_at = self.created_at
-
-        downloads = self.downloads
-
-        endpoint = self.endpoint
-
-        id = self.id
-
-        library_name = self.library_name
-
-        likes = self.likes
-
-        model_private = self.model_private
-
-        name = self.name
-
-        pipeline_tag = self.pipeline_tag
-
-        tags: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.tags, Unset):
-            tags = self.tags
-
-        trending_score = self.trending_score
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if author is not UNSET:
-            field_dict["author"] = author
-        if created_at is not UNSET:
-            field_dict["created_at"] = created_at
-        if downloads is not UNSET:
-            field_dict["downloads"] = downloads
-        if endpoint is not UNSET:
-            field_dict["endpoint"] = endpoint
-        if id is not UNSET:
-            field_dict["id"] = id
-        if library_name is not UNSET:
-            field_dict["library_name"] = library_name
-        if likes is not UNSET:
-            field_dict["likes"] = likes
-        if model_private is not UNSET:
-            field_dict["model_private"] = model_private
-        if name is not UNSET:
-            field_dict["name"] = name
-        if pipeline_tag is not UNSET:
-            field_dict["pipeline_tag"] = pipeline_tag
-        if tags is not UNSET:
-            field_dict["tags"] = tags
-        if trending_score is not UNSET:
-            field_dict["trending_score"] = trending_score
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        author = d.pop("author", UNSET)
-
-        created_at = d.pop("created_at", UNSET)
-
-        downloads = d.pop("downloads", UNSET)
-
-        endpoint = d.pop("endpoint", UNSET)
-
-        id = d.pop("id", UNSET)
-
-        library_name = d.pop("library_name", UNSET)
-
-        likes = d.pop("likes", UNSET)
-
-        model_private = d.pop("model_private", UNSET)
-
-        name = d.pop("name", UNSET)
-
-        pipeline_tag = d.pop("pipeline_tag", UNSET)
-
-        tags = cast(list[str], d.pop("tags", UNSET))
-
-        trending_score = d.pop("trending_score", UNSET)
-
-        integration_model = cls(
-            author=author,
-            created_at=created_at,
-            downloads=downloads,
-            endpoint=endpoint,
-            id=id,
-            library_name=library_name,
-            likes=likes,
-            model_private=model_private,
-            name=name,
-            pipeline_tag=pipeline_tag,
-            tags=tags,
-            trending_score=trending_score,
-        )
-
-        integration_model.additional_properties = d
-        return integration_model
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/job_execution_config.py

@@ -1,79 +0,0 @@
-from typing import Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="JobExecutionConfig")
-
-
-@_attrs_define
-class JobExecutionConfig:
-    """Configuration for a job execution
-
-    Attributes:
-        max_concurrent_tasks (Union[Unset, int]): The maximum number of concurrent tasks for an execution
-        max_retries (Union[Unset, int]): The maximum number of retries for the job execution
-        timeout (Union[Unset, int]): The timeout for the job execution in seconds
-    """
-
-    max_concurrent_tasks: Union[Unset, int] = UNSET
-    max_retries: Union[Unset, int] = UNSET
-    timeout: Union[Unset, int] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        max_concurrent_tasks = self.max_concurrent_tasks
-
-        max_retries = self.max_retries
-
-        timeout = self.timeout
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if max_concurrent_tasks is not UNSET:
-            field_dict["maxConcurrentTasks"] = max_concurrent_tasks
-        if max_retries is not UNSET:
-            field_dict["maxRetries"] = max_retries
-        if timeout is not UNSET:
-            field_dict["timeout"] = timeout
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        max_concurrent_tasks = d.pop("maxConcurrentTasks", d.pop("max_concurrent_tasks", UNSET))
-
-        max_retries = d.pop("maxRetries", d.pop("max_retries", UNSET))
-
-        timeout = d.pop("timeout", UNSET)
-
-        job_execution_config = cls(
-            max_concurrent_tasks=max_concurrent_tasks,
-            max_retries=max_retries,
-            timeout=timeout,
-        )
-
-        job_execution_config.additional_properties = d
-        return job_execution_config
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/job_metrics.py

@@ -1,262 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.job_metrics_executions_total import JobMetricsExecutionsTotal
-    from ..models.job_metrics_tasks_total import JobMetricsTasksTotal
-    from ..models.jobs_chart_value import JobsChartValue
-    from ..models.jobs_success_failed_chart import JobsSuccessFailedChart
-
-
-T = TypeVar("T", bound="JobMetrics")
-
-
-@_attrs_define
-class JobMetrics:
-    """Metrics for job
-
-    Attributes:
-        billable_time (Union[Unset, list['JobsChartValue']]): Billable time
-        cpu_usage (Union[Unset, list['JobsChartValue']]): CPU usage
-        executions_chart (Union[Unset, list['JobsSuccessFailedChart']]): Executions chart
-        executions_running (Union[Unset, list['JobsChartValue']]): Executions running
-        executions_total (Union[Unset, JobMetricsExecutionsTotal]): Total executions
-        ram_usage (Union[Unset, list['JobsChartValue']]): RAM usage
-        tasks_chart (Union[Unset, list['JobsSuccessFailedChart']]): Tasks chart
-        tasks_running (Union[Unset, list['JobsChartValue']]): Tasks running
-        tasks_total (Union[Unset, JobMetricsTasksTotal]): Total tasks
-    """
-
-    billable_time: Union[Unset, list["JobsChartValue"]] = UNSET
-    cpu_usage: Union[Unset, list["JobsChartValue"]] = UNSET
-    executions_chart: Union[Unset, list["JobsSuccessFailedChart"]] = UNSET
-    executions_running: Union[Unset, list["JobsChartValue"]] = UNSET
-    executions_total: Union[Unset, "JobMetricsExecutionsTotal"] = UNSET
-    ram_usage: Union[Unset, list["JobsChartValue"]] = UNSET
-    tasks_chart: Union[Unset, list["JobsSuccessFailedChart"]] = UNSET
-    tasks_running: Union[Unset, list["JobsChartValue"]] = UNSET
-    tasks_total: Union[Unset, "JobMetricsTasksTotal"] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        billable_time: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.billable_time, Unset):
-            billable_time = []
-            for billable_time_item_data in self.billable_time:
-                if type(billable_time_item_data) is dict:
-                    billable_time_item = billable_time_item_data
-                else:
-                    billable_time_item = billable_time_item_data.to_dict()
-                billable_time.append(billable_time_item)
-
-        cpu_usage: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.cpu_usage, Unset):
-            cpu_usage = []
-            for cpu_usage_item_data in self.cpu_usage:
-                if type(cpu_usage_item_data) is dict:
-                    cpu_usage_item = cpu_usage_item_data
-                else:
-                    cpu_usage_item = cpu_usage_item_data.to_dict()
-                cpu_usage.append(cpu_usage_item)
-
-        executions_chart: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.executions_chart, Unset):
-            executions_chart = []
-            for executions_chart_item_data in self.executions_chart:
-                if type(executions_chart_item_data) is dict:
-                    executions_chart_item = executions_chart_item_data
-                else:
-                    executions_chart_item = executions_chart_item_data.to_dict()
-                executions_chart.append(executions_chart_item)
-
-        executions_running: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.executions_running, Unset):
-            executions_running = []
-            for executions_running_item_data in self.executions_running:
-                if type(executions_running_item_data) is dict:
-                    executions_running_item = executions_running_item_data
-                else:
-                    executions_running_item = executions_running_item_data.to_dict()
-                executions_running.append(executions_running_item)
-
-        executions_total: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.executions_total
-            and not isinstance(self.executions_total, Unset)
-            and not isinstance(self.executions_total, dict)
-        ):
-            executions_total = self.executions_total.to_dict()
-        elif self.executions_total and isinstance(self.executions_total, dict):
-            executions_total = self.executions_total
-
-        ram_usage: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.ram_usage, Unset):
-            ram_usage = []
-            for ram_usage_item_data in self.ram_usage:
-                if type(ram_usage_item_data) is dict:
-                    ram_usage_item = ram_usage_item_data
-                else:
-                    ram_usage_item = ram_usage_item_data.to_dict()
-                ram_usage.append(ram_usage_item)
-
-        tasks_chart: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.tasks_chart, Unset):
-            tasks_chart = []
-            for tasks_chart_item_data in self.tasks_chart:
-                if type(tasks_chart_item_data) is dict:
-                    tasks_chart_item = tasks_chart_item_data
-                else:
-                    tasks_chart_item = tasks_chart_item_data.to_dict()
-                tasks_chart.append(tasks_chart_item)
-
-        tasks_running: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.tasks_running, Unset):
-            tasks_running = []
-            for tasks_running_item_data in self.tasks_running:
-                if type(tasks_running_item_data) is dict:
-                    tasks_running_item = tasks_running_item_data
-                else:
-                    tasks_running_item = tasks_running_item_data.to_dict()
-                tasks_running.append(tasks_running_item)
-
-        tasks_total: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.tasks_total
-            and not isinstance(self.tasks_total, Unset)
-            and not isinstance(self.tasks_total, dict)
-        ):
-            tasks_total = self.tasks_total.to_dict()
-        elif self.tasks_total and isinstance(self.tasks_total, dict):
-            tasks_total = self.tasks_total
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if billable_time is not UNSET:
-            field_dict["billableTime"] = billable_time
-        if cpu_usage is not UNSET:
-            field_dict["cpuUsage"] = cpu_usage
-        if executions_chart is not UNSET:
-            field_dict["executionsChart"] = executions_chart
-        if executions_running is not UNSET:
-            field_dict["executionsRunning"] = executions_running
-        if executions_total is not UNSET:
-            field_dict["executionsTotal"] = executions_total
-        if ram_usage is not UNSET:
-            field_dict["ramUsage"] = ram_usage
-        if tasks_chart is not UNSET:
-            field_dict["tasksChart"] = tasks_chart
-        if tasks_running is not UNSET:
-            field_dict["tasksRunning"] = tasks_running
-        if tasks_total is not UNSET:
-            field_dict["tasksTotal"] = tasks_total
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.job_metrics_executions_total import JobMetricsExecutionsTotal
-        from ..models.job_metrics_tasks_total import JobMetricsTasksTotal
-        from ..models.jobs_chart_value import JobsChartValue
-        from ..models.jobs_success_failed_chart import JobsSuccessFailedChart
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        billable_time = []
-        _billable_time = d.pop("billableTime", d.pop("billable_time", UNSET))
-        for billable_time_item_data in _billable_time or []:
-            billable_time_item = JobsChartValue.from_dict(billable_time_item_data)
-
-            billable_time.append(billable_time_item)
-
-        cpu_usage = []
-        _cpu_usage = d.pop("cpuUsage", d.pop("cpu_usage", UNSET))
-        for cpu_usage_item_data in _cpu_usage or []:
-            cpu_usage_item = JobsChartValue.from_dict(cpu_usage_item_data)
-
-            cpu_usage.append(cpu_usage_item)
-
-        executions_chart = []
-        _executions_chart = d.pop("executionsChart", d.pop("executions_chart", UNSET))
-        for executions_chart_item_data in _executions_chart or []:
-            executions_chart_item = JobsSuccessFailedChart.from_dict(executions_chart_item_data)
-
-            executions_chart.append(executions_chart_item)
-
-        executions_running = []
-        _executions_running = d.pop("executionsRunning", d.pop("executions_running", UNSET))
-        for executions_running_item_data in _executions_running or []:
-            executions_running_item = JobsChartValue.from_dict(executions_running_item_data)
-
-            executions_running.append(executions_running_item)
-
-        _executions_total = d.pop("executionsTotal", d.pop("executions_total", UNSET))
-        executions_total: Union[Unset, JobMetricsExecutionsTotal]
-        if isinstance(_executions_total, Unset):
-            executions_total = UNSET
-        else:
-            executions_total = JobMetricsExecutionsTotal.from_dict(_executions_total)
-
-        ram_usage = []
-        _ram_usage = d.pop("ramUsage", d.pop("ram_usage", UNSET))
-        for ram_usage_item_data in _ram_usage or []:
-            ram_usage_item = JobsChartValue.from_dict(ram_usage_item_data)
-
-            ram_usage.append(ram_usage_item)
-
-        tasks_chart = []
-        _tasks_chart = d.pop("tasksChart", d.pop("tasks_chart", UNSET))
-        for tasks_chart_item_data in _tasks_chart or []:
-            tasks_chart_item = JobsSuccessFailedChart.from_dict(tasks_chart_item_data)
-
-            tasks_chart.append(tasks_chart_item)
-
-        tasks_running = []
-        _tasks_running = d.pop("tasksRunning", d.pop("tasks_running", UNSET))
-        for tasks_running_item_data in _tasks_running or []:
-            tasks_running_item = JobsChartValue.from_dict(tasks_running_item_data)
-
-            tasks_running.append(tasks_running_item)
-
-        _tasks_total = d.pop("tasksTotal", d.pop("tasks_total", UNSET))
-        tasks_total: Union[Unset, JobMetricsTasksTotal]
-        if isinstance(_tasks_total, Unset):
-            tasks_total = UNSET
-        else:
-            tasks_total = JobMetricsTasksTotal.from_dict(_tasks_total)
-
-        job_metrics = cls(
-            billable_time=billable_time,
-            cpu_usage=cpu_usage,
-            executions_chart=executions_chart,
-            executions_running=executions_running,
-            executions_total=executions_total,
-            ram_usage=ram_usage,
-            tasks_chart=tasks_chart,
-            tasks_running=tasks_running,
-            tasks_total=tasks_total,
-        )
-
-        job_metrics.additional_properties = d
-        return job_metrics
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/jobs_chart_value.py

@@ -1,70 +0,0 @@
-from typing import Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="JobsChartValue")
-
-
-@_attrs_define
-class JobsChartValue:
-    """Jobs CPU usage
-
-    Attributes:
-        timestamp (Union[Unset, str]): Metric timestamp
-        value (Union[Unset, float]): Metric value
-    """
-
-    timestamp: Union[Unset, str] = UNSET
-    value: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        timestamp = self.timestamp
-
-        value = self.value
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-        if value is not UNSET:
-            field_dict["value"] = value
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        timestamp = d.pop("timestamp", UNSET)
-
-        value = d.pop("value", UNSET)
-
-        jobs_chart_value = cls(
-            timestamp=timestamp,
-            value=value,
-        )
-
-        jobs_chart_value.additional_properties = d
-        return jobs_chart_value
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/jobs_network_chart.py

@@ -1,102 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.jobs_chart_value import JobsChartValue
-
-
-T = TypeVar("T", bound="JobsNetworkChart")
-
-
-@_attrs_define
-class JobsNetworkChart:
-    """Jobs chart
-
-    Attributes:
-        received (Union[Unset, list['JobsChartValue']]): Received
-        sent (Union[Unset, list['JobsChartValue']]): Sent
-    """
-
-    received: Union[Unset, list["JobsChartValue"]] = UNSET
-    sent: Union[Unset, list["JobsChartValue"]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        received: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.received, Unset):
-            received = []
-            for received_item_data in self.received:
-                if type(received_item_data) is dict:
-                    received_item = received_item_data
-                else:
-                    received_item = received_item_data.to_dict()
-                received.append(received_item)
-
-        sent: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.sent, Unset):
-            sent = []
-            for sent_item_data in self.sent:
-                if type(sent_item_data) is dict:
-                    sent_item = sent_item_data
-                else:
-                    sent_item = sent_item_data.to_dict()
-                sent.append(sent_item)
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if received is not UNSET:
-            field_dict["received"] = received
-        if sent is not UNSET:
-            field_dict["sent"] = sent
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.jobs_chart_value import JobsChartValue
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        received = []
-        _received = d.pop("received", UNSET)
-        for received_item_data in _received or []:
-            received_item = JobsChartValue.from_dict(received_item_data)
-
-            received.append(received_item)
-
-        sent = []
-        _sent = d.pop("sent", UNSET)
-        for sent_item_data in _sent or []:
-            sent_item = JobsChartValue.from_dict(sent_item_data)
-
-            sent.append(sent_item)
-
-        jobs_network_chart = cls(
-            received=received,
-            sent=sent,
-        )
-
-        jobs_network_chart.additional_properties = d
-        return jobs_network_chart
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties