idegym-api 0.8.0__py3-none-any.whl

idegym/api/__init__.py

@@ -0,0 +1,9 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("idegym-api")
+except PackageNotFoundError:
+    __version__ = "0.0.0.dev0"
+
+if __version__ == "0.0.0.dev0":
+    __version__ = "latest"

idegym/api/auth.py

@@ -0,0 +1,21 @@
+from base64 import b64encode
+from typing import Optional
+
+from pydantic import BaseModel, Field, SecretStr
+
+
+class BasicAuth(BaseModel):
+    """Basic HTTP authentication credentials. Both fields are excluded from serialization."""
+
+    username: Optional[str] = Field(default=None, exclude=True)
+    password: Optional[SecretStr] = Field(default=None, exclude=True)
+
+    @property
+    def base64(self) -> Optional[str]:
+        """Returns Base64-encoded 'username:password' string, or None if username is not set."""
+        if not self.username:
+            return None
+        password = self.password.get_secret_value() if self.password else ""
+        value = self.username + ":" + password
+        encoded = value.encode()
+        return b64encode(encoded).decode()

idegym/api/config.py

@@ -0,0 +1,186 @@
+from os.path import abspath, join
+from tempfile import gettempdir
+from typing import Optional
+
+from idegym.api.auth import BasicAuth
+from idegym.api.data import DataSize
+from idegym.api.type import Duration, HttpUrl, IPvAddress, LogLevelName
+from pydantic import BaseModel, Field, field_validator
+
+
+class ServerConfig(BaseModel):
+    host: IPvAddress = Field(default="0.0.0.0")
+    port: int = Field(ge=0, le=65535, default=8000)
+    response_buffer_size: DataSize = Field(ge=0, default=DataSize(mb=8))
+    shutdown_delay: Duration = Field(default=Duration(seconds=30))
+
+
+class LoggingConfig(BaseModel):
+    level: LogLevelName = Field(default="INFO")
+    json_format: bool = Field(default=False)
+    file_path: str = Field(default=join(gettempdir(), "idegym.log"))
+    max_file_size: DataSize = Field(ge=0, default=DataSize(mb=10))
+    max_file_count: int = Field(description="Number of log file backups to keep", ge=0, default=5)
+
+    @field_validator("file_path")
+    def validate_file_path(cls, value: str) -> str:
+        path = value.strip() if value else None
+        if not path:
+            field = cls.__pydantic_fields__["file_path"]
+            return field.default
+        else:
+            return abspath(path)
+
+
+class ProjectConfig(BaseModel):
+    path: str = Field(default=".project")
+    archive: Optional[str] = Field(default=None)
+
+    @field_validator("path")
+    def validate_path(cls, value: str) -> str:
+        path = value.strip() if value else None
+        if not path:
+            field = cls.__pydantic_fields__["path"]
+            return field.default
+        else:
+            return abspath(path)
+
+    @field_validator("archive")
+    def validate_archive_path(cls, value: Optional[str]) -> Optional[str]:
+        path = value.strip() if value else None
+        if not path:
+            field = cls.__pydantic_fields__["archive"]
+            return field.default
+        else:
+            return abspath(path)
+
+
+class DatabaseConfig(BaseModel):
+    host: str = Field(default="localhost")
+    port: str = Field(default="5432")
+    user: str = Field(default="postgres")
+    password: str = Field(default="postgres")
+    db: str = Field(default="idegym")
+    clean_database: bool = Field(description="Drop and recreate all tables on startup", default=False)
+
+    @property
+    def url(self) -> str:
+        return f"postgresql+asyncpg://{self.user}:{self.password}@{self.host}:{self.port}/{self.db}"
+
+
+class SQLAlchemyConfig(BaseModel):
+    pool_size: int = Field(ge=0, default=20)
+    max_overflow: int = Field(ge=0, default=5)
+    pool_recycle: int = Field(ge=-1, default=1800, description="Connection recycling interval in seconds")
+    pool_timeout: int = Field(gt=0, default=1200, description="Connection acquisition timeout in seconds")
+    pool_pre_ping: bool = Field(default=True)
+
+
+class AsyncioConfig(BaseModel):
+    debug: bool = Field(default=False)
+    dump_interval: int = Field(description="Interval in seconds between asyncio task dumps", ge=1, default=300)
+
+
+class ResourcesConfig(BaseModel):
+    default_cpu_request: float = Field(description="Default CPU cores per environment", ge=0, default=1.0)
+    default_ram_request: float = Field(description="Default RAM per environment in GB", ge=0, default=2.0)
+
+
+class ConnectionLimitsConfig(BaseModel):
+    max_connections_or_asyncio_tasks: int = Field(
+        description="The maximum number of concurrent connections that may be established or asyncio tasks in uvicorn.",
+        ge=1,
+        default=1500,
+    )
+    unhealthy_connections_or_asyncio_tasks: int = Field(
+        description="The maximum number of concurrent connections that"
+        " may be established or asyncio tasks in uvicorn after which orchestrator becomes unhealthy.",
+        ge=1,
+        default=1000,
+    )
+    max_keepalive_connections: int = Field(
+        description="Allow the connection pool to maintain keep-alive connections below this point."
+        "Should be less than or equal to `max_connections`",
+        ge=1,
+        default=20,
+    )
+    keepalive_expiry: float = Field(
+        description="Time limit on idle keep-alive connections in seconds.", ge=1.0, default=5.0
+    )
+
+
+class TracingConfig(BaseModel):
+    endpoint: Optional[HttpUrl] = Field(description="OTLP HTTP endpoint for traces", default=None)
+    timeout: float = Field(description="Timeout for sending traces in seconds", ge=0, default=10)
+    auth: BasicAuth = Field(default_factory=BasicAuth)
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.endpoint)
+
+
+class OTELConfig(BaseModel):
+    service_name: Optional[str] = Field(default=None)
+    tracing: TracingConfig = Field(default_factory=TracingConfig)
+    attributes: dict[str, str] = Field(description="Extra attributes added to all spans", default_factory=dict)
+
+
+class WatcherConfig(BaseModel):
+    cleanup_interval: Duration = Field(default=Duration(seconds=60))
+    inactive_timeout: Duration = Field(
+        description="Inactivity timeout after which idle servers/clients are cleaned up",
+        default=Duration(minutes=10),
+    )
+    finished_timeout: Duration = Field(
+        description="How long to keep finished servers before deleting them",
+        default=Duration(minutes=5),
+    )
+    request_max_age: Duration = Field(
+        description="Maximum age of request records to retain",
+        default=Duration(days=14),
+    )
+    request_stale: Duration = Field(
+        description="Age after which IN_PROGRESS requests are marked as finished",
+        default=Duration(hours=24),
+    )
+
+
+class OrchestratorConfig(BaseModel):
+    host: IPvAddress = Field(default="0.0.0.0")
+    port: int = Field(ge=0, le=65535, default=8000)
+    workers: int = Field(description="Number of uvicorn worker processes", ge=1, default=1)
+    prometheus_multiproc_dir: str = Field(
+        description="Directory for Prometheus multiprocess metric files",
+        default=join(gettempdir(), "idegym", "prometheus"),
+    )
+    database: DatabaseConfig = Field(default_factory=DatabaseConfig)
+    sqlalchemy: SQLAlchemyConfig = Field(default_factory=SQLAlchemyConfig)
+    asyncio: AsyncioConfig = Field(default_factory=AsyncioConfig)
+    resources: ResourcesConfig = Field(default_factory=ResourcesConfig)
+    watcher: WatcherConfig = Field(default_factory=WatcherConfig)
+    client_request_timeout: float = Field(
+        description="Client request read timeout in seconds",
+        default=60.0 * 60,  # 1 hour
+    )
+    connection_limits: ConnectionLimitsConfig = Field(default_factory=ConnectionLimitsConfig)
+    enable_fifo_server_reuse: bool = Field(
+        description="Enable FIFO queue for server reuse to ensure fair provisioning",
+        default=False,
+    )
+
+    @field_validator("prometheus_multiproc_dir")
+    def validate_prometheus_multiproc_dir(cls, value: str) -> str:
+        path = value.strip() if value else None
+        if not path:
+            field = cls.__pydantic_fields__["prometheus_multiproc_dir"]
+            return field.default
+        else:
+            return abspath(path)
+
+
+class Config(BaseModel):
+    server: ServerConfig = Field(default_factory=ServerConfig)
+    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+    project: ProjectConfig = Field(default_factory=ProjectConfig)
+    otel: OTELConfig = Field(default_factory=OTELConfig)
+    orchestrator: OrchestratorConfig = Field(default_factory=OrchestratorConfig)

