def save(self, transactional=False, **kwargs):
for field_name, field_obj in self._fields.iteritems():
if isinstance(field_obj, DictField):
pre_save_func = getattr(field_obj, 'pre_save')
if not pre_save_func:
continue
value = getattr(self, field_name)
if isinstance(value, dict):
self._entity[field_name] = pre_save_func(value)
global ACTIVE_TRANSACTION
global TRANSACTION_ENTITIES
if transactional and not GAE_RUNNING:
batch = ACTIVE_TRANSACTION
if not batch:
batch = datastore.Batch()#Transaction()
#transaction.begin()
ACTIVE_TRANSACTION = batch
batch.put(self._entity)
TRANSACTION_ENTITIES.append(self._entity)
if len(TRANSACTION_ENTITIES) > 200:
batch.commit()
TRANSACTION_ENTITIES = []
ACTIVE_TRANSACTION = None
else:
if GAE_RUNNING:
self._entity.put()
else:
datastore.put([self._entity])
def create_report(employee_id, report_id, rows, description):
with Transaction():
if _get_report(employee_id, report_id, False) is not None:
raise DuplicateReport()
report = _upsert_report(employee_id, report_id, rows)
report['status'] = 'pending'
if description is not None:
report['description'] = description
report['created'] = report['updated'] = datetime.datetime.utcnow()
datastore.put([report])
def reject_report(employee_id, report_id, reason):
with Transaction():
report = _get_report(employee_id, report_id, False)
if report is None:
raise NoSuchReport()
if report['status'] != 'pending':
raise BadReportStatus(report['status'])
report['updated'] = datetime.datetime.utcnow()
report['status'] = 'rejected'
report['reason'] = reason
datastore.put([report])
def _get_report(employee_id, report_id, create=True):
key = Key('Employee', employee_id, 'Expense Report', report_id)
reports = datastore.get([key])
if len(reports) == 0:
if not create:
return None
report = Entity(key)
datastore.put([report])
else:
report, = reports
return report
def approve_report(employee_id, report_id, check_number):
with Transaction():
report = _get_report(employee_id, report_id, False)
if report is None:
raise NoSuchReport()
if report['status'] != 'pending':
raise BadReportStatus(report['status'])
report['updated'] = datetime.datetime.utcnow()
report['status'] = 'paid'
report['check_number'] = check_number
datastore.put([report])
def _get_employee(employee_id, create=True):
key = Key('Employee', employee_id)
employees = datastore.get([key])
if len(employees) == 0:
if not create:
return None
employee = Entity(key)
employee['created'] = employee['updated'] = datetime.datetime.utcnow()
datastore.put([employee])
else:
employee, = employees
return employee
def update_report(employee_id, report_id, rows, description):
with Transaction():
report = _get_report(employee_id, report_id, False)
if report is None:
raise NoSuchReport()
if report['status'] != 'pending':
raise BadReportStatus(report['status'])
_upsert_report(employee_id, report_id, rows)
if description is not None:
report['description'] = description
report['updated'] = datetime.datetime.utcnow()
datastore.put([report])
def _upsert_report(employee_id, report_id, rows):
_get_employee(employee_id) # force existence
report = _get_report(employee_id, report_id)
_purge_report_items(report)
# Add items based on rows.
report_path = list(report.key.flat_path)
for i, row in enumerate(rows):
path = report_path + ['Expense Item', i + 1]
key = Key(*path)
item = Entity(key)
for k, v in row.items():
item[k] = v
datastore.put([item])
return report
def _generic_test_post(self, name=None, key_id=None):
entity = self._get_post(id_or_name=(name or key_id))
datastore.put([entity])
# Register entity to be deleted.
self.case_entities_to_delete.append(entity)
if name is not None:
self.assertEqual(entity.key.name, name)
if key_id is not None:
self.assertEqual(entity.key.id, key_id)
retrieved_entity, = datastore.get([entity.key])
# Check the given and retrieved are the the same.
self.assertEqual(retrieved_entity, entity)
def _generic_test_post(self, name=None, key_id=None):
entity = self._get_post(id_or_name=(name or key_id))
datastore.put([entity])
# Register entity to be deleted.
self.case_entities_to_delete.append(entity)
if name is not None:
self.assertEqual(entity.key.name, name)
if key_id is not None:
self.assertEqual(entity.key.id, key_id)
retrieved_entity, = datastore.get([entity.key])
# Check the given and retrieved are the the same.
self.assertEqual(retrieved_entity, entity)
def test_save_key_self_reference(self):
parent_key = datastore.Key("Residence", "NewYork")
key = datastore.Key("Person", "name", parent=parent_key)
entity = datastore.Entity(key=key)
entity["fullName"] = u"Full name"
entity["linkedTo"] = key # Self reference.
datastore.put(entity)
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind="Person")
# Adding ancestor to ensure consistency.
query.ancestor = parent_key
query.add_filter("linkedTo", "=", key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(stored_persons, [entity])
def test_save_key_self_reference(self):
parent_key = datastore.Key('Residence', 'NewYork')
key = datastore.Key('Person', 'name', parent=parent_key)
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
# Adding ancestor to ensure consistency.
query.ancestor = parent_key
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(stored_persons, [entity])
def test_save_key_self_reference(self):
parent_key = datastore.Key('Residence', 'NewYork')
key = datastore.Key('Person', 'name', parent=parent_key)
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
# Adding ancestor to ensure consistency.
query.ancestor = parent_key
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(stored_persons, [entity])
def test_save_key_self_reference(self):
key = datastore.Key('Person', 'name')
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
with datastore.Transaction():
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(len(stored_persons), 1)
stored_person = stored_persons[0]
self.assertEqual(stored_person['fullName'], entity['fullName'])
self.assertEqual(stored_person.key.path, key.path)
self.assertEqual(stored_person.key.namespace, key.namespace)
def _generic_test_post(self, name=None, key_id=None):
entity = self._get_post(id_or_name=(name or key_id))
with datastore.Transaction():
datastore.put([entity])
# Register entity to be deleted.
self.case_entities_to_delete.append(entity)
if name is not None:
self.assertEqual(entity.key.name, name)
if key_id is not None:
self.assertEqual(entity.key.id, key_id)
retrieved_entity, = datastore.get([entity.key])
# Check the keys are the same.
self.assertEqual(retrieved_entity.key.path, entity.key.path)
self.assertEqual(retrieved_entity.key.namespace, entity.key.namespace)
self.assertTrue(
_compare_dataset_ids(retrieved_entity.key.dataset_id,
entity.key.dataset_id))
# Check the data is the same.
retrieved_dict = dict(retrieved_entity.items())
entity_dict = dict(entity.items())
self.assertEqual(retrieved_dict, entity_dict)
# Let's start by importing the demo module and initializing our connection.
from gcloud import datastore
from gcloud.datastore import demo
demo.initialize()
# Let's import the package containing our helper classes:
# Let's create a new entity of type "Thing" and name it 'Toy':
key = datastore.Key('Thing')
toy = datastore.Entity(key)
toy.update({'name': 'Toy'})
# Now let's save it to our datastore:
datastore.put(toy)
# If we look it up by its key, we should find it...
print(datastore.get(toy.key))
# And we should be able to delete it...
datastore.delete(toy.key)
# Since we deleted it, if we do another lookup it shouldn't be there again:
print(datastore.get(toy.key))
# Now let's try a more advanced query.
# First, let's create some entities.
SAMPLE_DATA = [
(1234, 'Computer', 10),
(2345, 'Computer', 8),
# Let's start by importing the demo module and initializing our connection.
from gcloud import datastore
from gcloud.datastore import demo
demo.initialize()
# Let's import the package containing our helper classes:
# Let's create a new entity of type "Thing" and name it 'Toy':
key = datastore.Key('Thing')
toy = datastore.Entity(key)
toy.update({'name': 'Toy'})
# Now let's save it to our datastore:
datastore.put(toy)
# If we look it up by its key, we should find it...
print(datastore.get(toy.key))
# And we should be able to delete it...
datastore.delete(toy.key)
# Since we deleted it, if we do another lookup it shouldn't be there again:
print(datastore.get(toy.key))
# Now let's try a more advanced query.
# First, let's create some entities.
SAMPLE_DATA = [(1234, 'Computer', 10), (2345, 'Computer', 8),
(3456, 'Laptop', 10), (4567, 'Printer', 11),
(5678, 'Printer', 12), (6789, 'Computer', 13)]
projection=["trial_id"],
).fetch()])
ids.add(0)
trial_id = max(ids)+1
perf_test_git_hash = subprocess.check_output(["git", "rev-parse", "HEAD"]).strip().decode("ascii")
dt = datastore.Entity(datastore.Key("DownloadTrial"))
dt.update({"trial_id": trial_id,
"notes": notes,
"perf_test_git_hash": perf_test_git_hash,
"client_tahoe_appname": tahoe_appname,
"client_tahoe_version": tahoe_version,
"client_tahoe_branch": tahoe_branch,
"client_tahoe_git_hash": tahoe_git_hash,
})
datastore.put([dt])
print "-- Starting trial id %d, mode=%s, gridconfig=%d" % (trial_id, mode, grid_config_id)
key = datastore.Key("DownloadPerf")
if mode == "k60":
values_of_filesize = SIZES.keys()
values_of_k = SHARES
elif mode == "k6":
values_of_filesize = SIZES.keys()
values_of_k = range(1,6+1)
elif mode == "partial-banding":
values_of_filesize = [M]
values_of_k = range(1,6+1) + [30,60]
elif mode == "partial-100MB":
values_of_filesize = [100*M]
# Let's start by importing the demo module and initializing our connection.
from gcloud import datastore
from gcloud.datastore import demo
demo.initialize()
# Let's import the package containing our helper classes:
# Let's create a new entity of type "Thing" and name it 'Toy':
key = datastore.Key('Thing')
toy = datastore.Entity(key)
toy.update({'name': 'Toy'})
# Now let's save it to our datastore:
datastore.put([toy])
# If we look it up by its key, we should find it...
print(datastore.get([toy.key]))
# And we should be able to delete it...
datastore.delete([toy.key])
# Since we deleted it, if we do another lookup it shouldn't be there again:
print(datastore.get([toy.key]))
# Now let's try a more advanced query.
# First, let's create some entities.
SAMPLE_DATA = [(1234, 'Computer', 10), (2345, 'Computer', 8),
(3456, 'Laptop', 10), (4567, 'Printer', 11),
(5678, 'Printer', 12), (6789, 'Computer', 13)]
# Let's start by importing the demo module and initializing our connection.
from gcloud import datastore
from gcloud.datastore import demo
demo.initialize()
# Let's import the package containing our helper classes:
# Let's create a new entity of type "Thing" and name it 'Toy':
key = datastore.Key('Thing')
toy = datastore.Entity(key)
toy.update({'name': 'Toy'})
# Now let's save it to our datastore:
datastore.put([toy])
# If we look it up by its key, we should find it...
print(datastore.get([toy.key]))
# And we should be able to delete it...
datastore.delete([toy.key])
# Since we deleted it, if we do another lookup it shouldn't be there again:
print(datastore.get([toy.key]))
# Now let's try a more advanced query.
# First, let's create some entities.
SAMPLE_DATA = [
(1234, 'Computer', 10),
(2345, 'Computer', 8),
