gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/boto/sdb/db/query.py

@@ -1,85 +0,0 @@
-# Copyright (c) 2006,2007,2008 Mitch Garnaat http://garnaat.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-class Query(object):
-    __local_iter__ = None
-    def __init__(self, model_class, limit=None, next_token=None, manager=None):
-        self.model_class = model_class
-        self.limit = limit
-        self.offset = 0
-        if manager:
-            self.manager = manager
-        else:
-            self.manager = self.model_class._manager
-        self.filters = []
-        self.select = None
-        self.sort_by = None
-        self.rs = None
-        self.next_token = next_token
-
-    def __iter__(self):
-        return iter(self.manager.query(self))
-
-    def next(self):
-        if self.__local_iter__ == None:
-            self.__local_iter__ = self.__iter__()
-        return self.__local_iter__.next()
-
-    def filter(self, property_operator, value):
-        self.filters.append((property_operator, value))
-        return self
-
-    def fetch(self, limit, offset=0):
-        """Not currently fully supported, but we can use this
-        to allow them to set a limit in a chainable method"""
-        self.limit = limit
-        self.offset = offset
-        return self
-
-    def count(self, quick=True):
-        return self.manager.count(self.model_class, self.filters, quick, self.sort_by, self.select)
-
-    def get_query(self):
-        return self.manager._build_filter_part(self.model_class, self.filters, self.sort_by, self.select)
-
-    def order(self, key):
-        self.sort_by = key
-        return self
-    
-    def to_xml(self, doc=None):
-        if not doc:
-            xmlmanager = self.model_class.get_xmlmanager()
-            doc = xmlmanager.new_doc()
-        for obj in self:
-            obj.to_xml(doc)
-        return doc
-
-    def get_next_token(self):
-        if self.rs:
-            return self.rs.next_token
-        if self._next_token:
-            return self._next_token
-        return None
-
-    def set_next_token(self, token):
-        self._next_token = token
-
-    next_token = property(get_next_token, set_next_token)

data/packages/gsutil/boto/boto/sdb/db/sequence.py

