models.py

"""TES models."""

# generated by datamodel-codegen:
#   filename:  task_execution_service.openapi.yaml
#   timestamp: 2022-07-07T11:45:30+00:00
# manually edited

# pragma pylint: disable=missing-class-docstring,invalid-name

from __future__ import annotations

from datetime import datetime
from enum import Enum
from typing import Optional

# pragma pylint: disable=no-name-in-module
from pydantic import AnyUrl, BaseModel, Field

# pragma pylint: disable=too-few-public-methods


class CustomBaseModel(BaseModel):
    """Base model that all other models derive from."""

    class Config:
        """Configuration class."""

        use_enum_values = True


class TesCancelTaskResponse(CustomBaseModel):
    pass


class TesCreateTaskResponse(CustomBaseModel):
    id: str = Field(..., description="Task identifier assigned by the server.")


class TesExecutor(CustomBaseModel):
    image: str = Field(
        default=[""],
        description=(
            "Name of the container image. The string will be passed as        "
            "    the image\nargument to the containerization run command.     "
            "        Examples:\n   - `ubuntu`\n   - `quay.io/aptible/ubuntu`\n"
            "              - `gcr.io/my-org/my-image`\n   -                "
            " `myregistryhost:5000/fedora/httpd:version1.0`"
        ),
        examples=["ubuntu:20.04"],
    )
    command: list[str] = Field(
        default=[""],
        description=(
            "A sequence of program arguments to execute, where the            "
            " first argument\nis the program to execute (i.e. argv).          "
            '  Example:\n```\n{\n  "command" :                 ["/bin/md5",'
            ' "/data/file1"]\n}\n```'
        ),
        examples=["/bin/md5", "/data/file1"],
    )
    workdir: Optional[str] = Field(
        default=None,
        description=(
            "The working directory that the command will be executed          "
            "   in.\nIf not defined, the system will default to the directory"
            " set                by\nthe container image."
        ),
        examples=["/data/"],
    )
    stdin: Optional[str] = Field(
        default=None,
        description=(
            "Path inside the container to a file which will be            "
            " piped\nto the executor's stdin. This must be an absolute path. "
            "           This mechanism\ncould be used in conjunction with the"
            " input             declaration to process\na data file using a"
            " tool that expects            STDIN.\n\nFor example, to get the"
            " MD5 sum of a file by reading             it into the"
            ' STDIN\n```\n{\n  "command" : ["/bin/md5"],\n  "stdin"           '
            '      : "/data/file1"\n}\n```'
        ),
        examples=["/data/file1"],
    )
    stdout: Optional[str] = Field(
        default=None,
        description=(
            "Path inside the container to a file where the            "
            " executor's\nstdout will be written to. Must be an absolute"
            ' path.                Example:\n```\n{\n  "stdout" :'
            ' "/tmp/stdout.log"\n}\n```'
        ),
        examples=["/tmp/stdout.log"],
    )
    stderr: Optional[str] = Field(
        default=None,
        description=(
            "Path inside the container to a file where the            "
            " executor's\nstderr will be written to. Must be an absolute"
            ' path.                 Example:\n```\n{\n  "stderr" :'
            ' "/tmp/stderr.log"\n}\n```'
        ),
        examples=["/tmp/stderr.log"],
    )
    env: Optional[dict[str, str]] = Field(
        default=None,
        description=(
            "Enviromental variables to set within the container.            "
            ' Example:\n```\n{\n  "env" : {\n                "ENV_CONFIG_PATH"'
            ' : "/data/config.file",\n    "BLASTDB" :            '
            ' "/data/GRC38",\n    "HMMERDB" : "/data/hmmer"\n  }\n}\n```'
        ),
        examples=[{"BLASTDB": "/data/GRC38", "HMMERDB": "/data/hmmer"}],
    )
    ignore_error: Optional[bool] = Field(
        default=None,
        description=(
            "Default behavior of running an array of executors is that "
            "execution stopson the first error. If `ignore_error` is `True`, "
            "then the runner will record error exit codes, but will continue "
            "on to the next tesExecutor."
        ),
    )


