o

ckF[@9�@s0dd
lm
Z

Gdd�de�ZGdd�de�ZdS)�)
�deepcopyc
@seZ
dZd
S)�NEWVALUEN)�__name__�
__module__�__qualname__�rr�6/usr/lib/python3/dist-packages/boto/dynamodb2/items.pyrsrc@s�eZ
dZd
Zd6dd�
Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
d7dd�
Zdd�Zdd�Z
dd�ZeZdd�Zd7dd�
Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd7d(d)�
Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd8d2d3�
Zd4d5�ZdS)9�Itema
    An object representing the item data within a DynamoDB table.

    An item is largely schema-free, meaning it can contain any data. The only
    limitation is that it must have data for the fields in the ``Table``'s
    schema.

    This object presents a dictionary-like interface for accessing/storing
    data. It also tries to intelligently track how data has changed throughout
    the life of the instance, to be as efficient as possible about updates.

    Empty items, or items that have no data, are considered falsey.

    NFcCs`|
|_||_
i|_||_|
j|_t|jt�r|jj|_|jd
ur#i|_|j
r.t|j�
|_d
Sd
S)a
        Constructs an (unsaved) ``Item`` instance.

        To persist the data in DynamoDB, you'll need to call the ``Item.save``
        (or ``Item.partial_save``) on the instance.

        Requires a ``table`` parameter, which should be a ``Table`` instance.
        This is required, as DynamoDB's API is focus around all operations
        being table-level. It's also for persisting schema around many objects.

        Optionally accepts a ``data`` parameter, which should be a dictionary
        of the fields & values of the item. Alternatively, an ``Item`` instance
        may be provided from which to extract the data.

        Optionally accepts a ``loaded`` parameter, which should be a boolean.
        ``True`` if it was preexisting data loaded from DynamoDB, ``False`` if
        it's new data from the user. Default is ``False``.

        Example::

            >>> users = Table('users')
            >>> user = Item(users, data={
            ...     'username': 'johndoe',
            ...     'first_name': 'John',
            ...     'date_joined': 1248o61592,
            ... })

            # Change existing data.
            >>> user['first_name'] = 'Johann'
            # Add more data.
            >>> user['last_name'] = 'Doe'
            # Delete data.
            >>> del user['date_joined']

            # Iterate over all the data.
            >>> for field, val in user.items():
            ...     print "%s: %s" % (field, val)
            username: johndoe
            first_name: John
            date_joined: 1248o61592

        N)�table�_loaded�
_orig_data�_data�
_dynamizer�
isinstancer	r)�selfr
�data�loadedrrr�__init__s+









�z
Item.__init__cCs|j�
|
d�S�
N�r
�get�r�keyrrr�__getitem__Q�
zItem.__getitem__cCs||j|
<dSr�
r
)rr�valuerrr�__setitem__TrzItem.__setitem__cCs|
|jv
rdS|j|
=dSrrrrrr�__delitem__Ws


zItem.__delitem__c

C�
|j�
�Sr)r
�keys�
rrrrr ]�

z	Item.keysc

Crr)r
�valuesr!rrrr#`r"zItem.valuesc

Crr)r
�itemsr!rrrr$cr"z
Item.itemscCs|j�
|
|�Srr)rr�defaultrrrrfrzItem.getc
cs�|jD]}
|j|
V
qdSrrrrrr�__iter__is�


�z
Item.__iter__cCs
|
|jvSrrrrrr�__contains__mr"zItem.__contains__c

Cs
t|j
�
Sr)�boolr
r!rrr�__bool__pr"z
Item.__bool__c
Cs�iigd
�}
t|j
���
}t|j���
}|�|�
D]%}|j||j
|kr>|�|j|�
r7|j||
d|<q|
d�|�

q|�|�
D]}|�|j|�
rW|j||
d|<qD|�|�
D]	}|
d�|�

q]|
S)z�
        Checks the ``-orig_data`` against the ``_data`` to determine what
        changes to the data are present.

        Returns a dictionary containing the keys ``adds``, ``changes`` &
        ``deletes``, containing the updated data.
        ��adds�changes�deletesr,r-r+)�setrr r
�intersection�_is_storable�append�
difference)r�alterations�	orig_keys�	data_keysrrrr�_determine_alterationsus&	

�



�

�
zItem._determine_alterationscCs8|
d
ur|��}
d}dD]
}t
|
|�
rd}
|Sq|S)a�

        Returns whether or not the data has changed on the ``Item``.

        Optionally accepts a ``data`` argument, which accepts the output from
        ``self._determine_alterations()`` if you've already called it. Typically
        unnecessary to do. Default is ``None``.

        Example:

            >>> user.needs_save()
            False
            >>> user['first_name'] = 'Johann'
            >>> user.needs_save()
            True

        NFr*T)r6�len)rr�
needs_save�kindrrrr8�s



�zItem.needs_savec

Cst|j
�
|_d
S)aM

        Marks an ``Item`` instance as no longer needing to be saved.

        Example:

            >>> user.needs_save()
            False
            >>> user['first_name'] = 'Johann'
            >>> user.needs_save()
            True
            >>> user.mark_clean()
            >>> user.needs_save()
            False

        N)rr
rr!rrr�
mark_clean�szItem.mark_cleanc


Csd
S)z�
        DEPRECATED: Marks an ``Item`` instance as needing to be saved.

        This method is no longer necessary, as the state tracking on ``Item``
        has been improved to automatically detect proper state.
        Nrr!rrr�
mark_dirty�szItem.mark_dirtycCsFi|_|
�
d
i���D]\}}|j�|�
||<qd|_t|j�
|_dS)aF

        This is only useful when being handed raw data from DynamoDB directly.
        If you have a Python datastructure already, use the ``__init__`` or
        manually set the data instead.

        Largely internal, unless you know what you're doing or are trying to
        mix the low-level & high-level APIs.
        r	TN)r
rr$r�decoderrr)rr�
field_name�field_valuerrr�load�s
	

z	Item.loadc
Cs(|j�
�}
i}|
D]}||||<q	|S)
z\
        Returns a Python-style dict of the keys/values.

        Largely internal.
        )r
�get_key_fields)r�
key_fields�key_datarrrr�get_keys�s



z
Item.get_keysc
Cs.i}
|���
�D]\}}|j�|�
|
|<q|
S)
z^
        Returns a DynamoDB-style dict of the keys/values.

        Largely internal.
        )rCr$r�encode)r�raw_key_datarrrrr�get_raw_keys�s
zItem.get_raw_keyscCs�i}|
d
urt|j
���
t|j���
}
t|
�
}
|
D]S}ddi
||<d
}||jv
r4||j
v
r4td|�
�
|j�|t�}|j
�|t�}||krI|}n||j
vr]||jv
rZd||d<n|}n|}|d
u
rm|j�	|�
||d<q|S)zm
        Builds up a list of expecations to hand off to DynamoDB on save.

        Largely internal.
        N�ExistsTzUnknown key %s provided.F�Value)
�listr
r rr.�
ValueErrorrrrrD)r�fields�expectsrr�
orig_value�
current_valuerrr�
build_expects�s.
�





�zItem.build_expectscCs|
s|
d
v
rdSdS)N)r
gFFTr)rrrrrr01
s

zItem._is_storablec
Cs8i}
|j�
�D]\}}|�|�
sq|j�|�
|
|<q|
S)
z�
        Runs through all fields & encodes them to be handed off to DynamoDB
        as part of an ``save`` (``put_item``) call.

        Largely internal.
        )r
r$r0rrD)r�
final_datarrrrr�prepare_full:
s	


zItem.prepare_fullc
Cs�i}
t�}|�
�}|d
��D]\}}d|j�|j|�
d�|
|<|�|�

q|d��D]\}}d|j�|j|�
d�|
|<|�|�

q-|dD]
}ddi
|
|<|�|�

qI|
|fS)z�
        Runs through **ONLY** the changed/deleted fields & encodes them to be
        handed off to DynamoDB as part of an ``partial_save`` (``update_item``)
        call.

        Largely internal.
        r+�PUT)�ActionrHr,r-rS�DELETE)r.r6r$rrDr
�add)rrPrKr3rrrrr�prepare_partialM
s$




�

��zItem.prepare_partialc
	Cs�|��}
|�
�\}}|sd
S|
��D]\}}||vr.||=z|�|�

Wqty-


Yqwq|j|d�
}|jj|
||d�}|��
|S)an
        Saves only the changed data to DynamoDB.

        Extremely useful for high-volume/high-write data sets, this allows
        you to update only a handful of fields rather than having to push
        entire items. This prevents many accidental overwrite situations as
        well as saves on the amount of data to transfer over the wire.

        Returns ``True`` on success, ``False`` if no save was performed or
        the write failed.

        Example::

            >>> user['last_name'] = 'Doh!'
            # Only the last name field will be sent to DynamoDB.
            >>> user.partial_save()

        F)
rK�
rL)	rCrVr$�remove�KeyErrorrOr
�_update_itemr:)rrrPrK�	fieldnamerrL�returnedrrr�partial_saveq
s"




��


zItem.partial_savecCsH|��s|
sd
S|�
�}d}|
d
ur|��}|jj||d�}|��
|S)aU
        Saves all data to DynamoDB.

        By default, this attempts to ensure that none of the underlying
        data has changed. If any fields have changed in between when the
        ``Item`` was constructed & when it is saved, this call will fail so
        as not to cause any data loss.

        If you're sure possibly overwriting data is acceptable, you can pass
        an ``overwrite=True``. If that's not acceptable, you may be able to use
        ``Item.partial_save`` to only write the changed field data.

        Optionally accepts an ``overwrite`` parameter, which should be a
        boolean. If you provide ``True``, the item will be forcibly overwritten
        within DynamoDB, even if another process changed the data in the
        meantime. (Default: ``False``)

        Returns ``True`` on success, ``False`` if no save was performed.

        Example::

            >>> user['last_name'] = 'Doh!'
            # All data on the Item is sent to DynamoDB.
            >>> user.save()

            # If it fails, you can overwrite.
            >>> user.save(overwrite=True)

        FNrW)r8rQrOr
�	_put_itemr:)r�	overwriterPrLr\rrr�save�
s


z	Item.savec
Cs|��}
|j
jdi|
�
�
S)z�
        Deletes the item's data to DynamoDB.

        Returns ``True`` on success.

        Example::

            # Buh-bye now.
            >>> user.delete()

        Nr)rCr
�delete_item)rrBrrr�delete�
s
zItem.delete)NFr)
F)rrr�__doc__rrrrr r#r$rr&r'r)�__nonzero__r6r8r:r;r?rCrFrOr0rQrVr]r`rbrrrrr		s8

9

$	

4	$
.-r	N)�copyr�objectrr	rrrr�<module>
s