idegym/api/ctx.py

@@ -0,0 +1,7 @@
+from contextvars import ContextVar
+from typing import Optional
+
+from structlog.contextvars import STRUCTLOG_KEY_PREFIX
+
+task_id_context_var: ContextVar[Optional[str]] = ContextVar(STRUCTLOG_KEY_PREFIX + "task_id", default=None)
+task_name_context_var: ContextVar[Optional[str]] = ContextVar(STRUCTLOG_KEY_PREFIX + "task_name", default=None)

idegym/api/data.py

@@ -0,0 +1,201 @@
+from enum import IntEnum, auto
+from functools import total_ordering
+from re import Pattern, compile
+from typing import Any, ClassVar, Union
+
+from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema
+
+
+class BinaryScaleEnum(IntEnum):
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> int:
+        return 2 ** (count * 10)
+
+
+class DataUnit(BinaryScaleEnum):
+    B = auto()
+    KB = auto()
+    MB = auto()
+    GB = auto()
+    TB = auto()
+    PB = auto()
+    EB = auto()
+    ZB = auto()
+    YB = auto()
+
+    @property
+    def bytes(self) -> int:
+        return self.value
+
+
+@total_ordering
+class DataSize:
+    PATTERN: ClassVar[Pattern] = compile(r"^([+\-]?\d+)(B|[EGKMPTYZ]B)?$")
+
+    def __init__(
+        self,
+        b: int = 0,
+        kb: int = 0,
+        mb: int = 0,
+        gb: int = 0,
+        tb: int = 0,
+        pb: int = 0,
+        eb: int = 0,
+        zb: int = 0,
+        yb: int = 0,
+    ):
+        args = {
+            DataUnit.KB: kb,
+            DataUnit.MB: mb,
+            DataUnit.GB: gb,
+            DataUnit.TB: tb,
+            DataUnit.PB: pb,
+            DataUnit.EB: eb,
+            DataUnit.ZB: zb,
+            DataUnit.YB: yb,
+        }
+        self._bytes = b + sum(size.bytes * amount for size, amount in args.items() if amount)
+
+    @classmethod
+    def parse(cls, value: str, unit: DataUnit = DataUnit.B) -> "DataSize":
+        try:
+            normalized = value.replace(" ", "").upper()
+            matcher = cls.PATTERN.match(normalized)
+            if not matcher:
+                raise ValueError(f"'{value}' does not match data size pattern")
+            amount, suffix = matcher.groups()
+            unit: DataUnit = DataUnit[suffix] if suffix else unit
+            return cls(b=unit.bytes * int(amount))
+        except Exception as ex:
+            raise ValueError(f"'{value}' is not a valid data size") from ex
+
+    @property
+    def negative(self) -> bool:
+        return self.bytes < 0
+
+    @property
+    def bytes(self) -> int:
+        return self._bytes
+
+    @property
+    def kilobytes(self) -> int:
+        return self.bytes // DataUnit.KB.bytes
+
+    @property
+    def megabytes(self) -> int:
+        return self.bytes // DataUnit.MB.bytes
+
+    @property
+    def gigabytes(self) -> int:
+        return self.bytes // DataUnit.GB.bytes
+
+    @property
+    def terabytes(self) -> int:
+        return self.bytes // DataUnit.TB.bytes
+
+    @property
+    def petabytes(self) -> int:
+        return self.bytes // DataUnit.PB.bytes
+
+    @property
+    def exabytes(self) -> int:
+        return self.bytes // DataUnit.EB.bytes
+
+    @property
+    def zettabytes(self) -> int:
+        return self.bytes // DataUnit.ZB.bytes
+
+    @property
+    def yottabytes(self) -> int:
+        return self.bytes // DataUnit.YB.bytes
+
+    def __eq__(self, other: Union["DataSize", int, str, None]) -> bool:
+        if self is other:
+            return True
+        match other:
+            case DataSize():
+                return self.bytes == other.bytes
+            case int():
+                parsed = DataSize(b=other)
+                return self.bytes == parsed.bytes
+            case str():
+                parsed = DataSize.parse(value=other)
+                return self.bytes == parsed.bytes
+            case _:
+                return NotImplemented
+
+    def __str__(self) -> str:
+        return f"{self.bytes}B"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(bytes={self.bytes})"
+
+    def __hash__(self) -> int:
+        return hash(self.bytes)
+
+    def __lt__(self, other: Union["DataSize", int, str]) -> bool:
+        match other:
+            case DataSize():
+                return self.bytes < other.bytes
+            case int():
+                parsed = DataSize(b=other)
+                return self.bytes < parsed.bytes
+            case str():
+                parsed = DataSize.parse(value=other)
+                return self.bytes < parsed.bytes
+            case _:
+                return NotImplemented
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Union["DataSize", int, str]) -> "DataSize":
+        match value:
+            case cls():
+                return value
+            case int():
+                return cls(b=value)
+            case str():
+                return cls.parse(value=value)
+            case _:
+                raise ValueError(f"Cannot convert {value} to {cls.__name__}")
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls,
+        _source_type: Any,
+        _handler: GetCoreSchemaHandler,
+    ) -> core_schema.CoreSchema:
+        return core_schema.union_schema(
+            [
+                core_schema.is_instance_schema(cls),
+                core_schema.chain_schema(
+                    [
+                        core_schema.int_schema(),
+                        core_schema.no_info_plain_validator_function(cls.validate),
+                    ]
+                ),
+                core_schema.chain_schema(
+                    [
+                        core_schema.str_schema(),
+                        core_schema.no_info_plain_validator_function(cls.parse),
+                    ]
+                ),
+            ]
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls,
+        _core_schema: core_schema.CoreSchema,
+        _handler: GetJsonSchemaHandler,
+    ) -> JsonSchemaValue:
+        return {
+            "type": "string",
+            "description": "Data size value (e.g. '5MB', '1GB')",
+            "examples": ["512B", "10KB", "5MB", "1GB", "2TB"],
+        }

