def test_process_env_install_from_source(
tmpdir: py.path.local,
tmpvenv_active: Tuple[py.path.local, py.path.local],
modules_v2_dir: str,
editable: bool,
) -> None:
"""
Install a package from source into the process_env. Make sure the editable option actually results in an editable install.
"""
venv_dir, python_path = tmpvenv_active
package_name: str = "inmanta-module-minimalv2module"
project_dir: str = os.path.join(modules_v2_dir, "minimalv2module")
assert package_name not in env.process_env.get_installed_packages()
env.process_env.install_from_source(
[env.LocalPackagePath(path=project_dir, editable=editable)])
assert package_name in env.process_env.get_installed_packages()
if editable:
assert any(package["name"] == package_name
for package in pydantic.parse_raw_as(
List[Dict[str, str]],
subprocess.check_output([
python_path, "-m", "pip", "list", "--editable",
"--format", "json"
]).decode(),
))
async def get(self):
"""Получить.
:return: list[BaseModel]
"""
logger.info('Searching cached...')
cache = await self._cache_connection.get(str(hash(self._origin)))
if cache:
logger.info('Cached data founded')
return parse_raw_as(list[self._model_to_parse],
cache) # type: ignore
logger.info('Cached data not founded')
origin_get_result = await self._origin.get()
logger.info('Setting data to cache')
pagination_elements = [
pagination_element.dict()
for pagination_element in origin_get_result
]
await self._cache_connection.set(
str(hash(self._origin)),
json.dumps(pagination_elements),
ex=60 * 60,
)
logger.info('Data setted to cache')
return origin_get_result
async def get_content_preview(self,
content_preview_link: str) -> ContentPreview:
"""
Returns the results from the specified content preview link.
"""
result = await self._get(content_preview_link)
return parse_raw_as(ContentPreview, result)
async def get_file(self, mod_id: int, file_id: int) -> File:
"""
Returns the specified file for the specified mod.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/files/{file_id}.json"
)
return parse_raw_as(File, result)
async def get_mod(self, mod_id: int) -> Mod:
"""
Returns a specified mod. Cached for 5 minutes.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}.json"
)
return parse_raw_as(Mod, result)
async def get_mod_changelogs(self, mod_id: int) -> dict[str, list[str]]:
"""
Returns a list of changelogs for the specified mod.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/changelogs.json"
)
return parse_raw_as(dict[str, list[str]], result)
async def get_trending_mods(self) -> list[Mod]:
"""
Returns 10 trending mods.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/trending.json"
)
return parse_raw_as(list[Mod], result)
def mock_lametric_cloud_config_flow() -> Generator[MagicMock, None, None]:
"""Return a mocked LaMetric Cloud client."""
with patch("homeassistant.components.lametric.config_flow.LaMetricCloud",
autospec=True) as lametric_mock:
lametric = lametric_mock.return_value
lametric.devices.return_value = parse_raw_as(
list[CloudDevice], load_fixture("cloud_devices.json", DOMAIN))
yield lametric
async def get_latest_updated_mods(self) -> list[Mod]:
"""
Returns the 10 latest updated mods.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/latest_updated.json"
)
return parse_raw_as(list[Mod], result)
def get_boards(member: str,
query: Optional[Dict[str, str]] = DEFAULT_QUERY) -> List[Board]:
"""
https://developer.atlassian.com/cloud/trello/rest/api-group-members/#api-members-id-boards-get
"""
url = f"https://api.trello.com/1/members/{ member }/boards"
headers = {"Accept": "application/json"}
response = requests.request("GET", url, headers=headers, params=query)
return parse_raw_as(List[Board], response.text)
async def get_md5_search(self, md5_hash: str) -> list[tuple[Mod, File]]:
"""
Returns a list of mod files for the given MD5 file hash.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/md5_search/{md5_hash}.json"
)
parsed = parse_raw_as(list[SearchResult], result)
return [(p.mod, p.file_details) for p in parsed]
async def get_download_links(self, mod_id: int,
file_id: int) -> list[DownloadLink]:
"""
Returns a generated download link for the specified mod file.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/files/{file_id}/download_link.json"
)
return parse_raw_as(list[DownloadLink], result)
async def get_files_and_updates(
self, mod_id: int) -> tuple[list[File], list[FileUpdate]]:
"""
Returns a list of files for the specified mod.
"""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/files.json"
)
parsed = parse_raw_as(FilesResult, result)
return parsed.files, parsed.file_updates
async def get_mod_updates(self, period: str) -> list[ModUpdate]:
"""
Returns a list of mods that have been updated in a given period, with timestamps of their last update.
Cached for 5 minutes.
The only accepted periods are '1d', '1w' and '1m' (1 day, 1 week and 1 month).
"""
json: _JsonDict = {"period": period}
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/updated.json",
json=json)
return parse_raw_as(list[ModUpdate], result)
def get_cards(board: Union[str, Board],
query: Optional[Dict[str, str]] = DEFAULT_QUERY) -> List[Card]:
"""
https://developer.atlassian.com/cloud/trello/rest/api-group-boards/#api-boards-id-cards-get
"""
if isinstance(board, Board):
board = board.id
url = f"https://api.trello.com/1/boards/{ board }/cards"
response = requests.request("GET", url, params=query)
return parse_raw_as(List[Card], response.text)
def update_employer_job_answers(event: dict, context: LambdaContext) -> dict:
try:
if 'pathParameters' not in event or not event['pathParameters'] \
or 'employer_id' not in event['pathParameters'] or 'job_id' not in event['pathParameters'] \
or 'body' not in event or not event['body']:
return {
'statusCode': HTTPStatus.BAD_REQUEST,
'headers': EmployerConstants.HEADERS,
'body': "Missing employer job body/path params to create"
}
employer_answers: List[Answer] = parse_raw_as(List[Answer],
event['body'])
employer_id = event['pathParameters']['employer_id']
job_id = event['pathParameters']['job_id']
dynamo_resource = boto3.resource("dynamodb")
jobs_table = dynamo_resource.Table(
get_env_or_raise(EmployerConstants.JOBS_TABLE_NAME))
stored_job: EmployerJob = EmployerJob.parse_obj(
jobs_table.get_item(Key={
'job_id': job_id
}).get('Item', {}))
if stored_job.employer_id != employer_id:
return {
'statusCode': HTTPStatus.BAD_REQUEST,
'headers': EmployerConstants.HEADERS,
'body': "Given employer id does not match job id"
}
stored_job.answers = employer_answers
jobs_table.update_item(Key={"job_id": job_id},
UpdateExpression="set answers=:a",
ExpressionAttributeValues={
":a":
[a.dict() for a in stored_job.answers],
},
ReturnValues="UPDATED_NEW")
return {
'statusCode': HTTPStatus.CREATED,
'headers': EmployerConstants.HEADERS,
'body': stored_job.json(exclude_none=True)
}
except (ValidationError, TypeError) as err:
return {
'statusCode': HTTPStatus.BAD_REQUEST,
'headers': EmployerConstants.HEADERS,
'body': str(err)
}
except Exception as err:
return {
'statusCode': HTTPStatus.INTERNAL_SERVER_ERROR,
'headers': EmployerConstants.HEADERS,
'body': str(err)
}
async def set_tracked(self, mod_id: int, tracked: bool) -> Message:
"""Track or untrack a mod."""
json: _JsonDict = {
"domain_name": self.game_domain_name,
"mod_id": mod_id
}
if tracked:
result = await self._post(
f"{self.BASE_URL}/user/tracked_mods.json", json=json)
else:
result = await self._delete(
f"{self.BASE_URL}/user/tracked_mods.json", json=json)
return parse_raw_as(Message, result)
def __call__(self, input: Any, **kwargs: Any) -> Any:
input_obj = input
if isinstance(input, str):
# Allow json input
input_obj = parse_raw_as(self.input_type, input)
if isinstance(input, dict):
# Allow dict input
input_obj = parse_obj_as(self.input_type, input)
return self.function(input_obj, **kwargs)
async def set_endorsed(self, mod_id: int, version: str,
endorsed: bool) -> Status:
"""Endorse or unendorse a mod."""
json: _JsonDict = {"version": version}
if endorsed:
result = await self._post(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/endorse.json",
json=json,
)
else:
result = await self._post(
f"{self.BASE_URL}/games/{self.game_domain_name}/mods/{mod_id}/abstain.json",
json=json,
)
return parse_raw_as(Status, result)
async def actions(request: Request):
form = await request.form()
payload: Payload = parse_raw_as(Payload, form['payload'])
if payload.is_view_submission:
# モーダルに入力した内容を送信するイベント
return RedirectResponse('./view_submission/')
if payload.is_shortcut:
# ショートカット（「emojiを追加」「emojiを編集」）を選択したイベント
return RedirectResponse('./shortcuts/')
if payload.is_block_actions:
if payload.container:
if payload.container.is_message:
# 「読んだ」ボタンを押したイベント
return RedirectResponse('./message/')
return Response()
def get_checklists(
card: Union[str, Card],
query: Optional[Dict[str, str]] = DEFAULT_QUERY) -> List[CheckList]:
"""
https://developer.atlassian.com/cloud/trello/rest/api-group-cards/#api-cards-id-checklists-get
"""
if isinstance(card, Card):
card = card.id
url = f"https://api.trello.com/1/cards/{ card }/checklists"
response = requests.request("GET", url, params=query)
try:
return parse_raw_as(List[CheckList], response.text)
except Exception as exception:
print(response.text)
def cli() -> None:
with open("senderconfig.json") as fh:
senderconfig = pydantic.parse_raw_as(SenderConfigFile, fh.read())
argparser = ArgumentParser()
argparser.add_argument("campaign",
help="The name of the data file + template to send")
argparser.add_argument("--sender",
choices=senderconfig.keys(),
help="Name of the senderconfig to use")
argparser.add_argument(
"--no-confirmations",
action="store_false",
default=True,
dest="confirmations",
help="I exactly know what I'm doing, just send everything immediately.",
)
args = argparser.parse_args()
sender_name = args.sender
if sender_name is None:
print("Please select a sender configuration:")
print()
for name, data in senderconfig.items():
print(" [{}]: {}".format(
name, ", ".join(f"{k}: '{v}'"
for k, v in data.headers.items())) +
(f"; mock send to {data.override_recipient}" if data.
override_recipient is not None else ""))
print()
sender_name = input("Your selection: ")
if sender_name not in senderconfig.keys():
print("Invalid selection", file=sys.stderr)
sys.exit(1)
print()
sys.exit(main(args.campaign, senderconfig[sender_name],
args.confirmations))
def __init__(self):
self.exit = 0
try:
self.settings = Settings()
except ValidationError as e:
log(f'error loading Settings:\n{e}')
self.exit = 1
return
contents = self.settings.github_event_path.read_text()
event = parse_raw_as(Union[IssueEvent, PullRequestEvent], contents)
force_assign_author = False
if hasattr(event, 'issue'):
event = cast(IssueEvent, event)
if event.issue.pull_request is None:
log('action only applies to pull requests, not issues')
return
comment = event.comment
pr = event.issue
event_type = 'comment'
else:
event = cast(PullRequestEvent, event)
comment = event.review
if comment.body is None:
log('review has no body, stopping')
return
pr = event.pull_request
force_assign_author = event.review.state == 'changes_requested'
event_type = 'review'
self.commenter = comment.user.login
body = comment.body.lower()
number = pr.number
self.author = pr.user.login
# hack until https://github.com/samuelcolvin/pydantic/issues/1458 gets fixed
self.reviewers = [
r.strip(' ') for r in self.settings.reviewers.split(',')
if r.strip(' ')
]
g = Github(self.settings.token.get_secret_value())
repo = g.get_repo(self.settings.github_repository)
self.pr = repo.get_pull(number)
self.commenter_is_reviewer = self.commenter in self.reviewers
self.commenter_is_author = self.author == self.commenter
log(f'{self.commenter} ({event_type}): {body!r}')
if self.settings.request_review_trigger in body:
success, msg = self.request_review()
elif self.settings.request_update_trigger in body or force_assign_author:
success, msg = self.assign_author()
else:
success = False
msg = (
f'neither {self.settings.request_update_trigger!r} nor {self.settings.request_review_trigger!r} '
f'found in comment body, not proceeding')
if success:
if event_type == 'comment':
self.pr.get_issue_comment(comment.id).create_reaction('+1')
log(f'success: {msg}')
else:
log(f'warning: {msg}')
async def get_game(self) -> Game:
"""Returns the specified game."""
result = await self._get(
f"{self.BASE_URL}/games/{self.game_domain_name}.json")
return parse_raw_as(Game, result)
async def get_user(self) -> User:
"""Returns the current user."""
result = await self._get(f"{self.BASE_URL}/users/validate.json")
return parse_raw_as(User, result)
async def get_tracked_mods(self) -> list[TrackedMod]:
"""Returns all the mods being tracked by the current user."""
result = await self._get(f"{self.BASE_URL}/user/tracked_mods.json")
return parse_raw_as(list[TrackedMod], result)
def json_string_to_pydantic(
serialized_value: str,
destination_type: Type[PydanticModel],
) -> PydanticModel:
"""Convert a JSON representation of a Pydantic model into model instance."""
return pydantic.parse_raw_as(destination_type, serialized_value)
def parse_configuration(content: str) -> list[Configuration]:
config_lst = parse_raw_as(List[Configuration], content)
if len(config_lst) == 0:
sys.exit("Leere Konfigurationsdateien sind nicht erlaubt.\n")
return config_lst
async def get_endorsements(self) -> list[Endorsement]:
"""Returns a list of all endorsements for the current user."""
result = await self._get(f"{self.BASE_URL}/user/endorsements.json")
return parse_raw_as(list[Endorsement], result)
async def get_colour_schemes(self) -> list[ColourScheme]:
"""
Returns list of all colour schemes, including the primary, secondary and 'darker' colours.
"""
result = await self._get(f"{self.BASE_URL}/colourschemes.json")
return parse_raw_as(list[ColourScheme], result)
