Register release (packages) in artifact-store/repository.
8731
def register_packages(ctx, repo=None, dry_run=False):
    """"""
    original_ctx = ctx
    if repo is None:
        repo = ctx.project.repo or "pypi"
    if dry_run:
        ctx = DryRunContext(ctx)

    packages = ensure_packages_exist(original_ctx)
    print_packages(packages)
    for artifact in packages:
        ctx.run("twine register --repository={repo} {artifact}".format(
                artifact=artifact, repo=repo))
1124313
public function register()
    {
        $this->app->bindShared('packages', function ($app)
        {
            $repository = new Repository($app['config'], $app['files']);

            return new PackageManager($app, $repository);
        });
    }
1031164
protected function registerViewPublisher(): void
    {
        $this->app->singleton('view.publisher', function (Application $app) {
            $viewPath = $app->basePath().'/resources/views';

            // Once we have created the view publisher, we will set the default packages
            // path on this object so that it knows where to find all of the packages
            // that are installed for the application and can move them to the app.
            $publisher = new View($app->make('files'), $viewPath);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
957490
function createRelease(version) {
      if(version) {
        releaseOptions.target_commitish = version;
      }
      github.repos.createRelease(releaseOptions, function() {
        nextRepo();
      });
    }
606824
def freeze():
    """"""
    echo_waiting('Verifying collected packages...')
    catalog, errors = make_catalog()
    if errors:
        for error in errors:
            echo_failure(error)
        abort()

    static_file = get_agent_requirements()

    echo_info('Static file: {}'.format(static_file))

    pre_packages = list(read_packages(static_file))

    catalog.write_packages(static_file)

    post_packages = list(read_packages(static_file))
    display_package_changes(pre_packages, post_packages)
659769
def _add_apt_repository(spec):
    
    if '{series}' in spec:
        series = get_distrib_codename()
        spec = spec.replace('{series}', series)
    # software-properties package for bionic properly reacts to proxy settings
    # passed as environment variables (See lp:1433761). This is not the case
    # LTS and non-LTS releases below bionic.
    _run_with_retries(['add-apt-repository', '--yes', spec],
                      cmd_env=env_proxy_settings(['https']))
976855
private function registerSidebarPackage()
    {
        $this->registerProvider(SidebarServiceProvider::class);

        $this->alias('Sidebar', \Arcanesoft\Sidebar\Facades\Sidebar::class);
    }
886764
public static function register()
    {
        \Deployer\set('release_path_app', function () { return ReleaseConfig::getReleasePathAppDir(); });
        \Deployer\set('shared_path_app', function () { return ReleaseConfig::getSharedPathAppDir(); });

        \Deployer\set('release_name', function () { return GetReleasesNameService::execute(); });
        \Deployer\set('releases_list', function () { return GetReleasesListService::execute(); });
    }
149115
public void deploy(RemoteRepository target, Artifact ... artifacts) throws DeploymentException {
        deploy(target, null, Arrays.asList(artifacts));
    }
1246336
def register_target(repo_cmd, repo_service):
    """"""
    def decorate(klass):
        log.debug('Loading service module class: {}'.format(klass.__name__) )
        klass.command = repo_cmd
        klass.name = repo_service
        RepositoryService.service_map[repo_service] = klass
        RepositoryService.command_map[repo_cmd] = repo_service
        return klass
    return decorate
12212
def register_target_artifact_metadata(self, target: str, metadata: dict):
        """"""
        with self.context_lock:
            self.artifacts_metadata[target.name] = metadata
448034
def release(path, repository):
    """"""
    upgrader = InvenioUpgrader()
    logger = upgrader.get_logger()

    try:
        endpoints = upgrader.find_endpoints()

        if not endpoints:
            logger.error("No upgrades found.")
            click.Abort()

        depends_on = []
        for repo, upgrades in endpoints.items():
            depends_on.extend(upgrades)

        return recipe(path,
                      repository=repository,
                      depends_on=depends_on,
                      release=True,
                      output_path=output_path)

    except RuntimeError as e:
        for msg in e.args:
            logger.error(unicode(msg))
        raise
742040
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/Storage/migrations' => database_path('migrations'),
            ], 'telescope-migrations');

            $this->publishes([
                __DIR__.'/../public' => public_path('vendor/telescope'),
            ], 'telescope-assets');

            $this->publishes([
                __DIR__.'/../config/telescope.php' => config_path('telescope.php'),
            ], 'telescope-config');

            $this->publishes([
                __DIR__.'/../stubs/TelescopeServiceProvider.stub' => app_path('Providers/TelescopeServiceProvider.php'),
            ], 'telescope-provider');
        }
    }
1353195
protected function registerPublishes(): void
    {
        if ($this->app->runningInConsole()) {
            $migrationsPath = __DIR__ . '/../../database/migrations';

            $this->publishes([
                $migrationsPath => database_path('migrations'),
            ], 'migrations');

            $this->loadMigrationsFrom($migrationsPath);
        }
    }
1264705
protected function registerRepository()
    {
        $this->app->singleton(RepositoryContract::class, function (Container $container) {
            $config = $container->make(ConfigRepository::class);
            $guard  = $container->make(Guard::class);
            $cache  = $container->make(CacheFactory::class)->store($config->get('vi-kon.db-config.cache'));

            return new Repository($guard, $cache);
        });

        $this->app->alias(RepositoryContract::class, 'config.db');
    }
753535
private function registerSettingsPackage()
    {
        $this->registerProvider(SettingsServiceProvider::class);

        $this->alias('Settings', \Arcanedev\LaravelSettings\Facades\Settings::class);
    }
544935
def process_package(self, package_name):
        

        metadata = super(ArtifactRegistry, self).process_package(package_name)
        if metadata:
            self.update_artifact_metadata(package_name, metadata)