idegym/api/docker.py

@@ -0,0 +1,71 @@
+from enum import StrEnum
+from typing import Any, Optional
+
+from idegym.api.data import DataSize
+from pydantic import BaseModel, Field, model_serializer, model_validator
+from pydantic_core.core_schema import SerializerFunctionWrapHandler
+
+
+class BaseImage(StrEnum):
+    DEBIAN = "debian-bookworm-20250520-slim"
+    UBUNTU = "ubuntu-jammy-20250530"
+
+    DEFAULT = DEBIAN
+
+
+class ContainerConfig(BaseModel):
+    cpu_period: Optional[int] = Field(
+        description="Length of a CPU period in microseconds",
+        default=None,
+        gt=0,
+    )
+    cpu_quota: Optional[int] = Field(
+        description="Microseconds of CPU time that the container can get in a CPU period",
+        default=None,
+        gt=0,
+    )
+    cpu_rt_period: Optional[int] = Field(
+        description="Limit CPU real-time period in microseconds",
+        default=None,
+        gt=0,
+    )
+    cpu_rt_runtime: Optional[int] = Field(
+        description="Limit CPU real-time runtime in microseconds",
+        default=None,
+        gt=0,
+    )
+    cpu_shares: Optional[int] = Field(
+        description="CPU shares (relative weight)",
+        default=None,
+        gt=0,
+    )
+    memory: Optional[DataSize] = Field(
+        description="Memory limit",
+        ge="6MB",
+        default=None,
+    )
+    memory_reservation: Optional[DataSize] = Field(
+        description="Memory soft limit",
+        ge="6MB",
+        default=None,
+    )
+    memory_swappiness: Optional[int] = Field(
+        description="Tune a container's memory swappiness behavior",
+        default=None,
+        ge=0,
+        le=100,
+    )
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, nxt: SerializerFunctionWrapHandler) -> dict[str, Any]:
+        return {
+            key: (str(value) if key in ("memory", "memory_reservation") and value is not None else value)
+            for key, value in nxt(self).items()
+        }
+
+    @model_validator(mode="after")
+    def validate_cpu_constraints(self):
+        if self.cpu_rt_runtime is not None and self.cpu_rt_period is not None:
+            if self.cpu_rt_runtime > self.cpu_rt_period:
+                raise ValueError("'cpu_rt_runtime' must be less than or equal to 'cpu_rt_period'")
+        return self

