dstack 0.0.9__py3-none-any.whl → 0.20.7__py3-none-any.whl

dstack/jobs.py

@@ -1,255 +0,0 @@
-from abc import abstractmethod
-from enum import Enum
-from typing import Optional, List, Dict
-
-from dstack.repo import RepoData
-from dstack.util import _quoted
-
-
-class GpusRequirements:
-    def __init__(self, count: Optional[int] = None, memory_mib: Optional[int] = None, name: Optional[str] = None):
-        self.count = count
-        self.memory_mib = memory_mib
-        self.name = name
-
-    def __str__(self) -> str:
-        return f'GpusRequirements(count={self.count}, memory_mib={self.memory_mib}, ' \
-               f'name={_quoted(self.name)})'
-
-
-class Requirements:
-    def __init__(self, cpus: Optional[int] = None, memory_mib: Optional[int] = None,
-                 gpus: Optional[GpusRequirements] = None, shm_size_mib: Optional[int] = None,
-                 interruptible: Optional[bool] = None):
-        self.cpus = cpus
-        self.memory_mib = memory_mib
-        self.gpus = gpus
-        self.shm_size_mib = shm_size_mib
-        self.interruptible = interruptible
-
-    def __str__(self) -> str:
-        return f'Requirements(cpus={self.cpus}, memory_mib={self.memory_mib}, ' \
-               f'gpus={self.gpus}, ' \
-               f'shm_size_mib={self.shm_size_mib}, ' \
-               f'interruptible={self.interruptible})'
-
-
-class JobRef:
-    @abstractmethod
-    def get_id(self) -> Optional[str]:
-        pass
-
-    @abstractmethod
-    def set_id(self, job_id: Optional[str]):
-        pass
-
-
-class JobRefId(JobRef):
-    def get_id(self) -> Optional[str]:
-        return self.job_id
-
-    def set_id(self, job_id: Optional[str]):
-        self.job_id = job_id
-
-    def __init__(self, job_id: str):
-        self.job_id = job_id
-
-    def __str__(self) -> str:
-        return f'JobRefId(job_id="{self.job_id}")'
-
-
-class AppSpec:
-    def __init__(self, port_index: int, app_name: str, url_path: Optional[str] = None,
-                 url_query_params: Optional[Dict[str, str]] = None):
-        self.port_index = port_index
-        self.app_name = app_name
-        self.url_path = url_path
-        self.url_query_params = url_query_params
-
-    def __str__(self) -> str:
-        return f'AppSpec(app_name={self.app_name}, port_index={self.port_index}, ' \
-               f'url_path={_quoted(self.url_path)}, url_query_params={self.url_query_params})'
-
-
-class JobStatus(Enum):
-    SUBMITTED = "submitted"
-    DOWNLOADING = "downloading"
-    RUNNING = "running"
-    UPLOADING = "uploading"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ABORTING = "aborting"
-    ABORTED = "aborted"
-    FAILED = "failed"
-    DONE = "done"
-
-    def is_finished(self):
-        return self in [self.STOPPED, self.ABORTED, self.FAILED, self.DONE]
-
-    def is_unfinished(self):
-        return not self.is_finished()
-
-
-class JobHead(JobRef):
-    def __init__(self, job_id: str, repo_user_name: str, repo_name: str, run_name: str, workflow_name: Optional[str],
-                 provider_name: str, status: JobStatus, submitted_at: int, artifact_paths: Optional[List[str]],
-                 tag_name: Optional[str],
-                 app_names: Optional[List[str]]):
-        self.job_id = job_id
-        self.repo_user_name = repo_user_name
-        self.repo_name = repo_name
-        self.run_name = run_name
-        self.workflow_name = workflow_name
-        self.provider_name = provider_name
-        self.status = status
-        self.submitted_at = submitted_at
-        self.artifact_paths = artifact_paths
-        self.tag_name = tag_name
-        self.app_names = app_names
-
-    def get_id(self) -> Optional[str]:
-        return self.job_id
-
-    def set_id(self, job_id: Optional[str]):
-        self.job_id = job_id
-
-    def __str__(self) -> str:
-        artifact_paths = ("[" + ", ".join(
-            map(lambda a: _quoted(str(a)), self.artifact_paths)) + "]") if self.artifact_paths else None
-        app_names = ("[" + ", ".join(map(lambda a: _quoted(a), self.app_names)) + "]") if self.app_names else None
-        return f'JobHead(job_id="{self.job_id}", repo_user_name="{self.repo_user_name}", ' \
-               f'repo_name="{self.repo_name}", ' \
-               f'run_name="{self.run_name}", workflow_name={_quoted(self.workflow_name)}, ' \
-               f'provider_name="{self.provider_name}", ' \
-               f'status=JobStatus.{self.status.name}, ' \
-               f'submitted_at={self.submitted_at}, ' \
-               f'artifact_paths={artifact_paths}, ' \
-               f'tag_name={_quoted(self.tag_name)}, ' \
-               f'app_names={app_names})'
-
-
-class DepSpec:
-    def __init__(self, repo_user_name: str, repo_name: str, run_name: str, mount: bool):
-        self.repo_user_name = repo_user_name
-        self.repo_name = repo_name
-        self.run_name = run_name
-        self.mount = mount
-
-    def __str__(self) -> str:
-        return f'DepSpec(repo_user_name="{self.repo_user_name}", ' \
-               f'repo_name="{self.repo_name}", ' \
-               f'run_name="{self.run_name}",' \
-               f'mount={self.mount})'
-
-
-class ArtifactSpec:
-    def __init__(self, artifact_path: str, mount: bool):
-        self.artifact_path = artifact_path
-        self.mount = mount
-
-    def __str__(self) -> str:
-        return f'ArtifactSpec(artifact_path="{self.artifact_path}", ' \
-               f'mount={self.mount})'
-
-
-class Job(JobHead):
-    def __init__(self, job_id: Optional[str], repo_data: RepoData, run_name: str, workflow_name: Optional[str],
-                 provider_name: str, status: JobStatus, submitted_at: int, image_name: str,
-                 commands: Optional[List[str]], env: Optional[Dict[str, str]], working_dir: Optional[str],
-                 artifact_specs: Optional[List[ArtifactSpec]], port_count: Optional[int], ports: Optional[List[int]],
-                 host_name: Optional[str], requirements: Optional[Requirements], dep_specs: Optional[List[DepSpec]],
-                 master_job: Optional[JobRef], app_specs: Optional[List[AppSpec]], runner_id: Optional[str],
-                 request_id: Optional[str], tag_name: Optional[str]):
-        super().__init__(job_id, repo_data.repo_user_name, repo_data.repo_name, run_name, workflow_name, provider_name,
-                         status, submitted_at,
-                         [a.artifact_path for a in artifact_specs] if artifact_specs else None,
-                         tag_name,
-                         [a.app_name for a in app_specs] if app_specs else None)
-        self.repo_data = repo_data
-        self.runner_id = runner_id
-        self.request_id = request_id
-        self.image_name = image_name
-        self.commands = commands
-        self.env = env
-        self.working_dir = working_dir
-        self.artifact_specs = artifact_specs
-        self.port_count = port_count
-        self.ports = ports
-        self.host_name = host_name
-        self.requirements = requirements
-        self.dep_specs = dep_specs
-        self.master_job = master_job
-        self.app_specs = app_specs
-
-    def get_id(self) -> Optional[str]:
-        return self.job_id
-
-    def set_id(self, job_id: Optional[str]):
-        self.job_id = job_id
-
-    def __str__(self) -> str:
-        commands = ("[" + ", ".join(map(lambda a: _quoted(str(a)), self.commands)) + "]") if self.commands else None
-        artifact_specs = ("[" + ", ".join(
-            map(lambda a: _quoted(str(a)), self.artifact_specs)) + "]") if self.artifact_specs else None
-        app_specs = ("[" + ", ".join(map(lambda a: str(a), self.app_specs)) + "]") if self.app_specs else None
-        dep_specs = ("[" + ", ".join(map(lambda d: str(d), self.dep_specs)) + "]") if self.dep_specs else None
-        return f'Job(job_id="{self.job_id}", repo_data={self.repo_data}, ' \
-               f'run_name="{self.run_name}", workflow_name={_quoted(self.workflow_name)}, ' \
-               f'provider_name="{self.provider_name}", ' \
-               f'status=JobStatus.{self.status.name}, ' \
-               f'submitted_at={self.submitted_at}, ' \
-               f'image_name="{self.image_name}", ' \
-               f'commands={commands}, ' \
-               f'env={self.env}, ' \
-               f'working_dir={_quoted(self.working_dir)}, ' \
-               f'port_count={self.port_count}, ' \
-               f'ports={self.ports}, ' \
-               f'host_name={_quoted(self.host_name)}, ' \
-               f'artifact_specs={artifact_specs}, ' \
-               f'requirements={self.requirements}, ' \
-               f'dep_specs={dep_specs}, ' \
-               f'master_job={self.master_job}, ' \
-               f'app_specs={app_specs}, ' \
-               f'runner_id={_quoted(self.runner_id)}, ' \
-               f'request_id={_quoted(self.request_id)}, ' \
-               f'tag_name={_quoted(self.tag_name)})'
-
-
-class JobSpec(JobRef):
-    def __init__(self, image_name: str, commands: Optional[List[str]] = None,
-                 env: Optional[Dict[str, str]] = None, working_dir: Optional[str] = None,
-                 artifact_specs: Optional[List[ArtifactSpec]] = None,
-                 port_count: Optional[int] = None,
-                 requirements: Optional[Requirements] = None,
-                 master_job: Optional[JobRef] = None, app_specs: Optional[List[AppSpec]] = None):
-        self.job_id = None
-        self.image_name = image_name
-        self.commands = commands
-        self.env = env
-        self.working_dir = working_dir
-        self.port_count = port_count
-        self.artifact_specs = artifact_specs
-        self.requirements = requirements
-        self.master_job = master_job
-        self.app_specs = app_specs
-
-    def get_id(self) -> Optional[str]:
-        return self.job_id
-
-    def set_id(self, job_id: Optional[str]):
-        self.job_id = job_id
-
-    def __str__(self) -> str:
-        commands = ("[" + ", ".join(map(lambda a: _quoted(str(a)), self.commands)) + "]") if self.commands else None
-        artifact_specs = ("[" + ", ".join(
-            map(lambda a: str(a), self.artifact_specs)) + "]") if self.artifact_specs else None
-        app_specs = ("[" + ", ".join(map(lambda a: str(a), self.app_specs)) + "]") if self.app_specs else None
-        return f'JobSpec(job_id="{self.job_id}", image_name="{self.image_name}", ' \
-               f'commands={commands}, ' \
-               f'env={self.env}, ' \
-               f'working_dir={_quoted(self.working_dir)}, ' \
-               f'port_count={self.port_count}, ' \
-               f'artifact_specs={artifact_specs}, ' \
-               f'requirements={self.requirements}, ' \
-               f'master_job={self.master_job}, ' \
-               f'app_specs={app_specs})'

