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 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 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