buildkite_sdk.types

  1from typing import Optional, Union, List, Dict, Any
  2from buildkite_sdk.schema import (
  3    Adjustment as _matrix_adjustment,
  4    AutomaticRetry as _automatic_retry,
  5    BlockedState as _blocked_state,
  6    Build as _build,
  7    CacheClass as _cache_class,
  8    ConcurrencyMethod as _concurrency_method,
  9    DependsOnClass as _depends_on_class,
 10    ExitStatusEnum as _exit_status_enum,
 11    Field as _field,
 12    FluffyBuildNotify as _fluffy_build_notify,
 13    ManualClass as _manual_retry,
 14    MatrixClass as _matrix_class,
 15    NotifyEnum as _notify_enum,
 16    Option as _select_option,
 17    PurpleBuildNotify as _purple_build_notify,
 18    PurpleGithubCommitStatus as _purple_github_commit_status,
 19    PurpleSlack as _purple_slack,
 20    Retry as _retry,
 21    SignalReason as _signal_reason,
 22    Signature as _signature,
 23    SoftFailElement as _soft_fail,
 24    TentacledSlack as _tentacled_slack,
 25)
 26
 27BlockedStateEnum = _blocked_state
 28ConcurrencyMethod = _concurrency_method
 29ExitStatusEnum = _exit_status_enum
 30NotifyEnum = _notify_enum
 31SignalReasonEnum = _signal_reason
 32
 33
 34class Cache(_cache_class):
 35    def __init__(
 36        self,
 37        paths: List[str],
 38        name: Optional[str] = None,
 39        size: Optional[str] = None,
 40    ):
 41        super().__init__(name, paths, size)
 42
 43
 44class DependsOn(_depends_on_class):
 45    def __init__(
 46        self,
 47        step: str,
 48        allow_failure: Optional[bool] = None,
 49    ) -> None:
 50        super.__init__(
 51            self,
 52            allow_failure,
 53            step,
 54        )
 55
 56
 57class TextField(_field):
 58    def __init__(
 59        self,
 60        key: str,
 61        default: Optional[str] = None,
 62        hint: Optional[str] = None,
 63        required: Optional[bool] = None,
 64        text: Optional[str] = None,
 65    ) -> None:
 66        super().__init__(
 67            default=default,
 68            hint=hint,
 69            key=key,
 70            required=required,
 71            text=text,
 72            multiple=None,
 73            options=None,
 74            select=None,
 75            format=None,
 76        )
 77
 78
 79class SelectFieldOption(_select_option):
 80    def __init__(
 81        self,
 82        label: str,
 83        value: str,
 84        hint: Optional[str] = None,
 85        required: Optional[bool] = None,
 86    ):
 87        super().__init__(hint, label, required, value)
 88
 89
 90class SelectField(_field):
 91    def __init__(
 92        self,
 93        name: str,
 94        key: str,
 95        options: List[SelectFieldOption],
 96        default: Optional[str] = None,
 97        hint: Optional[str] = None,
 98        required: Optional[bool] = None,
 99        multiple: Optional[bool] = None,
100    ) -> None:
101        super().__init__(
102            default,
103            hint,
104            key,
105            required,
106            multiple,
107            options,
108            select=name,
109        )
110
111
112class SoftFail(_soft_fail):
113    def __init__(self, exit_status: Union[str, int]):
114        super().__init__(exit_status)
115
116
117class NotifySlack(_tentacled_slack):
118    def __init__(self, channels: Optional[List[str]], message: Optional[str]) -> None:
119        super().__init__(channels, message)
120
121    def _to_pipeline_notify(self) -> _purple_slack:
122        return _purple_slack(
123            channels=self.channels,
124            message=self.message,
125        )
126
127
128class StepNotify(_fluffy_build_notify):
129    def __init__(
130        self,
131        slack: Optional[Union[NotifySlack, str]],
132    ) -> None:
133        super().__init__(
134            slack,
135            basecamp_campfire=None,
136            build_notify_if=None,
137            github_commit_status=None,
138            github_check=None,
139            email=None,
140            webhook=None,
141            pagerduty_change_event=None,
142        )
143
144
145class NotifyGitHubCommitStatus(_purple_github_commit_status):
146    def __init__(self, context: Optional[str]):
147        super().__init__(context=context)
148
149
150class PipelineNotify(_purple_build_notify):
151    def __init__(
152        self,
153        email: Optional[str],
154        build_notify_if: Optional[str],
155        basecamp_campfire: Optional[str],
156        slack: Optional[NotifySlack],
157        webhook: Optional[str],
158        pagerduty_change_event: Optional[str],
159        github_commit_status: Optional[NotifyGitHubCommitStatus],
160        github_check: Optional[Dict[str, Any]],
161    ) -> None:
162        super().__init__(
163            email=email,
164            build_notify_if=build_notify_if,
165            basecamp_campfire=basecamp_campfire,
166            slack=slack._to_pipeline_notify(),
167            webhook=webhook,
168            pagerduty_change_event=pagerduty_change_event,
169            github_commit_status=github_commit_status,
170            github_check=github_check,
171        )
172
173
174# Matrix
175class MatrixAdjustment(_matrix_adjustment):
176    def __init__(
177        self,
178        adjustment_with: Union[List[Union[int, bool, str]], Dict[str, str]],
179        skip: Optional[bool] = None,
180        soft_fail: Optional[Union[SoftFail, bool]] = None,
181    ) -> None:
182        super().__init__(skip, soft_fail, adjustment_with)
183
184
185class MatrixAdvanced(_matrix_class):
186    def __init__(
187        self,
188        setup: Union[
189            List[Union[int, bool, str]], Dict[str, List[Union[int, bool, str]]]
190        ],
191        adjustments: Optional[List[MatrixAdjustment]] = None,
192    ) -> None:
193        super().__init__(adjustments, setup)
194
195
196# Retry
197class AutomaticRetry(_automatic_retry):
198    def __init__(
199        self,
200        exit_status: Optional[Union[int, List[int], ExitStatusEnum]] = None,
201        limit: Optional[int] = None,
202        signal: Optional[str] = None,
203        signal_reason: Optional[SignalReasonEnum] = None,
204    ) -> None:
205        super().__init__(exit_status, limit, signal, signal_reason)
206
207
208class ManualRetry(_manual_retry):
209    def __init__(
210        self,
211        allowed: Optional[bool] = None,
212        permit_on_passed: Optional[bool] = None,
213        reason: Optional[str] = None,
214    ) -> None:
215        super().__init__(allowed, permit_on_passed, reason)
216
217
218class Retry(_retry):
219    def __init__(
220        self,
221        automatic: Optional[Union[bool, AutomaticRetry, List[AutomaticRetry]]],
222        manual: Optional[Union[bool, ManualRetry]] = None,
223    ) -> None:
224        super().__init__(automatic, manual)
225
226
227# Signature
228class Signature(_signature):
229    def __init__(
230        self,
231        algorithm: Optional[str],
232        signed_fields: Optional[List[str]],
233        value: Optional[str],
234    ) -> None:
235        super().__init__(algorithm, signed_fields, value)
236
237
238# Build
239class Build(_build):
240    def __init__(
241        self,
242        branch: Optional[str],
243        commit: Optional[str],
244        env: Optional[Dict[str, Any]],
245        message: Optional[str],
246        meta_data: Optional[Dict[str, Any]],
247    ) -> None:
248        super().__init__(branch, commit, env, message, meta_data)