dstack/providers/__init__.py

@@ -1,316 +0,0 @@
-import importlib
-import sys
-import time
-from abc import abstractmethod
-from argparse import ArgumentParser, Namespace
-from pkgutil import iter_modules
-from typing import Optional, List, Dict, Any, Union
-
-from dstack.backend import load_backend, Backend
-from dstack.jobs import Job, JobStatus, JobSpec, Requirements, GpusRequirements, DepSpec, ArtifactSpec
-from dstack.repo import load_repo_data, RepoData
-from dstack.util import _quoted
-
-
-def _str_to_mib(s: str) -> int:
-    ns = s.replace(" ", "").lower()
-    if ns.endswith('mib'):
-        return int(s[:-3])
-    elif ns.endswith('gib'):
-        return int(s[:-3]) * 1024
-    elif ns.endswith('mi'):
-        return int(s[:-2])
-    elif ns.endswith('gi'):
-        return int(s[:-2]) * 1024
-    elif ns.endswith('mb'):
-        return int(int(s[:-2]) * 1000 * 1000 / 1024 / 1024)
-    elif ns.endswith('gb'):
-        return int(int(s[:-2]) * (1000 * 1000 * 1000) / 1024 / 1024)
-    elif ns.endswith('m'):
-        return int(int(s[:-1]) * 1000 * 1000 / 1024 / 1024)
-    elif ns.endswith('g'):
-        return int(int(s[:-1]) * (1000 * 1000 * 1000) / 1024 / 1024)
-    else:
-        raise Exception(f"Unknown memory unit: {s}")
-
-
-class Provider:
-    def __init__(self, provider_name: str):
-        self.provider_name: str = provider_name
-        self.provider_data: Optional[Dict[str, Any]] = None
-        self.provider_args: Optional[List[str]] = None
-        self.workflow_name: Optional[str] = None
-        self.run_as_provider: Optional[bool] = None
-        self.dep_specs: Optional[List[DepSpec]] = None
-        self.loaded = False
-
-    def __str__(self) -> str:
-        return f'Provider(name="{self.provider_name}", ' \
-               f'workflow_data="{self.provider_data}", ' \
-               f'workflow_name="{_quoted(self.workflow_name)}, ' \
-               f'provider_name="{self.provider_name}", ' \
-               f'run_as_provider={self.run_as_provider})'
-
-    # TODO: This is a dirty hack
-    def _safe_python_version(self, name: str):
-        python_version: str
-        v = self.provider_data.get(name)
-        if isinstance(v, str):
-            python_version = v
-        elif v == 3.1:
-            python_version = "3.10"
-        elif v:
-            python_version = str(v)
-        else:
-            version_info = sys.version_info
-            python_version = f"{version_info.major}.{version_info.minor}"
-        supported_python_versions = ["3.7", "3.8", "3.9", "3.10"]
-        if python_version not in supported_python_versions:
-            sys.exit(f"Python version `{python_version}` is not supported. "
-                     f"Supported versions: {str(supported_python_versions)}.")
-        return python_version
-
-    def load(self, provider_args: List[str], workflow_name: Optional[str], provider_data: Dict[str, Any]):
-        self.provider_args = provider_args
-        self.workflow_name = workflow_name
-        self.provider_data = provider_data
-        self.run_as_provider = not workflow_name
-        self.parse_args()
-        self.dep_specs = self._dep_specs()
-        self.loaded = True
-
-    @abstractmethod
-    def _create_parser(self, workflow_name: Optional[str]) -> Optional[ArgumentParser]:
-        return None
-
-    def help(self, workflow_name: Optional[str]):
-        parser = self._create_parser(workflow_name)
-        if parser:
-            parser.print_help()
-
-    @abstractmethod
-    def create_job_specs(self) -> List[JobSpec]:
-        pass
-
-    @staticmethod
-    def _add_base_args(parser: ArgumentParser):
-        parser.add_argument("-r", "--requirements", metavar="PATH", type=str)
-        parser.add_argument("-e", "--env", action='append')
-        parser.add_argument("-a", "--artifact", metavar="PATH", dest="artifacts", action='append')
-        parser.add_argument("--dep", metavar="(:TAG | WORKFLOW)", dest="deps", action='append')
-        parser.add_argument("-w", "--working-dir", metavar="PATH", type=str)
-        parser.add_argument("-i", "--interruptible", action="store_true")
-        parser.add_argument("--cpu", metavar="NUM", type=int)
-        parser.add_argument("--memory", metavar="SIZE", type=str)
-        parser.add_argument("--gpu", metavar="NUM", type=int)
-        parser.add_argument("--gpu-name", metavar="NAME", type=str)
-        parser.add_argument("--gpu-memory", metavar="SIZE", type=str)
-        parser.add_argument("--shm-size", metavar="SIZE", type=str)
-
-    def _parse_base_args(self, args: Namespace):
-        if args.requirements:
-            self.provider_data["requirements"] = args.requirements
-        if args.artifacts:
-            self.provider_data["artifacts"] = args.artifacts
-        if args.deps:
-            self.provider_data["deps"] = args.deps
-        if args.working_dir:
-            self.provider_data["working_dir"] = args.working_dir
-        if args.env:
-            env = self.provider_data.get("env") or []
-            env.extend(args.env)
-            self.provider_data["env"] = env
-        if args.cpu or args.memory or args.gpu or args.gpu_name or args.gpu_memory or args.shm_size \
-                or args.interruptible:
-            resources = self.provider_data.get("resources") or {}
-            self.provider_data["resources"] = resources
-            if args.cpu:
-                resources["cpu"] = args.cpu
-            if args.memory:
-                resources["memory"] = args.memory
-            if args.gpu or args.gpu_name or args.gpu_memory:
-                gpu = self.provider_data["resources"].get("gpu") or {} if self.provider_data.get("resources") else {}
-                if type(gpu) is int:
-                    gpu = {
-                        "count": gpu
-                    }
-                resources["gpu"] = gpu
-                if args.gpu:
-                    gpu["count"] = args.gpu
-                if args.gpu_memory:
-                    gpu["memory"] = args.gpu_memory
-                if args.gpu_name:
-                    gpu["name"] = args.gpu_name
-            if args.shm_size:
-                resources["shm_size"] = args.shm_size
-            if args.interruptible:
-                resources["interruptible"] = True
-
-    def parse_args(self):
-        pass
-
-    def submit_jobs(self, run_name: str, tag_name: str) -> List[Job]:
-        if not self.loaded:
-            raise Exception("The provider is not loaded")
-        job_specs = self.create_job_specs()
-        repo_data = load_repo_data()
-        backend = load_backend()
-        # [TODO] Handle master job
-        jobs = []
-        counter = []
-        for job_spec in job_specs:
-            submitted_at = int(round(time.time() * 1000))
-            job = Job(None, repo_data, run_name, self.workflow_name or None,
-                      self.provider_name, JobStatus.SUBMITTED, submitted_at,
-                      job_spec.image_name, job_spec.commands, job_spec.env,
-                      job_spec.working_dir, job_spec.artifact_specs, job_spec.port_count, None, None,
-                      job_spec.requirements, self.dep_specs, job_spec.master_job, job_spec.app_specs, None, None,
-                      tag_name)
-            backend.submit_job(job, counter)
-            jobs.append(job)
-        if tag_name:
-            backend.add_tag_from_run(repo_data.repo_user_name, repo_data.repo_name, tag_name,
-                                     run_name, run_jobs=jobs)
-        return jobs
-
-    def _dep_specs(self) -> Optional[List[DepSpec]]:
-        if self.provider_data.get("deps"):
-            repo_data = load_repo_data()
-            backend = load_backend()
-            return [self._parse_dep_spec(dep, backend, repo_data) for dep in self.provider_data["deps"]]
-        else:
-            return None
-
-    def _artifact_specs(self) -> Optional[List[ArtifactSpec]]:
-        if self.provider_data.get("artifacts"):
-            return [self._parse_artifact_spec(a) for a in self.provider_data["artifacts"]]
-        else:
-            return None
-
-    @staticmethod
-    def _parse_artifact_spec(artifact: Union[dict, str]) -> ArtifactSpec:
-        def remove_prefix(text: str, prefix: str) -> str:
-            if text.startswith(prefix):
-                return text[len(prefix):]
-            return text
-
-        if isinstance(artifact, str):
-            return ArtifactSpec(remove_prefix(artifact, "./"), False)
-        else:
-            return ArtifactSpec(remove_prefix(artifact["path"], "./"), artifact.get("mount") is True)
-
-    @staticmethod
-    def _parse_dep_spec(dep: Union[dict, str], backend: Backend, repo_data: RepoData) -> DepSpec:
-        if isinstance(dep, str):
-            mount = False
-            if dep.startswith(":"):
-                tag_dep = True
-                dep = dep[1:]
-            else:
-                tag_dep = False
-        else:
-            mount = dep.get("mount") is True
-            tag_dep = dep.get("tag") is not None
-            dep = dep.get("tag") or dep.get("workflow")
-        t = dep.split("/")
-        if len(t) == 1:
-            if tag_dep:
-                return Provider._tag_dep(backend, repo_data.repo_user_name, repo_data.repo_name, t[0], mount)
-            else:
-                return Provider._workflow_dep(backend, repo_data.repo_user_name, repo_data.repo_name, t[0], mount)
-        elif len(t) == 3:
-            if tag_dep:
-                return Provider._tag_dep(backend, t[0], t[1], t[2], mount)
-            else:
-                return Provider._workflow_dep(backend, t[0], t[1], t[2], mount)
-        else:
-            sys.exit(f"Invalid dep format: {dep}")
-
-    @staticmethod
-    def _tag_dep(backend: Backend, repo_user_name: str, repo_name: str, tag_name: str, mount: bool) -> DepSpec:
-        tag_head = backend.get_tag_head(repo_user_name, repo_name, tag_name)
-        if tag_head:
-            return DepSpec(repo_user_name, repo_name, tag_head.run_name, mount)
-        else:
-            sys.exit(f"Cannot find the tag '{tag_name}' in the '{repo_user_name}/{repo_name}' repo")
-
-    @staticmethod
-    def _workflow_dep(backend: Backend, repo_user_name: str, repo_name: str, workflow_name: str,
-                      mount: bool) -> DepSpec:
-        job_heads = sorted(backend.list_job_heads(repo_user_name, repo_name),
-                           key=lambda j: j.submitted_at, reverse=True)
-        run_name = next(iter([job_head.run_name for job_head in job_heads if
-                              job_head.workflow_name == workflow_name and job_head.status == JobStatus.DONE]),
-                        None)
-        if run_name:
-            return DepSpec(repo_user_name, repo_name, run_name, mount)
-        else:
-            sys.exit(f"Cannot find any successful workflow with the name '{workflow_name}' "
-                     f"in the '{repo_user_name}/{repo_name}' repo")
-
-    def _env(self) -> Optional[Dict[str, str]]:
-        if self.provider_data.get("env"):
-            env = {}
-            for e in self.provider_data.get("env"):
-                if "=" in e:
-                    tokens = e.split("=", maxsplit=1)
-                    env[tokens[0]] = tokens[1]
-                else:
-                    env[e] = ""
-            return env
-        else:
-            return None
-
-    def _resources(self) -> Optional[Requirements]:
-        if self.provider_data.get("resources"):
-            resources = Requirements()
-            if self.provider_data["resources"].get("cpu"):
-                if not str(self.provider_data["resources"]["cpu"]).isnumeric():
-                    sys.exit("resources.cpu in workflows.yaml should be an integer")
-                cpu = int(self.provider_data["resources"]["cpu"])
-                if cpu > 0:
-                    resources.cpus = cpu
-            if self.provider_data["resources"].get("memory"):
-                resources.memory_mib = _str_to_mib(self.provider_data["resources"]["memory"])
-            gpu = self.provider_data["resources"].get("gpu")
-            if gpu:
-                if str(gpu).isnumeric():
-                    gpu = int(self.provider_data["resources"]["gpu"])
-                    if gpu > 0:
-                        resources.gpus = GpusRequirements(gpu)
-                else:
-                    gpu_count = 0
-                    gpu_name = None
-                    if str(gpu.get("count")).isnumeric():
-                        gpu_count = int(gpu.get("count"))
-                    if gpu.get("name"):
-                        gpu_name = gpu.get("name")
-                        if not gpu_count:
-                            gpu_count = 1
-                    if gpu_count:
-                        resources.gpus = GpusRequirements(gpu_count, name=gpu_name)
-            for resource_name in self.provider_data["resources"]:
-                if resource_name.endswith("/gpu") and len(resource_name) > 4:
-                    if not str(self.provider_data["resources"][resource_name]).isnumeric():
-                        sys.exit(f"resources.'{resource_name}' in workflows.yaml should be an integer")
-                    gpu = int(self.provider_data["resources"][resource_name])
-                    if gpu > 0:
-                        resources.gpus = GpusRequirements(gpu, name=resource_name[:-4])
-            if self.provider_data["resources"].get("shm_size"):
-                resources.shm_size_mib = _str_to_mib(self.provider_data["resources"]["shm_size"])
-            if self.provider_data["resources"].get("interruptible"):
-                resources.interruptible = self.provider_data["resources"]["interruptible"]
-            if resources.cpus or resources.memory_mib or resources.gpus or resources.shm_size_mib \
-                    or resources.interruptible:
-                return resources
-            else:
-                return None
-
-
-def get_provider_names() -> List[str]:
-    return list(map(lambda m: m[1], filter(lambda m: m.ispkg and not m[1].startswith("_"),
-                                           iter_modules(sys.modules[__name__].__path__))))
-
-
-def load_provider(provider_name) -> Provider:
-    return importlib.import_module(f"dstack.providers.{provider_name}.main").__provider__()

