Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/looker_sdk/sdk/api40/methods.py: 27%

1# MIT License 

2# 

3# Copyright (c) 2023 Looker Data Sciences, Inc. 

4# 

5# Permission is hereby granted, free of charge, to any person obtaining a copy 

6# of this software and associated documentation files (the "Software"), to deal 

7# in the Software without restriction, including without limitation the rights 

8# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 

9# copies of the Software, and to permit persons to whom the Software is 

10# furnished to do so, subject to the following conditions: 

11# 

12# The above copyright notice and this permission notice shall be included in all 

13# copies or substantial portions of the Software. 

14# 

15# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 

16# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 

17# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 

18# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 

19# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 

20# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 

21# SOFTWARE. 

22# 

23 

24# 483 API methods 

25 

26 

27# NOTE: Do not edit this file generated by Looker SDK Codegen for API 4.0 

28import datetime 

29from typing import Any, MutableMapping, Optional, Sequence, Union, cast 

30import warnings 

31 

32from . import models as mdls 

33from looker_sdk.rtl import api_methods 

34from looker_sdk.rtl import transport 

35 

36 

37class Looker40SDK(api_methods.APIMethods): 

38 

39 # region Alert: Alert 

40 

41 # Follow an alert. 

42 # 

43 # POST /alerts/{alert_id}/follow -> None 

44 def follow_alert( 

45 self, 

46 # ID of an alert 

47 alert_id: str, 

48 transport_options: Optional[transport.TransportOptions] = None, 

49 ) -> None: 

50 """Follow an alert""" 

51 alert_id = self.encode_path_param(alert_id) 

52 response = cast( 

53 None, 

54 self.post( 

55 path=f"/alerts/{alert_id}/follow", 

56 structure=None, 

57 transport_options=transport_options, 

58 ), 

59 ) 

60 return response 

61 

62 # Unfollow an alert. 

63 # 

64 # DELETE /alerts/{alert_id}/follow -> None 

65 def unfollow_alert( 

66 self, 

67 # ID of an alert 

68 alert_id: str, 

69 transport_options: Optional[transport.TransportOptions] = None, 

70 ) -> None: 

71 """Unfollow an alert""" 

72 alert_id = self.encode_path_param(alert_id) 

73 response = cast( 

74 None, 

75 self.delete( 

76 path=f"/alerts/{alert_id}/follow", 

77 structure=None, 

78 transport_options=transport_options, 

79 ), 

80 ) 

81 return response 

82 

83 # ### Search Alerts 

84 # 

85 # GET /alerts/search -> Sequence[mdls.Alert] 

86 def search_alerts( 

87 self, 

88 # (Optional) Number of results to return (used with `offset`). 

89 limit: Optional[int] = None, 

90 # (Optional) Number of results to skip before returning any (used with `limit`). 

91 offset: Optional[int] = None, 

92 # (Optional) Dimension by which to order the results(`dashboard` | `owner`) 

93 group_by: Optional[str] = None, 

94 # (Optional) Requested fields. 

95 fields: Optional[str] = None, 

96 # (Optional) Filter on returning only enabled or disabled alerts. 

97 disabled: Optional[bool] = None, 

98 # (Optional) Filter on alert frequency, such as: monthly, weekly, daily, hourly, minutes 

99 frequency: Optional[str] = None, 

100 # (Optional) Filter on whether the alert has met its condition when it last executed 

101 condition_met: Optional[bool] = None, 

102 # (Optional) Filter on the start range of the last time the alerts were run. Example: 2021-01-01T01:01:01-08:00. 

103 last_run_start: Optional[str] = None, 

104 # (Optional) Filter on the start range of the last time the alerts were run. Example: 2021-01-01T01:01:01-08:00. 

105 last_run_end: Optional[str] = None, 

106 # (Admin only) (Optional) Filter for all owners. 

107 all_owners: Optional[bool] = None, 

108 transport_options: Optional[transport.TransportOptions] = None, 

109 ) -> Sequence[mdls.Alert]: 

110 """Search Alerts""" 

111 response = cast( 

112 Sequence[mdls.Alert], 

113 self.get( 

114 path="/alerts/search", 

115 structure=Sequence[mdls.Alert], 

116 query_params={ 

117 "limit": limit, 

118 "offset": offset, 

119 "group_by": group_by, 

120 "fields": fields, 

121 "disabled": disabled, 

122 "frequency": frequency, 

123 "condition_met": condition_met, 

124 "last_run_start": last_run_start, 

125 "last_run_end": last_run_end, 

126 "all_owners": all_owners, 

127 }, 

128 transport_options=transport_options, 

129 ), 

130 ) 

131 return response 

132 

133 # ### Get an alert by a given alert ID 

134 # 

135 # GET /alerts/{alert_id} -> mdls.Alert 

136 def get_alert( 

137 self, 

138 # ID of an alert 

139 alert_id: str, 

140 transport_options: Optional[transport.TransportOptions] = None, 

141 ) -> mdls.Alert: 

142 """Get an alert""" 

143 alert_id = self.encode_path_param(alert_id) 

144 response = cast( 

145 mdls.Alert, 

146 self.get( 

147 path=f"/alerts/{alert_id}", 

148 structure=mdls.Alert, 

149 transport_options=transport_options, 

150 ), 

151 ) 

152 return response 

153 

