|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/boto/dynamodb2/__pycache__/ |
Upload File : |
o
ckF[@9 � @ s0 d dl mZ G dd� de�ZG dd� de�ZdS )� )�deepcopyc @ s e Zd ZdS )�NEWVALUEN)�__name__�
__module__� __qualname__� r r �6/usr/lib/python3/dist-packages/boto/dynamodb2/items.pyr s r c @ s� e Zd ZdZd6dd�Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
d7dd�Z dd� Z dd� Z
dd� ZeZdd� Zd7d d �Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd7d(d)�Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd8d2d3�Z d4d5� Z dS )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.
NFc C s` || _ || _i | _|| _|j| _t| jt�r| jj| _| jdu r#i | _| jr.t| j�| _dS dS )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�loadedr r r �__init__ s +
�z
Item.__init__c C s | j �|d �S �N�r
�get�r �keyr r r � __getitem__Q � zItem.__getitem__c C s || j |< d S r �r
)r r �valuer r r � __setitem__T r zItem.__setitem__c C s || j vrd S | j |= d S r r r r r r � __delitem__W s
zItem.__delitem__c C �
| j �� S r )r
�keys�r r r r r ] �
z Item.keysc C r r )r
�valuesr! r r r r# ` r" z Item.valuesc C r r )r
�itemsr! r r r r$ c r" z
Item.itemsc C s | j �||�S r r )r r �defaultr r r r f r zItem.getc c s � | j D ]}| j | V qd S r r r r r r �__iter__i s �
�z
Item.__iter__c C s
|| j v S r r r r r r � __contains__m r" zItem.__contains__c C s
t | j�S r )�boolr
r! r r r �__bool__p r" z
Item.__bool__c C s� i i g d�}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_keysr r r r �_determine_alterationsu s& ���zItem._determine_alterationsc C s8 |du r| � � }d}dD ]
}t|| �rd} |S q |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)r r �
needs_save�kindr r r r8 � s �zItem.needs_savec C s t | j�| _dS )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)r r
r r! r r r �
mark_clean� s zItem.mark_cleanc C s dS )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.
Nr r! r r r �
mark_dirty� s zItem.mark_dirtyc C sF i | _ |�di ��� D ] \}}| j�|�| |< q d| _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
r r$ r �decoder r r )r r �
field_name� field_valuer r r �load� s
z Item.loadc C s( | 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_datar r r r �get_keys� s
z
Item.get_keysc C s. i }| � � �� D ] \}}| j�|�||< q|S )z^
Returns a DynamoDB-style dict of the keys/values.
Largely internal.
)rC r$ r �encode)r � raw_key_datar r r r r � get_raw_keys� s zItem.get_raw_keysc C s� i }|du rt | j�� �t | j�� � }t|�}|D ]S}ddi||< d}|| jvr4|| jvr4td| ��| j�|t�}| j�|t�}||krI|}n|| jv r]|| jvrZd|| d< n|}n|}|durm| 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. �
ValueErrorr r r rD )r �fields�expectsr r �
orig_value�
current_valuer r r �
build_expects� s. �
�zItem.build_expectsc C s |s|dvrdS dS )N)r g FFTr )r r r r r r0 1 s zItem._is_storablec C s8 i }| 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$ r0 r rD )r �
final_datar r r r r � prepare_full: s
zItem.prepare_fullc C s� i }t � }| �� }|d �� D ]\}}d| j�| j| �d�||< |�|� q|d �� D ]\}}d| j�| j| �d�||< |�|� q-|d D ]
}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)�ActionrH r, r- rS �DELETE)r. r6 r$ r rD r
�add)r rP rK r3 r r r r r �prepare_partialM s$
�
� � zItem.prepare_partialc C s� | � � }| �� \}}|sdS |�� D ] \}}||v r.||= z|�|� W q ty- Y qw q| 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 ) rC rV r$ �remove�KeyErrorrO r
� _update_itemr: )r r rP rK � fieldnamer rL �returnedr r r � partial_saveq s" ��
zItem.partial_savec C sH | � � s|sdS | �� }d}|du r| �� }| 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 )r8 rQ rO r
� _put_itemr: )r � overwriterP rL r\ r r r �save� s z Item.savec C s | � � }| jjdi |��S )z�
Deletes the item's data to DynamoDB.
Returns ``True`` on success.
Example::
# Buh-bye now.
>>> user.delete()
Nr )rC r
� delete_item)r rB r r r �delete� s z Item.delete)NFr )F) r r r �__doc__r r r r r r# r$ r r& r' r) � __nonzero__r6 r8 r: r; r? rC rF rO r0 rQ rV r] r` rb r r r r r s8
9
$
4 $
. -r N)�copyr �objectr r r r r r �<module> s