dstack/providers/_python/main.py

@@ -1,88 +0,0 @@
-import argparse
-from argparse import ArgumentParser
-from typing import List, Optional, Dict, Any
-
-from dstack.jobs import JobSpec
-from dstack.providers import Provider
-
-
-class PythonProvider(Provider):
-    def __init__(self):
-        super().__init__("python")
-        self.file = None
-        self.before_run = None
-        # TODO: Handle numbers such as 3.1 (e.g. require to use strings)
-        self.version = None
-        self.args = None
-        self.requirements = None
-        self.env = None
-        self.artifact_specs = None
-        self.working_dir = None
-        self.resources = None
-        self.image_name = None
-
-    def load(self, provider_args: List[str], workflow_name: Optional[str], provider_data: Dict[str, Any]):
-        super().load(provider_args, workflow_name, provider_data)
-        self.file = self.provider_data["file"]
-        self.before_run = self.provider_data.get("before_run")
-        self.version = self._safe_python_version("version")
-        self.args = self.provider_data.get("args")
-        self.requirements = self.provider_data.get("requirements")
-        self.env = self._env()
-        self.artifact_specs = self._artifact_specs()
-        self.working_dir = self.provider_data.get("working_dir")
-        self.resources = self._resources()
-        self.image_name = self._image_name()
-
-    def _create_parser(self, workflow_name: Optional[str]) -> Optional[ArgumentParser]:
-        parser = ArgumentParser(prog="dstack run " + (workflow_name or self.provider_name))
-        self._add_base_args(parser)
-        if not workflow_name:
-            parser.add_argument("file", metavar="FILE", type=str)
-            parser.add_argument("args", metavar="ARGS", nargs=argparse.ZERO_OR_MORE)
-        return parser
-
-    def parse_args(self):
-        parser = self._create_parser(self.workflow_name)
-        args, unknown_args = parser.parse_known_args(self.provider_args)
-        self._parse_base_args(args)
-        if self.run_as_provider:
-            self.provider_data["file"] = args.file
-            _args = args.args + unknown_args
-            if _args:
-                self.provider_data["args"] = _args
-
-    def create_job_specs(self) -> List[JobSpec]:
-        return [JobSpec(
-            image_name=self.image_name,
-            commands=self._commands(),
-            env=self.env,
-            working_dir=self.working_dir,
-            artifact_specs=self.artifact_specs,
-            requirements=self.resources,
-        )]
-
-    def _image_name(self) -> str:
-        cuda_is_required = self.resources and self.resources.gpus
-        return f"dstackai/miniconda:{self.version}-cuda-11.1" if cuda_is_required else f"dstackai/miniconda:{self.version}"
-
-    def _commands(self):
-        commands = []
-        if self.requirements:
-            commands.append("pip install -r " + self.requirements)
-        if self.before_run:
-            commands.extend(self.before_run)
-        args_init = ""
-        if self.args:
-            if isinstance(self.args, str):
-                args_init += " " + self.args
-            if isinstance(self.args, list):
-                args_init += " " + ",".join(map(lambda arg: "\"" + arg.replace('"', '\\"') + "\"", self.args))
-        commands.append(
-            f"python {self.file}{args_init}"
-        )
-        return commands
-
-
-def __provider__():
-    return PythonProvider()