154 # ### Update an alert 

155 # # Required fields: `owner_id`, `field`, `destinations`, `comparison_type`, `threshold`, `cron` 

156 # # 

157 # 

158 # PUT /alerts/{alert_id} -> mdls.Alert 

159 def update_alert( 

160 self, 

161 # ID of an alert 

162 alert_id: str, 

163 body: mdls.WriteAlert, 

164 transport_options: Optional[transport.TransportOptions] = None, 

165 ) -> mdls.Alert: 

166 """Update an alert""" 

167 alert_id = self.encode_path_param(alert_id) 

168 response = cast( 

169 mdls.Alert, 

170 self.put( 

171 path=f"/alerts/{alert_id}", 

172 structure=mdls.Alert, 

173 body=body, 

174 transport_options=transport_options, 

175 ), 

176 ) 

177 return response 

178 

179 # ### Update select alert fields 

180 # # Available fields: `owner_id`, `is_disabled`, `disabled_reason`, `is_public`, `threshold` 

181 # # 

182 # 

183 # PATCH /alerts/{alert_id} -> mdls.Alert 

184 def update_alert_field( 

185 self, 

186 # ID of an alert 

187 alert_id: str, 

188 body: mdls.AlertPatch, 

189 transport_options: Optional[transport.TransportOptions] = None, 

190 ) -> mdls.Alert: 

191 """Update select fields on an alert""" 

192 alert_id = self.encode_path_param(alert_id) 

193 response = cast( 

194 mdls.Alert, 

195 self.patch( 

196 path=f"/alerts/{alert_id}", 

197 structure=mdls.Alert, 

198 body=body, 

199 transport_options=transport_options, 

200 ), 

201 ) 

202 return response 

203 

204 # ### Delete an alert by a given alert ID 

205 # 

206 # DELETE /alerts/{alert_id} -> None 

207 def delete_alert( 

208 self, 

209 # ID of an alert 

210 alert_id: str, 

211 transport_options: Optional[transport.TransportOptions] = None, 

212 ) -> None: 

213 """Delete an alert""" 

214 alert_id = self.encode_path_param(alert_id) 

215 response = cast( 

216 None, 

217 self.delete( 

218 path=f"/alerts/{alert_id}", 

219 structure=None, 

220 transport_options=transport_options, 

221 ), 

222 ) 

223 return response 

224 

225 # ### Create a new alert and return details of the newly created object 

226 # 

227 # Required fields: `field`, `destinations`, `comparison_type`, `threshold`, `cron` 

228 # 

229 # Example Request: 

230 # Run alert on dashboard element '103' at 5am every day. Send an email to 'test@test.com' if inventory for Los Angeles (using dashboard filter `Warehouse Name`) is lower than 1,000 

231 # ``` 

232 # { 

233 # "cron": "0 5 * * *", 

234 # "custom_title": "Alert when LA inventory is low", 

235 # "dashboard_element_id": 103, 

236 # "applied_dashboard_filters": [ 

237 # { 

238 # "filter_title": "Warehouse Name", 

239 # "field_name": "distribution_centers.name", 

240 # "filter_value": "Los Angeles CA", 

241 # "filter_description": "is Los Angeles CA" 

242 # } 

243 # ], 

244 # "comparison_type": "LESS_THAN", 

245 # "destinations": [ 

246 # { 

247 # "destination_type": "EMAIL", 

248 # "email_address": "test@test.com" 

249 # } 

250 # ], 

251 # "field": { 

252 # "title": "Number on Hand", 

253 # "name": "inventory_items.number_on_hand" 

254 # }, 

255 # "is_disabled": false, 

256 # "is_public": true, 

257 # "threshold": 1000 

258 # } 

259 # ``` 

260 # 

261 # POST /alerts -> mdls.Alert 

262 def create_alert( 

263 self, 

264 body: mdls.WriteAlert, 

265 transport_options: Optional[transport.TransportOptions] = None, 

266 ) -> mdls.Alert: 

267 """Create an alert""" 

268 response = cast( 

269 mdls.Alert, 

270 self.post( 

271 path="/alerts", 

272 structure=mdls.Alert, 

273 body=body, 

274 transport_options=transport_options, 

275 ), 

276 ) 

277 return response 

278 

279 # ### Enqueue an Alert by ID 

280 # 

281 # POST /alerts/{alert_id}/enqueue -> None 

282 def enqueue_alert( 

283 self, 

284 # ID of an alert 

285 alert_id: str, 

286 # Whether to enqueue an alert again if its already running. 

287 force: Optional[bool] = None, 

288 transport_options: Optional[transport.TransportOptions] = None, 

289 ) -> None: 

290 """Enqueue an alert""" 

291 alert_id = self.encode_path_param(alert_id) 

292 response = cast( 

293 None, 

294 self.post( 

295 path=f"/alerts/{alert_id}/enqueue", 

296 structure=None, 

297 query_params={"force": force}, 

298 transport_options=transport_options, 

299 ), 

300 ) 

301 return response 

302 

303 # # Alert Notifications. 

304 # The endpoint returns all the alert notifications received by the user on email in the past 7 days. It also returns whether the notifications have been read by the user. 

305 # 

306 # GET /alert_notifications -> Sequence[mdls.AlertNotifications] 

