Skip to content
Navigation Menu
{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathworkflow.py
More file actions
236 lines (168 loc) · 9.38 KB
/
Copy pathworkflow.py
File metadata and controls
236 lines (168 loc) · 9.38 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
from typing import List, Optional
from datetime import datetime
from pydantic import Field as FieldInfo
from .._models import BaseModel
from .shared.subject import Subject
from .workflow_action import WorkflowAction
from .workflow_trigger import WorkflowTrigger
__all__ = ["Workflow", "Metadata", "Spec"]
class Metadata(BaseModel):
"""WorkflowMetadata contains workflow metadata."""
created_at: Optional[datetime] = FieldInfo(alias="createdAt", default=None)
"""
A Timestamp represents a point in time independent of any time zone or local
calendar, encoded as a count of seconds and fractions of seconds at nanosecond
resolution. The count is relative to an epoch at UTC midnight on January 1,
1970, in the proleptic Gregorian calendar which extends the Gregorian calendar
backwards to year one.
All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
second table is needed for interpretation, using a
[24-hour linear smear](https://developers.google.com/time/smear).
The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
restricting to that range, we ensure that we can convert to and from
[RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
# Examples
Example 1: Compute Timestamp from POSIX `time()`.
Timestamp timestamp;
timestamp.set_seconds(time(NULL));
timestamp.set_nanos(0);
Example 2: Compute Timestamp from POSIX `gettimeofday()`.
struct timeval tv;
gettimeofday(&tv, NULL);
Timestamp timestamp;
timestamp.set_seconds(tv.tv_sec);
timestamp.set_nanos(tv.tv_usec * 1000);
Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
// A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
Timestamp timestamp;
timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
long millis = System.currentTimeMillis();
Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
.setNanos((int) ((millis % 1000) * 1000000)).build();
Example 5: Compute Timestamp from Java `Instant.now()`.
Instant now = Instant.now();
Timestamp timestamp =
Timestamp.newBuilder().setSeconds(now.getEpochSecond())
.setNanos(now.getNano()).build();
Example 6: Compute Timestamp from current time in Python.
timestamp = Timestamp()
timestamp.GetCurrentTime()
# JSON Mapping
In JSON format, the Timestamp type is encoded as a string in the
[RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is
"{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always
expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are
zero-padded to two digits each. The fractional seconds, which can go up to 9
digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix
indicates the timezone ("UTC"); the timezone is required. A proto3 JSON
serializer should always use UTC (as indicated by "Z") when printing the
Timestamp type and a proto3 JSON parser should be able to accept both UTC and
other timezones (as indicated by an offset).
For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on
January 15, 2017.
In JavaScript, one can convert a Date object to this format using the standard
[toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
method. In Python, a standard `datetime.datetime` object can be converted to
this format using
[`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the
time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the
Joda Time's
[`ISODateTimeFormat.dateTime()`](<http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()>)
to obtain a formatter capable of generating timestamps in this format.
"""
creator: Optional[Subject] = None
description: Optional[str] = None
executor: Optional[Subject] = None
name: Optional[str] = None
updated_at: Optional[datetime] = FieldInfo(alias="updatedAt", default=None)
"""
A Timestamp represents a point in time independent of any time zone or local
calendar, encoded as a count of seconds and fractions of seconds at nanosecond
resolution. The count is relative to an epoch at UTC midnight on January 1,
1970, in the proleptic Gregorian calendar which extends the Gregorian calendar
backwards to year one.
All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
second table is needed for interpretation, using a
[24-hour linear smear](https://developers.google.com/time/smear).
The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
restricting to that range, we ensure that we can convert to and from
[RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
# Examples
Example 1: Compute Timestamp from POSIX `time()`.
Timestamp timestamp;
timestamp.set_seconds(time(NULL));
timestamp.set_nanos(0);
Example 2: Compute Timestamp from POSIX `gettimeofday()`.
struct timeval tv;
gettimeofday(&tv, NULL);
Timestamp timestamp;
timestamp.set_seconds(tv.tv_sec);
timestamp.set_nanos(tv.tv_usec * 1000);
Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
// A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
Timestamp timestamp;
timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
long millis = System.currentTimeMillis();
Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
.setNanos((int) ((millis % 1000) * 1000000)).build();
Example 5: Compute Timestamp from Java `Instant.now()`.
Instant now = Instant.now();
Timestamp timestamp =
Timestamp.newBuilder().setSeconds(now.getEpochSecond())
.setNanos(now.getNano()).build();
Example 6: Compute Timestamp from current time in Python.
timestamp = Timestamp()
timestamp.GetCurrentTime()
# JSON Mapping
In JSON format, the Timestamp type is encoded as a string in the
[RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is
"{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always
expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are
zero-padded to two digits each. The fractional seconds, which can go up to 9
digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix
indicates the timezone ("UTC"); the timezone is required. A proto3 JSON
serializer should always use UTC (as indicated by "Z") when printing the
Timestamp type and a proto3 JSON parser should be able to accept both UTC and
other timezones (as indicated by an offset).
For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on
January 15, 2017.
In JavaScript, one can convert a Date object to this format using the standard
[toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
method. In Python, a standard `datetime.datetime` object can be converted to
this format using
[`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the
time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the
Joda Time's
[`ISODateTimeFormat.dateTime()`](<http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()>)
to obtain a formatter capable of generating timestamps in this format.
"""
class Spec(BaseModel):
action: Optional[WorkflowAction] = None
"""WorkflowAction defines the actions to be executed in a workflow."""
report: Optional[WorkflowAction] = None
"""WorkflowAction defines the actions to be executed in a workflow."""
triggers: Optional[List[WorkflowTrigger]] = None
class Workflow(BaseModel):
"""Workflow represents a workflow configuration."""
id: Optional[str] = None
metadata: Optional[Metadata] = None
"""WorkflowMetadata contains workflow metadata."""
spec: Optional[Spec] = None
webhook_url: Optional[str] = FieldInfo(alias="webhookUrl", default=None)
"""
Webhook URL for triggering this workflow via HTTP POST Format:
{base_url}/workflows/{workflow_id}/webhooks
"""
You can’t perform that action at this time.