Publish to the cheeseshop.
5313
def publish(ctx, test=False):
    """"""
    clean(ctx)
    if test:
        run('python setup.py register -r test sdist bdist_wheel', echo=True)
        run('twine upload dist/* -r test', echo=True)
    else:
        run('python setup.py register sdist bdist_wheel', echo=True)
        run('twine upload dist/*', echo=True)
751579
def publish(self, msg):
        
        self.pub.send("{} {}".format(self.name, msg))
        log.debug('Published message from {}'.format(self))
1297824
def publish(self):
        ''''''
        if self.config.publish:
            logger.info('Publish')
            self.execute(self.config.publish)
82969
public void open() {
		Futures.transform(lcm, new Subscribe(subscriber));
		publishTask = Futures.transform(lcm, publisher);
	}
859014
protected function triggerPublish()
    {
        $this->info('Starting publishing vendor assets.');
        $this->call('vendor:publish');
        $this->info('Publishing vendor assets finished.');

        // Reload config
        $this->laravel['Illuminate\Foundation\Bootstrap\LoadConfiguration']->bootstrap($this->laravel);
    }
769106
def publish(self):
        """"""
        with db.session.begin_nested():
            deposit = self.deposit_class.create(self.metadata)
            deposit['_deposit']['created_by'] = self.event.user_id
            deposit['_deposit']['owners'] = [self.event.user_id]

            # Fetch the deposit files
            for key, url in self.files:
                deposit.files[key] = self.gh.api.session.get(
                    url, stream=True).raw

            deposit.publish()
            recid, record = deposit.fetch_published()
            self.model.recordmetadata = record.model
1339415
def publish(self, message):
        
        if self._stopping:
            return
        self._logger.info("publishing\t%s" % message)
        properties = pika.BasicProperties(content_type=self._content_type,
                                          delivery_mode=1)

        self._channel.basic_publish(self._exchange,
                                    self._routing_key,
                                    message,
                                    properties)
1241741
def _publish(self, obj):
        '''
        
        '''
        bin_obj = umsgpack.packb(obj)
        self.pub.send(bin_obj)
777865
def publish (self):
        '''
         
        '''
        self.lock.acquire()
        tw = cmdvel2Twist(self.data)
        self.lock.release()
        self.pub.publish(tw)
621604
def publish_synchronous(self, *args, **kwargs):
        '''
        
        '''
        cb = kwargs.pop('cb', None)
        self.tx.select()
        self.basic.publish(*args, **kwargs)
        self.tx.commit(cb=cb)
132499
def send(self, message_data, delivery_mode=None):
        """"""
        self.publisher.send(message_data, delivery_mode=delivery_mode)
1160401
def publish(self,  cat, **kwargs):
                
                res=request.publish_cat1("POST", self.con, self.token,  cat, kwargs)    
                return res
286069
def publish(build_entry: dict):
    """"""
    for tag in build_entry['tags']:
        print('[PUSHING]:', tag)
        os.system('docker push {}'.format(tag))
327100
async def _publish(self, model, path):
        """"""
        if model['type'] != 'notebook':
            raise web.HTTPError(400, "bookstore only publishes notebooks")
        content = model['content']

        full_s3_path = s3_path(
            self.bookstore_settings.s3_bucket, self.bookstore_settings.published_prefix, path
        )
        file_key = s3_key(self.bookstore_settings.published_prefix, path)

        self.log.info(
            "Publishing to %s",
            s3_display_path(
                self.bookstore_settings.s3_bucket, self.bookstore_settings.published_prefix, path
            ),
        )

        async with self.session.create_client(
            's3',
            aws_secret_access_key=self.bookstore_settings.s3_secret_access_key,
            aws_access_key_id=self.bookstore_settings.s3_access_key_id,
            endpoint_url=self.bookstore_settings.s3_endpoint_url,
            region_name=self.bookstore_settings.s3_region_name,
        ) as client:
            self.log.info("Processing published write of %s", path)
            obj = await client.put_object(
                Bucket=self.bookstore_settings.s3_bucket, Key=file_key, Body=json.dumps(content)
            )
            self.log.info("Done with published write of %s", path)

        self.set_status(201)

        resp_content = {"s3path": full_s3_path}

        if 'VersionId' in obj:
            resp_content["versionID"] = obj['VersionId']

        resp_str = json.dumps(resp_content)
        self.finish(resp_str)
525737
function (next) {

									minify(
										outputJsFile,
										_.extend({optimize: true},uglifyOptions),
										function(err){
											if ( err ){
												return next(err);
											}

											if ( isForPublish ){
												publisher(
													outputJsFile,
													function (err) {
														return next(err);
													},
													options.forceminified
												);
											}else {
												return next();
											}

										}
									);

								}
1189539
def publish(self):
        
        if self.published is False:
            self.published = True
        else:
            raise Warning(self.title + ' is already published.')
815771
def publish (self):
        '''
         
        '''
        self.lock.acquire()
        tw = cmdvel2Twist(self.vel)
        self.lock.release()
        if (self.jdrc.getState() == "flying"):
            self.pub.publish(tw)