307 def alert_notifications( 

308 self, 

309 # (Optional) Number of results to return (used with `offset`). 

310 limit: Optional[int] = None, 

311 # (Optional) Number of results to skip before returning any (used with `limit`). 

312 offset: Optional[int] = None, 

313 transport_options: Optional[transport.TransportOptions] = None, 

314 ) -> Sequence[mdls.AlertNotifications]: 

315 """Alert Notifications""" 

316 response = cast( 

317 Sequence[mdls.AlertNotifications], 

318 self.get( 

319 path="/alert_notifications", 

320 structure=Sequence[mdls.AlertNotifications], 

321 query_params={"limit": limit, "offset": offset}, 

322 transport_options=transport_options, 

323 ), 

324 ) 

325 return response 

326 

327 # # Reads a Notification 

328 # The endpoint marks a given alert notification as read by the user, in case it wasn't already read. The AlertNotification model is updated for this purpose. It returns the notification as a response. 

329 # 

330 # PATCH /alert_notifications/{alert_notification_id} -> mdls.AlertNotifications 

331 def read_alert_notification( 

332 self, 

333 # ID of a notification 

334 alert_notification_id: str, 

335 transport_options: Optional[transport.TransportOptions] = None, 

336 ) -> mdls.AlertNotifications: 

337 """Read a Notification""" 

338 alert_notification_id = self.encode_path_param(alert_notification_id) 

339 response = cast( 

340 mdls.AlertNotifications, 

341 self.patch( 

342 path=f"/alert_notifications/{alert_notification_id}", 

343 structure=mdls.AlertNotifications, 

344 transport_options=transport_options, 

345 ), 

346 ) 

347 return response 

348 

349 # endregion 

350 

351 # region ApiAuth: API Authentication 

352 

353 # ### Present client credentials to obtain an authorization token 

354 # 

355 # Looker API implements the OAuth2 [Resource Owner Password Credentials Grant](https://docs.cloud.google.com/looker/docs/r/api/outh2_resource_owner_pc) pattern. 

356 # The client credentials required for this login must be obtained by creating an API key on a user account 

357 # in the Looker Admin console. The API key consists of a public `client_id` and a private `client_secret`. 

358 # 

359 # The access token returned by `login` must be used in the HTTP Authorization header of subsequent 

360 # API requests, like this: 

361 # ``` 

362 # Authorization: token 4QDkCyCtZzYgj4C2p2cj3csJH7zqS5RzKs2kTnG4 

363 # ``` 

364 # Replace "4QDkCy..." with the `access_token` value returned by `login`. 

365 # The word `token` is a string literal and must be included exactly as shown. 

366 # 

367 # This function can accept `client_id` and `client_secret` parameters as URL query params or as www-form-urlencoded params in the body of the HTTP request. Since there is a small risk that URL parameters may be visible to intermediate nodes on the network route (proxies, routers, etc), passing credentials in the body of the request is considered more secure than URL params. 

368 # 

369 # Example of passing credentials in the HTTP request body: 

370 # ```` 

371 # POST HTTP /login 

372 # Content-Type: application/x-www-form-urlencoded 

373 # 

374 # client_id=CGc9B7v7J48dQSJvxxx&client_secret=nNVS9cSS3xNpSC9JdsBvvvvv 

375 # ```` 

376 # 

377 # ### Best Practice: 

378 # Always pass credentials in body params. Pass credentials in URL query params **only** when you cannot pass body params due to application, tool, or other limitations. 

379 # 

380 # For more information and detailed examples of Looker API authorization, see [How to Authenticate to Looker API](https://github.com/looker/looker-sdk-ruby/blob/master/authentication.md). 

381 # 

382 # POST /login -> mdls.AccessToken 

383 def login( 

384 self, 

385 # client_id part of API Key. 

386 client_id: Optional[str] = None, 

387 # client_secret part of API Key. 

388 client_secret: Optional[str] = None, 

389 transport_options: Optional[transport.TransportOptions] = None, 

390 ) -> mdls.AccessToken: 

391 """Login""" 

392 response = cast( 

393 mdls.AccessToken, 

394 self.post( 

395 path="/login", 

396 structure=mdls.AccessToken, 

397 query_params={"client_id": client_id, "client_secret": client_secret}, 

398 transport_options=transport_options, 

399 ), 

400 ) 

401 return response 

402 

403 # ### Create an access token that runs as a given user. 

404 # 

405 # This can only be called by an authenticated admin user. It allows that admin to generate a new 

406 # authentication token for the user with the given user id. That token can then be used for subsequent 

407 # API calls - which are then performed *as* that target user. 

408 # 

409 # The target user does *not* need to have a pre-existing API client_id/client_secret pair. And, no such 

410 # credentials are created by this call. 

411 # 

412 # This allows for building systems where api user authentication for an arbitrary number of users is done 

413 # outside of Looker and funneled through a single 'service account' with admin permissions. Note that a 

414 # new access token is generated on each call. If target users are going to be making numerous API 

415 # calls in a short period then it is wise to cache this authentication token rather than call this before 

416 # each of those API calls. 

417 # 

418 # See 'login' for more detail on the access token and how to use it. 

419 # 

420 # In [Looker (Google Cloud core)](https://docs.cloud.google.com/looker/docs/r/looker-core/overview) this call will be denied unless all of the following criteria are met: 