@@ -1,226 +0,0 @@
-# Copyright (c) 2010 Chris Moyer http://coredumped.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-from boto.exception import SDBResponseError
-
-class SequenceGenerator(object):
-    """Generic Sequence Generator object, this takes a single
-    string as the "sequence" and uses that to figure out
-    what the next value in a string is. For example
-    if you give "ABC" and pass in "A" it will give you "B",
-    and if you give it "C" it will give you "AA".
-
-    If you set "rollover" to True in the above example, passing
-    in "C" would give you "A" again.
-
-    The Sequence string can be a string or any iterable
-    that has the "index" function and is indexable.
-    """
-    __name__ = "SequenceGenerator"
-
-    def __init__(self, sequence_string, rollover=False):
-        """Create a new SequenceGenerator using the sequence_string
-        as how to generate the next item.
-
-        :param sequence_string: The string or list that explains
-        how to generate the next item in the sequence
-        :type sequence_string: str,iterable
-
-        :param rollover: Rollover instead of incrementing when
-        we hit the end of the sequence
-        :type rollover: bool
-        """
-        self.sequence_string = sequence_string
-        self.sequence_length = len(sequence_string[0])
-        self.rollover = rollover
-        self.last_item = sequence_string[-1]
-        self.__name__ = "%s('%s')" % (self.__class__.__name__, sequence_string)
-
-    def __call__(self, val, last=None):
-        """Get the next value in the sequence"""
-        # If they pass us in a string that's not at least
-        # the lenght of our sequence, then return the
-        # first element in our sequence
-        if val == None or len(val) < self.sequence_length:
-            return self.sequence_string[0]
-        last_value = val[-self.sequence_length:]
-        if (not self.rollover) and (last_value == self.last_item):
-            val = "%s%s" % (self(val[:-self.sequence_length]), self._inc(last_value))
-        else:
-            val = "%s%s" % (val[:-self.sequence_length], self._inc(last_value))
-        return val
-
-    def _inc(self, val):
-        """Increment a single value"""
-        assert(len(val) == self.sequence_length)
-        return self.sequence_string[(self.sequence_string.index(val)+1) % len(self.sequence_string)]
-
-
-
-#
-# Simple Sequence Functions
-#
-def increment_by_one(cv=None, lv=None):
-    if cv == None:
-        return 0
-    return cv + 1
-
-def double(cv=None, lv=None):
-    if cv == None:
-        return 1
-    return cv * 2
-
-def fib(cv=1, lv=0):
-    """The fibonacci sequence, this incrementer uses the
-    last value"""
-    if cv == None:
-        cv = 1
-    if lv == None:
-        lv = 0
-    return cv + lv
-
-increment_string = SequenceGenerator("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-
-
-
-class Sequence(object):
-    """A simple Sequence using the new SDB "Consistent" features
-    Based largly off of the "Counter" example from mitch garnaat:
-    http://bitbucket.org/mitch/stupidbototricks/src/tip/counter.py"""
-
-
-    def __init__(self, id=None, domain_name=None, fnc=increment_by_one, init_val=None):
-        """Create a new Sequence, using an optional function to 
-        increment to the next number, by default we just increment by one.
-        Every parameter here is optional, if you don't specify any options
-        then you'll get a new SequenceGenerator with a random ID stored in the
-        default domain that increments by one and uses the default botoweb 
-        environment
-
-        :param id: Optional ID (name) for this counter
-        :type id: str
-
-        :param domain_name: Optional domain name to use, by default we get this out of the
-            environment configuration
-        :type domain_name:str
-
-        :param fnc: Optional function to use for the incrementation, by default we just increment by one
-            There are several functions defined in this module.
-            Your function must accept "None" to get the initial value
-        :type fnc: function, str
-
-        :param init_val: Initial value, by default this is the first element in your sequence, 
-            but you can pass in any value, even a string if you pass in a function that uses
-            strings instead of ints to increment
-        """
-        self._db = None
-        self._value = None
-        self.last_value = None
-        self.domain_name = domain_name
-        self.id = id
-        if init_val == None:
-            init_val = fnc(init_val)
-
-        if self.id == None:
-            import uuid
-            self.id = str(uuid.uuid4())
-
-        self.item_type = type(fnc(None))
-        self.timestamp = None
-        # Allow us to pass in a full name to a function
-        if isinstance(fnc, str):
-            from boto.utils import find_class
-            fnc = find_class(fnc)
-        self.fnc = fnc
-
-        # Bootstrap the value last
-        if not self.val:
-            self.val = init_val
-
-    def set(self, val):
-        """Set the value"""
-        import time
-        now = time.time()
-        expected_value = []
-        new_val = {}
-        new_val['timestamp'] = now
-        if self._value != None:
-            new_val['last_value'] = self._value
-            expected_value = ['current_value', str(self._value)]
-        new_val['current_value'] = val
-        try:
-            self.db.put_attributes(self.id, new_val, expected_value=expected_value)
-            self.timestamp = new_val['timestamp']
-        except SDBResponseError, e:
-            if e.status == 409:
-                raise ValueError("Sequence out of sync")
-            else:
-                raise
-
-
-    def get(self):
-        """Get the value"""
-        val = self.db.get_attributes(self.id, consistent_read=True)
-        if val:
-            if 'timestamp' in val:
-                self.timestamp = val['timestamp']
-            if 'current_value' in val:
-                self._value = self.item_type(val['current_value'])
-            if "last_value" in val and val['last_value'] != None:
-                self.last_value = self.item_type(val['last_value'])
-        return self._value
-
-    val = property(get, set)
-
-    def __repr__(self):
-        return "%s('%s', '%s', '%s.%s', '%s')" % (
-            self.__class__.__name__,
-            self.id,
-            self.domain_name,
-            self.fnc.__module__, self.fnc.__name__,
-            self.val)
-
-
-    def _connect(self):
-        """Connect to our domain"""
-        if not self._db:
-            import boto
-            sdb = boto.connect_sdb()
-            if not self.domain_name:
-                self.domain_name = boto.config.get("DB", "sequence_db", boto.config.get("DB", "db_name", "default"))
-            try:
-                self._db = sdb.get_domain(self.domain_name)
-            except SDBResponseError, e:
-                if e.status == 400:
-                    self._db = sdb.create_domain(self.domain_name)
-                else:
-                    raise
-        return self._db
-
-    db = property(_connect)
-
-    def next(self):
-        self.val = self.fnc(self.val, self.last_value)
-        return self.val
-
-    def delete(self):
-        """Remove this sequence"""
-        self.db.delete_attributes(self.id)

data/packages/gsutil/boto/boto/sdb/db/test_db.py

@@ -1,231 +0,0 @@
-import logging
-import time
-from datetime import datetime
-
-from boto.sdb.db.model import Model
-from boto.sdb.db.property import StringProperty, IntegerProperty, BooleanProperty
-from boto.sdb.db.property import DateTimeProperty, FloatProperty, ReferenceProperty
-from boto.sdb.db.property import PasswordProperty, ListProperty, MapProperty
-from boto.exception import SDBPersistenceError
-
-logging.basicConfig()
-log = logging.getLogger('test_db')
-log.setLevel(logging.DEBUG)
-
-_objects = {}
-
-#
-# This will eventually be moved to the boto.tests module and become a real unit test
-# but for now it will live here.  It shows examples of each of the Property types in
-# use and tests the basic operations.
-#
-class TestBasic(Model):
-
-    name = StringProperty()
-    size = IntegerProperty()
-    foo = BooleanProperty()
-    date = DateTimeProperty()
-
-class TestFloat(Model):
-
-    name = StringProperty()
-    value = FloatProperty()
-
-class TestRequired(Model):
-
-    req = StringProperty(required=True, default='foo')
-
-class TestReference(Model):
-
-    ref = ReferenceProperty(reference_class=TestBasic, collection_name='refs')
-
-class TestSubClass(TestBasic):
-
-    answer = IntegerProperty()
-
-class TestPassword(Model):
-    password = PasswordProperty()
-
-class TestList(Model):
-
-    name = StringProperty()
-    nums = ListProperty(int)
-
-class TestMap(Model):
-
-    name = StringProperty()
-    map = MapProperty()
-
-class TestListReference(Model):
-
-    name = StringProperty()
-    basics = ListProperty(TestBasic)
-
-class TestAutoNow(Model):
-
-    create_date = DateTimeProperty(auto_now_add=True)
-    modified_date = DateTimeProperty(auto_now=True)
-
-class TestUnique(Model):
-    name = StringProperty(unique=True)
-
-def test_basic():
-    global _objects
-    t = TestBasic()
-    t.name = 'simple'
-    t.size = -42
-    t.foo = True
-    t.date = datetime.now()
-    log.debug('saving object')
-    t.put()
-    _objects['test_basic_t'] = t
-    time.sleep(5)
-    log.debug('now try retrieving it')
-    tt = TestBasic.get_by_id(t.id)
-    _objects['test_basic_tt'] = tt
-    assert tt.id == t.id
-    l = TestBasic.get_by_id([t.id])
-    assert len(l) == 1
-    assert l[0].id == t.id
-    assert t.size == tt.size
-    assert t.foo == tt.foo
-    assert t.name == tt.name
-    #assert t.date == tt.date
-    return t
-
-def test_float():
-    global _objects
-    t = TestFloat()
-    t.name = 'float object'
-    t.value = 98.6
-    log.debug('saving object')
-    t.save()
-    _objects['test_float_t'] = t
-    time.sleep(5)
-    log.debug('now try retrieving it')
-    tt = TestFloat.get_by_id(t.id)
-    _objects['test_float_tt'] = tt
-    assert tt.id == t.id
-    assert tt.name == t.name
-    assert tt.value == t.value
-    return t
-    
-def test_required():
-    global _objects
-    t = TestRequired()
-    _objects['test_required_t'] = t
-    t.put()
-    return t
-
-def test_reference(t=None):
-    global _objects
-    if not t:
-        t = test_basic()
-    tt = TestReference()
-    tt.ref = t
-    tt.put()
-    time.sleep(10)
-    tt = TestReference.get_by_id(tt.id)
-    _objects['test_reference_tt'] = tt
-    assert tt.ref.id == t.id
-    for o in t.refs:
-        log.debug(o)
-
-def test_subclass():
-    global _objects
-    t = TestSubClass()
-    _objects['test_subclass_t'] = t
-    t.name = 'a subclass'
-    t.size = -489
-    t.save()
-
-def test_password():
-    global _objects
-    t = TestPassword()
-    _objects['test_password_t'] = t
-    t.password = "foo"
-    t.save()
-    time.sleep(5)
-    # Make sure it stored ok
-    tt = TestPassword.get_by_id(t.id)
-    _objects['test_password_tt'] = tt
-    #Testing password equality
-    assert tt.password == "foo"
-    #Testing password not stored as string
-    assert str(tt.password) != "foo"
-
-def test_list():
-    global _objects
-    t = TestList()
-    _objects['test_list_t'] = t
-    t.name = 'a list of ints'
-    t.nums = [1, 2, 3, 4, 5]
-    t.put()
-    tt = TestList.get_by_id(t.id)
-    _objects['test_list_tt'] = tt
-    assert tt.name == t.name
-    for n in tt.nums:
-        assert isinstance(n, int)
-
-def test_list_reference():
-    global _objects
-    t = TestBasic()
-    t.put()
-    _objects['test_list_ref_t'] = t
-    tt = TestListReference()
-    tt.name = "foo"
-    tt.basics = [t]
-    tt.put()
-    time.sleep(5)
-    _objects['test_list_ref_tt'] = tt
-    ttt = TestListReference.get_by_id(tt.id)
-    assert ttt.basics[0].id == t.id
-
-def test_unique():
-    global _objects
-    t = TestUnique()
-    name = 'foo' + str(int(time.time()))
-    t.name = name
-    t.put()
-    _objects['test_unique_t'] = t
-    time.sleep(10)
-    tt = TestUnique()
-    _objects['test_unique_tt'] = tt
-    tt.name = name
-    try:
-        tt.put()
-        assert False
-    except(SDBPersistenceError):
-        pass
-
-def test_datetime():
-    global _objects
-    t = TestAutoNow()
-    t.put()
-    _objects['test_datetime_t'] = t
-    time.sleep(5)
-    tt = TestAutoNow.get_by_id(t.id)
-    assert tt.create_date.timetuple() == t.create_date.timetuple()
-
-def test():
-    log.info('test_basic')
-    t1 = test_basic()
-    log.info('test_required')
-    test_required()
-    log.info('test_reference')
-    test_reference(t1)
-    log.info('test_subclass')
-    test_subclass()
-    log.info('test_password')
-    test_password()
-    log.info('test_list')
-    test_list()
-    log.info('test_list_reference')
-    test_list_reference()
-    log.info("test_datetime")
-    test_datetime()
-    log.info('test_unique')
-    test_unique()
-
-if __name__ == "__main__":
-    test()