Retrieve an existing :class:`meteorpi_model.Observation` by its ID

        :param string observation_id:
            UUID of the observation
        :return:
            A :class:`meteorpi_model.Observation` instance, or None if not found
770069
def get_observation(self, observation_id):
        
        search = mp.ObservationSearch(observation_id=observation_id)
        b = search_observations_sql_builder(search)
        sql = b.get_select_sql(columns='l.publicId AS obstory_id, l.name AS obstory_name, '
                                       'o.obsTime, s.name AS obsType, o.publicId, o.uid',
                               skip=0, limit=1, order='o.obsTime DESC')
        obs = list(self.generators.observation_generator(sql=sql, sql_args=b.sql_args))
        if not obs:
            return None
        return obs[0]
182510
def getReference(self, id_):
        
        if id_ not in self._referenceIdMap:
            raise exceptions.ReferenceNotFoundException(id_)
        return self._referenceIdMap[id_]
999887
def get(self, obj_id):
        
        response = self._client.session.get(
            '{url}/{id}'.format(
                url=self.endpoint_url, id=obj_id
            )
        )
        return self.process_response(response)
431325
def get_detector(self, id, **kwargs):
        "
        resp = self._get_object_by_name(self._DETECTOR_ENDPOINT_SUFFIX, id,
                                        **kwargs)
        return resp
1375058
def get_id(self):
        
        if self._id is None:
            self._id = graceful_get(self.inspect(refresh=True), "ID")
        return self._id
860703
def get_object(self, ObjectClass, id):
        
        print('dynamo.get(%s, %s)' % (ObjectClass, str(id)))
        resp = self.db.engine.get(ObjectClass, [id])
        if resp:
            return resp[0]
        else:
            return None
1174243
def get_by_id(id)
      accts = @accounts.select {|acct| acct.uuid == id }

      if accts.size == 0
        raise KeyError, "account with id #{id} unknown"
      elsif accts.size > 1
        logger.warn "multiple accounts with same UUID found", uuid: id
      end

      accts[0]
    end
1154393
def getContinuousSet(self, id_):
        
        if id_ not in self._continuousSetIdMap:
            raise exceptions.ContinuousSetNotFoundException(id_)
        return self._continuousSetIdMap[id_]
1294568
def from_uuid(cls, uuid, **extra_data):
        
        model = Workflow.query.get(uuid)
        if model is None:
            raise LookupError(
                "No workflow with UUID {} was found".format(uuid)
            )
        instance = cls(model=model, **extra_data)
        instance.objects = WorkflowObjectModel.query.filter(
            WorkflowObjectModel.id_workflow == uuid,
            WorkflowObjectModel.id_parent == None,  # noqa
        ).all()
        return instance
1170693
def get_instance_id(self, instance):
        "  "
        if type(instance) in [list, tuple]:
            core_signals.request_finished.connect(receiver=RichTextField.reset_instance_counter_listener)
            if RichTextField.__inst_counter >= len(instance):
                return None
            else:
                obj_id = self.instance[ RichTextField.__inst_counter ].pk
            RichTextField.__inst_counter += 1
        else:
            obj_id = instance.pk
        return obj_id
1293469
def find(id)
      result = self.class.get(worksheet_url + "/" + id).parsed_response
      check_and_raise_error(result)
      Record.new(result_attributes(result)) if result.present? && result["id"]
    end
926000
def getById(self, Id):
        
        # we need to create a new object to insure we don't corrupt the generator count
        csvsource = CSVSource(self.source, self.factory, self.key())
        try:
            for item in csvsource.items():
                if Id == item.getId():
                    return item
        except StopIteration:
            return None
792327
def find(cls, _id):
        

        if not _id:
            return None
        try:
            return next(cls.where(id=_id))
        except StopIteration:
            raise PanoptesAPIException(
                "Could not find {} with id='{}'".format(cls.__name__, _id)
            )
1183491
def get_instance(self, id=None, name=None):
        
        log.info("Picking instance: %s (%s)" % (name, id))
        if id:  # submodule instances are invisible for lists
            return Instance(id=id, organization=self).init_router(self._router)
        return Instance.get(self._router, self, name)
1247858
def get(cls, bucket_id):
        
        return cls.query.filter_by(
            id=bucket_id,
            deleted=False
        ).one_or_none()
850656
def watcher(self) -> Watcher:
        
        if not hasattr(self, "_watcher"):
            self._watcher = Watcher()
        return self._watcher
1126952
def get_instance_for_uuid(self, uuid, project_id):
        
        instance_name = self._inst_info_cache.get((uuid, project_id))
        if instance_name:
            return instance_name
        instances = self._get_instances_for_project(project_id)
        for inst in instances:
            if inst.id.replace('-', '') == uuid:
                LOG.debug('get_instance_for_uuid: name=%s', inst.name)
                instance_name = inst.name
                self._inst_info_cache[(uuid, project_id)] = instance_name
                return instance_name
        return instance_name