421 # 1. The calling user is an [API-only Service Account](https://docs.cloud.google.com/looker/docs/looker-core-user-management#creating_an_api-only_service_account) with the Admin role 

422 # 2. The target user is an [Embed User type](https://docs.cloud.google.com/looker/docs/r/single-sign-on-embedding) 

423 # Regular user types can not be impersonated in [Looker (Google Cloud core)](https://docs.cloud.google.com/looker/docs/r/looker-core/overview). If your application needs to call the API for these users, use OAuth authentication instead. 

424 # 

425 # POST /login/{user_id} -> mdls.AccessToken 

426 def login_user( 

427 self, 

428 # Id of user. 

429 user_id: str, 

430 # When true (default), API calls using the returned access_token are attributed to the admin user who created the access_token. When false, API activity is attributed to the user the access_token runs as. False requires a looker license. 

431 associative: Optional[bool] = None, 

432 transport_options: Optional[transport.TransportOptions] = None, 

433 ) -> mdls.AccessToken: 

434 """Login user""" 

435 user_id = self.encode_path_param(user_id) 

436 warnings.warn( 

437 "login_user behavior changed significantly in 21.4.0. See https://git.io/JOtH1" 

438 ) 

439 response = cast( 

440 mdls.AccessToken, 

441 self.post( 

442 path=f"/login/{user_id}", 

443 structure=mdls.AccessToken, 

444 query_params={"associative": associative}, 

445 transport_options=transport_options, 

446 ), 

447 ) 

448 return response 

449 

450 # ### Logout of the API and invalidate the current access token. 

451 # 

452 # DELETE /logout -> str 

453 def logout( 

454 self, 

455 transport_options: Optional[transport.TransportOptions] = None, 

456 ) -> str: 

457 """Logout""" 

458 response = cast( 

459 str, 

460 self.delete( 

461 path="/logout", structure=str, transport_options=transport_options 

462 ), 

463 ) 

464 return response 

465 

466 # endregion 

467 

468 # region Artifact: Artifact Storage 

469 

470 # Get the maximum configured size of the entire artifact store, and the currently used storage in bytes. 

471 # 

472 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

473 # 

474 # GET /artifact/usage -> mdls.ArtifactUsage 

475 def artifact_usage( 

476 self, 

477 # Comma-delimited names of fields to return in responses. Omit for all fields 

478 fields: Optional[str] = None, 

479 transport_options: Optional[transport.TransportOptions] = None, 

480 ) -> mdls.ArtifactUsage: 

481 """Artifact store usage""" 

482 response = cast( 

483 mdls.ArtifactUsage, 

484 self.get( 

485 path="/artifact/usage", 

486 structure=mdls.ArtifactUsage, 

487 query_params={"fields": fields}, 

488 transport_options=transport_options, 

489 ), 

490 ) 

491 return response 

492 

493 # Get all artifact namespaces and the count of artifacts in each namespace 

494 # 

495 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

496 # 

497 # GET /artifact/namespaces -> Sequence[mdls.ArtifactNamespace] 

498 def artifact_namespaces( 

499 self, 

500 # Comma-delimited names of fields to return in responses. Omit for all fields 

501 fields: Optional[str] = None, 

502 # Number of results to return. (used with offset) 

503 limit: Optional[int] = None, 

504 # Number of results to skip before returning any. (used with limit) 

505 offset: Optional[int] = None, 

506 transport_options: Optional[transport.TransportOptions] = None, 

507 ) -> Sequence[mdls.ArtifactNamespace]: 

508 """Get namespaces and counts""" 

509 response = cast( 

510 Sequence[mdls.ArtifactNamespace], 

511 self.get( 

512 path="/artifact/namespaces", 

513 structure=Sequence[mdls.ArtifactNamespace], 

514 query_params={"fields": fields, "limit": limit, "offset": offset}, 

515 transport_options=transport_options, 

516 ), 

517 ) 

518 return response 

519 

520 # ### Return the value of an artifact 

521 # 

522 # The MIME type for the API response is set to the `content_type` of the value 

523 # 

524 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

525 # 

526 # GET /artifact/{namespace}/value -> str 

527 def artifact_value( 

528 self, 

529 # Artifact storage namespace 

530 namespace: str, 

531 # Artifact storage key. Namespace + Key must be unique 

532 key: Optional[str] = None, 

533 transport_options: Optional[transport.TransportOptions] = None, 

534 ) -> str: 

535 """Get an artifact value""" 

536 namespace = self.encode_path_param(namespace) 

537 response = cast( 

538 str, 

539 self.get( 

540 path=f"/artifact/{namespace}/value", 

541 structure=str, 

542 query_params={"key": key}, 

543 transport_options=transport_options, 

544 ), 

545 ) 

546 return response 

547 

548 # Remove *all* artifacts from a namespace. Purged artifacts are permanently deleted 

549 # 

550 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

551 # 

552 # DELETE /artifact/{namespace}/purge -> None 

553 def purge_artifacts( 

554 self, 

555 # Artifact storage namespace 

556 namespace: str, 

557 transport_options: Optional[transport.TransportOptions] = None, 

558 ) -> None: 

559 """Purge artifacts""" 

560 namespace = self.encode_path_param(namespace) 

561 response = cast( 

562 None, 

563 self.delete( 

564 path=f"/artifact/{namespace}/purge", 

565 structure=None, 

566 transport_options=transport_options, 

567 ), 

568 ) 

