async def run_trigger(
self,
name: str,
tag_name: str = None,
branch_name: str = None,
commit_sha: str = None,
project_id: str = None,
) -> TriggerType:
params = [tag_name, branch_name, commit_sha]
if len([x for x in params if x]) != 1:
raise exceptions.ValidationError(
"Only one of {tag_name, branch_name, commit_sha} must be provided"
)
event = cloudbuild_v1.RepoSource(
project_id=project_id or self.project_id,
tag_name=tag_name,
branch_name=branch_name,
commit_sha=commit_sha,
)
response = self.client.run_build_trigger(
trigger_id=name,
source=event,
project_id=project_id or self.project_id,
)
return response
async def execute(
self,
sql: str,
params: Dict[str, Any] = None,
destination_table_name: str = None,
destination_dataset_name: str = None,
destination_project: str = None,
truncate: bool = None,
):
job_config = bigquery.QueryJobConfig()
if destination_table_name or destination_dataset_name:
if not destination_table_name and destination_dataset_name:
raise exceptions.ValidationError(
"Both destination_dataset_name and destination_table_name must be provided."
)
destination_project = destination_project or self.project_id
destination_dataset = destination_dataset_name
destination = f"{destination_project}.{destination_dataset}.{destination_table_name}"
job_config.destination = destination
if truncate:
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
elif truncate is False:
job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
if params:
query_params = [
_BigQueryParam.parse(key, value)
for key, value in params.items()
]
job_config.query_parameters = query_params
query_job = self.client.query(sql, job_config=job_config)
return self._wait_for_job(job=query_job)
def _get_event_param():
valid_events = {
"trigger_template": cloudbuild_v1.RepoSource,
"github": cloudbuild_v1.GitHubEventsConfig,
}
for key, klass in valid_events.items():
if isinstance(event, klass):
return key
raise exceptions.ValidationError(
f"Unsupported event type {event.__class__.__name__,}")
def _change_record(
self,
action: str,
zone_name: str,
zone_dns: str,
name: str,
record_type: RecordType,
record_data: List[str] = None,
ttl: int = 60 * 60,
wait: bool = True,
) -> dns.ResourceRecordSet:
zone = self._build_zone(name=zone_name, dns_name=zone_dns)
parsed_record_data = ([
RecordType.prepare(record_type=record_type, record=record)
for record in record_data
] if record_data else [])
record_set = zone.resource_record_set(
name=RecordType.build_dns_name(name=name),
record_type=record_type.name,
ttl=ttl,
rrdatas=parsed_record_data,
)
changes = zone.changes()
if action == "add":
changes.add_record_set(record_set)
elif action == "delete":
changes.delete_record_set(record_set)
else:
raise exceptions.ValidationError(
f"Action {action} is not support for record sets")
try:
changes.create()
except BadRequest as exc:
if "is only permitted to have one record" in exc.message:
raise exceptions.AlreadyExists(exc.message) from exc
raise
except Conflict as exc:
raise exceptions.AlreadyExists(exc.message) from exc
if wait:
while changes.status != "done":
print("Waiting for changes to complete")
time.sleep(60)
changes.reload()
return record_set
def reset_password(self, email: str, new_password: str, old_password: str = None, oob_code: str = None):
data = {
"newPassword": new_password,
"email": email,
}
if oob_code:
data["oobCode"] = oob_code
elif old_password:
data["oldPassword"] = old_password
else:
raise exceptions.ValidationError("Either `old_password` or `oob_code` must be provided")
response = self._execute(method=self.client.accounts().resetPassword, body=data)
return response
def lookup(self, email: str = None, phone_number: str = None, project_id: str = None) -> Iterator[User]:
if not email and not phone_number:
raise exceptions.ValidationError("Either `email` or `phone_number` must be provided")
data = {
"target_project_id": project_id or self.project_id,
}
if email:
data["email"] = email
if phone_number:
if not phone_number.startswith("+"):
phone_number = f"+{phone_number}"
data["phone_number"] = phone_number
response = self._execute(method=self.client.accounts().lookup, body=data)
for item in response.get("users", []):
yield User.create(data=item)
def _get_type(cls, variable: Any) -> str:
TYPES = { # pylint: disable=invalid-name
"int": "INT64",
"str": "STRING",
"datetime": "DATETIME",
"date": "DATE",
"bool": "BOOL",
"float": "FLOAT64",
"Decimal": "FLOAT64",
}
python_type = type(variable).__name__
param_type = TYPES.get(python_type, None)
if param_type is None:
raise exceptions.ValidationError(
f"Parameter with type {param_type} not supported")
return param_type
def _build_filter(self, key: str,
value: Any) -> List[Tuple[str, str, Any]]:
operator = None
*field_parts, lookup = key.split("__")
if lookup:
try:
operator = self.lookup_operators[lookup]
if callable(operator):
field_name = ".".join(field_parts)
return operator(field_name, value)
except KeyError:
field_parts.append(lookup)
if len(field_parts) > 1 and field_parts[0] not in self.fields:
raise exceptions.ValidationError(
f"{field_parts[0]} is not a valid field. Excepted one of {' | '.join(self.fields)}"
)
field_name = ".".join(field_parts)
return [(field_name, (operator or "="), value)]
def create_or_update_resource(
self,
data: Dict[str, Any],
resource_type: str,
store_name: str,
dataset_name: str,
query: Dict[str, Any] = None,
project_id: str = None,
location: str = None,
) -> ResourceType:
if not query:
identifiers = data.get("identifier")
if not identifiers:
raise exceptions.ValidationError(
"Either `query` or identifiers must be provided to create-or-update"
)
query_values = []
for identifier in identifiers:
query_values.append(identifier["system"])
query_values.append(identifier["value"])
query = {"identifier": "|".join(query_values)}
parent = self._store_path(
name=store_name,
dataset_name=dataset_name,
project_id=project_id,
location=location,
)
url = f"{self._base_url}/{parent}/fhir/{resource_type}"
params = dict(
url=url,
params=query,
headers={"Content-Type": "application/fhir+json;charset=utf-8"},
json=data,
)
return self._execute(method=self._session.put, **params)
def build_repo_source(
cls,
name,
branch: str = None,
commit: str = None,
tag: str = None,
directory: str = None,
project_id: str = None,
) -> Dict[str, Any]:
valid_references = [ref for ref in [branch, commit, tag] if ref]
if len(valid_references) > 1:
raise exceptions.ValidationError(
"Only one of branch|tag|commit must be provided")
if branch:
ref = f"moveable-aliases/{branch}"
elif commit:
ref = f"revisions{commit}"
elif tag:
ref = f"fixed-aliases/{tag}"
else:
ref = "moveable-aliases/master"
path = f"/paths/{directory}" if directory else ""
if "/" in name:
# Assume it's a repository integrated through Github App
org, repo = name.split("/")
repo_name = f"github_{org}_{repo}"
else:
repo_name = name
REPO_SOURCE_URL = "https://source.developers.google.com" # pylint: disable=invalid-name
url = f"{REPO_SOURCE_URL}/projects/{project_id}/repos/{repo_name}/{ref}{path}"
repo = dict(url=url)
return repo