idegym/api/download.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from idegym.api.type import AuthType, HttpUrl
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class Authorization(BaseModel):
+    """Authorization credentials. Both fields are excluded from serialization."""
+
+    type: Optional[AuthType] = Field(
+        default=None,
+        exclude=True,
+        repr=False,
+    )
+    token: Optional[str] = Field(
+        default=None,
+        exclude=True,
+        repr=False,
+    )
+
+    model_config = ConfigDict(frozen=True)
+
+    @model_validator(mode="after")
+    def validate_auth(self):
+        if self.type is not None and self.token is None:
+            raise ValueError("Authorization token is required when type is specified")
+        return self
+
+
+class ArchiveDescriptor(BaseModel):
+    name: str = Field(pattern=r"^.+\.(?:zip|tar\.gz)$")
+    url: HttpUrl
+
+    model_config = ConfigDict(frozen=True)
+
+
+class DownloadRequest(BaseModel):
+    descriptor: ArchiveDescriptor
+    auth: Authorization = Field(default_factory=Authorization)
+
+    model_config = ConfigDict(frozen=True)

idegym/api/exceptions.py

@@ -0,0 +1,10 @@
+class IdeGYMException(Exception):
+    pass
+
+
+class InspectionsNotReadyException(IdeGYMException):
+    pass
+
+
+class ResourceDeletionFailedException(IdeGYMException):
+    """Raised when one or more Kubernetes resources fail to be deleted."""

idegym/api/git.py

@@ -0,0 +1,103 @@
+from enum import StrEnum
+
+from idegym.api.download import ArchiveDescriptor
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GitServer(StrEnum):
+    GITHUB = "github.com"
+    GITLAB = "gitlab.com"
+    HUGGING_FACE_DATASETS = "huggingface.co/datasets"
+    HUGGING_FACE_MODELS = "huggingface.co"
+
+
+class GitRepository(BaseModel):
+    server: GitServer
+    owner: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+
+    model_config = ConfigDict(frozen=True)
+
+    @property
+    def qualified_name(self) -> str:
+        return f"{self.owner}/{self.name}"
+
+    @property
+    def url(self) -> str:
+        return f"https://{self.server}/{self.qualified_name}.git"
+
+    def head(self) -> "GitRepositorySnapshot":
+        return self.at("HEAD")
+
+    def at(self, reference: str) -> "GitRepositorySnapshot":
+        return GitRepositorySnapshot(repository=self, reference=reference)
+
+    @classmethod
+    def parse(cls, url: str) -> "GitRepository":
+        if not url.startswith("https://"):
+            raise ValueError("URL must start with 'https://'")
+        value = url.removeprefix("https://").removesuffix(".git")
+        for server in GitServer:
+            if value.startswith(server):
+                path = value.removeprefix(server)
+                _, owner, name, *other = path.split("/")
+                if len(other) != 0:
+                    raise ValueError(f"URL must be in the format 'https://{server}/<owner>/<name>.git', got '{url}'")
+                return cls(owner=owner, name=name, server=server)
+        raise ValueError(f"Invalid URL: '{url}'")
+
+
+class GitRepositorySnapshot(BaseModel):
+    repository: GitRepository
+    reference: str = Field(
+        description="Branch, tag, commit hash, or HEAD",
+        pattern=r"^(HEAD|([\w\-.]+)(/[\w\-.]+)?|refs/(heads|tags|remotes)/[\w\-./]+)$",
+        default="HEAD",
+    )
+
+    model_config = ConfigDict(frozen=True)
+
+    @property
+    def filename(self) -> str:
+        return f"{self.repository.name}-{self.reference}.tar.gz"
+
+    def descriptor(self) -> ArchiveDescriptor:
+        url = self.repository.url.removesuffix(".git")
+        match self.repository.server:
+            case GitServer.GITHUB:
+                url += f"/archive/{self.reference}.tar.gz"
+            case GitServer.GITLAB:
+                url += f"/-/archive/{self.reference}/{self.repository.name}-{self.reference}.tar.gz"
+            case _:
+                # Downloading entire repositories from HuggingFace is not supported!
+                raise NotImplementedError(f"Unsupported server: '{self.repository.server}'")
+        return ArchiveDescriptor(name=self.filename, url=url)
+
+    def resource(self, path: str) -> "GitRepositoryResource":
+        return GitRepositoryResource(snapshot=self, path=path)
+
+
+class GitRepositoryResource(BaseModel):
+    snapshot: GitRepositorySnapshot
+    path: str = Field(description="Relative path within the repository")
+
+    model_config = ConfigDict(frozen=True)
+
+    @property
+    def filename(self) -> str:
+        *_, filename = self.path.split("/")
+        return filename
+
+    def descriptor(self) -> ArchiveDescriptor:
+        url = self.snapshot.repository.url.removesuffix(".git")
+        match self.snapshot.repository.server:
+            case GitServer.GITHUB:
+                url = url.replace(GitServer.GITHUB, "raw.githubusercontent.com")
+                url += f"/{self.snapshot.reference}/{self.path}"
+            case GitServer.GITLAB:
+                url += f"/-/raw/{self.snapshot.reference}/{self.path}"
+            case GitServer.HUGGING_FACE_DATASETS | GitServer.HUGGING_FACE_MODELS:
+                url += f"/resolve/{self.snapshot.reference}/{self.path}"
+            case _:
+                raise NotImplementedError(f"Unsupported server: '{self.snapshot.repository.server}'")
+        return ArchiveDescriptor(name=self.filename, url=url)

idegym/api/health.py

@@ -0,0 +1,8 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class HealthCheckResponse(BaseModel):
+    status: str = Field(description="Service health status, e.g. 'healthy'")
+    message: Optional[str] = Field(default=None, description="Optional message with details")

idegym/api/image_build.py