569 return response 

570 

571 # ### Search all key/value pairs in a namespace for matching criteria. 

572 # 

573 # Returns an array of artifacts matching the specified search criteria. 

574 # 

575 # Key search patterns use case-insensitive matching and can contain `%` and `_` as SQL LIKE pattern match wildcard expressions. 

576 # 

577 # The parameters `min_size` and `max_size` can be used individually or together. 

578 # 

579 # - `min_size` finds artifacts with sizes greater than or equal to its value 

580 # - `max_size` finds artifacts with sizes less than or equal to its value 

581 # - using both parameters restricts the minimum and maximum size range for artifacts 

582 # 

583 # **NOTE**: Artifacts are always returned in alphanumeric order by key. 

584 # 

585 # Get a **single artifact** by namespace and key with [`artifact`](#!/Artifact/artifact) 

586 # 

587 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

588 # 

589 # GET /artifact/{namespace}/search -> Sequence[mdls.Artifact] 

590 def search_artifacts( 

591 self, 

592 # Artifact storage namespace 

593 namespace: str, 

594 # Comma-delimited names of fields to return in responses. Omit for all fields 

595 fields: Optional[str] = None, 

596 # Key pattern to match 

597 key: Optional[str] = None, 

598 # Ids of users who created or updated the artifact (comma-delimited list) 

599 user_ids: Optional[str] = None, 

600 # Minimum storage size of the artifact 

601 min_size: Optional[int] = None, 

602 # Maximum storage size of the artifact 

603 max_size: Optional[int] = None, 

604 # Number of results to return. (used with offset) 

605 limit: Optional[int] = None, 

606 # Number of results to skip before returning any. (used with limit) 

607 offset: Optional[int] = None, 

608 # Return the full count of results in the X-Total-Count response header. (Slight performance hit.) 

609 tally: Optional[bool] = None, 

610 transport_options: Optional[transport.TransportOptions] = None, 

611 ) -> Sequence[mdls.Artifact]: 

612 """Search artifacts""" 

613 namespace = self.encode_path_param(namespace) 

614 response = cast( 

615 Sequence[mdls.Artifact], 

616 self.get( 

617 path=f"/artifact/{namespace}/search", 

618 structure=Sequence[mdls.Artifact], 

619 query_params={ 

620 "fields": fields, 

621 "key": key, 

622 "user_ids": user_ids, 

623 "min_size": min_size, 

624 "max_size": max_size, 

625 "limit": limit, 

626 "offset": offset, 

627 "tally": tally, 

628 }, 

629 transport_options=transport_options, 

630 ), 

631 ) 

632 return response 

633 

634 # ### Get one or more artifacts 

635 # 

636 # Returns an array of artifacts matching the specified key value(s). 

637 # 

638 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

639 # 

640 # GET /artifact/{namespace} -> Sequence[mdls.Artifact] 

641 def artifact( 

642 self, 

643 # Artifact storage namespace 

644 namespace: str, 

645 # Comma-delimited list of keys. Wildcards not allowed. 

646 key: str, 

647 # Comma-delimited names of fields to return in responses. Omit for all fields 

648 fields: Optional[str] = None, 

649 # Number of results to return. (used with offset) 

650 limit: Optional[int] = None, 

651 # Number of results to skip before returning any. (used with limit) 

652 offset: Optional[int] = None, 

653 # Return the full count of results in the X-Total-Count response header. (Slight performance hit.) 

654 tally: Optional[bool] = None, 

655 transport_options: Optional[transport.TransportOptions] = None, 

656 ) -> Sequence[mdls.Artifact]: 

657 """Get one or more artifacts""" 

658 namespace = self.encode_path_param(namespace) 

659 response = cast( 

660 Sequence[mdls.Artifact], 

661 self.get( 

662 path=f"/artifact/{namespace}", 

663 structure=Sequence[mdls.Artifact], 

664 query_params={ 

665 "key": key, 

666 "fields": fields, 

667 "limit": limit, 

668 "offset": offset, 

669 "tally": tally, 

670 }, 

671 transport_options=transport_options, 

672 ), 

673 ) 

674 return response 

675 

676 # ### Delete one or more artifacts 

677 # 

678 # To avoid rate limiting on deletion requests, multiple artifacts can be deleted at the same time by using a comma-delimited list of artifact keys. 

679 # 

680 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

681 # 

682 # DELETE /artifact/{namespace} -> None 

683 def delete_artifact( 

684 self, 

685 # Artifact storage namespace 

686 namespace: str, 

687 # Comma-delimited list of keys. Wildcards not allowed. 

688 key: str, 

689 transport_options: Optional[transport.TransportOptions] = None, 

690 ) -> None: 

691 """Delete one or more artifacts""" 

692 namespace = self.encode_path_param(namespace) 

693 response = cast( 

694 None, 

695 self.delete( 

696 path=f"/artifact/{namespace}", 

697 structure=None, 

698 query_params={"key": key}, 

699 transport_options=transport_options, 

700 ), 

701 ) 

702 return response 

703 

704 # ### Create or update one or more artifacts 

705 # 

706 # Only `key` and `value` are required to _create_ an artifact. 

707 # To _update_ an artifact, its current `version` value must be provided. 

708 # 

709 # In the following example `body` payload, `one` and `two` are existing artifacts, and `three` is new: 

