Python config.load_shub_config函数代码示例

 def test_autocreate_empty_global_scrapinghub_yml(self):
     os.remove(self.globalpath)
     os.remove(self.globalscrapycfgpath)
     os.remove(self.netrcpath)
     load_shub_config()
     self.assertTrue(os.path.isfile(self.globalpath))
     with open(self.globalpath, 'r') as f:
         self.assertEqual(f.read(), "")

def cli():
    global_conf = load_shub_config(load_local=False, load_env=False)
    if 'default' in global_conf.apikeys:
        raise AlreadyLoggedInException

    conf = load_shub_config()
    key = _get_apikey(
        suggestion=conf.apikeys.get('default'),
        endpoint=global_conf.endpoints.get('default'),
    )
    with update_yaml_dict(GLOBAL_SCRAPINGHUB_YML_PATH) as conf:
        conf.setdefault('apikeys', {})
        conf['apikeys']['default'] = key

 def test_remove_key(self):
     GLOBAL_SH_YML = textwrap.dedent("""
         apikeys:
             default: LOGGED_IN_KEY
     """)
     with self.runner.isolated_filesystem():
         with open('.scrapinghub.yml', 'w') as f:
             f.write(GLOBAL_SH_YML)
         conf = config.load_shub_config()
         self.assertIn('default', conf.apikeys)
         self.runner.invoke(logout.cli)
         conf = config.load_shub_config()
         self.assertNotIn('default', conf.apikeys)

def build_cmd(target, version, skip_tests, no_cache, filename='Dockerfile'):
    config = load_shub_config()
    create_scrapinghub_yml_wizard(config, target=target, image=True)
    client = utils.get_docker_client()
    project_dir = utils.get_project_dir()
    image = config.get_image(target)
    image_name = utils.format_image_name(image, version)
    if not os.path.exists(os.path.join(project_dir, filename)):
        raise shub_exceptions.NotFoundException(
            "Dockerfile is not found and it is required because project '{}' is configured "
            "to deploy Docker images. Please add a Dockerfile that will be used to build "
            "the image and retry this command. If you want to migrate an existing Scrapy project "
            "you can use `shub image init` command to create a Dockerfile.".format(target))
    if utils.is_verbose():
        build_progress_cls = _LoggedBuildProgress
    else:
        build_progress_cls = _BuildProgress
    click.echo("Building {}.".format(image_name))
    events = client.build(
        path=project_dir,
        tag=image_name,
        decode=True,
        dockerfile=filename,
        nocache=no_cache
    )
    build_progress = build_progress_cls(events)
    build_progress.show()
    click.echo("The image {} build is completed.".format(image_name))
    # Test the image content after building it
    if not skip_tests:
        test_cmd(target, version)

def push_cmd(target, version, username, password, email, apikey, insecure, skip_tests):
    # Test the image content after building it
    if not skip_tests:
        test_cmd(target, version)

    client = utils.get_docker_client()
    config = load_shub_config()
    image = config.get_image(target)
    username, password = utils.get_credentials(
        username=username, password=password, insecure=insecure,
        apikey=apikey, target_apikey=config.get_apikey(target))

    if username:
        _execute_push_login(client, image, username, password, email)
    image_name = utils.format_image_name(image, version)
    click.echo("Pushing {} to the registry.".format(image_name))
    events = client.push(image_name, stream=True, decode=True,
                         insecure_registry=not bool(username))
    if utils.is_verbose():
        push_progress_cls = _LoggedPushProgress
    else:
        push_progress_cls = _PushProgress
    push_progress = push_progress_cls(events)
    push_progress.show()
    click.echo("The image {} pushed successfully.".format(image_name))