class TesExecutorLog(CustomBaseModel):
    start_time: Optional[str] = Field(
        default=None,
        description="Time the executor started, in RFC 3339 format.",
        examples=["2020-10-02T10:00:00-05:00"],
    )
    end_time: Optional[str] = Field(
        default=None,
        description="Time the executor ended, in RFC 3339 format.",
        examples=["2020-10-02T11:00:00-05:00"],
    )
    stdout: Optional[str] = Field(
        default=None,
        description=(
            "Stdout content.\n\nThis is meant for convenience. No           "
            " guarantees are made about the content.\nImplementations may"
            " chose            different approaches: only the head, only the"
            " tail,\na URL             reference only, etc.\n\nIn order to"
            " capture the full stdout             client should set"
            " Executor.stdout\nto a container file path,            and use"
            " Task.outputs to upload that file\nto permanent storage."
        ),
    )
    stderr: Optional[str] = Field(
        default=None,
        description=(
            "Stderr content.\n\nThis is meant for convenience. No            "
            " guarantees are made about the content.\nImplementations may"
            " chose             different approaches: only the head, only the"
            " tail,\na URL             reference only, etc.\n\nIn order to"
            " capture the full stderr            client should set"
            " Executor.stderr\nto a container file path,            and use"
            " Task.outputs to upload that file\nto permanent storage."
        ),
    )
    # exit code not optional according to specs, but Funnel may return 'null'
    exit_code: Optional[int] = Field(
        default=None,
        description="Exit code.",
    )


class TesFileType(Enum):
    FILE = "FILE"
    DIRECTORY = "DIRECTORY"