710 # 

711 # ```json 

712 # [ 

713 # { "key": "one", "value": "[ \"updating\", \"existing\", \"one\" ]", "version": 10, "content_type": "application/json" }, 

714 # { "key": "two", "value": "updating existing two", "version": 20 }, 

715 # { "key": "three", "value": "creating new three" }, 

716 # ] 

717 # ``` 

718 # 

719 # Notes for this body: 

720 # 

721 # - The `value` for `key` **one** is a JSON payload, so a `content_type` override is needed. This override must be done **every** time a JSON value is set. 

722 # - The `version` values for **one** and **two** mean they have been saved 10 and 20 times, respectively. 

723 # - If `version` is **not** provided for an existing artifact, the entire request will be refused and a `Bad Request` response will be sent. 

724 # - If `version` is provided for an artifact, it is only used for helping to prevent inadvertent data overwrites. It cannot be used to **set** the version of an artifact. The Looker server controls `version`. 

725 # - We suggest encoding binary values as base64. Because the MIME content type for base64 is detected as plain text, also provide `content_type` to correctly indicate the value's type for retrieval and client-side processing. 

726 # 

727 # Because artifacts are stored encrypted, the same value can be written multiple times (provided the correct `version` number is used). Looker does not examine any values stored in the artifact store, and only decrypts when sending artifacts back in an API response. 

728 # 

729 # **Note**: The artifact storage API can only be used by Looker-built extensions. 

730 # 

731 # PUT /artifacts/{namespace} -> Sequence[mdls.Artifact] 

732 def update_artifacts( 

733 self, 

734 # Artifact storage namespace 

735 namespace: str, 

736 body: Sequence[mdls.UpdateArtifact], 

737 # Comma-delimited names of fields to return in responses. Omit for all fields 

738 fields: Optional[str] = None, 

739 transport_options: Optional[transport.TransportOptions] = None, 

740 ) -> Sequence[mdls.Artifact]: 

741 """Create or update artifacts""" 

742 namespace = self.encode_path_param(namespace) 

743 response = cast( 

744 Sequence[mdls.Artifact], 

745 self.put( 

746 path=f"/artifacts/{namespace}", 

747 structure=Sequence[mdls.Artifact], 

748 query_params={"fields": fields}, 

749 body=body, 

750 transport_options=transport_options, 

751 ), 

752 ) 

753 return response 

754 

755 # endregion 

756 

757 # region Auth: Manage User Authentication Configuration 

758 

759 # ### Create an embed secret using the specified information. 

760 # 

761 # The value of the `secret` field will be set by Looker and returned. 

762 # 

763 # **NOTE**: Calls to this endpoint require [Embedding](https://docs.cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled. Usage of this endpoint is not authorized for Looker Core Standard and Looker Core Enterprise. 

764 # 

765 # POST /embed_config/secrets -> mdls.EmbedSecret 

766 def create_embed_secret( 

767 self, 

768 body: Optional[mdls.WriteEmbedSecret] = None, 

769 transport_options: Optional[transport.TransportOptions] = None, 

770 ) -> mdls.EmbedSecret: 

771 """Create Embed Secret""" 

772 response = cast( 

773 mdls.EmbedSecret, 

774 self.post( 

775 path="/embed_config/secrets", 

776 structure=mdls.EmbedSecret, 

777 body=body, 

778 transport_options=transport_options, 

779 ), 

780 ) 

781 return response 

782 

783 # ### Delete an embed secret. 

784 # 

785 # **NOTE**: Calls to this endpoint require [Embedding](https://docs.cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled. Usage of this endpoint is not authorized for Looker Core Standard and Looker Core Enterprise. 

786 # 

787 # DELETE /embed_config/secrets/{embed_secret_id} -> str 

788 def delete_embed_secret( 

789 self, 

790 # Id of Embed Secret 

791 embed_secret_id: str, 

792 transport_options: Optional[transport.TransportOptions] = None, 

793 ) -> str: 

794 """Delete Embed Secret""" 

795 embed_secret_id = self.encode_path_param(embed_secret_id) 

796 response = cast( 

797 str, 

798 self.delete( 

799 path=f"/embed_config/secrets/{embed_secret_id}", 

800 structure=str, 

801 transport_options=transport_options, 

802 ), 

803 ) 

804 return response 

805 

806 # ### Create Signed Embed URL 

807 # 

808 # Creates a signed embed URL and cryptographically signs it with an embed secret. 

809 # This signed URL can then be used to instantiate a Looker embed session in a PBL web application. 

810 # Do not make any modifications to the returned URL - any change may invalidate the signature and 

811 # cause the URL to fail to load a Looker embed session. 

812 # 

813 # A signed embed URL can only be **used once**. After the URL has been used to request a page from the 

814 # Looker server, it is invalid. Future requests using the same URL will fail. This is to prevent 

815 # 'replay attacks'. 

816 # 

817 # The `target_url` property must be a complete URL of a Looker UI page - scheme, hostname, path and query params. 

818 # To load a dashboard with id 56 and with a filter of `Date=1 years`, the looker URL would look like `https:/myname.looker.com/dashboards/56?Date=1%20years`. 

819 # The best way to obtain this `target_url` is to navigate to the desired Looker page in your web browser and use the "Get embed URL" menu option 

