gitlab-cicd-python-wrapper 0.1.0__py3-none-any.whl

gitlab_cicd_python_wrapper/job.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+from gitlab_cicd_python_wrapper.artifacts import Artifacts
+from gitlab_cicd_python_wrapper.cache import Cache
+from gitlab_cicd_python_wrapper.common import WhenCondition
+from gitlab_cicd_python_wrapper.environment import Environment
+from gitlab_cicd_python_wrapper.image import Image, Service
+from gitlab_cicd_python_wrapper.needs import Need, NeedsPipeline
+from gitlab_cicd_python_wrapper.pages import Pages
+from gitlab_cicd_python_wrapper.release import Release
+from gitlab_cicd_python_wrapper.retry import Retry
+from gitlab_cicd_python_wrapper.rules import Rule
+from gitlab_cicd_python_wrapper.secrets import Secret
+from gitlab_cicd_python_wrapper.trigger import Trigger
+from gitlab_cicd_python_wrapper.variables import Variable
+
+
+class AllowFailure(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    exit_codes: list[int] | int
+
+
+class DastConfiguration(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    site_profile: str | None = None
+    scanner_profile: str | None = None
+
+
+class Identity(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    aud: str
+
+
+class Inherit(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    default: bool | list[str] | None = None
+    variables: bool | list[str] | None = None
+
+
+class Parallel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    matrix: list[dict[str, list[str]]]
+
+
+class RunConfig(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    shell: str | None = None
+    timeout: int | None = None
+
+
+class Job(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    script: list[str] | None = None
+    before_script: list[str] | None = None
+    after_script: list[str] | None = None
+    stage: str | None = None
+    image: str | Image | None = None
+    services: list[str | Service] | None = None
+    variables: dict[str, str | Variable] | None = None
+    rules: list[Rule] | None = None
+    allow_failure: bool | AllowFailure | None = None
+    artifacts: Artifacts | None = None
+    cache: Cache | list[Cache] | None = None
+    needs: list[str | Need | NeedsPipeline] | None = None
+    tags: list[str] | None = None
+    when: WhenCondition | None = None
+    environment: str | Environment | None = None
+    extends: str | list[str] | None = None
+    dependencies: list[str] | None = None
+    coverage: str | None = None
+    retry: int | Retry | None = None
+    timeout: str | None = None
+    parallel: int | Parallel | None = None
+    trigger: str | Trigger | None = None
+    resource_group: str | None = None
+    interruptible: bool | None = None
+    start_in: str | None = None
+    release: Release | None = None
+    secrets: dict[str, Secret] | None = None
+    pages: Pages | None = None
+    inherit: Inherit | None = None
+    dast_configuration: DastConfiguration | None = None
+    identity: Identity | None = None
+    manual_confirmation: str | None = None
+    run: RunConfig | None = None
+    id_tokens: dict[str, dict[str, str]] | None = None
+    hooks: dict[str, list[str]] | None = None

gitlab_cicd_python_wrapper/needs.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Need(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    job: str
+    artifacts: bool | None = None
+    optional: bool | None = None
+
+
+class NeedsPipeline(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    pipeline: str
+    job: str
+    artifacts: bool | None = None

gitlab_cicd_python_wrapper/pages.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Pages(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    publish: str | None = None
+    expire_in: str | None = None

gitlab_cicd_python_wrapper/pipeline.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+from gitlab_cicd_python_wrapper.globals import Default, Workflow
+from gitlab_cicd_python_wrapper.job import Job
+from gitlab_cicd_python_wrapper.serialization import dump_yaml, load_yaml
+from gitlab_cicd_python_wrapper.spec import ComponentSpec
+from gitlab_cicd_python_wrapper.variables import Variable
+
+GLOBAL_KEYWORDS = frozenset(
+    {
+        "stages",
+        "variables",
+        "default",
+        "workflow",
+        "include",
+        "spec",
+    }
+)
+
+
+class Pipeline(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    stages: list[str] | None = None
+    variables: dict[str, str | Variable] | None = None
+    default: Default | None = None
+    workflow: Workflow | None = None
+    include: list[dict[str, Any] | str] | None = None
+    spec: ComponentSpec | None = None
+    jobs: dict[str, Job] = {}
+
+    _raw: Any = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def separate_jobs_from_globals(cls, data: Any) -> Any:
+        if not isinstance(data, dict):
+            return data
+        if "jobs" in data:
+            return data
+        globals_ = {}
+        jobs = {}
+        for key, value in data.items():
+            if key in GLOBAL_KEYWORDS:
+                globals_[key] = value
+            else:
+                jobs[key] = value
+        globals_["jobs"] = jobs
+        return globals_
+
+    @classmethod
+    def from_yaml(cls, source: str | Path) -> Pipeline:
+        data, raw = load_yaml(source)
+        pipeline = cls.model_validate(data)
+        pipeline._raw = raw
+        return pipeline
+
+    def to_yaml(self, target: str | Path | None = None) -> str:
+        if self._raw is not None:
+            return dump_yaml(self._raw, target)
+        from ruamel.yaml.comments import CommentedMap
+
+        raw = CommentedMap()
+        if self.stages:
+            raw["stages"] = self.stages
+        if self.variables:
+            raw["variables"] = {
+                k: v if isinstance(v, str) else v.model_dump(exclude_none=True) for k, v in self.variables.items()
+            }
+        if self.default:
+            raw["default"] = self.default.model_dump(exclude_none=True, by_alias=True)
+        if self.workflow:
+            raw["workflow"] = self.workflow.model_dump(exclude_none=True, by_alias=True)
+        if self.include:
+            raw["include"] = self.include
+        for name, job in self.jobs.items():
+            raw[name] = job.model_dump(exclude_none=True, by_alias=True)
+        result = dump_yaml(raw)
+        if target is not None:
+            Path(target).write_text(result)
+        return result
+
+    @classmethod
+    def validate_file(cls, path: Path) -> list[str]:
+        try:
+            cls.from_yaml(path)
+            return []
+        except Exception as e:
+            return [str(e)]
+
+    @classmethod
+    def validate_file_from_string(cls, content: str) -> list[str]:
+        try:
+            cls.from_yaml(content)
+            return []
+        except Exception as e:
+            return [str(e)]

gitlab_cicd_python_wrapper/release.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Release(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    tag_name: str
+    description: str
+    name: str | None = None
+    ref: str | None = None
+    milestones: list[str] | None = None
+    released_at: str | None = None

gitlab_cicd_python_wrapper/retry.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from gitlab_cicd_python_wrapper.common import RetryWhen
+
+
+class Retry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    max: int = Field(ge=0, le=5)
+    when: list[RetryWhen] | None = None

gitlab_cicd_python_wrapper/rules.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from gitlab_cicd_python_wrapper.common import WhenCondition
+
+
+class Rule(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    if_: str | None = Field(None, alias="if")
+    changes: list[str] | None = None
+    exists: list[str] | None = None
+    when: WhenCondition | None = None
+    allow_failure: bool | None = None
+    variables: dict[str, str] | None = None
+    start_in: str | None = None
+
+
+class WorkflowRule(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    if_: str | None = Field(None, alias="if")
+    changes: list[str] | None = None
+    exists: list[str] | None = None
+    when: WhenCondition | None = None
+    variables: dict[str, str] | None = None
+    auto_cancel: dict | None = None

gitlab_cicd_python_wrapper/secrets.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class VaultEngine(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    name: str
+    path: str
+
+
+class VaultConfig(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    engine: VaultEngine
+    path: str
+    field: str
+
+
+class Secret(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    vault: VaultConfig

gitlab_cicd_python_wrapper/serialization.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from io import StringIO
+from pathlib import Path
+
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+
+
+def _make_yaml() -> YAML:
+    yaml = YAML(typ="rt")
+    yaml.preserve_quotes = True
+    yaml.width = 4096
+    yaml.indent(mapping=2, sequence=4, offset=2)
+    return yaml
+
+
+def load_yaml(source: str | Path) -> tuple[dict, CommentedMap]:
+    yaml = _make_yaml()
+    if isinstance(source, Path):
+        with open(source) as fh:
+            raw = yaml.load(fh)
+    else:
+        raw = yaml.load(source)
+    plain = dict(raw)
+    return plain, raw
+
+
+def dump_yaml(raw: CommentedMap, target: str | Path | None = None) -> str:
+    yaml = _make_yaml()
+    buf = StringIO()
+    yaml.dump(raw, buf)
+    text = buf.getvalue()
+    if target is not None:
+        path = Path(target)
+        path.write_text(text)
+    return text
+
+
+def yaml_round_trip(source: str | Path) -> str:
+    _, raw = load_yaml(source)
+    return dump_yaml(raw)
+
+
+def load_yaml_multi(source: str | Path) -> tuple[list[dict], list[CommentedMap]]:
+    yaml = _make_yaml()
+    if isinstance(source, Path):
+        with open(source) as fh:
+            docs = list(yaml.load_all(fh))
+    else:
+        docs = list(yaml.load_all(source))
+    plains = [dict(d) for d in docs]
+    return plains, docs
+
+
+def dump_yaml_multi(raws: list[CommentedMap], target: str | Path | None = None) -> str:
+    yaml = _make_yaml()
+    buf = StringIO()
+    yaml.dump_all(raws, buf)
+    text = buf.getvalue()
+    if target is not None:
+        path = Path(target)
+        path.write_text(text)
+    return text

gitlab_cicd_python_wrapper/spec.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from gitlab_cicd_python_wrapper.common import InputType
+
+
+class InputRule(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    if_: str = Field(alias="if")
+    options: list[str | int | float | bool] | None = None
+    default: str | int | float | bool | list | None = None
+
+
+class ComponentInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    type: InputType = InputType.string
+    default: str | int | float | bool | list | None = None
+    description: str | None = None
+    options: list[str | int | float | bool] | None = None
+    regex: str | None = None
+    rules: list[InputRule] | None = None
+
+    @model_validator(mode="after")
+    def validate_default_in_options(self) -> ComponentInput:
+        if self.options is not None and self.default is not None:
+            if self.default not in self.options:
+                raise ValueError(f"default {self.default!r} must be one of options {self.options!r}")
+        return self
+
+    @model_validator(mode="after")
+    def validate_regex_only_for_string(self) -> ComponentInput:
+        if self.regex is not None and self.type != InputType.string:
+            raise ValueError("regex is only valid for type 'string'")
+        return self
+
+
+class ComponentSpec(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    description: str | None = None
+    inputs: dict[str, ComponentInput] | None = None
+    include: list[dict[str, Any]] | None = None
+    component: list[str] | None = None
+
+    @field_validator("inputs")
+    @classmethod
+    def inputs_not_empty(cls, v: dict[str, ComponentInput] | None) -> dict[str, ComponentInput] | None:
+        if v is not None and len(v) == 0:
+            raise ValueError("spec:inputs cannot be empty")
+        return v

gitlab_cicd_python_wrapper/trigger.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class TriggerForward(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    yaml_variables: bool | None = None
+    pipeline_variables: bool | None = None
+    dotenv_variables: bool | None = None
+
+
+class Trigger(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    project: str | None = None
+    branch: str | None = None
+    strategy: str | None = None
+    include: list[dict[str, Any]] | None = None
+    forward: TriggerForward | None = None

gitlab_cicd_python_wrapper/variables.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Variable(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    value: str
+    description: str | None = None
+    options: list[str] | None = None
+    expand: bool | None = None