SDB DB Reference

This module offers an ORM-like layer on top of SimpleDB.

boto.sdb.db

boto.sdb.db.blob

class boto.sdb.db.blob.Blob(value=None, file=None, id=None)

Blob object

file

next()

read()

readline()

size

boto.sdb.db.key

class boto.sdb.db.key.Key(encoded=None, obj=None)

app()

classmethod from_path(*args, **kwds)

has_id_or_name()

id()

id_or_name()

kind()

name()

parent()

boto.sdb.db.manager

boto.sdb.db.manager.get_manager(cls)

Returns the appropriate Manager class for a given Model class. It does this by looking in the boto config for a section like this:

[DB]
db_type = SimpleDB
db_user = <aws access key id>
db_passwd = <aws secret access key>
db_name = my_domain
[DB_TestBasic]
db_type = SimpleDB
db_user = <another aws access key id>
db_passwd = <another aws secret access key>
db_name = basic_domain
db_port = 1111

The values in the DB section are “generic values” that will be used if nothing more specific is found. You can also create a section for a specific Model class that gives the db info for that class. In the example above, TestBasic is a Model subclass.

boto.sdb.db.manager.sdbmanager

class boto.sdb.db.manager.sdbmanager.SDBConverter(manager)

Responsible for converting base Python types to format compatible with underlying database. For SimpleDB, that means everything needs to be converted to a string when stored in SimpleDB and from a string when retrieved.

To convert a value, pass it to the encode or decode method. The encode method will take a Python native value and convert to DB format. The decode method will take a DB format value and convert it to Python native format. To find the appropriate method to call, the generic encode/decode methods will look for the type-specific method by searching for a method called”encode_<type name>” or “decode_<type name>”.

decode(item_type, value)

decode_blob(value)

decode_bool(value)

decode_date(value)

decode_datetime(value)

Handles both Dates and DateTime objects

decode_float(value)

decode_int(value)

decode_list(prop, value)

decode_long(value)

decode_map(prop, value)

decode_map_element(item_type, value)

Decode a single element for a map

decode_prop(prop, value)

decode_reference(value)

decode_string(value)

Decoding a string is really nothing, just return the value as-is

decode_time(value)

converts strings in the form of HH:MM:SS.mmmmmm (created by datetime.time.isoformat()) to datetime.time objects.

Timzone-aware strings (“HH:MM:SS.mmmmmm+HH:MM”) won’t be handled right now and will raise TimeDecodeError.

encode(item_type, value)

encode_blob(value)

encode_bool(value)

encode_date(value)

encode_datetime(value)

encode_float(value)

See http://tools.ietf.org/html/draft-wood-ldapext-float-00.

encode_int(value)

encode_list(prop, value)

encode_long(value)

encode_map(prop, value)

encode_prop(prop, value)

encode_reference(value)

encode_string(value)

Convert ASCII, Latin-1 or UTF-8 to pure Unicode

encode_time(value)

class boto.sdb.db.manager.sdbmanager.SDBManager(cls, db_name, db_user, db_passwd, db_host, db_port, db_table, ddl_dir, enable_ssl, consistent=None)

count(cls, filters, quick=True, sort_by=None, select=None)

Get the number of results that would be returned in this query

decode_value(prop, value)

delete_key_value(obj, name)

delete_object(obj)

domain

encode_value(prop, value)

get_blob_bucket(bucket_name=None)

get_key_value(obj, name)

get_object(cls, id, a=None)

get_object_from_id(id)

get_property(prop, obj, name)

get_raw_item(obj)

get_s3_connection()

load_object(obj)

query(query)

query_gql(query_string, *args, **kwds)

save_object(obj, expected_value=None)

sdb

set_key_value(obj, name, value)

set_property(prop, obj, name, value)

exception boto.sdb.db.manager.sdbmanager.TimeDecodeError

boto.sdb.db.manager.xmlmanager

boto.sdb.db.model

boto.sdb.db.property

class boto.sdb.db.property.BlobProperty(verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False)

data_type

alias of Blob

type_name = 'blob'

class boto.sdb.db.property.BooleanProperty(verbose_name=None, name=None, default=False, required=False, validator=None, choices=None, unique=False)

data_type

alias of bool

empty(value)

type_name = 'Boolean'

class boto.sdb.db.property.CalculatedProperty(verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, calculated_type=<type 'int'>, unique=False, use_method=False)

get_value_for_datastore(model_instance)

class boto.sdb.db.property.DateProperty(verbose_name=None, auto_now=False, auto_now_add=False, name=None, default=None, required=False, validator=None, choices=None, unique=False)

data_type

alias of date

default_value()

get_value_for_datastore(model_instance)

now()

