Retrieve tracking ID from settings
513219
def get_ga_tracking_id(self):
        
        if hasattr(settings, self.ga_tracking_id_settings_key):
            return getattr(settings, self.ga_tracking_id_settings_key)
        return super(GARequestErrorReportingMixin, self).get_ga_tracking_id()
178785
def get_tracks(self, offset=0, limit=50):
        
        response = self.client.get(
            self.client.USER_TRACKS % (self.name, offset, limit))
        return self._parse_response(response, strack)
377619
function extractRunIdAndAppId(mqtt_channel) {
    var sp =  mqtt_channel.replace('/nutella/apps/', '').split('/');
    return {appId: sp[0], runId: sp[2]};
}
240657
def build_tracking_request(order_ids, options)
      xml = Builder::XmlMarkup.new :indent => 2
      xml.instruct!
      xml.tag! 'TrackingXML' do
        add_credentials(xml)

        order_ids.each do |o_id|
          xml.tag! 'Tracking' do
            xml.tag! 'Order', o_id
          end
        end
      end
    end
96816
def start_tracker(self, id_, **kwargs):
        
        data = None
        if kwargs:
            data = self._wrap_dict("tracker",
                self._wrap_dict("tracking_time_entry", kwargs))
        return self.patch("/tracker/{}.json".format(id_), data=data)
551128
def get_tracking_beacon(self, tracking_beacons_id, **data):
        
        
        return self.get("/tracking_beacons/{0}/".format(tracking_beacons_id), data=data)
878839
static void writeTracker(JSONWriter writer, Tracker tracker)
			throws JSONException {
		writer.key("id");
		writer.value(tracker.getId());
		writer.key("name");
		writer.value(tracker.getName());
	}
434711
private static String trackingNumberURL(String carrier, String trackingNumber)
			throws AuthenticationException, InvalidRequestException, APIConnectionException, APIException {
		try {
			return String.format("%s/%s/%s", classURL(Track.class), urlEncode(carrier), urlEncode(trackingNumber));
		} catch (UnsupportedEncodingException e) {
			throw new InvalidRequestException("Unable to encode parameters to " + CHARSET
					+ ". Please contact support@goshippo.com for assistance.", null, e);
		}
	}
1178656
def get_track_info(track_id):
    
    logger.info('Retrieving more info on the track')
    info_url = url["trackinfo"].format(track_id)
    r = requests.get(info_url, params={'client_id': CLIENT_ID}, stream=True)
    item = r.json()
    logger.debug(item)
    return item
392218
def get_track_by_mbid(self, mbid):
        """"""

        params = {"mbid": mbid}

        doc = _Request(self, "track.getInfo", params).execute(True)

        return Track(_extract(doc, "name", 1), _extract(doc, "name"), self)
940879
def update(self):
        
        rec = self._c.find_one({}, {self._fld: 1}, sort=[(self._fld, -1)], limit=1)
        if rec is None:
            self._pos = self._empty_pos()
        elif not self._fld in rec:
            _log.error("Tracking field not found. field={} collection={}"
                       .format(self._fld, self._c.name))
            _log.warn("Continuing without tracking")
            self._pos = self._empty_pos()
        else:
            self._pos = {self._fld: rec[self._fld]}
        return self
1129305
def value(self, name):
        """"""
        return self.tracks.get(name).row_value(self.controller.row)
772133
def get_id(self):
        
        import warnings
        warnings.warn('{0}.get_id() is deprecated, '
                      'use {0}.id instead'.format(type(self).__name__),
                      DeprecationWarning)
        return self.get('_id')
899101
def get_item(track_url, client_id=CLIENT_ID):
    
    try:
        item_url = url['resolve'].format(track_url)

        r = requests.get(item_url, params={'client_id': client_id})
        logger.debug(r.url)
        if r.status_code == 403:
            return get_item(track_url, ALT_CLIENT_ID)

        item = r.json()
        no_tracks = item['kind'] == 'playlist' and not item['tracks']
        if no_tracks and client_id != ALT_CLIENT_ID:
            return get_item(track_url, ALT_CLIENT_ID)
    except Exception:
        if client_id == ALT_CLIENT_ID:
            logger.error('Failed to get item...')
            return
        logger.error('Error resolving url, retrying...')
        time.sleep(5)
        try:
            return get_item(track_url, ALT_CLIENT_ID)
        except Exception as e:
            logger.error('Could not resolve url {0}'.format(track_url))
            logger.exception(e)
            sys.exit(0)
    return item
100281
function obtainInfo(action, id, hash, cb) {
    request.post({
        url: action,
        form: {
            trackingNo: id,
            trackingNoString: id,
            __hash__: hash
        },
        jar: j,
        timeout: 30000
    }, function (error, response, body) {
        if (error || response.statusCode != 200) {
            cb(utils.errorDown())
            return
        }

        let $ = parser.load(body);
        let trs = $('.center_table table tbody tr');
        // Not found
        if (trs.length < 2) {
            cb(utils.errorNoData())
            return
        }

        let entity = null
        try {
            entity = createWinitEntity(
                trs[1].children[0].children[0].data,
                $('.center_table table tbody tr td a.poptips')[0].attribs['data-id'])
        } catch (error) {
            return cb(utils.errorParser(id, error.message))
        }

        cb(null, entity)
    })
}
1092493
public static Trajectory getTrajectoryByID(List<? extends Trajectory> t, int id){
		Trajectory track = null;
		for(int i = 0; i < t.size() ; i++){
			if(t.get(i).getID()==id){
				track = t.get(i);
				break;
			}
		}
		return track;
	}
1100474
def get_trail_ids(cls, event, mode):
        """"""
        resource_ids = ()
        event_name = event['detail']['eventName']
        event_source = event['detail']['eventSource']
        for e in mode.get('events', []):
            if not isinstance(e, dict):
                # Check if we have a short cut / alias
                info = CloudWatchEvents.match(event)
                if info:
                    return info['ids'].search(event)
                continue
            if event_name != e.get('event'):
                continue
            if event_source != e.get('source'):
                continue

            id_query = e.get('ids')
            if not id_query:
                raise ValueError("No id query configured")
            evt = event
            # be forgiving for users specifying with details or without
            if not id_query.startswith('detail.'):
                evt = event.get('detail', {})
            resource_ids = jmespath.search(id_query, evt)
            if resource_ids:
                break
        return resource_ids