Python datastore.Key类代码示例

 def post(self):
     query = self.request.get('symptoms')
     id= self.request.get('id')
     did= self.request.get('did')
     dis = self.request.get('disease').split(' ')
     med = self.request.get('medicine')
     		
     sym  = summarize.doctor_symptoms(query)
     q= patient.all(keys_only=True)
     q.filter("__key__ >=", Key.from_path('patient', id))
     res = q.get()
     
     if res:
         d= doctor.all(keys_only=True)
         d.filter("__key__ >=", Key.from_path('doctor', did))
         resd = d.get()
         if resd:
             result ="Updated successfully"
             rec = record(parent=res, symptoms = sym, disease =dis,medicine=med, doc = did)
             rec.rec_date =datetime.datetime.now().date()
             rec.put() 
         else:
             result ="Invalid DocID"
     else:
         result ="Invalid PatientID"
     
     
     
     template_values = {
     'result': result
     
     }
     template = jinja_environment.get_template('message.html')
     self.response.out.write(template.render(template_values))

    def _map_entity(self, entity):
        new_key = Key.from_path(
            self.to_kind, entity.key().id_or_name(), namespace=self.to_namespace
        )

        parent = entity.parent()
        if parent:
            # If the entity has an ancestor then we need to make sure that that ancestor exists in
            # the new namespace as well
            new_parent_key = Key.from_path(
                parent.kind(), parent.is_or_name(), namespace=self.to_namespace
            )
            new_parent_exists = Get([new_parent_key])[0]
            if not new_parent_exists:
                raise DataError(
                    "Trying to copy entity with an ancestor (%r) to a new namespace but the "
                    "ancestor does not exist in the new namespace. Copy the ancestors first."
                    % entity.key()
                )

        def txn():
            existing = Get([new_key])[0]
            if existing and not self.overwrite_existing:
                return
            if isinstance(entity.key().id_or_name(), (int, long)):
                reserve_id(self.to_kind, entity.key().id_or_name(), self.to_namespace)
            new_entity = clone_entity(entity, new_key)
            Put(new_entity)

        RunInTransaction(txn)

def create_key(db_table, value):
    if isinstance(value, GAEKey):
        parent = None
        if value.parent_key() is not None:
            parent = value.parent_key().real_key()
        return Key.from_path(db_table, value.id_or_name(), parent=parent)
    if isinstance(value, (int, long)) and value < 1:
        return None
    return Key.from_path(db_table, value)

    def put_from_message(cls, message):
        """
        Inserts a patient into the DB

        Args:
            message: A PatientPut instance to be inserted.
        Returns:
            The Patient entity that was inserted.
        """
        q = Doctor.all()
        q.filter('__key__ =', Key.from_path('Doctor', message.doctor_email))
        doctor = q.get()

        new_patient = None
        patient = Patient.get_patient(message.email)
        if patient != None:
            new_patient = cls(key_name=message.email,
                        doctor=doctor,
                        first_name=message.first_name,
                        last_name=message.last_name,
                        phone=message.phone,
                        diagnosis=patient.diagnosis,
                        septic_risk=patient.septic_risk,
                        basis_pass=patient.basis_pass)
        else:
            new_patient = cls(key_name=message.email,
                        doctor=doctor,
                        first_name=message.first_name,
                        last_name=message.last_name,
                        phone=message.phone,
                        diagnosis='No',
                        septic_risk=-1.0)
        new_patient.put()
        return new_patient

    def to_python(self, value):
        if value is None:
            return None
        if isinstance(value, GAEKey):
            return value
        if isinstance(value, Key):
            return GAEKey(real_key=value)
        if isinstance(value, basestring):
            try:
                return GAEKey(real_key=Key(encoded=value))
            except datastore_errors.BadKeyError:
                return GAEKey(real_key=Key.from_path(self.model._meta.db_table, long(value)))
        if isinstance(value, (int, long)):
            return GAEKey(real_key=Key.from_path(self.model._meta.db_table, value))

        raise ValidationError("GAEKeyField does not accept %s" % type(value))

    def acquire_marker(identifier):
        # Key.from_path expects None for an empty namespace, but Key.namespace() returns ''
        namespace = entity_key.namespace() or None
        identifier_key = Key.from_path(UniqueMarker.kind(), identifier, namespace=namespace)

        marker = UniqueMarker.get(identifier_key)
        if marker:
            # If the marker instance is None, and the marker is older then 5 seconds then we wipe it out
            # and assume that it's stale.
            if not marker.instance and (datetime.datetime.utcnow() - marker.created).seconds > 5:
                marker.delete()
            elif marker.instance and marker.instance != entity_key and key_exists(marker.instance):
                fields_and_values = identifier.split("|")
                table_name = fields_and_values[0]
                fields_and_values = fields_and_values[1:]
                fields = [ x.split(":")[0] for x in fields_and_values ]
                raise IntegrityError("Unique constraint violation for kind {} on fields: {}".format(table_name, ", ".join(fields)))
            else:
                # The marker is ours anyway
                return marker

        marker = UniqueMarker(
            key=identifier_key,
            instance=entity_key if entity_key.id_or_name() else None,  # May be None if unsaved
            created=datetime.datetime.utcnow()
        )
        marker.put()
        return marker

    def _fetch_entity(self, instance):
        kind = instance._meta.db_table
        namespace = connection.settings_dict["NAMESPACE"]

        return Get(
            Key.from_path(kind, instance.pk, namespace=namespace)
        )

