Return the information about a sprint.

        :param sprint_id: the sprint retrieving issues from

        :type sprint_id: int

        :rtype: :class:`~jira.resources.Sprint`
505572
def sprint(self, id):
        
        sprint = Sprint(self._options, self._session)
        sprint.find(id)
        return sprint
1290203
def get_running_race(self, race_id):
                
        raw = self.protocol.get('/running_races/{id}', id=race_id)
        return model.RunningRace.deserialize(raw, bind_client=self)
1099979
def usable_id(cls, id):
        
        hcs = cls.from_fqdn(id)
        if hcs:
            return [hc_['id'] for hc_ in hcs]

        try:
            return int(id)
        except (TypeError, ValueError):
            pass
835409
def get(self, id):
        
        ctx = self.context.copy()
        ctx['active_test'] = False
        results = self.rpc_model.search_read(
            [('id', '=', id)],
            None, None, None, self.fields,
            context=ctx
        )
        return results and results[0] or None
868968
def get(self, run_id):
        
        id = self._parse_id(run_id)

        run = self.generic_dao.find_record(self.collection_name,
                                           {"_id": id})
        if run is None:
            raise NotFoundError("Run %s not found." % run_id)
        return run
1319543
def get_item_with_id(self, uid):
        
        for item in self.get_items():
            if item.id == uid:
                return item

        return None
1186169
def get_service_details(self, service_id):
        
        service_query = \
            self._soap_client.service['LDBServiceSoap']['GetServiceDetails']
        try:
            soap_response = service_query(serviceID=service_id)
        except WebFault:
            raise WebServiceError
        return ServiceDetails(soap_response)
1140860
def get(self, id):
        
        url = self._url('%s' % (id))
        return self.client.get(url)
744356
def get(self, report_id):
        
        return Report(
            self._app,
            self._swimlane.request('get', "reports/{0}".format(report_id)).json()
        )
1147820
def get_mark(self, mark_id):
        
        if mark_id in self.idx:
            return Cmarkable(self.idx[mark_id], self.type)
        else:
            return None
892211
def get_requests_request_id(self, request_id):
        
        route_values = {}
        if request_id is not None:
            route_values['requestId'] = self._serialize.url('request_id', request_id, 'str')
        response = self._send(http_method='GET',
                              location_id='ebc09fe3-1b20-4667-abc5-f2b60fe8de52',
                              version='5.0-preview.1',
                              route_values=route_values)
        return self._deserialize('Request', response)
621172
def tripleExprFor(self, id_: ShExJ.tripleExprLabel) -> ShExJ.tripleExpr:
        
        return self.te_id_map.get(id_)
310739
def get_connection(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        schema = ConnectionSchema()
        resp = self.service.get(self.base+str(id)+'/connect/')
        return self.service.decode(schema, resp)
107088
def get(self, run_id):
        
        config = _read_json(_path_to_config(self.directory, run_id))
        run = _read_json(_path_to_run(self.directory, run_id))
        try:
            info = _read_json(_path_to_info(self.directory, run_id))
        except IOError:
            info = {}

        return _create_run(run_id, run, config, info)
10039
def get(self, id, param):
        
        assert isinstance(id, basestring)
        assert isinstance(param, basestring)
        return self.params_.get(param, {}).get(id)
955279
def get_sds_by_id(self,id):
        
        for sds in self.sds:
            if sds.id == id:
                return sds
        raise KeyError("SDS with that ID not found")
1358040
def get_contact(self, contact_id):
        
        url = self.CONTACTS_ID_URL % contact_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.get_request()