Ingest the data for the given bundle.
435544
def ingest(bundle, assets_version, show_progress):
    
    bundles_module.ingest(
        bundle,
        os.environ,
        pd.Timestamp.utcnow(),
        assets_version,
        show_progress,
    )
935666
def bundle(self, name: str) -> models.Bundle:
        """"""
        return self.Bundle.filter_by(name=name).first()
766129
public void stream (final String bundle, final String path, final boolean loop,
        final ResultListener<Stream> listener)
        throws IOException
    {
        if (!path.endsWith(".ogg")) {
            log.warning("Unknown file type for streaming", "bundle", bundle, "path", path);
            return;
        }
        InputStream rsrc = _loader.getSound(bundle, path);
        final StreamDecoder dec = new OggStreamDecoder();
        dec.init(rsrc);
        getSoundQueue().postRunnable(new Runnable() {
            public void run () {
                Stream s = new Stream(_alSoundManager) {
                    @Override
                    protected void update (float time) {
                        super.update(time);
                        if (_state != AL10.AL_PLAYING) {
                            return;
                        }
                        super.setGain(_clipVol * _streamGain);
                    }

                    @Override
                    public void setGain (float gain) {
                        _streamGain = gain;
                        super.setGain(_clipVol * _streamGain);
                    }

                    @Override
                    protected int getFormat () {
                        return dec.getFormat();
                    }

                    @Override
                    protected int getFrequency () {
                        return dec.getFrequency();
                    }

                    @Override
                    protected int populateBuffer (ByteBuffer buf) throws IOException {
                        int read = dec.read(buf);
                        if (buf.hasRemaining() && loop) {
                            dec.init(_loader.getSound(bundle, path));
                            read = Math.max(0, read);
                            read += dec.read(buf);
                        }
                        return read;
                    }

                    protected float _streamGain = 1F;
                };
                s.setGain(_clipVol);
                listener.requestCompleted(s);
            }});
    }
1020421
def set_data(self, data):
        ''' 
        '''
        data = array.array('B', struct.unpack("{}B".format(len(data) * 4), struct.pack("{}I".format(len(data)), *data)))
        self._intf._send_tcp_data(data)
828293
def ingest(self, token, endpoint=None, timeout=None, compress=None):
        """"""
        from . import ingest
        if ingest.sf_pbuf:
            client = ingest.ProtoBufSignalFxIngestClient
        else:
            _logger.warn('Protocol Buffers not installed properly; '
                         'falling back to JSON.')
            client = ingest.JsonSignalFxIngestClient
        compress = compress if compress is not None else self._compress
        return client(
            token=token,
            endpoint=endpoint or self._ingest_endpoint,
            timeout=timeout or self._timeout,
            compress=compress)
800309
def ingest(topic, text, **kwargs):
    
    if not text:
        raise ValueError('No text given to ingest for topic: ' + topic)
    data = {'topic': topic, 'text': text.strip()}
    data.update(kwargs)
    db.markovify.insert(data)
1237150
def send(self, data):
        """"""
        self._send_data(int_to_hex(len(data)))

        self._send_data(data)
831839
def consume(self, amount=1):
        """"""
        # First, cleanup old stock
        current = self.leak()

        if current + amount > self.capacity:
            return False

        self._incr(amount)
        return True
1222418
protected void processBundle(Bundle bundle) {
        Properties props = readMessageRouterProps(bundle);

        if (props != null) {
            msgRouter.modified(props);
        }
    }
276830
def bundle(self, bundle_id, channel=None):
        '''
        '''
        return self.entity(bundle_id, get_files=True, channel=channel)
874448
private void startBundle( final Bundle bundle )
        throws BundleException
    {
        // Don't start if bundle already active
        int bundleState = bundle.getState();
        if( bundleState == Bundle.ACTIVE )
        {
            return;
        }

        // Don't start if bundle is a fragment bundle
        Dictionary bundleHeaders = bundle.getHeaders();
        if( bundleHeaders.get( Constants.FRAGMENT_HOST ) != null )
        {
            return;
        }

        // Start bundle
        bundle.start();

        bundleState = bundle.getState();
        if( bundleState != Bundle.ACTIVE )
        {
            long bundleId = bundle.getBundleId();
            String bundleName = bundle.getSymbolicName();
            String bundleStateStr = bundleStateToString( bundleState );
            throw new BundleException(
                "Bundle (" + bundleId + ", " + bundleName + ") not started (still " + bundleStateStr + ")"
            );
        }
    }
822678
private void instantiateIngest() throws IOException {
    InjectionHandler.processEvent(InjectionEvent.STANDBY_INSTANTIATE_INGEST);
    try {
      synchronized (ingestStateLock) {
        if (checkIngestState()) {
          LOG.info("Standby: Ingest for txid: " + currentSegmentTxId
              + " is already running");
          return;
        }
        assertState(StandbyIngestState.NOT_INGESTING);
        ingest = new Ingest(this, fsnamesys, confg, currentSegmentTxId);
        ingestThread = new Thread(ingest);
        ingestThread.setName("Ingest_for_" + currentSegmentTxId);
        ingestThread.start();
        currentIngestState = StandbyIngestState.INGESTING_EDITS;
      }
      LOG.info("Standby: Instatiated ingest for txid: " + currentSegmentTxId);
    } catch (IOException e) {
      setIngestFailures(ingestFailures + 1);
      currentIngestState = StandbyIngestState.NOT_INGESTING;
      throw e;
    }
  }
1054645
def used_by(self, bundle):
        
        if bundle is None or bundle is self.__bundle:
            # Ignore
            return

        with self.__usage_lock:
            self.__using_bundles.setdefault(bundle, _UsageCounter()).inc()
503203
private void storeBundle(String bundleId, JoinableResourceBundleContent store) {

		stopProcessIfNeeded();

		if (bundleMustBeProcessedInLive(store.getContent().toString())) {
			liveProcessBundles.add(bundleId);
		}
		resourceBundleHandler.storeBundle(bundleId, store);
	}
599649
private void loadMoreData() {
        isLoading = true;
        Util.getClient()
                .getCloudItemsAsync(sourceId, currentPath, nextTokens.get(currentPath))
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(this);
    }
414696
def data_received(self, data):
        """"""
        if self._on_data:
            self._on_data(data)
            return
        self._queued_data.append(data)
602305
function getReaddirAttributes(bundle) {
		debugLS('in getReaddirAttributes');
		var defered = q.defer();
		self.iReadMultiple([
			'FILE_IO_NAME_READ_LEN',
			'FILE_IO_ATTRIBUTES',
			'FILE_IO_SIZE',
		])
		.then(function(results) {
			debugLS('in getReaddirAttributes res', results);
			results.forEach(function(result) {
				if(!result.isErr) {
					bundle[result.data.name] = result.data;
				}
			});
			// console.log("HERE!@'");
			// bundle.FILE_IO_NAME_READ_LEN = 0;
			defered.resolve(bundle);
		}, function(err) {
			debugLS('in getReaddirAttributes err', err);
			bundle.isError = true;
			bundle.errorStep = 'getReaddirAttributes';
			bundle.error = modbusMap.getErrorInfo(err);
			bundle.errorCode = err;
			defered.reject(bundle);
		});
		return defered.promise;
	}