def test_list_of_map_with_of_and_custom_attribute(self, mocker): class CustomMapAttribute(MapAttribute): custom = NumberAttribute() def __eq__(self, other): return self.custom == other.custom serialize_mock = mocker.spy( CustomMapAttribute.custom, 'serialize', ) deserialize_mock = mocker.spy(CustomMapAttribute.custom, 'deserialize') attribute1 = CustomMapAttribute() attribute1.custom = 1 attribute2 = CustomMapAttribute() attribute2.custom = 2 inp = [attribute1, attribute2] list_attribute = ListAttribute(default=[], of=CustomMapAttribute) serialized = list_attribute.serialize(inp) deserialized = list_attribute.deserialize(serialized) assert deserialized == inp assert serialize_mock.call_args_list == [call(1), call(2)] assert deserialize_mock.call_args_list == [call('1'), call('2')]
def test_list_of_map_with_of(self): class Person(MapAttribute): name = UnicodeAttribute() age = NumberAttribute() def __lt__(self, other): return self.name < other.name def __eq__(self, other): return (self.name == other.name and self.age == other.age) person1 = Person() person1.name = 'john' person1.age = 40 person2 = Person() person2.name = 'Dana' person2.age = 41 inp = [person1, person2] list_attribute = ListAttribute(default=[], of=Person) serialized = list_attribute.serialize(inp) deserialized = list_attribute.deserialize(serialized) assert sorted(deserialized) == sorted(inp)
def test_double_indexing(self): condition = ListAttribute(attr_name='foo')[0][1] == 'bar' placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "#0[0][1] = :0" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == {':0': {'S' : 'bar'}}
def test_list_comparison(self): condition = ListAttribute(attr_name='foo') == ['bar', 'baz'] placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "#0 = :0" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == {':0': {'L': [{'S' : 'bar'}, {'S': 'baz'}]}}
def test_contains_list(self): condition = ListAttribute(attr_name='foo').contains('bar') placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "contains (#0, :0)" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == {':0': {'S' : 'bar'}}
def test_contains_attribute(self): condition = ListAttribute(attr_name='foo').contains(Path('bar')) placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "contains (#0, #1)" assert placeholder_names == {'foo': '#0', 'bar': '#1'} assert expression_attribute_values == {}
def test_double_indexing(self): condition = ListAttribute(attr_name='foo')[0][1] == 'bar' placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "#0[0][1] = :0" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == {':0': {'S' : 'bar'}}
def test_contains_attribute(self): condition = ListAttribute(attr_name='foo').contains(Path('bar')) placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "contains (#0, #1)" assert placeholder_names == {'foo': '#0', 'bar': '#1'} assert expression_attribute_values == {}
def test_contains_list(self): condition = ListAttribute(attr_name='foo').contains('bar') placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "contains (#0, :0)" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == {':0': {'S' : 'bar'}}
def test_list_of_map_with_of_and_custom_attribute(self, mocker): class CustomMapAttribute(MapAttribute): custom = NumberAttribute() def __eq__(self, other): return self.custom == other.custom serialize_mock = mocker.spy(CustomMapAttribute.custom, 'serialize',) deserialize_mock = mocker.spy(CustomMapAttribute.custom, 'deserialize') attribute1 = CustomMapAttribute() attribute1.custom = 1 attribute2 = CustomMapAttribute() attribute2.custom = 2 inp = [attribute1, attribute2] list_attribute = ListAttribute(default=[], of=CustomMapAttribute) serialized = list_attribute.serialize(inp) deserialized = list_attribute.deserialize(serialized) assert deserialized == inp assert serialize_mock.call_args_list == [call(1), call(2)] assert deserialize_mock.call_args_list == [call('1'), call('2')]
def test_list_of_map_with_of(self): class Person(MapAttribute): name = UnicodeAttribute() age = NumberAttribute() def __lt__(self, other): return self.name < other.name def __eq__(self, other): return (self.name == other.name and self.age == other.age) person1 = Person() person1.name = 'john' person1.age = 40 person2 = Person() person2.name = 'Dana' person2.age = 41 inp = [person1, person2] list_attribute = ListAttribute(default=[], of=Person) serialized = list_attribute.serialize(inp) deserialized = list_attribute.deserialize(serialized) assert sorted(deserialized) == sorted(inp)
def test_untyped_list(self): untyped_list = [{ 'Hello': 'World' }, ['!'], {'foo', 'bar'}, None, "", 0, False] serialized = ListAttribute().serialize(untyped_list) # set attributes are serialized as lists untyped_list[2] = list(untyped_list[2]) assert ListAttribute().deserialize(serialized) == untyped_list
class RetrospectiveV2(Retrospective): class Meta: table_name = 'retrospective-{}'.format(ENVIRONMENT) if ENVIRONMENT == 'test': host = "http://localhost:8008" issues = ListAttribute(of=IssueAttributeV2) groups = ListAttribute(of=GroupAttribute) version = UnicodeAttribute()
class ReceiptLinesModel(Model): class Meta: region = config.AWS_REGION_DEFAULT table_name = 'receipt_lines' host = config.DYNAMODB_LOCAL_URL if is_lambda_local() else None image_hash = UnicodeAttribute(hash_key=True) receipt_lines = ListAttribute(default=None) receipt_lines_tokens = ListAttribute(default=None)
def test_typed_list_indexing(self): class StringMap(MapAttribute): bar = UnicodeAttribute() condition = ListAttribute(attr_name='foo', of=StringMap)[0].bar == 'baz' placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "#0[0].#1 = :0" assert placeholder_names == {'foo': '#0', 'bar': '#1'} assert expression_attribute_values == {':0': {'S': 'baz'}}
class UserReminder(Model): class Meta: table_name = TABLE_USER_REMINDER region = 'us-east-2' user_id = NumberAttribute(hash_key=True) registration_time = NumberAttribute() time_delta = NumberAttribute(default=DEFAULT_DELTA) active_reminders = ListAttribute(default=list, of=ReminderMap) passive_reminders = ListAttribute(default=list, of=ReminderMap) temp_reminder = ReminderMap(default=ReminderMap)
class Retrospective(Model): class Meta: table_name = 'retrospective-{}'.format(ENVIRONMENT) if ENVIRONMENT == 'test': host = "http://localhost:8008" id = UnicodeAttribute(hash_key=True) name = UnicodeAttribute() current_step = UnicodeAttribute() issues = ListAttribute(of=IssueAttribute) participants = ListAttribute(of=ParticipantAttribute) version = UnicodeAttribute()
class Doc(MapAttribute): aliases = ListAttribute(attr_name="aliases", default=[]) status = UnicodeAttribute(attr_name="status", default="ready") columns = ListAttribute(attr_name="columns", of=Column, default=[]) bucket = UnicodeAttribute(attr_name="bucket", default="") database = UnicodeAttribute(attr_name="database", default="") tablename = UnicodeAttribute(attr_name="tablename", default="") field = UnicodeAttribute(attr_name="field", default="") crawler = UnicodeAttribute(attr_name="crawler", default="") prefix = UnicodeAttribute(attr_name="prefix", default="") replacements = ListAttribute(attr_name="replacements", default=[]) sql = UnicodeAttribute(attr_name="sql", default="") reply = ListAttribute(attr_name="reply", default=[])
class LogMessage(Model): class Meta: table_name = 'hakkuu_message' guild = NumberAttribute(hash_key=True) snowflake = NumberAttribute(range_key=True) author = NumberAttribute() channel = NumberAttribute() revisions = ListAttribute(of=LogRevision) embeds = ListAttribute(of=LogEmbed) attachments = ListAttribute(of=LogAttachment) tts = BooleanAttribute(null=True) deleted = BooleanAttribute(null=True) deleted_by = BooleanAttribute(null=True)
class Office(Model): class Meta: table_name = "OfficeModel" host = "http://localhost:{}".format(environ.get("DOCKER_PORT", 8000)) aws_access_key_id = "my_access_key_id" aws_secret_access_key = "my_secret_access_key" office_id = UUIDAttribute(hash_key=True) address = Location() employees = ListAttribute(of=OfficeEmployeeMap) departments = UnicodeSetAttribute() numbers = NumberSetAttribute() security_number = UnicodeAttribute(null=True) office_times = ListAttribute() cls = DiscriminatorAttribute()
class TrackMap(MapAttribute): id = UnicodeAttribute() name = UnicodeAttribute() album_id = UnicodeAttribute() album_name = UnicodeAttribute() artist_id = UnicodeAttribute() artist_name = UnicodeAttribute() duration = NumberAttribute() listeners = NumberAttribute() playback_date = UnicodeAttribute() playcount = UnicodeAttribute() reproduction = NumberAttribute() total_tracks = NumberAttribute() tags = ListAttribute() genres = ListAttribute() release_date = UnicodeAttribute()
class ReplyIdsByQid(BaseModel): class Meta: table_name = gen_table_name("qanda-reply-ids-ddb") region = env.AWS_REGION qid = UnicodeAttribute(hash_key=True) rids = ListAttribute(of=GenericPointer, default=list)
class UserQuestionsModel(BaseModel): class Meta: table_name = gen_table_name("qanda-user-qs-ddb") region = env.AWS_REGION uid = UnicodeAttribute(hash_key=True) qs = ListAttribute(of=UserQuestionLogEntry, default=list)
class RumorModel(Model): class Meta: region = setting.region if setting.region else 'ap-northeast-1' table_name = setting.rumor_ddb_table if setting.rumor_ddb_table else 'stg-rumor_source' if setting.role: credentials = gen_sts_credentials(setting) aws_access_key_id = credentials["AccessKeyId"] aws_secret_access_key = credentials["SecretAccessKey"] aws_session_token = credentials["SessionToken"] id = UnicodeAttribute(hash_key=True) clarification = UnicodeAttribute(null=True) preface = UnicodeAttribute(null=True) create_date = UnicodeAttribute(null=True) link = UnicodeAttribute(null=True) rumors = ListAttribute(null=True) source = UnicodeAttribute(null=True) title = UnicodeAttribute(null=True) original_title = UnicodeAttribute(null=True) image_link = UnicodeAttribute(null=True) tags = UnicodeAttribute(null=True) sensitive_categories = UnicodeAttribute(null=True) rating = UnicodeAttribute(null=True) source_create_date_index = SourceCreateDateIndex()
class Poll(Model): """ A DynamoDB User """ class Meta: table_name = DYNAMO_DB_TABLE_NAME key = UnicodeAttribute(hash_key=True) question = UnicodeAttribute() author = JSONAttribute() # option_id is index of the option in the list options = ListAttribute(default=list) votes = MapAttribute(default=dict) # user_id -> option_id users = MapAttribute(default=dict) # user_id -> data # see https://pynamodb.readthedocs.io/en/latest/optimistic_locking.html version = VersionAttribute() # information about poll message in telegram telegram_version = NumberAttribute() telegram_datetime = UTCDateTimeAttribute() def get_users_by_option_id(self): users_by_option_id = {} for user_id in self.votes: option_id = self.votes[user_id] users_by_option_id.setdefault(option_id, []) users_by_option_id[option_id].append(self.users[user_id]) return users_by_option_id
class BaseTestModel(BaseModel): __update_action_hooks__ = { 'set': { 'non_key_value': 'test_hook_action_generation' } } class Meta(BaseMeta): table_name = 'base' def __init__(self, hash_key=None, range_key=None, **attributes): self.assign_or_update('update_action_hooks', __class__.__update_action_hooks__) super().__init__(hash_key, range_key, **attributes) hash_key = UnicodeAttribute(hash_key=True) range_key = UnicodeAttribute(range_key=True) hook_attribute = UnicodeAttribute(null=True) list_attribute = ListAttribute(default=list()) non_key_value = UnicodeAttribute() numeric_value = NumberAttribute(null=True) unicode_set = UnicodeSetAttribute(default=set()) def test_hook_action_generation(self, value): return [BaseTestModel.hook_attribute.set(value)]
def test_list_comparison(self): condition = ListAttribute(attr_name='foo') == ['bar', 'baz'] placeholder_names, expression_attribute_values = {}, {} expression = condition.serialize(placeholder_names, expression_attribute_values) assert expression == "#0 = :0" assert placeholder_names == {'foo': '#0'} assert expression_attribute_values == { ':0': { 'L': [{ 'S': 'bar' }, { 'S': 'baz' }] } }
def test_should_list_convert_list_of_map(): class Address(MapAttribute): latitude = NumberAttribute(null=False) longitude = NumberAttribute(null=False) address = UnicodeAttribute() assert_attribute_conversion(ListAttribute(of=Address), ListOfMapToObject)
class VPCModel(object): VpcId = UnicodeAttribute() State = UnicodeAttribute() CidrBlock = UnicodeAttribute() Tags = ListAttribute() IsDefault = BooleanAttribute() Name = UnicodeAttribute(null=True)
class PaintingModel(Model): class Meta: table_name = "painting" episode = UnicodeAttribute(hash_key=True) title = UnicodeAttribute() colors = ListAttribute()
class Game(BaseModel): class Meta(BaseModel.Meta): pass game_id = UnicodeAttribute( hash_key=True, attr_name="pk", default_for_new=str(uuid4()) ) secret = UnicodeAttribute(default_for_new="".join(choices(COLORS, k=TOTAL_LETTERS))) tries_left = NumberAttribute(default_for_new=MAX_TRIES) created_at = UTCDateTimeAttribute(default_for_new=datetime.utcnow()) is_solved = BooleanAttribute(default_for_new=False) guesses = ListAttribute(of=Guess, null=True, default=[]) def check_win_condition(self, guess: Guess) -> None: if guess.combination == self.secret: self.is_solved = True def get_info(self) -> dict: return {k: v for k, v in self.to_dict().items() if k != "secret"} def save_guess(self, guess: Guess): self.update( actions=[ Game.guesses.set((Game.guesses | []).append([guess])), Game.tries_left.set(Game.tries_left - 1), Game.is_solved.set(self.is_solved), ] ) def is_playable(self) -> bool: if not self.is_solved and self.tries_left: return True return False def get_black_and_white_pegs(self, guess: Guess) -> Tuple[int, int]: combination_cp = guess.combination secret_cp = self.secret black_pegs_counter = 0 black_pegs_indexes = [] white_pegs_counter = 0 for i, letter in enumerate(self.secret): if guess.combination[i] == letter: black_pegs_counter += 1 black_pegs_indexes.append(i) black_pegs_indexes.reverse() for index in black_pegs_indexes: combination_cp = combination_cp[:index] + combination_cp[index + 1 :] secret_cp = secret_cp[:index] + secret_cp[index + 1 :] for letter in combination_cp: if letter in secret_cp: white_pegs_counter += 1 return black_pegs_counter, white_pegs_counter
class Planets(Model): """ Describes the schema used on our DynamoDB table. """ class Meta: """ Table name on DynamoDB """ PlanetsConfig.table_name = 'Planets' climate = ListAttribute(null=False) terrain = ListAttribute(null=False) name = UnicodeAttribute(null=False) planet_id = NumberAttribute(hash_key=True) read_capacity_units = 5 write_capacity_units = 5 PlanetsConfig.region = 'us-east-1'
class SecurityGroupModel(object): GroupId = UnicodeAttribute() GroupName = UnicodeAttribute() VpcId = UnicodeAttribute(null=True) OwnerId = UnicodeAttribute() Description = UnicodeAttribute() Tags = ListAttribute() Region = UnicodeAttribute()
class UserModel(BaseModel): class Meta: table_name = 'users' user_id = UnicodeAttribute(hash_key=True) email = UnicodeAttribute() email_index = EmailIndex() password = UnicodeAttribute() lists = ListAttribute(default=[])
class Thread(Model): class Meta: table_name = 'Thread' forum_name = UnicodeAttribute(hash_key=True) subjects = UnicodeSetAttribute(default=dict) views = NumberAttribute(default=0) notes = ListAttribute(default=list)
class DiscriminatorTestModel(Model, discriminator='Parent'): class Meta: host = 'http://localhost:8000' table_name = 'test' hash_key = UnicodeAttribute(hash_key=True) value = TypedValue() values = ListAttribute(of=TypedValue) type = DiscriminatorAttribute()