yamloom 0.1.0__cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl

yamloom/actions/toolchains/ruby.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from yamloom.actions.utils import validate_choice
+
+from typing import TYPE_CHECKING
+
+from ..._yamloom import Step
+from ..._yamloom import action
+from ..types import (
+    Oboollike,
+    Oboolstr,
+    Ointlike,
+    Ostr,
+    Ostrlike,
+    StringLike,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+__all__ = ['setup_ruby']
+
+
+def setup_ruby(
+    *,
+    name: Ostrlike = None,
+    version: str = 'v1',
+    ruby_version: Ostrlike = None,
+    rubygems: Ostrlike = None,
+    bundler: Ostrlike = None,
+    bundler_cache: Oboollike = None,
+    ruby_working_directory: Ostrlike = None,
+    cache_version: Ostrlike = None,
+    self_hosted: Oboollike = None,
+    windows_toolchain: Ostrlike = None,
+    token: Ostrlike = None,
+    args: Ostrlike = None,
+    entrypoint: Ostrlike = None,
+    condition: Oboolstr = None,
+    working_directory: Ostrlike = None,
+    shell: Ostr = None,
+    id: Ostr = None,  # noqa: A002
+    env: Mapping[str, StringLike] | None = None,
+    continue_on_error: Oboollike = None,
+    timeout_minutes: Ointlike = None,
+) -> Step:
+    options: dict[str, object] = {
+        'ruby-version': ruby_version,
+        'rubygems': rubygems,
+        'bundler': bundler,
+        'bundler-cache': bundler_cache,
+        'working-directory': ruby_working_directory,
+        'cache-version': cache_version,
+        'self-hosted': self_hosted,
+        'windows-toolchain': validate_choice(
+            'windows-toolchain', windows_toolchain, ['defauult', 'none']
+        ),
+        'token': token,
+    }
+    options = {key: value for key, value in options.items() if value is not None}
+
+    if name is None:
+        name = 'Setup Ruby'
+
+    return action(
+        name,
+        'actions/setup-ruby',
+        ref=version,
+        with_opts=options or None,
+        args=args,
+        entrypoint=entrypoint,
+        condition=condition,
+        working_directory=working_directory,
+        shell=shell,
+        id=id,
+        env=env,
+        continue_on_error=continue_on_error,
+        timeout_minutes=timeout_minutes,
+    )

yamloom/actions/toolchains/rust.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+from yamloom.actions.utils import validate_choice
+
+from typing import TYPE_CHECKING
+
+from ..._yamloom import Step
+from ..._yamloom import action
+from ..types import (
+    Oboollike,
+    Oboolstr,
+    Ointlike,
+    Ostr,
+    Ostrlike,
+    StringLike,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+__all__ = ['install_rust_tool', 'setup_rust']
+
+
+def setup_rust(
+    *,
+    name: Ostrlike = None,
+    version: str = 'v1',
+    toolchain: Ostrlike = None,
+    target: Ostrlike = None,
+    components: Sequence[StringLike] | None = None,
+    cache: Oboollike = None,
+    cache_directories: Sequence[StringLike] | None = None,
+    cache_workspaces: Sequence[StringLike] | None = None,
+    cache_on_failure: Oboollike = None,
+    cache_key: Ostrlike = None,
+    cache_shared_key: Ostrlike = None,
+    cache_bin: Oboollike = None,
+    cache_provider: Ostrlike = None,
+    cache_all_crates: Oboollike = None,
+    cache_workspace_crates: Oboollike = None,
+    matcher: Oboollike = None,
+    rustflags: Ostrlike = None,
+    override: Oboollike = None,
+    rust_src_dir: Ostrlike = None,
+    args: Ostrlike = None,
+    entrypoint: Ostrlike = None,
+    condition: Oboolstr = None,
+    working_directory: Ostrlike = None,
+    shell: Ostr = None,
+    id: Ostr = None,  # noqa: A002
+    env: Mapping[str, StringLike] | None = None,
+    continue_on_error: Oboollike = None,
+    timeout_minutes: Ointlike = None,
+) -> Step:
+    options: dict[str, object] = {
+        'toolchain': toolchain,
+        'target': target,
+        'components': ','.join(str(s) for s in components)
+        if components is not None
+        else None,
+        'cache': cache,
+        'cache-directories': '\n'.join(str(s) for s in cache_directories)
+        if cache_directories is not None
+        else None,
+        'cache-workspaces': '\n'.join(str(s) for s in cache_workspaces)
+        if cache_workspaces is not None
+        else None,
+        'cache-on-failure': cache_on_failure,
+        'cache-key': cache_key,
+        'cache-shared-key': cache_shared_key,
+        'cache-bin': cache_bin,
+        'cache-provider': validate_choice(
+            'cache_provider', cache_provider, ['github', 'buildjet', 'warpbuild']
+        ),
+        'cache-all-crates': cache_all_crates,
+        'cache-workspace-crates': cache_workspace_crates,
+        'matcher': matcher,
+        'rustflags': rustflags,
+        'override': override,
+        'rust-src-dir': rust_src_dir,
+    }
+
+    options = {key: value for key, value in options.items() if value is not None}
+
+    if name is None:
+        name = 'Setup Rust'
+
+    return action(
+        name,
+        'actions-rust-lang/setup-rust-toolchain',
+        ref=version,
+        with_opts=options or None,
+        args=args,
+        entrypoint=entrypoint,
+        condition=condition,
+        working_directory=working_directory,
+        shell=shell,
+        id=id,
+        env=env,
+        continue_on_error=continue_on_error,
+        timeout_minutes=timeout_minutes,
+    )
+
+
+def install_rust_tool(
+    *,
+    tool: Sequence[StringLike],
+    name: Ostrlike = None,
+    version: str = 'v1',
+    checksum: Oboollike = None,
+    fallback: Ostrlike = None,
+    args: Ostrlike = None,
+    entrypoint: Ostrlike = None,
+    condition: Oboolstr = None,
+    working_directory: Ostrlike = None,
+    shell: Ostr = None,
+    id: Ostr = None,  # noqa: A002
+    env: Mapping[str, StringLike] | None = None,
+    continue_on_error: Oboollike = None,
+    timeout_minutes: Ointlike = None,
+) -> Step:
+    if not tool:
+        msg = "at least one 'tool' must be specified"
+        raise ValueError(msg)
+
+    options: dict[str, object] = {
+        'tool': ','.join(str(s) for s in tool),
+        'checksum': checksum,
+        'fallback': validate_choice(
+            'fallback', fallback, ['none', 'cargo-binstall', 'cargo-install']
+        ),
+    }
+
+    options = {key: value for key, value in options.items() if value is not None}
+
+    if name is None:
+        suffix = 's' if len(tool) > 1 else ''
+        name = f'Install Rust Tool{suffix}'
+
+    return action(
+        name,
+        'taiki-e/install-action',
+        ref=version,
+        with_opts=options or None,
+        args=args,
+        entrypoint=entrypoint,
+        condition=condition,
+        working_directory=working_directory,
+        shell=shell,
+        id=id,
+        env=env,
+        continue_on_error=continue_on_error,
+        timeout_minutes=timeout_minutes,
+    )

yamloom/actions/toolchains/system.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from yamloom.actions.utils import validate_choice, check_string
+
+from typing import TYPE_CHECKING
+
+from ..._yamloom import Step
+from ..._yamloom import action
+from ..types import (
+    Oboollike,
+    Oboolstr,
+    Ointlike,
+    Ostr,
+    Ostrlike,
+    StringLike,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+__all__ = ['setup_mpi']
+
+
+def setup_mpi(
+    *,
+    name: Ostrlike = None,
+    version: str = 'v1',
+    mpi: Ostrlike = None,
+    args: Ostrlike = None,
+    entrypoint: Ostrlike = None,
+    condition: Oboolstr = None,
+    working_directory: Ostrlike = None,
+    shell: Ostr = None,
+    id: Ostr = None,  # noqa: A002
+    env: Mapping[str, StringLike] | None = None,
+    continue_on_error: Oboollike = None,
+    timeout_minutes: Ointlike = None,
+) -> Step:
+    options: dict[str, object] = {
+        'mpi': validate_choice('mpi', mpi, ['mpich', 'openmpi', 'intelmpi', 'msmpi']),
+    }
+
+    options = {key: value for key, value in options.items() if value is not None}
+
+    mpi_names = {
+        'mpich': 'MPICH',
+        'openmpi': 'Open MPI',
+        'intelmpi': 'Intel MPI',
+        'msmpi': 'Microsoft MPI',
+    }
+
+    if name is None:
+        mpi_str = check_string(options.get('mpi'))
+        if mpi_str:
+            name = f'Setup {mpi_names[mpi_str]}'
+        else:
+            name = 'Setup MPI'
+
+    return action(
+        name,
+        'mpi4py/setup-mpi',
+        ref=version,
+        with_opts=options or None,
+        args=args,
+        entrypoint=entrypoint,
+        condition=condition,
+        working_directory=working_directory,
+        shell=shell,
+        id=id,
+        env=env,
+        continue_on_error=continue_on_error,
+        timeout_minutes=timeout_minutes,
+    )

yamloom/actions/types.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import Union
+
+from ..expressions import BooleanExpression, NumberExpression, StringExpression
+
+Ostr = Union[str, None]
+Obool = Union[bool, None]
+Oint = Union[int, None]
+StringLike = Union[str, StringExpression]
+BoolLike = Union[bool, BooleanExpression]
+IntLike = Union[int, NumberExpression]
+Ostrlike = Union[StringLike, None]
+Oboolstr = Union[BooleanExpression, str, None]
+Oboollike = Union[BoolLike, None]
+Ointlike = Union[IntLike, None]
+StringOrBoolLike = Union[StringLike, BoolLike]
+
+__all__ = [
+    'Ostr',
+    'Obool',
+    'Oint',
+    'StringLike',
+    'BoolLike',
+    'IntLike',
+    'Ostrlike',
+    'Oboolstr',
+    'Oboollike',
+    'Ointlike',
+    'StringOrBoolLike',
+]

yamloom/actions/utils.py

@@ -0,0 +1,32 @@
+from yamloom.actions.types import Ostrlike
+from collections.abc import Sequence
+
+
+def validate_choice(
+    option_name: str, option_value: Ostrlike, choices: Sequence[str]
+) -> Ostrlike:
+    if option_value is not None:
+        if isinstance(option_value, str):
+            lowered = option_value.lower()
+            if option_value not in choices:
+                quoted_choices = [f"'{c}'" for c in choices]
+                if len(choices) > 2:
+                    choices_str = (
+                        f'{", ".join(quoted_choices[:-1])}, or {quoted_choices[-1]}'
+                    )
+                else:
+                    choices_str = ' or '.join(quoted_choices)
+                msg = f"'{option_name}' must be {choices_str}"
+                raise ValueError(msg)
+            return lowered
+        else:
+            return option_value
+    else:
+        return None
+
+
+def check_string(s: object | None) -> str | None:
+    if isinstance(s, str):
+        if '${{' not in s:
+            return s
+    return None

yamloom/expressions.py

@@ -0,0 +1,5 @@
+from ._yamloom import expressions as _expressions
+
+globals().update(_expressions.__dict__)
+
+__all__ = _expressions.__all__