type_name = 'Date'

validate(value)

class boto.sdb.db.property.DateTimeProperty(verbose_name=None, auto_now=False, auto_now_add=False, name=None, default=None, required=False, validator=None, choices=None, unique=False)

This class handles both the datetime.datetime object And the datetime.date objects. It can return either one, depending on the value stored in the database

data_type

alias of datetime

default_value()

get_value_for_datastore(model_instance)

now()

type_name = 'DateTime'

validate(value)

class boto.sdb.db.property.FloatProperty(verbose_name=None, name=None, default=0.0, required=False, validator=None, choices=None, unique=False)

data_type

alias of float

empty(value)

type_name = 'Float'

validate(value)

class boto.sdb.db.property.IntegerProperty(verbose_name=None, name=None, default=0, required=False, validator=None, choices=None, unique=False, max=2147483647, min=-2147483648)

data_type

alias of int

empty(value)

type_name = 'Integer'

validate(value)

class boto.sdb.db.property.ListProperty(item_type, verbose_name=None, name=None, default=None, **kwds)

data_type

alias of list

default_value()

empty(value)

type_name = 'List'

validate(value)

class boto.sdb.db.property.LongProperty(verbose_name=None, name=None, default=0, required=False, validator=None, choices=None, unique=False)

data_type

alias of long

empty(value)

type_name = 'Long'

validate(value)

class boto.sdb.db.property.MapProperty(item_type=<type 'str'>, verbose_name=None, name=None, default=None, **kwds)

data_type

alias of dict

default_value()

empty(value)

type_name = 'Map'

validate(value)

class boto.sdb.db.property.PasswordProperty(verbose_name=None, name=None, default='', required=False, validator=None, choices=None, unique=False, hashfunc=None)

Hashed property whose original value can not be retrieved, but still can be compared.

Works by storing a hash of the original value instead of the original value. Once that’s done all that can be retrieved is the hash.

The comparison

obj.password == ‘foo’

generates a hash of ‘foo’ and compares it to the stored hash.

Underlying data type for hashing, storing, and comparing is boto.utils.Password. The default hash function is defined there ( currently sha512 in most cases, md5 where sha512 is not available )

It’s unlikely you’ll ever need to use a different hash function, but if you do, you can control the behavior in one of two ways:

1. Specifying hashfunc in PasswordProperty constructor

   import hashlib

   class MyModel(model):

   password = PasswordProperty(hashfunc=hashlib.sha224)

2. Subclassing Password and PasswordProperty

   class SHA224Password(Password):

   hashfunc=hashlib.sha224

   class SHA224PasswordProperty(PasswordProperty):

   data_type=MyPassword type_name=”MyPassword”

   class MyModel(Model):

   password = SHA224PasswordProperty()

The hashfunc parameter overrides the default hashfunc in boto.utils.Password.

The remaining parameters are passed through to StringProperty.__init__

data_type

alias of Password

get_value_for_datastore(model_instance)

make_value_from_datastore(value)

type_name = 'Password'

validate(value)

class boto.sdb.db.property.Property(verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False)

data_type

alias of str

default_validator(value)

default_value()

empty(value)

get_choices()

get_value_for_datastore(model_instance)

make_value_from_datastore(value)

name = ''

type_name = ''

validate(value)

verbose_name = ''

class boto.sdb.db.property.ReferenceProperty(reference_class=None, collection_name=None, verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False)

check_instance(value)

check_uuid(value)

data_type

alias of Key

type_name = 'Reference'

validate(value)

class boto.sdb.db.property.S3KeyProperty(verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False)

data_type

alias of Key

get_value_for_datastore(model_instance)

type_name = 'S3Key'

validate(value)

validate_regex = '^s3:\\/\\/([^\\/]*)\\/(.*)$'

class boto.sdb.db.property.StringProperty(verbose_name=None, name=None, default='', required=False, validator=<function validate_string at 0x1127ff7d0>, choices=None, unique=False)

type_name = 'String'

class boto.sdb.db.property.TextProperty(verbose_name=None, name=None, default='', required=False, validator=None, choices=None, unique=False, max_length=None)

type_name = 'Text'

validate(value)

class boto.sdb.db.property.TimeProperty(verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False)

data_type

alias of time

type_name = 'Time'

validate(value)

boto.sdb.db.property.validate_string(value)

boto.sdb.db.query

class boto.sdb.db.query.Query(model_class, limit=None, next_token=None, manager=None)

count(quick=True)

fetch(limit, offset=0)

Not currently fully supported, but we can use this to allow them to set a limit in a chainable method

filter(property_operator, value)

get_next_token()

get_query()

next()

next_token

order(key)

set_next_token(token)

to_xml(doc=None)