Registers a pusher to be used for pushing statistics to various remotes/locals.

        :param Pusher|list[Pusher] pusher:
160574
def register_stats_pusher(self, pusher):
        
        for pusher in listify(pusher):
            self._set('stats-push', pusher, multi=True)

        return self._section
507178
def push(self, buf):
        
        self._src.emit('push-buffer', Gst.Buffer.new_wrapped(buf))
974852
def register(self, locator, factory):
        
        if locator == None:
            raise Exception("Locator cannot be null")
        if factory == None:
            raise Exception("Factory cannot be null")

        self._registrations.append(Registration(locator, factory))
123595
def register_converter(self, converter, conv_type, conv_format=None):
        
        self.flask_plugin.register_converter(converter, conv_type, conv_format)
511064
def register(self, prefix, viewset, base_name=None, router_class=None):
        
        if base_name is None:
            base_name = self.get_default_base_name(viewset)

        if router_class is not None:
            kwargs = {'trailing_slash': bool(self.trailing_slash)}
            single_object_router_classes = (
                AuthenticationRouter, SingleObjectRouter)

            if issubclass(router_class, single_object_router_classes):
                router = router_class(**kwargs)
                router.register(prefix, viewset, base_name=base_name)
                self._single_object_registry.append(router)

        else:
            self.registry.append((prefix, viewset, base_name))
650933
def push_plugin(self, name):
        
        url = self._url('/plugins/{0}/pull', name)

        headers = {}
        registry, repo_name = auth.resolve_repository_name(name)
        header = auth.get_config_header(self, registry)
        if header:
            headers['X-Registry-Auth'] = header
        res = self._post(url, headers=headers)
        self._raise_for_status(res)
        return self._stream_helper(res, decode=True)
404704
public function boot()
    {
        $this->app->when(PusherChannel::class)
            ->needs(Pusher::class)
            ->give(function () {
                $pusherConfig = config('broadcasting.connections.pusher');

                return new Pusher(
                    $pusherConfig['key'],
                    $pusherConfig['secret'],
                    $pusherConfig['app_id']
                );
            });
    }
720289
def registerHandler(self, matcher, handler):
        '''
        
        '''
        self.handlers[matcher] = handler
        self.scheduler.register((matcher,), self)
        self._setDaemon()
207172
protected void registerForPostCommit(MultiMEProxyHandler proxyHandler,
                                       DestinationHandler destination, 
                                       PubSubOutputHandler handler,
                                       Neighbour neighbour)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "registerForPostCommit", 
        new Object[] { proxyHandler, destination, handler, neighbour });

    _proxyHandler = proxyHandler;
    _destination = destination;
    _handler = handler;
    _neighbour = neighbour;
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "registerForPostCommit");
  }
1307596
def _pusher_connect_handler(self, data):
        
        self.channel = self.pusher.subscribe(self.pos_callback_chan)
        for listener in self.pusher_connected_listeners:
            listener(data)
258612
def register(self, collector):
        
        if not isinstance(collector, Collector):
            raise TypeError(
                "Can't register instance, not a valid type of collector")

        if collector.name in self.collectors:
            raise ValueError("Collector already exists or name colision")

        with mutex:
            self.collectors[collector.name] = collector
336716
def register_producer(cls, producer):
        
        log.info('@Registry.register_producer `{}`'
                 .format(producer.__class__.__name__))
        cls._producer = (cls._producer or producer)
1175956
def register_payload(self, *payloads, flavour: ModuleType):
        """"""
        for payload in payloads:
            self._logger.debug('registering payload %s (%s)', NameRepr(payload), NameRepr(flavour))
            self.runners[flavour].register_payload(payload)
749489
def push(self, local: _PATH = 'LICENSE', remote: _PATH = '/sdcard/LICENSE') -> None:
        ''''''
        if not os.path.exists(local):
            raise FileNotFoundError(f'Local {local!r} does not exist.')
        self._execute('-s', self.device_sn, 'push', local, remote)
52804
public void registerReceiver (InvocationDecoder decoder)
    {
        // add the receiver to the list
        _reclist.add(decoder);

        // if we're already online, assign a receiver id to this decoder
        if (_clobj != null) {
            assignReceiverId(decoder);
        }
    }
44902
def __register_driver(self, channel, webdriver):
        ""

        # Add to list of webdrivers to cleanup.
        if not self.__registered_drivers.has_key(channel):
            self.__registered_drivers[channel] = []  # set to new empty array

        self.__registered_drivers[channel].append(webdriver)

        # Set singleton instance for the channel
        self.__webdriver[channel] = webdriver
927657
public void push(CollectorRegistry registry) throws IOException {
    Socket s = new Socket(host, port);
    BufferedWriter writer = new BufferedWriter(new PrintWriter(s.getOutputStream()));
    Matcher m = INVALID_GRAPHITE_CHARS.matcher("");
    long now = System.currentTimeMillis() / 1000;
    for (Collector.MetricFamilySamples metricFamilySamples: Collections.list(registry.metricFamilySamples())) {
      for (Collector.MetricFamilySamples.Sample sample: metricFamilySamples.samples) {
        m.reset(sample.name);
        writer.write(m.replaceAll("_"));
        for (int i = 0; i < sample.labelNames.size(); ++i) {
          m.reset(sample.labelValues.get(i));
          writer.write("." + sample.labelNames.get(i) + "." + m.replaceAll("_"));
        }
        writer.write(" " + sample.value + " " + now + "\n");
      }
    }
    writer.close();
    s.close();
  }