def deploy_cmd(target, version, debug, egg, build_egg, verbose, keep_log,
               conf=None):
    tmpdir = None
    try:
        if build_egg:
            egg, tmpdir = _build_egg()
            click.echo("Writing egg to %s" % build_egg)
            shutil.copyfile(egg, build_egg)
        else:
            conf = conf or load_shub_config()
            targetconf = conf.get_target_conf(target)
            version = version or targetconf.version
            auth = (targetconf.apikey, '')

            if egg:
                click.echo("Using egg: %s" % egg)
                egg = egg
            else:
                click.echo("Packing version %s" % version)
                egg, tmpdir = _build_egg()

            _upload_egg(targetconf.endpoint, egg, targetconf.project_id,
                        version, auth, verbose, keep_log, targetconf.stack,
                        targetconf.requirements_file, targetconf.eggs)
            click.echo("Run your spiders at: "
                       "https://app.scrapinghub.com/p/%s/"
                       "" % targetconf.project_id)
    finally:
        if tmpdir:
            if debug:
                click.echo("Output dir not removed: %s" % tmpdir)
            else:
                shutil.rmtree(tmpdir, ignore_errors=True)

def list_targets(ctx, param, value):
    if not value:
        return
    conf = load_shub_config()
    for name in conf.projects:
        click.echo(name)
    ctx.exit()

 def test_envvar_precedence(self):
     _old_environ = dict(os.environ)
     os.environ['SHUB_APIKEY'] = 'key_env'
     conf = load_shub_config()
     self.assertEqual(conf.get_apikey('shproj'), 'key_env')
     os.environ.clear()
     os.environ.update(_old_environ)

def cli():
    global_conf = load_shub_config(load_local=False, load_env=False)
    if 'default' not in global_conf.apikeys:
        click.echo("You are not logged in.")
        return 0

    with update_config() as conf:
        del conf['apikeys']['default']

def cli():
    global_conf = load_shub_config(load_local=False, load_env=False)
    if 'default' not in global_conf.apikeys:
        click.echo("You are not logged in.")
        return 0

    with update_yaml_dict(GLOBAL_SCRAPINGHUB_YML_PATH) as conf:
        del conf['apikeys']['default']

 def test_scrapinghub_ymls_read(self):
     conf = load_shub_config()
     self.assertEqual(conf.get_apikey('shproj'), 'key')
     self.assertEqual(
         conf.get_endpoint('externalproj'),
         'local_ext_endpoint',
     )
     self.assertEqual(conf.get_apikey('externalproj'), 'key_ext')
     with self.assertRaises(BadParameterException):
         conf.get_project_id('ext2')

def test_cmd(target, version):
    config = load_shub_config()
    image = config.get_image(target)
    version = version or config.get_version()
    image_name = utils.format_image_name(image, version)
    docker_client = utils.get_docker_client()
    for check in [_check_image_size,
                  _check_start_crawl_entry,
                  _check_shub_image_info_entry]:
        check(image_name, docker_client)

 def _check_conf():
     conf = load_shub_config()
     self.assertEqual(
         conf.get_target('default'),
         (222, 'scrapycfg_endpoint', 'key'),
     )
     self.assertEqual(
         conf.get_target('ext2'),
         (333, 'ext2_endpoint', 'ext2_key'),
     )
     self.assertEqual(conf.get_version(), 'ext2_ver')

 def _check_conf():
     conf = load_shub_config()
     self.assertEqual(
         conf.get_target('123'),
         (123, 'dotsc_endpoint', 'netrc_key'),
     )
     self.assertEqual(conf.projects['ext2'], 'ext2/333')
     self.assertEqual(
         conf.get_target('ext2'),
         (333, 'ext2_endpoint', 'ext2_key'),
     )

def list_cmd_full(target, silent, version):
    config = load_shub_config()
    image = config.get_image(target)
    version = version or config.get_version()
    image_name = utils.format_image_name(image, version)
    target_conf = config.get_target_conf(target)
    metadata = list_cmd(image_name,
                        target_conf.project_id,
                        target_conf.endpoint,
                        target_conf.apikey)
    for spider in metadata.get('spiders', []):
        click.echo(spider)