820 # to copy it to your clipboard and paste it into the `target_url` property as a quoted string value in this API request. 

821 # 

822 # Permissions for the embed user are defined by the groups in which the embed user is a member (`group_ids` property) 

823 # and the lists of models and permissions assigned to the embed user. 

824 # At a minimum, you must provide values for either the `group_ids` property, or **both** the models and permissions properties. 

825 # These properties are additive; an embed user can be a member of certain groups AND be granted access to models and permissions. 

826 # 

827 # The embed user's access is the union of permissions granted by the `group_ids`, `models`, and `permissions` properties. 

828 # 

829 # This function does not strictly require all group_ids, user attribute names, or model names to exist at the moment the 

830 # embed url is created. Unknown group_id, user attribute names or model names will be passed through to the output URL. 

831 # Because of this, **these parameters are not validated** when the API call is made. 

832 # 

833 # The [Get Embed Url](https://docs.cloud.google.com/looker/docs/r/get-signed-url) dialog can be used to determine and validate the correct permissions for signing an embed url. 

834 # This dialog also provides the SDK syntax for the API call to make. Alternatively, you can copy the signed URL into the Embed URI Validator text box 

835 # in `<your looker instance>/admin/embed` to diagnose potential problems. 

836 # 

837 # The `secret_id` parameter is optional. If specified, its value must be the id of an active secret defined in the Looker instance. 

838 # if not specified, the URL will be signed using the most recent active signing secret. If there is no active secret for signing embed urls, 

839 # a default secret will be created. This default secret is encrypted using HMAC/SHA-256. 

840 # 

841 # The `embed_domain` parameter is optional. If specified and valid, the domain will be added to the embed domain allowlist if it is missing. 

842 # 

843 # #### Security Note 

844 # Protect this signed URL as you would an access token or password credentials - do not write 

845 # it to disk, do not pass it to a third party, and only pass it through a secure HTTPS 

846 # encrypted transport. 

847 # 

848 # 

849 # **NOTE**: Calls to this endpoint require [Embedding](https://docs.cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled. Usage of this endpoint is not authorized for Looker Core Standard and Looker Core Enterprise. 

850 # 

851 # POST /embed/sso_url -> mdls.EmbedUrlResponse 

852 def create_sso_embed_url( 

853 self, 

854 body: mdls.EmbedSsoParams, 

855 transport_options: Optional[transport.TransportOptions] = None, 

856 ) -> mdls.EmbedUrlResponse: 

857 """Create Signed Embed Url""" 

858 response = cast( 

859 mdls.EmbedUrlResponse, 

860 self.post( 

861 path="/embed/sso_url", 

862 structure=mdls.EmbedUrlResponse, 

863 body=body, 

864 transport_options=transport_options, 

865 ), 

866 ) 

867 return response 

868 

869 # ### Create an Embed URL 

870 # 

871 # Creates an embed URL that runs as the Looker user making this API call. ("Embed as me") 

872 # This embed URL can then be used to instantiate a Looker embed session in a 

873 # "Powered by Looker" (PBL) web application. 

874 # 

875 # This is similar to Private Embedding (https://docs.cloud.google.com/looker/docs/r/admin/embed/private-embed). Instead of 

876 # logging into the Web UI to authenticate, the user has already authenticated against the API to be able to 

877 # make this call. However, unlike Private Embed where the user has access to any other part of the Looker UI, 

878 # the embed web session created by requesting the EmbedUrlResponse.url in a browser only has access to 

879 # content visible under the `/embed` context. 

880 # 

881 # An embed URL can only be used once, and must be used within 5 minutes of being created. After it 

882 # has been used to request a page from the Looker server, the URL is invalid. Future requests using 

883 # the same URL will fail. This is to prevent 'replay attacks'. 

884 # 

885 # The `target_url` property must be a complete URL of a Looker Embedded UI page - scheme, hostname, path starting with "/embed" and query params. 

886 # To load a dashboard with id 56 and with a filter of `Date=1 years`, the looker Embed URL would look like `https://myname.looker.com/embed/dashboards/56?Date=1%20years`. 

887 # The best way to obtain this target_url is to navigate to the desired Looker page in your web browser, 

888 # copy the URL shown in the browser address bar, insert "/embed" after the host/port, and paste it into the `target_url` property as a quoted string value in this API request. 

889 # 

890 # #### Security Note 

891 # Protect this signed URL as you would an access token or password credentials - do not write 

892 # it to disk, do not pass it to a third party, and only pass it through a secure HTTPS 

893 # encrypted transport. 

894 # 

895 # POST /embed/token_url/me -> mdls.EmbedUrlResponse 

896 def create_embed_url_as_me( 

897 self, 

898 body: mdls.EmbedParams, 

899 transport_options: Optional[transport.TransportOptions] = None, 

900 ) -> mdls.EmbedUrlResponse: 

901 """Create Embed URL""" 

902 response = cast( 

903 mdls.EmbedUrlResponse, 

904 self.post( 

905 path="/embed/token_url/me", 

906 structure=mdls.EmbedUrlResponse, 

907 body=body, 

908 transport_options=transport_options, 

909 ), 

910 ) 

911 return response 

912 

913 # ### Validate a Signed Embed URL 

914 # 

915 # GET /embed/sso/validate -> mdls.EmbedUrlResponse 

