Get a :class:`Task` by ref.

        :param ref: :class:`Task` reference
496417
def get_task_by_ref(self, ref):
        
        response = self.requester.get(
            '/{endpoint}/by_ref?ref={task_ref}&project={project_id}',
            endpoint=Task.endpoint,
            task_ref=ref,
            project_id=self.id
        )
        return Task.parse(self.requester, response.json())
182510
def getReference(self, id_):
        
        if id_ not in self._referenceIdMap:
            raise exceptions.ReferenceNotFoundException(id_)
        return self._referenceIdMap[id_]
536536
def reference(self):
        
        ref = ModelReference()
        ref._proto = self._proto.model_reference
        return ref
371645
def _reference_getter(table):
    
    from google.cloud.bigquery import dataset

    dataset_ref = dataset.DatasetReference(table.project, table.dataset_id)
    return TableReference(dataset_ref, table.table_id)
560659
def get_tasks(self):
        

        def predicate(item):
            return (inspect.isfunction(item) and
                    item.__name__ not in self._helper_names)
        return inspect.getmembers(self._tasks, predicate)
888747
def findReference(self, name, cls=QtGui.QWidget):
        
        ref_widget = self._referenceWidget
        if not ref_widget:
            return None
        
        if ref_widget.objectName() == name:
            return ref_widget
        return ref_widget.findChild(cls, name)
993805
def _get(self, target, alias):
        
        if target not in self._aliases:
            return
        return self._aliases[target].get(alias)
1320420
def lookup_task(self, task):
        
        if isinstance(task, str):
            try:
                return self[task]
            except KeyError:
                pass
        raise TaskError('Unknown task %s' % task)
528009
def getReferenceByName(self, name):
        
        if name not in self._referenceNameMap:
            raise exceptions.ReferenceNameNotFoundException(name)
        return self._referenceNameMap[name]
918719
def fetch_import_ref_restriction(self,):
        
        inter = self.get_refobjinter()
        restricted = self.status() not in (self.LOADED, self.UNLOADED)
        return restricted or inter.fetch_action_restriction(self, 'import_reference')
238660
def path(cls, ref):
        
        return osp.join(ref.repo.git_dir, "logs", to_native_path(ref.path))
1247234
def get instance_reference, keys = nil
    if keys
      namespace = keys.delete(:namespace) || "root/cimv2"
      instance_reference = Sfcc::Cim::ObjectPath.new(namespace, instance_reference)
      keys.each do |k,v|
        instance_reference.add_key k, v
      end
    end
    puts "@client.get #{instance_reference.class}..." if Wbem.debug
    case instance_reference
    when Sfcc::Cim::ObjectPath
      get_by_objectpath instance_reference
    when String
      get_by_objectpath CimxmlClient.parse_object_path(instance_reference)
    else
      raise "Unsupported Wbem::get #{instance_reference.class}"
    end
  end
1268221
def get_copy_reference(path)
      resp = request('/files/copy_reference/get', path: path)
      metadata = parse_tagged_response(resp['metadata'])
      return metadata, resp['copy_reference']
    end
1255708
public List<Task> getTasksWithReference(Reference reference) {
		return getResourceFactory().getApiResource(
				"/task/" + reference.getType().name().toLowerCase() + "/"
						+ reference.getId() + "/").get(
				new GenericType<List<Task>>() {
				});
	}
38096
def _get_reference(self):
        """"""
        sha, target_ref_path = self._get_ref_info(self.repo, self.path)
        if target_ref_path is None:
            raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
        return self.from_path(self.repo, target_ref_path)
19252
def validate_reference(self, reference: ReferenceDefinitionType) -> Optional[Path]:
        
        if reference is not None:
            if isinstance(reference, bytes):
                reference = reference.decode("utf-8")
            try:
                return Path(reference)
            except TypeError:
                raise ValueError(f"Can't convert reference path {reference} to a pathlib.Path")

        return None
401225
def resolve_ref(cls, domain, env, fromdocname, builder, typ, target, node,
                    contnode):
        
        targets = domain.data['targets'].get(cls.ref_type, {})
        try:
            todocname, targetname = targets[target]
        except KeyError:
            env.warn(fromdocname, "Missing BB reference: bb:%s:%s" % (cls.ref_type, target),
                     node.line)
            return None

        return make_refnode(builder, fromdocname,
                            todocname, targetname,
                            contnode, target)