class TesInput(CustomBaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    url: Optional[str] = Field(
        default=None,
        description=(
            'REQUIRED, unless "content" is set.\n\nURL in long term        '
            " storage, for example:\n - s3://my-object-store/file1\n -        "
            "     gs://my-bucket/file2\n - file:///path/to/my/file\n -        "
            "     /path/to/my/file"
        ),
        examples=["s3://my-object-store/file1"],
    )
    path: str = Field(
        ...,
        description=(
            "Path of the file inside the container.\nMust be an            "
            " absolute path."
        ),
        examples=["/data/file1"],
    )
    type: Optional[TesFileType] = TesFileType.FILE
    content: Optional[str] = Field(
        default=None,
        description=(
            "File content literal.\n\nImplementations should support a        "
            "    minimum of 128 KiB in this field\nand may define their own   "
            "         maximum.\n\nUTF-8 encoded\n\nIf content is not empty,"
            ' "url"             must be ignored.'
        ),
    )
    streamable: Optional[bool] = Field(
        default=None,
        description=(
            "Indicate that a file resource could be accessed using a"
            " streaming interface, ie a FUSE mounted s3 object. This flag"
            " indicates that using a streaming mount, as opposed to "
            "downloading the whole file to the local scratch space, may be "
            "faster despite the latency and overhead. This does not mean that"
            " the backend will use a streaming interface, as it may not be "
            "provided by the vendor, but if the capacity is avalible it can "
            " be used without degrading the performance of the underlying"
            " program."
        ),
    )


class TesOutput(CustomBaseModel):
    name: Optional[str] = Field(
        default=None, description="User-provided name of         output file"
    )
    description: Optional[str] = Field(
        default=None,
        description=(
            "Optional users provided description field, can be used           "
            "  for documentation."
        ),
    )
    url: str = Field(
        ...,
        description=(
            "URL for the file to be copied by the TES server after the        "
            "    task is complete.\nFor Example:\n -                "
            " `s3://my-object-store/file1`\n - `gs://my-bucket/file2`\n       "
            "          - `file:///path/to/my/file`"
        ),
    )
    path: str = Field(
        ...,
        description=(
            "Path of the file inside the container.\nMust be an            "
            " absolute path."
        ),
    )
    type: Optional[TesFileType] = TesFileType.FILE


class TesOutputFileLog(CustomBaseModel):
    url: str = Field(
        ...,
        description=(
            "URL of the file in storage,             e.g. s3://bucket/file.txt"
        ),
    )
    path: str = Field(
        ...,
        description=(
            "Path of the file inside the container. Must be an            "
            " absolute path."
        ),
    )
    size_bytes: str = Field(
        ...,
        description=(
            "Size of the file in bytes. Note, this is currently coded         "
            "    as a string\nbecause official JSON doesn't support int64"
            " numbers."
        ),
        examples=["1024"],
    )


class TesResources(CustomBaseModel):
    cpu_cores: Optional[int] = Field(
        default=None, description="Requested number of CPUs", examples=[4]
    )
    preemptible: Optional[bool] = Field(
        default=None,
        description=(
            "Define if the task is allowed to run on preemptible            "
            " compute instances,\nfor example, AWS Spot. This option may have"
            " no            effect when utilized\non some backends that don't"
            " have the             concept of preemptible jobs."
        ),
        examples=[False],
    )
    ram_gb: Optional[float] = Field(
        default=None,
        description="Requested RAM required in gigabytes (GB)",
        examples=[8]
    )
    disk_gb: Optional[float] = Field(
        default=None,
        description="Requested disk size in gigabytes (GB)",
        examples=[40]
    )
    zones: Optional[list[str]] = Field(
        default=None,
        description=(
            "Request that the task be run in these compute zones. How         "
            "   this string\nis utilized will be dependent on the backend"
            " system.            For example, a\nsystem based on a cluster"
            " queueing system may use             this string to"
            " define\npriorty queue to which the job is               "
            " assigned."
        ),
        examples=["us-west-1"],
    )
    backend_parameters: Optional[dict[str, str]] = Field(
        default=None,
        description=(
            "Key/value pairs for backend configuration.ServiceInfo shall "
            "return a list of keys that a backend supports. Keys are case "
            "insensitive. It is expected that clients pass all runtime or "
            "hardware requirement key/values that are not mapped to existing"
            " tesResources properties to backend_parameters. Backends shall"
            " log system warnings if a key is passed that is unsupported. "
            "Backends shall not store or return unsupported keys if included "
            "in a task. If backend_parameters_strict equals true, backends "
            "should fail the task if any key/values are unsupported, "
            " otherwise, backends should attempt to run the task Intended "
            "uses include VM size selection, coprocessor configuration,"
            ' etc. \nExample: ```\n{\n  "backend_parameters" : {\n    '
            '"VmSize" :"Standard_D64_v3"\n  }\n}\n```'
        ),
        examples=[{"VmSize": "Standard_D64_v3"}],
    )
    backend_parameters_strict: Optional[bool] = Field(
        default=False,
        description=(
            "If set to true, backends should fail the task if any"
            " backend_parameters key/values are unsupported, otherwise, "
            "backends should attempt to run the task"
        ),
        examples=[False],
    )


class Artifact(Enum):
    tes = "tes"


class ServiceType(CustomBaseModel):
    group: str = Field(
        ...,
        description=(
            "Namespace in reverse domain name format. Use `org.ga4gh`         "
            "    for implementations compliant with official GA4GH"
            " specifications.            For services with custom APIs not"
            " standardized by GA4GH, or             implementations diverging"
            " from official GA4GH specifications,            use a different"
            " namespace (e.g. your organization's reverse domain              "
            "  name)."
        ),
        examples=["org.ga4gh"],
    )
    artifact: Enum = Field(
        ...,
        description=(
            "Name of the API or GA4GH specification implemented.            "
            " Official GA4GH types should be assigned as part of standards    "
            "         approval process. Custom artifacts are supported."
        ),
        examples=["beacon"],
    )
    version: str = Field(
        ...,
        description=(
            "Version of the API or specification. GA4GH specifications        "
            "    use semantic versioning."
        ),
        examples=["1.0.0"],
    )


class Organization(CustomBaseModel):
    name: str = Field(
        ...,
        description="Name of the organization responsible for the service",
        examples=["My organization"],
    )
    url: AnyUrl = Field(
        ...,
        description="URL of the website of the organization (RFC 3986 format)",
        examples=["https://example.com"],
    )


class Service(CustomBaseModel):
    id: str = Field(
        ...,
        description=(
            "Unique ID of this service. Reverse domain name notation          "
            "   is recommended, though not required. The identifier should"
            " attempt            to be globally unique so it can be used in"
            " downstream aggregator             services e.g. Service"
            " Registry."
        ),
        examples=["org.ga4gh.myservice"],
    )
    name: str = Field(
        ...,
        description="Name of this service. Should be human readable.",
        examples=["My project"],
    )
    type: Optional[ServiceType]
    description: Optional[str] = Field(
        default=None,
        description=(
            "Description of the service. Should be human readable and         "
            "    provide information about the service."
        ),
        examples=["This service provides..."],
    )
    organization: Organization = Field(
        ..., description="Organization providing the service"
    )
    contactUrl: Optional[AnyUrl] = Field(
        default=None,
        description=(
            "URL of the contact for the provider of this service, e.g.        "
            "    a link to a contact form (RFC 3986 format), or an email      "
            "           (RFC 2368 format)."
        ),
        examples=["mailto:support@example.com"],
    )
    documentationUrl: Optional[AnyUrl] = Field(
        default=None,
        description=(
            "URL of the documentation of this service             (RFC 3986"
            " format).This should help someone learn how             to use"
            " your service, including any specifics required to            "
            " access data, e.g. authentication."
        ),
        examples=["https://docs.myservice.example.com"],
    )
    createdAt: Optional[datetime] = Field(
        default=None,
        description=(
            "Timestamp describing when the service was first deployed         "
            "   and available (RFC 3339 format)"
        ),
        examples=["2019-06-04T12:58:19Z"],
    )
    updatedAt: Optional[datetime] = Field(
        default=None,
        description=(
            "Timestamp describing when the service was last updated           "
            " (RFC 3339 format)"
        ),
        examples=["2019-06-04T12:58:19Z"],
    )
    environment: Optional[str] = Field(
        default=None,
        description=(
            "Environment the service is running in. Use this to            "
            " distinguish between production, development and testing/staging "
            "                deployments. Suggested values are prod, test,"
            " dev, staging.                 However this is advised and not"
            " enforced."
        ),
        examples=["test"],
    )
    version: str = Field(
        ...,
        description=(
            "Version of the service being described. Semantic           "
            " versioning is recommended, but other identifiers, such as dates"
            " or                commit hashes, are also allowed. The version"
            " should be changed                whenever the service is"
            " updated."
        ),
        examples=["1.0.0"],
    )


class TesState(Enum):
    UNKNOWN = "UNKNOWN"
    QUEUED = "QUEUED"
    INITIALIZING = "INITIALIZING"
    RUNNING = "RUNNING"
    PAUSED = "PAUSED"
    COMPLETE = "COMPLETE"
    EXECUTOR_ERROR = "EXECUTOR_ERROR"
    SYSTEM_ERROR = "SYSTEM_ERROR"
    CANCELED = "CANCELED"
    PREEMPTED = "PREEMPTED"
    CANCELING = "CANCELING"


class TesNextTes(CustomBaseModel):
    """Create model instance for next TESNextTes."""

    url: str = Field(
        ...,
        description="TES server to which the task was forwarded.",
        examples=["https://my.tes.instance/"],
    )
    id: str = Field(
        ...,
        description=(
            "Task identifier assigned by the "
            "TES server to which the task was forwarded."
        ),
        examples=["job-0012345"],
    )
    forwarded_to: Optional[TesNextTes] = None


class Metadata(CustomBaseModel):
    """Create model instance for metadata."""

    forwarded_to: Optional[TesNextTes] = Field(
        default=None,
        description="TaskLog describes logging information related to a Task",
    )


class TesTaskLog(CustomBaseModel):
    logs: list[TesExecutorLog] = Field(
        ..., description="Logs for each executor"
    )
    metadata: Optional[Metadata] = Field(
        default=None,
        description=(
            "Arbitrary logging metadata included by the implementation."
        ),
        examples=[{"host": "worker-001", "slurmm_id": 123456}],
    )
    start_time: Optional[str] = Field(
        default=None,
        description="When the task started, in RFC 3339 format.",
        examples=["2020-10-02T10:00:00-05:00"],
    )
    end_time: Optional[str] = Field(
        default=None,
        description="When the task ended, in RFC 3339 format.",
        examples=["2020-10-02T11:00:00-05:00"],
    )
    outputs: list[TesOutputFileLog] = Field(
        ...,
        description=(
            "Information about all output files. Directory outputs are        "
            "    \nflattened into separate items."
        ),
    )
    system_logs: Optional[list[str]] = Field(
        default=None,
        description=(
            "System logs are any logs the system decides are relevant,        "
            "    \nwhich are not tied directly to an Executor"
            " process.\nContent is             implementation specific:"
            " format, size, etc.\n\nSystem logs may             be collected"
            " here to provide convenient access.\n\nFor             example,"
            " the system may include the name of the host\\nwhere           "
            " the task is executing, an error message that caused\na          "
            "   SYSTEM_ERROR state (e.g. disk is full), etc.\n\nSystem logs"
            " are             only included in the FULL task view."
        ),
    )


class TesServiceType(ServiceType):
    artifact: Artifact = Field(..., examples=["tes"])


class TesServiceInfo(Service):
    storage: Optional[list[str]] = Field(
        default=None,
        description=(
            "Lists some, but not necessarily all, storage locations           "
            "  supported\nby the service."
        ),
        examples=[
            "file:///path/to/local/funnel-storage",
            "s3://ohsu-compbio-funnel/storage",
        ],
    )
    type: Optional[TesServiceType] = None


class TesTask(CustomBaseModel):
    id: Optional[str] = Field(
        default=None,
        description="Task identifier assigned by the server.",
        examples=["job-0012345"],
    )
    state: Optional[TesState] = None
    name: Optional[str] = Field(
        default=None,
        description="User-provided task name."
    )
    description: Optional[str] = Field(
        default=None,
        description=(
            "Optional user-provided description of task for           "
            " documentation purposes."
        ),
    )
    inputs: Optional[list[TesInput]] = Field(
        default=None,
        description=(
            "Input files that will be used by the task. Inputs will be        "
            "    downloaded\nand mounted into the executor container as"
            " defined by                 the task request\ndocument."
        ),
        examples=[[{
                    "url": "s3://my-object-store/file1",
                    "path": "/data/file1"
                }]]
    )
    outputs: Optional[list[TesOutput]] = Field(
        default=None,
        description=(
            "Output files.\nOutputs will be uploaded from the executor        "
            "    container to long-term storage."
        ),
        examples=[
            {
                "path": "/data/outfile",
                "url": "s3://my-object-store/outfile-1",
                "type": "FILE",
            }
        ],
    )
    resources: Optional[TesResources] = None
    executors: list[TesExecutor] = Field(
        default=[TesExecutor],
        description=(
            "An array of executors to be run. Each of the executors           "
            " will run one\nat a time sequentially. Each executor is a"
            " different            command that\nwill be run, and each can"
            " utilize a different docker            image. But each of\nthe"
            " executors will see the same mapped inputs             and"
            " volumes that are declared\nin the parent CreateTask            "
            " message.\n\nExecution stops on the first error."
        ),
    )
    volumes: Optional[list[str]] = Field(
        default=None,
        description=(
            "Volumes are directories which may be used to share data          "
            "  between\nExecutors. Volumes are initialized as empty"
            " directories             by the\nsystem when the task starts and"
            " are mounted at the same             path\nin each"
            " Executor.\n\nFor example, given a volume defined at            "
            " `/vol/A`,\nexecutor 1 may write a file to"
            " `/vol/A/exec1.out.txt`,             then \n executor 2 may read"
            " from that file.\n\n(Essentially, this             translates to"
            " a `docker run -v` flag where\nthe container path is            "
            " the same for each executor)."
        ),
        examples=[["/vol/A/"]],
    )
    tags: Optional[dict[str, str]] = Field(
        default=None,
        description=(
            "A key-value map of arbitrary tags. These can be used to          "
            "   store meta-data\nand annotations about a task."
            ' Example:\n```\n{\n             "tags" : {\n      "WORKFLOW_ID" :'
            ' "cwl-01234",\n                  "PROJECT_GROUP" : "alice-lab"\n '
            " }\n}\n```"
        ),
        examples=[{"WORKFLOW_ID": "cwl-01234", "PROJECT_GROUP": "alice-lab"}],
    )
    logs: Optional[list[TesTaskLog]] = Field(
        default=None,
        description=(
            "Task logging information.\nNormally, this will contain           "
            "  only one entry, but in the case where\na task fails and is     "
            "        retried, an entry will be appended to this list."
        ),
    )
    creation_time: Optional[str] = Field(
        default=None,
        description=(
            "Date + time the task was created, in RFC 3339 format.\n          "
            "   This is set by the system, not the client."
        ),
        examples=["2020-10-02T10:00:00-05:00"],
    )

    class Config:
        """Pydantic configuration for model."""

        use_enum_values = True


class TesListTasksResponse(CustomBaseModel):
    tasks: list[TesTask] = Field(
        ...,
        description=(
            "List of tasks. These tasks will be based on the original         "
            "    submitted\ntask document, but with other fields, such as the"
            " job             state and\nlogging info, added/changed as the"
            " job progresses."
        ),
    )
    next_page_token: Optional[str] = Field(
        default=None,
        description=(
            "Token used to return the next page of results. This value        "
            "    can be used\nin the `page_token` field of the next ListTasks "
            "            request."
        ),
    )


class BasicAuth(CustomBaseModel):
    """Model instance for basic authorization credentials.

    Args:
        username: Username for basic authorization.
        password: Password for basic authorization.

    Attributes:
        username: Username for basic authorization.
        password: Password for basic authorization.
    """

    username: Optional[str] = None
    password: Optional[str] = None


class TesEndpoint(CustomBaseModel):
    """Create model instance for external TES endpoint.

    Args:
        host: Host at which the TES API is served that is processing this
            request; note that this should include the path information but
            *not* the base path defined in the TES API specification; e.g.,
            specify https://my.tes.com/api if the actual API is hosted a
            https://my.tes.com/api/ga4gh/tes/v1.
        base_path: Override the default path suffix defined in the TES API
            specification, i.e., `/ga4gh/tes/v1`.
        task_id: Identifier for task on external TES endpoint.

    Attributes:
        host: Host at which the TES API is served that is processing this
            request; note that this should include the path information but
            *not* the base path defined in the TES API specification; e.g.,
            specify https://my.tes.com/api if the actual API is hosted at
            https://my.tes.com/api/ga4gh/tes/v1.
        base_path: Override the default path suffix defined in the TES API
            specification, i.e., `/ga4gh/tes/v1`.
        task_id: Identifier for tasks on external TES endpoint.
    """

    host: str = ""
    base_path: str = ""


class DbDocument(CustomBaseModel):
    """Create model instance for task request database document.

    Args:
        task: Information about task.
        task_original: Information about original task.
        user_id: Identifier of resource owner.
        worker_id: Identifier of worker task.
        basic_auth: Basic authentication credentials.
        tes_endpoint: External TES endpoint.

    Attributes:
        task: Information about task.
        task_original: Information about original task.
        user_id: Identifier of resource owner.
        worker_id: Identifier of worker task.
        basic_auth: Basic authentication credentials.
        tes_endpoint: External TES endpoint.
    """

    task: TesTask = TesTask()
    task_original: TesTask = TesTask(executors=[])  # type: ignore
    user_id: Optional[str] = None
    worker_id: str = ""
    basic_auth: BasicAuth = BasicAuth()
    tes_endpoint: TesEndpoint = TesEndpoint()

    class Config:
        """Pydantic configuration for model."""

        use_enum_values = True


TesNextTes.update_forward_refs()