@@ -0,0 +1,28 @@
+from json import dumps as dump_json
+from typing import Any, Optional
+
+from idegym.api.download import DownloadRequest
+from idegym.utils.hashing import md5
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ImageBuildSpec(BaseModel):
+    name: Optional[str] = None
+    request: Optional[DownloadRequest] = Field(default=None, description="Optional project download request")
+    dockerfile_content: str = Field(description="Fully rendered Dockerfile content", min_length=1)
+    labels: dict[str, str] = Field(default_factory=dict, description="Image labels")
+    context_path: str = Field(default=".", description="Docker build context path")
+    platforms: list[str] = Field(default_factory=list, description="Build target platforms")
+    runtime_class_name: str = Field(default="gvisor", description="Kubernetes runtime class name")
+    resources: Optional[dict[str, Any]] = Field(default=None, description="Build resources")
+
+    model_config = ConfigDict(extra="forbid")
+
+    def image_version(self) -> str:
+        identifiers = []
+        if self.request is not None:
+            identifiers.append(dump_json(self.request.descriptor.model_dump(mode="json"), sort_keys=True))
+        identifiers.append(dump_json(self.labels, sort_keys=True))
+        identifiers.append(self.context_path)
+        identifiers.append(self.dockerfile_content)
+        return md5(*identifiers)

idegym/api/orchestrator/build.py

@@ -0,0 +1,34 @@
+from idegym.api.orchestrator.jobs import JobPollResult
+from pydantic import BaseModel, Field, field_validator, model_validator
+from yaml import YAMLError
+from yaml import safe_load as parse_yaml
+
+
+class BuildFromYamlRequest(BaseModel):
+    namespace: str = Field(default="idegym")
+    yaml_content: str = Field(description="YAML content containing image build job definitions")
+
+    @field_validator("yaml_content")
+    def validate_yaml_content(cls, value: str) -> str:
+        try:
+            parse_yaml(value)
+            return value
+        except YAMLError as ex:
+            raise ValueError("Yaml content is not valid") from ex
+
+
+class BuildFromYamlResponse(BaseModel):
+    job_names: list[str] = Field(description="Names of started Kubernetes build jobs")
+
+
+class BuildJobsSummary(BaseModel):
+    total_jobs: int = Field(ge=0)
+    failed_jobs: int = Field(ge=0)
+    total_time: str = Field(description="Total elapsed time, e.g. '12.34s'")
+    jobs_results: list[JobPollResult]
+
+    @model_validator(mode="after")
+    def validate_jobs_results(self):
+        if not len(self.jobs_results) == self.total_jobs:
+            raise ValueError("Number of jobs results does not match total jobs")
+        return self

idegym/api/orchestrator/clients.py

@@ -0,0 +1,67 @@
+from enum import StrEnum
+from typing import Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class AvailabilityStatus(StrEnum):
+    ALIVE = "ALIVE"
+    FINISHED = "FINISHED"
+    REUSED = "REUSED"
+    FAILED_TO_START = "FAILED_TO_START"
+    STOPPED = "STOPPED"
+    KILLED = "KILLED"
+    CRASHED = "CRASHED"
+    DELETION_FAILED = "DELETION_FAILED"
+    RESTART_FAILED = "RESTART_FAILED"
+
+    @property
+    def is_terminal(self) -> bool:
+        """Returns True if this status represents a terminal state."""
+        return self in {
+            AvailabilityStatus.FAILED_TO_START,
+            AvailabilityStatus.KILLED,
+            AvailabilityStatus.STOPPED,
+            AvailabilityStatus.CRASHED,
+            AvailabilityStatus.DELETION_FAILED,
+            AvailabilityStatus.RESTART_FAILED,
+        }
+
+
+class RegisterClientRequest(BaseModel):
+    name: str = Field(description="Human-readable name for the client")
+    nodes_count: int = Field(default=0, ge=0, description="Number of nodes to spin up for the client")
+    namespace: str = Field(default="idegym")
+
+
+class SendClientHeartbeatRequest(BaseModel):
+    client_id: UUID
+    availability: AvailabilityStatus = Field(default=AvailabilityStatus.ALIVE)
+
+
+class StopClientRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+
+
+class StopClientResponse(BaseModel):
+    operation_id: Optional[int] = Field(default=None, description="Async operation ID to poll for client stop status")
+
+
+class FinishClientRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+
+
+class RegisteredClientResponse(BaseModel):
+    id: UUID
+    name: str = Field(default=None)
+    nodes_count: int = Field(ge=0)
+    namespace: str
+    last_heartbeat_time: int = Field(description="Epoch milliseconds")
+    availability: str
+    created_at: int = Field(description="Epoch milliseconds")
+    operation_id: Optional[int] = Field(
+        default=None, description="Async operation ID to poll for client registration status"
+    )

idegym/api/orchestrator/jobs.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class JobStatusResponse(BaseModel):
+    id: int = Field(default=0)
+    job_name: str
+    status: str
+    created_at: int = Field(default=0, description="Epoch milliseconds")
+    updated_at: int = Field(default=0, description="Epoch milliseconds")
+    details: Optional[str] = Field(default=None)
+    tag: Optional[str] = Field(default=None)
+    request_id: Optional[str] = Field(default=None)
+
+
+class JobPollResult(BaseModel):
+    job_name: str
+    status: str
+    tag: Optional[str] = Field(default=None)
+    details: Optional[str] = Field(default=None)

idegym/api/orchestrator/operations.py