916 def validate_embed_url( 

917 self, 

918 # URL to validate 

919 url: Optional[str] = None, 

920 transport_options: Optional[transport.TransportOptions] = None, 

921 ) -> mdls.EmbedUrlResponse: 

922 """Get Embed URL Validation""" 

923 response = cast( 

924 mdls.EmbedUrlResponse, 

925 self.get( 

926 path="/embed/sso/validate", 

927 structure=mdls.EmbedUrlResponse, 

928 query_params={"url": url}, 

929 transport_options=transport_options, 

930 ), 

931 ) 

932 return response 

933 

934 # ### Acquire a cookieless embed session. 

935 # 

936 # The acquire session endpoint negates the need for signing the embed url and passing it as a parameter 

937 # to the embed login. This endpoint accepts an embed user definition and creates or updates it. This is 

938 # similar behavior to the embed SSO login as they both can create and update embed user data. 

939 # 

940 # The endpoint also accepts an optional `session_reference_token`. If present and the session has not expired 

941 # and the credentials match the credentials for the embed session, a new authentication token will be 

942 # generated. This allows the embed session to attach a new embedded IFRAME to the embed session. Note that 

943 # the session is NOT extended in this scenario. In other words the session_length parameter is ignored. 

944 # 

945 # **IMPORTANT:** If the `session_reference_token` is provided and the session has NOT expired, the embed user 

946 # is NOT updated. This is done for performance reasons and to support the embed SSO usecase where the 

947 # first IFRAME created on a page uses a signed url and subsequently created IFRAMEs do not. 

948 # 

949 # If the `session_reference_token` is provided but the session has expired, the token will be ignored and a 

950 # new embed session will be created. Note that the embed user definition will be updated in this scenario. 

951 # 

952 # If the credentials do not match the credentials associated with an existing session_reference_token, a 

953 # 404 will be returned. 

954 # 

955 # The endpoint returns the following: 

956 # - Authentication token - a token that is passed to `/embed/login` endpoint that creates or attaches to the 

957 # embed session. This token can be used once and has a lifetime of 30 seconds. 

958 # - Session reference token - a token that lives for the length of the session. This token is used to 

959 # generate new api and navigation tokens OR create new embed IFRAMEs. 

960 # - Api token - lives for 10 minutes. The Looker client will ask for this token once it is loaded into the 

961 # iframe. 

962 # - Navigation token - lives for 10 minutes. The Looker client will ask for this token once it is loaded into 

963 # the iframe. 

964 # 

965 # **NOTE**: Calls to this endpoint require [Embedding](https://docs.cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled. Usage of this endpoint is not authorized for Looker Core Standard and Looker Core Enterprise. 

966 # 

967 # POST /embed/cookieless_session/acquire -> mdls.EmbedCookielessSessionAcquireResponse 

968 def acquire_embed_cookieless_session( 

969 self, 

970 body: mdls.EmbedCookielessSessionAcquire, 

971 transport_options: Optional[transport.TransportOptions] = None, 

972 ) -> mdls.EmbedCookielessSessionAcquireResponse: 

973 """Create Acquire cookieless embed session""" 

974 response = cast( 

975 mdls.EmbedCookielessSessionAcquireResponse, 

976 self.post( 

977 path="/embed/cookieless_session/acquire", 

978 structure=mdls.EmbedCookielessSessionAcquireResponse, 

979 body=body, 

980 transport_options=transport_options, 

981 ), 

982 ) 

983 return response 

984 

985 # ### Delete cookieless embed session 

986 # 

987 # This will delete the session associated with the given session reference token. Calling this endpoint will result 

988 # in the session and session reference data being cleared from the system. This endpoint can be used to log an embed 

989 # user out of the Looker instance. 

990 # 

991 # **NOTE**: Calls to this endpoint require [Embedding](https://docs.cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled. Usage of this endpoint is not authorized for Looker Core Standard and Looker Core Enterprise. 

992 # 

993 # DELETE /embed/cookieless_session/{session_reference_token} -> str 

994 def delete_embed_cookieless_session( 

995 self, 

996 # Embed session reference token 

997 session_reference_token: str, 

998 transport_options: Optional[transport.TransportOptions] = None, 

999 ) -> str: 

1000 """Delete cookieless embed session""" 

1001 session_reference_token = self.encode_path_param(session_reference_token) 

1002 response = cast( 

1003 str, 

1004 self.delete( 

1005 path=f"/embed/cookieless_session/{session_reference_token}", 

1006 structure=str, 

1007 transport_options=transport_options, 

1008 ), 

1009 ) 

1010 return response 

1011 

1012 # ### Generate api and navigation tokens for a cookieless embed session 

1013 # 

1014 # The generate tokens endpoint is used to create new tokens of type: 

1015 # - Api token. 

1016 # - Navigation token. 

1017 # The generate tokens endpoint should be called every time the Looker client asks for a token (except for the 

1018 # first time when the tokens returned by the acquire_session endpoint should be used). 

1019 # 

1020 # #### Embed session expiration handling 

1021 # 

1022 # This endpoint does NOT return an error when the embed session expires. This is to simplify processing 

1023 # in the caller as errors can happen for non session expiration reasons. Instead the endpoint returns 

1024 # the session time to live in the `session_reference_token_ttl` response property. If this property 

1025 # contains a zero, the embed session has expired. 

1026 #