def find_one(self, type: str, date: Optional[datetime] = None) -> Optional[SlackMessage]:
query = {'type': type}
if date is not None:
query['date'] = date
doc = self.collection.find_one(query)
if doc is not None:
return parse(SlackMessage, doc)
def test_basic_dataclass():
@dataclass
class Foo:
x: int
y: int = 1
assert parse(Foo, {'x': 2}) == Foo(2, 1)
def avg(self):
points = [
parse(UserPoints, doc).points for doc in self.collection.find()
]
if points:
return int(statistics.mean(points))
return 0
def wrapper(instance, flask_params: dict, user: Optional[User]):
fargs = flask_params.copy()
if 'data' in parameters and request.method == 'POST':
data = request.get_json(force=True)
self.fix_arrays(data)
fargs['data'] = parse(parameters['data'].annotation, data)
if user and 'user' in parameters and parameters['user'].annotation == User:
fargs['user'] = user
return method(instance, **fargs)
def get_by_pos(self, galaxy: int, sector: int,
position: int) -> Optional[Resa]:
doc = self.collection.find_one({
'galaxy': galaxy,
'sector': sector,
'position': position
})
if doc is not None:
return parse(Resa, doc)
def test_parse_date_with_formatter():
@date_formatter(TestFormatter())
class Foo:
def __init__(self, bar: datetime):
self.bar = bar
result = parse(Foo, {'bar': 42})
assert result.bar == datetime(2018, 3, 8, 14, 5, 10)
def top_land(self, galaxy: int) -> Iterable[Place]:
query = {
'place.galaxy': galaxy,
'place.planet.land': {'$gt': 120},
'place.planet.owner': {'$exists': False}
}
for doc in self.collection.find(query):
mongo_place = parse(MongoPlace, doc)
yield mongo_place.place
def list_users(self) -> Iterator[User]:
result = self.client.api_call('users.list')
for member in result['members']:
member = parse(Member, member)
name = member.profile.display_name or member.profile.real_name
all_names = [member.name, member.profile.display_name, member.profile.real_name,
member.profile.real_name_normalized, member.profile.display_name_normalized]
all_names = list(map(str.lower, all_names))
yield User(member.id, name, member.profile.email, all_names)
def run(self, payload: dict):
message = parse(ViewClosedPayload, payload)
for descriptor in self.find_callback(message.view.callback_id):
user = self.users.get_user(message.user.id)
self.endpoints.run(descriptor.plugin,
descriptor.method,
user=user,
callback_id=message.view.callback_id,
private_metadata=message.view.private_metadata)
def build_state(self, state: dict) -> Dict[str, BlockAction]:
if 'values' not in state:
return {}
result = {}
for block_id, block_data in state['values'].items():
for action_id, action_data in block_data.items():
action_data['block_id'] = block_id
action_data['action_id'] = action_id
result[action_id] = parse(BlockAction, action_data)
return result
def top_spe(self, galaxy: int) -> Iterable[Place]:
query = {
'place.galaxy': galaxy,
'place.specials.0': {'$exists': True},
'place.category': PlaceType.planet.name,
'place.planet.owner': {'$exists': False}
}
for doc in self.collection.find(query):
mongo_place = parse(MongoPlace, doc)
yield mongo_place.place
def get_sector(self, galaxy: int, sector: int) -> Sector:
docs = self.collection.find({'place.galaxy': galaxy, 'place.sector': sector})
places = [parse(MongoPlace, doc).place for doc in docs]
places_by_pos = {place.position: place for place in places}
ordered_places = []
for i in range(1, 26):
if i in places_by_pos:
ordered_places.append(places_by_pos[i])
else:
ordered_places.append(Place(galaxy, sector, i))
return Sector(galaxy, sector, ordered_places)
def test_rename_rule(self):
@pyckson
@rename(foo="_foo", bar="bar_")
class Foo:
def __init__(self, foo: str, bar: str):
self.foo = foo
self.bar = bar
foo = Foo("foo", "bar")
self.assertEqual(serialize(foo), {"_foo": "foo", "bar_": "bar"})
foo = parse(Foo, {"_foo": "foo", "bar_": "bar"})
self.assertEqual(foo.foo, "foo")
self.assertEqual(foo.bar, "bar")
def test_rename_rule(self):
@pyckson
@rename(foo='_foo', bar='bar_')
class Foo:
def __init__(self, foo: str, bar: str):
self.foo = foo
self.bar = bar
foo = Foo('foo', 'bar')
self.assertEqual(serialize(foo), {'_foo': 'foo', 'bar_': 'bar'})
foo = parse(Foo, {'_foo': 'foo', 'bar_': 'bar'})
self.assertEqual(foo.foo, 'foo')
self.assertEqual(foo.bar, 'bar')
def jira_creation_hook(self):
event = parse(JiraEvent, request.json)
user = self.users.get_by_email(event.user.email_address)
url = 'https://jira.antidot.net/browse/' + event.issue.key
active_sprint = self.active_sprint()
if active_sprint is not None and event.issue.fields.project.key == 'FT':
self.jira.add_issues_to_sprint(active_sprint.id, [event.issue.key])
if event.issue.fields.priority.id == JiraPriority.Blocker:
text = '<!channel> <{}|{}> was just created by <@{}>.'
text = text.format(url, event.issue.key, user.id)
priority = event.issue.fields.priority.name
attachment1 = Attachment('-', text='Priority is {}'.format(priority), color='#ff0000')
attachment2 = Attachment('-', text='*{}*'.format(event.issue.fields.summary), color='#ff0000')
self.api.post_message('ft-product-team', Message(text=text, attachments=[attachment1, attachment2]))
def run_callback(self, payload: dict):
message = parse(BlockPayload, payload)
state = self.build_state(message.state.copy()) if message.state else {}
for action in message.actions:
for block_action in self.find_block_action(action.block_id, action.action_id):
user = self.users.get_user(message.user.id)
channel = Channel(message.channel.id, message.channel.name) if message.channel else None
values = message.view.state.values if message.view and message.view.state else None
reply = self.endpoints.run(block_action.plugin, block_action.method,
user=user, channel=channel,
action=action, trigger_id=message.trigger_id,
timestamp=message.container.message_ts,
response_url=message.response_url,
view_id=message.view.id if message.view else None,
private_metadata=message.view.private_metadata if message.view else None,
values=values, state=state)
if isinstance(reply, Message):
self.api.respond(message.response_url, reply)
def jira_hook(self):
event = parse(JiraEvent, request.json)
user = self.users.get_by_email(event.user.email_address)
if 'not-for-release-note' in event.issue.fields.labels:
return
if event.issue.fields.issuetype.name in ['Task', 'Think']:
return
problems = []
if event.issue.fields.release_note is None \
or event.issue.fields.release_note == 'None' \
or len(event.issue.fields.release_note.strip()) == 0:
problems.append('has no release note information')
if len(event.issue.fields.fix_versions) == 0:
problems.append('has no release version')
url = 'https://jira.antidot.net/browse/' + event.issue.key
if len(problems) > 0:
count = self.errors.get_and_inc(user)
problems = ' and '.join(problems)
msg_template = '<@{}> <{}|{}> was moved to done but {}'
message = msg_template.format(user.id, url, event.issue.key, problems)
suf = lambda n: "%d%s" % (n, {1: "st", 2: "nd", 3: "rd"}.get(n if n < 20 else n % 10, "th"))
attachment_text = 'This is the {} time this month {}'.format(suf(count), self.smiley(count))
attachment = Attachment('void', text=attachment_text)
self.api.post_message('ft-product-team', Message(text=message, attachments=[attachment]))
else:
msg_template = '<{}|{}> was move to done by <@{}>'
message = msg_template.format(url, event.issue.key, user.id)
attachments = []
rn_attachment = '{}'.format(event.issue.fields.release_note)
color = '#ff0a0a' if event.issue.fields.issuetype.name == 'Bug' else '#7acc00'
attachments.append(Attachment('void', text=rn_attachment, color=color))
if event.issue.fields.upgrade_information is not None \
and event.issue.fields.upgrade_information.strip() not in ['', 'None']:
ui_attachment = 'Upgrade Information : {}'.format(event.issue.fields.upgrade_information)
attachments.append(Attachment('void', text=ui_attachment, color='#2196f3'))
self.api.post_message('ft-product-team', Message(text=message, attachments=attachments))
def run(self, payload: dict):
message = parse(ViewSubmitPayload, payload)
for descriptor in self.find_callback(message.view.callback_id):
user = self.users.get_user(message.user.id)
reply = self.endpoints.run(
descriptor.plugin,
descriptor.method,
user=user,
callback_id=message.view.callback_id,
values=message.view.state.values,
view_id=message.view.id,
private_metadata=message.view.private_metadata)
if isinstance(reply, View):
return {'response_action': 'update', 'view': serialize(reply)}
if isinstance(reply, ViewError):
return {
'response_action': 'errors',
'errors': {
reply.block_id: reply.message
}
}
def get(self, user: User) -> UserPoints:
document = self.collection.find_one({'user.id': user.id})
if document is None:
return self.create(user, self.avg())
return parse(UserPoints, document)
def test_should_raise_error_on_unresolvedtype(self):
with self.assertRaises(TypeError):
parse(Fail('toto'))
def upload_and_share(self, content: bytes, filename: str, title: str,
content_type: str, channels: List[str]) -> File:
result = self.client.files_upload(file=BytesIO(content), filename=filename,
title=title, content_type=content_type,
channels=','.join(channels))
return parse(File, result.data['file'])
def test_custom_parser_on_param_forwardref():
result = parse(Foo2, {'bar': {}})
assert result.bar.x == 42
def find_all(self, type: str, date: Optional[datetime] = None) -> Iterator[SlackMessage]:
query = {'type': type}
if date is not None:
query['date'] = date
for item in self.collection.find(query):
yield parse(SlackMessage, item)
def upload_file(self, channel_id: str, filename: str, title: str, content: bytes):
result = self.client.files_upload(file=BytesIO(content), filename=filename,
title=title, channels=channel_id)
return parse(File, result.data['file'])
def test_custom_parser_forwardref():
result = parse(Foo, {'x': 42})
assert result.bar == 42
def find_all(self, type: str, date: Optional[datetime] = None) -> Iterator[SlackMessage]:
query = {'type': type}
if date is not None:
query['date'] = date
for item in self.collection.find(query):
yield parse(SlackMessage, item)
def get_by_apikey(self, apikey: str) -> Optional[User]:
doc = self.collection.find_one({'apikey': apikey})
if doc:
return parse(User, doc)
def get_by_user(self, username: str) -> Iterable[Resa]:
for doc in self.collection.find({'username': username}):
yield parse(Resa, doc)
def get_all(self) -> Iterable[Resa]:
for doc in self.collection.find():
yield parse(Resa, doc)
def get(self, user: User) -> ErrorCount:
doc = self.collection.find_one({'user.id': user.id, 'month': self.month})
if doc is None:
return ErrorCount(user, self.month, 0)
else:
return parse(ErrorCount, doc)
def test_should_parse_class_with_forwarf_list(self):
result = parse(ClsWithForwardList, {'x': [{'y': 1}, {'y': 2}]})
self.assertEqual(result.x[0].y, 1)
self.assertEqual(result.x[1].y, 2)
def find(self, date: datetime, user: User) -> Optional[Order]:
document = self.collection.find_one({'date': date, 'user.id': user.id})
if document is None:
return None
return parse(Order, document)
def find_all(self, date: datetime) -> Iterator[Order]:
for doc in self.collection.find({'date': date}):
yield parse(Order, doc)
def get(self, order_id: str) -> Optional[Order]:
document = self.collection.find_one({'_id': order_id})
if document is None:
return None
return parse(Order, document)
def test_should_parse_indirect_recursive(self):
result = parse(Bar, {'quz': {'x': 'a', 'bar': {'quz': {'x': 'b'}}}})
self.assertEqual(result.quz.x, 'a')
self.assertEqual(result.quz.bar.quz.x, 'b')
self.assertIsNone(result.quz.bar.quz.bar)
def test_should_raise_error_on_unresolvedtype(self):
with self.assertRaises(TypeError):
parse(Fail, {'bar': 1})
def test_should_parse_recursive(self):
result = parse(Foo, {'x': 'a', 'foo': {'x': 'b', 'foo': {'x': 'c'}}})
self.assertEqual(result.x, 'a')
self.assertEqual(result.foo.x, 'b')
self.assertEqual(result.foo.foo.x, 'c')
self.assertIsNone(result.foo.foo.foo)
def find_all(self) -> Iterable[UserPoints]:
for doc in self.collection.find(sort=[('points', -1)]):
yield parse(UserPoints, doc)
def get_user(self, username) -> Optional[User]:
doc = self.collection.find_one({'username': username})
if doc:
return parse(User, doc)
def test_should_parse_indirect_recursive(self):
result = parse(Bar, {'quz': {'x': 'a', 'bar': {'quz': {'x': 'b'}}}})
self.assertEqual(result.quz.x, 'a')
self.assertEqual(result.quz.bar.quz.x, 'b')
self.assertIsNone(result.quz.bar.quz.bar)
def get(self, key, default=None, cls=None):
result = self.collection.find_one({'_id': key})
result = result['value'] if result is not None else default
result = parse(cls, result) if cls is not None else result
return result
def get_channel(self, channel_id) -> Channel:
result = self.client.conversations_info(channel=channel_id)
channel = parse(Channel, result['channel'])
return channel