@@ -0,0 +1,58 @@
+from enum import StrEnum
+from typing import Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class AsyncOperationType(StrEnum):
+    REGISTER_CLIENT_WITH_NODES = "REGISTER_CLIENT_WITH_NODES"
+    START_SERVER = "START_SERVER"
+    RESTART_SERVER = "RESTART_SERVER"
+    STOP_SERVER = "STOP_SERVER"
+    STOP_CLIENT = "STOP_CLIENT"
+    FORWARD_REQUEST = "FORWARD_REQUEST"
+
+
+class AsyncOperationStatus(StrEnum):
+    SCHEDULED = "SCHEDULED"
+    IN_PROGRESS = "IN_PROGRESS"
+    FAILED = "FAILED"
+    SUCCEEDED = "SUCCEEDED"
+    CANCELLED = "CANCELLED"
+    FINISHED_BY_WATCHER = "FINISHED_BY_WATCHER"
+
+
+class AsyncOperationStatusResponse(BaseModel):
+    id: int
+    request_type: str
+    status: str
+
+    request: Optional[str] = Field(default=None, description="Original request payload (JSON)")
+    result: Optional[str] = Field(default=None, description="Operation result payload (JSON or string)")
+
+    client_id: Optional[UUID] = Field(default=None)
+    server_id: Optional[int] = Field(default=None)
+
+    orchestrator_pod: Optional[str] = Field(default=None)
+
+    scheduled_at: int = Field(description="Epoch milliseconds")
+    started_at: Optional[int] = Field(default=None, description="Epoch milliseconds")
+    finished_at: Optional[int] = Field(default=None, description="Epoch milliseconds")
+
+
+class ForwardRequestPayload(BaseModel):
+    method: str
+    path: str
+    headers: dict[str, str] = Field(default_factory=dict, description="Sanitized request headers")
+    body: Optional[str] = Field(default=None, description="Request body as text, if present")
+    target_url: str = Field(description="Resolved target URL to forward the request to")
+    server_id: int
+
+
+class ForwardRequestResponse(BaseModel):
+    async_operation_id: Optional[int] = Field(default=None, description="Async operation ID to poll for request status")
+
+    status_code: Optional[int] = Field(default=None)
+    headers: Optional[dict[str, str]] = Field(default_factory=dict, description="Sanitized response headers")
+    body: Optional[str] = Field(default=None)

idegym/api/orchestrator/servers.py

@@ -0,0 +1,95 @@
+from enum import StrEnum
+from typing import Any, Optional
+from uuid import UUID
+
+from idegym.api.type import KubernetesNodeSelector, KubernetesObjectName, OCIImageName
+from pydantic import BaseModel, Field
+
+
+class ServerReuseStrategy(StrEnum):
+    NONE = "NONE"
+    RESTART = "RESTART"
+    RESET = "RESET"
+    CHECKPOINT = "CHECKPOINT"
+
+
+class ServerKind(StrEnum):
+    IDEGYM = "idegym"
+    OPENENV = "openenv"
+
+
+class StartServerRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+    image_tag: OCIImageName
+    server_name: KubernetesObjectName = Field(default="default-idegym-server")
+    runtime_class_name: Optional[str] = Field(default=None)
+    run_as_root: bool = Field(default=False)
+    service_port: int = Field(default=80, ge=0, le=65535)
+    container_port: int = Field(default=8000, ge=0, le=65535)
+    resources: Optional[dict[str, Any]] = Field(default=None, description="Kubernetes resource requirements")
+    node_selector: Optional[KubernetesNodeSelector] = Field(default=None)
+    server_start_wait_timeout_in_seconds: int = Field(
+        default=60, description="Seconds to wait for server readiness", ge=0
+    )
+    reuse_strategy: ServerReuseStrategy = Field(
+        default=ServerReuseStrategy.RESET,
+        description="What to do with an existing matching server instead of starting a new one",
+    )
+    server_kind: ServerKind = Field(default=ServerKind.IDEGYM, description="Server type: idegym or openenv")
+
+
+class StopServerRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+    server_id: int
+
+
+class FinishServerRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+    server_id: int
+
+
+class RestartServerRequest(BaseModel):
+    client_id: UUID
+    namespace: str = Field(default="idegym")
+    server_id: int
+    server_start_wait_timeout_in_seconds: int = Field(
+        default=60, description="Seconds to wait for server readiness after restart", ge=0
+    )
+
+
+class StartServerResponse(BaseModel):
+    namespace: str
+    client_id: UUID
+    operation_id: Optional[int] = Field(default=None, description="Async operation ID to poll for server start status")
+    server_id: Optional[int] = Field(default=None)
+    server_name: Optional[str] = Field(default=None, description="Logical server name as provided in the request")
+    generated_name: Optional[str] = Field(default=None, description="Generated Kubernetes resource name")
+    service_name: Optional[str] = Field(default=None, description="Kubernetes Service name for the server")
+    image_tag: Optional[str] = Field(default=None)
+    need_to_reset: bool = Field(default=False, description="True if the reused server requires a project reset")
+
+
+class ErrorResponse(BaseModel):
+    status_code: Optional[int] = Field(default=None)
+    headers: Optional[dict[str, str]] = Field(default_factory=dict, description="Sanitized response headers")
+    body: Optional[str] = Field(default=None)
+
+
+class ServerActionResponse(BaseModel):
+    server_name: str
+    message: str
+    operation_id: Optional[int] = Field(default=None, description="Async operation ID to poll for server action status")
+
+
+class ServerRequestResponse(BaseModel):
+    id: UUID
+    server_id: int
+    request: str = Field(description="Original request payload or summary")
+    path: Optional[str] = Field(default=None)
+    started_at: int = Field(description="Epoch milliseconds", ge=0)
+    result: Optional[str] = Field(default=None)
+    finished_at: Optional[int] = Field(default=None, description="Epoch milliseconds", ge=0)
+    status: str

idegym/api/paths.py

@@ -0,0 +1,45 @@
+from enum import StrEnum
+
+API_BASE_PATH = "/api"
+
+
+class APIPath(StrEnum):
+    pass
+
+
+class ActuatorPath(APIPath):
+    HEALTH = "/health"
+    LOG = "/log"
+    METRICS = "/metrics"
+    SHUTDOWN = "/shutdown"
+
+
+class OpenenvPath(APIPath):
+    """Path constants for OpenEnv servers deployed alongside IdeGYM without the IdeGYM API."""
+
+    HEALTH = "/health"
+
+
+class FSPath(APIPath):
+    LIST_DIRECTORY = "/fs/ls"
+    READ_FILE = "/fs/cat"
+    CREATE_FILE = "/fs/touch"
+    CREATE_DIRECTORY = "/fs/mkdir"
+    DELETE_PATH = "/fs/rm"
+
+
+class ProjectPath(APIPath):
+    RESET = "/project/reset"
+
+
+class RewardsPath(APIPath):
+    SETUP = "/rewards/setup"
+    COMPILATION = "/rewards/compilation"
+    TEST = "/rewards/test"
+
+
+class ToolsPath(APIPath):
+    BASH = "/tools/bash"
+    CREATE_FILE = "/tools/file/create"
+    EDIT_FILE = "/tools/file/edit"
+    PATCH_FILE = "/tools/file/patch"