def get_count(datastore, counter_id):
  key = Key.from_path('Counter', counter_id, _app=PROJECT_ID)
  entity = yield datastore.get(key)
  if entity is None:
    raise gen.Return(0)

  raise gen.Return(entity.get('count', 0))

 def test_blob(self):
     x = BlobModel(data='lalala')
     x.full_clean()
     x.save()
     e = Get(Key.from_path(BlobModel._meta.db_table, x.pk))
     self.assertEqual(e['data'], x.data)
     x = BlobModel.objects.all()[0]
     self.assertEqual(e['data'], x.data)

 def from_service_id(cls, service, id):
     '''
     Use this with data returned from get_id().
     '''
     if use_ancestor:
         return cls.objects.get(key=Key.from_path(
             cls._meta.db_table, long(id), parent=service.key
         ))
     return cls.objects.get(service=service, pk=id)

    def delete(self):
        from rogerthat.models import DSPicklePart, DSPickle

        while True:
            parts = DSPicklePart.all(keys_only=True).ancestor(self.ancestor()).fetch(200)
            if not parts:
                break
            db.delete(parts)
        db.delete(Key.from_path(DSPickle.kind(), self.key))

 def get_db_prep_value(self, value, connection, prepared=False):
     if isinstance(value, AncestorKey):
         # If the key isn't fully initialized pass it through, the InserCompiler will handle it
         if value.key_id is None:
             return value
         return Key.from_path(
             self.model._meta.db_table,
             value.key_id,
             parent=value._parent_key
         )
     return super(GAEKeyField, self).get_db_prep_value(value, connection)

    def read(key):
        from rogerthat.models import DSPicklePart, DSPickle

        dsp = db.get(Key.from_path(DSPickle.kind(), key))
        if not dsp:
            return DSPickler(key)
        stream = StringIO()
        for dspp in DSPicklePart.all().ancestor(dsp).filter('version =', dsp.version).order('number'):
            stream.write(str(dspp.data))
        stream.seek(0)
        data = pickle.load(stream)
        return DSPickler(key, dsp.version, data)

    def get_patient(cls, email):
        """
        Gets patient data

        Args:
            email: Patient e-mail address
        Returns:
            The Patient entity with corresponsing e-mail address
        """
        p = cls.all()
        p.filter('__key__ =', Key.from_path('Patient', email))
        return p.get()

        def mark_deleted_tx():
            user = users.get_current_user()
            entry = db.get(Key.from_path(cls.__name__, int(id)))
            if not entry or entry.deleted:
                return  None

            if not user or entry.user_id != user.user_id():
                return None

            entry.modified = now
            entry.deleted = True
            entry.put()
            return entry