idegym/api/project/reset.py

@@ -0,0 +1,14 @@
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class ResetRequest(BaseModel):
+    timeout: float = Field(default=600.0, description="Timeout for the reset operation in seconds")
+    graceful_termination_timeout: float = Field(
+        default=2.0, description="Timeout in seconds for graceful process termination"
+    )
+
+
+class ResetResult(BaseModel):
+    status: Status
+    output: str

idegym/api/rewards/compilation.py

@@ -0,0 +1,19 @@
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class CompilationRequest(BaseModel):
+    compilation_script: str = Field(default="./gradlew assemble")
+    timeout: float = Field(default=600.0, description="Timeout for the compilation in seconds")
+    graceful_termination_timeout: float = Field(
+        default=2.0, description="Timeout in seconds for graceful process termination"
+    )
+
+
+class CompilationResult(BaseModel):
+    status: Status
+    output: str
+
+
+class CompilationError(BaseModel):
+    message: str

idegym/api/rewards/inspection.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class InspectionRequest(BaseModel):
+    files_to_analyze: Optional[list[str]] = Field(default=None)
+    timeout: float = Field(default=600.0, description="Timeout for the analysis in seconds")
+
+
+class InspectionResult(BaseModel):
+    status: Status
+    output: str = Field(description="Analysis output, or error message if analysis failed", default="")
+
+
+class InspectionError(BaseModel):
+    message: str

idegym/api/rewards/setup.py

@@ -0,0 +1,19 @@
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class SetupRequest(BaseModel):
+    setup_check_script: str = Field(default="true")
+    timeout: float = Field(default=600.0, description="Timeout for the setup in seconds")
+    graceful_termination_timeout: float = Field(
+        default=2.0, description="Timeout in seconds for graceful process termination"
+    )
+
+
+class SetupResult(BaseModel):
+    status: Status
+    output: str
+
+
+class SetupError(BaseModel):
+    message: str

idegym/api/rewards/test.py

@@ -0,0 +1,26 @@
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class TestRequest(BaseModel):
+    test_script: str = Field(default="python -m pytest --junitxml=test-results.xml")
+    timeout: float = Field(default=600.0, description="Timeout for the test in seconds")
+    graceful_termination_timeout: float = Field(
+        default=2.0, description="Timeout in seconds for graceful process termination"
+    )
+
+
+class TestScores(BaseModel):
+    total: int = Field(ge=0)
+    passed: int = Field(ge=0)
+    failed: int = Field(ge=0)
+    skipped: int = Field(ge=0)
+
+
+class TestReport(BaseModel):
+    status: Status
+    scores: TestScores
+
+
+class TestError(BaseModel):
+    message: str

idegym/api/status.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class Status(StrEnum):
+    SUCCESS = "success"
+    FAILURE = "failure"
+    IN_PROGRESS = "in_progress"

idegym/api/tools/bash.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field
+
+
+class BashCommandRequest(BaseModel):
+    command: str = Field(description="Command to execute as a bash script")
+    timeout: float = Field(default=600.0, description="Timeout for the command execution in seconds")
+    graceful_termination_timeout: float = Field(
+        default=2.0, description="Timeout in seconds for graceful process termination"
+    )
+
+
+class BashCommandResponse(BaseModel):
+    stdout: str
+    stderr: str
+    exit_code: int
+
+
+class BashCommandErrorResponse(BaseModel):
+    message: str

idegym/api/tools/file.py

@@ -0,0 +1,26 @@
+from idegym.api.status import Status
+from pydantic import BaseModel, Field
+
+
+class FileRequest(BaseModel):
+    file_path: str
+
+
+class CreateFileRequest(FileRequest):
+    content: str
+
+
+class EditFileRequest(FileRequest):
+    start_line: int = Field(ge=0)
+    end_line: int = Field(ge=0)
+    new_content: str
+
+
+class PatchFileRequest(FileRequest):
+    """Applies a unified diff patch generated by `diff_patch.compute_diff`."""
+
+    patch: str
+
+
+class FileResult(BaseModel):
+    status: Status

idegym/api/type.py

@@ -0,0 +1,56 @@
+from datetime import timedelta
+from typing import Annotated, Literal, Type, TypeAlias
+
+from pydantic import AnyHttpUrl, BeforeValidator, IPvAnyAddress, StringConstraints, TypeAdapter
+
+ipv_address_adapter = TypeAdapter(IPvAnyAddress)
+http_url_adapter = TypeAdapter(AnyHttpUrl)
+
+HttpUrl = Annotated[str, BeforeValidator(lambda value: str(http_url_adapter.validate_python(value)))]
+IPvAddress = Annotated[str, BeforeValidator(lambda value: str(ipv_address_adapter.validate_python(value)))]
+
+# https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names
+KubernetesObjectName = Annotated[
+    str,
+    StringConstraints(
+        min_length=1,
+        max_length=63,
+        # language=regexp
+        pattern="^[a-z]([-a-z0-9]*[a-z0-9])?$",
+    ),
+]
+# https://github.com/opencontainers/distribution-spec/blob/main/spec.md#workflow-categories
+OCIImageName = Annotated[
+    str,
+    StringConstraints(
+        min_length=1,
+        max_length=383,  # The maximum length is set to 255 + 128
+        # language=regexp
+        pattern="^[a-z0-9._/:@-]+$",
+    ),
+]
+# https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#syntax-and-character-set
+KubernetesLabelKey = Annotated[
+    str,
+    StringConstraints(
+        min_length=1,
+        max_length=317,  # 253 (prefix) + 1 (/) + 63 (name)
+        # language=regexp
+        pattern=r"^([a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?/)?[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$",
+    ),
+]
+KubernetesLabelValue = Annotated[
+    str,
+    StringConstraints(
+        max_length=63,
+        # language=regexp
+        pattern=r"^([a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?)?$",
+    ),
+]
+
+
+KubernetesNodeSelector: TypeAlias = dict[KubernetesLabelKey, KubernetesLabelValue]
+AuthType: Type[str] = Literal["Basic", "Bearer", "Token"]
+Duration: TypeAlias = timedelta
+LogLevel: TypeAlias = int
+LogLevelName: Type[str] = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]

idegym_api-0.8.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: idegym-api
+Version: 0.8.0
+Summary: IdeGYM API
+Author-email: Daniil Mironov <daniil.mironov@jetbrains.com>, Ozren Dabić <ozren.dabic@jetbrains.com>, Vladimir Poliakov <vladimir.poliakov@jetbrains.com>, Vseslav Kasatskii <vseslav.kasatskii@jetbrains.com>
+Requires-Python: >=3.12
+Requires-Dist: idegym-common-utils>=0.8.0
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: structlog>=25.4.0

idegym_api-0.8.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+idegym/api/__init__.py,sha256=jQ8BJhwmXkWE6I6fVaU6bcAWeoZEnDaSL7AE3mYOSns,227
+idegym/api/auth.py,sha256=vCzMWcYlbpioEHOqS6Hu_Fwyude83n0BwKYaLBLVBYA,771
+idegym/api/config.py,sha256=udYkygaGtqBb7J-yk5Ei7_JRa6OfFe0Ckb8iNx7gM2I,7403
+idegym/api/ctx.py,sha256=3RTOSaZvaAunZe1UPF36KwmW22L9sba98TuA6ogeAe4,340
+idegym/api/data.py,sha256=Dk7rBglat28fWRey_YDWcu6HS9xvoDDbPRe9i7DLSM4,5730
+idegym/api/docker.py,sha256=aZgnnTbaK4uEnr1URK7YBi_pVcFWGdBAwOrp1Tb70_E,2221
+idegym/api/download.py,sha256=sBVk569b16CO8Vs7vxpOSyqrVWJzHMgQGkEF833fnYY,1076
+idegym/api/exceptions.py,sha256=7V4xt_4MtqtLFV43PTBib69kr-uXZGxgqPKfzqMIAv4,240
+idegym/api/git.py,sha256=CDJ879GzImiZo5r5-hhJ7HfEPw7wz8E-Oe0JQ2bGICM,3865
+idegym/api/health.py,sha256=jmhn8JPdVlTQDVoLLzElyL-Z254E-svDwRzzeF3nuJ0,278
+idegym/api/image_build.py,sha256=Nch0zhWuSza9DURdi9flOuxGmu8y1q7_9tPHyEATmc0,1385
+idegym/api/paths.py,sha256=8S232AexPiVLy_27HrMs6fWvvFzMTfloyf2KS2w5Sek,879
+idegym/api/status.py,sha256=Hu3ZggQIqhh1TyvLt7o5wXBakvHCUupKpbD2Ihkz3IE,130
+idegym/api/type.py,sha256=fI8E8vAI9p23j31L-sZMye2VN9QXLHe88ab6Ta8Tjos,1950
+idegym/api/orchestrator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idegym/api/orchestrator/build.py,sha256=aBh_77A_Zst_PCSXwqVtt5ezjYVI8nGywsRnsXdMOOg,1219
+idegym/api/orchestrator/clients.py,sha256=7-NTzuEeAk9kJlwgpVW-F7ZjlH0Y2RoaFTr28srEQAs,2043
+idegym/api/orchestrator/jobs.py,sha256=UCrGuzSqt5NF8_QP2KA7Srs_PPz_Wx4SXFGEbIalVVU,624
+idegym/api/orchestrator/operations.py,sha256=XH67IeV4_gjDJOy1O8edPzWWBSvEGKlDl3THgBWXVXA,2063
+idegym/api/orchestrator/servers.py,sha256=8i_ke27p9JhXlvbqfjwhrm-KxzxGiBtuErc_SvQukF4,3603
+idegym/api/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idegym/api/project/reset.py,sha256=7XJakz35TCNTkPwSleED-wp7umh-Cwf9SgcldjtMe2A,417
+idegym/api/rewards/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idegym/api/rewards/compilation.py,sha256=pAchlZPQ-K3qv7xOXUs2DDCbTgi6HevWoD8JaGDshhw,545
+idegym/api/rewards/inspection.py,sha256=YZUsjH-eaUF4k064Z9qsfl0LaY3jN4Z0lzvMXatN8so,512
+idegym/api/rewards/setup.py,sha256=omz4mMvb2NmTN_mzcUKH7GQOS_m1AU2Hodx6C0os4EM,507
+idegym/api/rewards/test.py,sha256=t8ztRcETGcnvoWdm1C2S1rwM9JjuTLxVZwxttFaVGsE,694
+idegym/api/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idegym/api/tools/bash.py,sha256=_Hjlljk1BwEwueQVPNvdmtyG-vpEtjK7URe86xuR2j8,550
+idegym/api/tools/file.py,sha256=JkdktteXmnJE0TLnZyZjLSA-6LKP1eHAtOoj_2fi1Og,492
+idegym_api-0.8.0.dist-info/METADATA,sha256=njU_6ixGDVfOWWia8lvK-u3cQ5lSfA0n0Y88vtoRB5c,442
+idegym_api-0.8.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+idegym_api-0.8.0.dist-info/RECORD,,

idegym_api-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any