def _get_boards(installed=False): boards = PlatformManager().get_installed_boards() if not installed: know_boards = ["%s:%s" % (b['platform'], b['id']) for b in boards] for board in PlatformManager().get_registered_boards(): key = "%s:%s" % (board['platform'], board['id']) if key not in know_boards: boards.append(board) return boards
def _get_boards(installed=False): boards = PlatformManager().get_installed_boards() if not installed: know_boards = ["%s:%s" % (b['platform'], b['id']) for b in boards] try: for board in PlatformManager().get_registered_boards(): key = "%s:%s" % (board['platform'], board['id']) if key not in know_boards: boards.append(board) except InternetIsOffline: pass return sorted(boards, key=lambda b: b['name'])
def platform_list(json_output): platforms = [] pm = PlatformManager() for manifest in pm.get_installed(): p = PlatformFactory.newPlatform( pm.get_manifest_path(manifest['__pkg_dir'])) platforms.append({ "name": p.name, "title": p.title, "description": p.description, "version": p.version, "url": p.vendor_url, "packages": p.get_installed_packages().keys(), 'forDesktop': any([p.name.startswith(n) for n in ("native", "linux", "windows")]) }) if json_output: click.echo(json.dumps(platforms)) else: _print_platforms(platforms)
def _upgrade_to_3_0_0b11(ctx): current_platforms = [m['name'] for m in PlatformManager().get_installed()] if "espressif" not in current_platforms: return ctx.invoke(cmd_platform_install, platforms=["espressif8266"]) ctx.invoke(cmd_platform_uninstall, platforms=["espressif"])
def pytest_generate_tests(metafunc): if "pioproject_dir" not in metafunc.fixturenames: return examples_dirs = [] # repo examples examples_dirs.append(normpath(join(dirname(__file__), "..", "examples"))) # dev/platforms for manifest in PlatformManager().get_installed(): p = PlatformFactory.newPlatform(manifest['__pkg_dir']) if not p.is_embedded(): continue examples_dir = join(p.get_dir(), "examples") assert isdir(examples_dir) examples_dirs.append(examples_dir) project_dirs = [] for examples_dir in examples_dirs: platform_examples = [] for root, _, files in walk(examples_dir): if "platformio.ini" not in files or ".skiptest" in files: continue platform_examples.append(root) # test random 3 examples random.shuffle(platform_examples) project_dirs.extend(platform_examples[:3]) project_dirs.sort() metafunc.parametrize("pioproject_dir", project_dirs)
def pytest_generate_tests(metafunc): if "pioproject_dir" not in metafunc.fixturenames: return examples_dirs = [] # repo examples examples_dirs.append(normpath(join(dirname(__file__), "..", "examples"))) # dev/platforms for manifest in PlatformManager().get_installed(): p = PlatformFactory.newPlatform(manifest['__pkg_dir']) if not p.is_embedded(): continue # issue with "version `CXXABI_1.3.9' not found (required by sdcc)" if "linux" in util.get_systype() and p.name in ("intel_mcs51", "ststm8"): continue examples_dir = join(p.get_dir(), "examples") assert isdir(examples_dir) examples_dirs.append(examples_dir) project_dirs = [] for examples_dir in examples_dirs: platform_examples = [] for root, _, files in walk(examples_dir): if "platformio.ini" not in files or ".skiptest" in files: continue platform_examples.append(root) # test random 3 examples random.shuffle(platform_examples) project_dirs.extend(platform_examples[:3]) project_dirs.sort() metafunc.parametrize("pioproject_dir", project_dirs)
def _get_registry_platform_data( # pylint: disable=unused-argument platform, with_boards=True, expose_packages=True): _data = None for p in _get_registry_platforms(): if p["name"] == platform: _data = p break if not _data: return None data = dict( name=_data["name"], title=_data["title"], description=_data["description"], homepage=_data["homepage"], repository=_data["repository"], url=_data["url"], license=_data["license"], forDesktop=_data["forDesktop"], frameworks=_data["frameworks"], packages=_data["packages"], versions=_data["versions"], ) if with_boards: data["boards"] = [ board for board in PlatformManager().get_registered_boards() if board["platform"] == _data["name"] ] return data
def platform_uninstall(platforms): pm = PlatformManager() for platform in platforms: if pm.uninstall(platform): click.secho("The platform '%s' has been successfully " "uninstalled!" % platform, fg="green")
def _get_registry_platform_data( # pylint: disable=unused-argument platform, with_boards=True, expose_packages=True): _data = None for p in _get_registry_platforms(): if p['name'] == platform: _data = p break if not _data: return None data = dict(name=_data['name'], title=_data['title'], description=_data['description'], homepage=_data['homepage'], repository=_data['repository'], url=_data['url'], license=_data['license'], forDesktop=_data['forDesktop'], frameworks=_data['frameworks'], packages=_data['packages'], versions=_data['versions']) if with_boards: data['boards'] = [ board for board in PlatformManager().get_registered_boards() if board['platform'] == _data['name'] ] return data
def _install_dependent_platforms(ctx, platforms): installed_platforms = [p["name"] for p in PlatformManager().get_installed()] if set(platforms) <= set(installed_platforms): return ctx.invoke( cli_platform_install, platforms=list(set(platforms) - set(installed_platforms)) )
def get_project_examples(): result = [] for manifest in PlatformManager().get_installed(): examples_dir = join(manifest['__pkg_dir'], "examples") if not isdir(examples_dir): continue items = [] for project_dir, _, __ in os.walk(examples_dir): project_description = None try: config = ProjectConfig(join(project_dir, "platformio.ini")) config.validate(silent=True) project_description = config.get("platformio", "description") except exception.PlatformIOProjectException: continue path_tokens = project_dir.split(sep) items.append({ "name": "/".join(path_tokens[path_tokens.index("examples") + 1:]), "path": project_dir, "description": project_description }) result.append({ "platform": { "title": manifest['title'], "version": manifest['version'] }, "items": sorted(items, key=lambda item: item['name']) }) return sorted(result, key=lambda data: data['platform']['title'])
def check_internal_updates(ctx, what): last_check = app.get_state_item("last_check", {}) interval = int(app.get_setting("check_%s_interval" % what)) * 3600 * 24 if (time() - interval) < last_check.get(what + "_update", 0): return last_check[what + '_update'] = int(time()) app.set_state_item("last_check", last_check) pm = PlatformManager() if what == "platforms" else LibraryManager() outdated_items = [] for manifest in pm.get_installed(): if manifest['name'] not in outdated_items and \ pm.is_outdated(manifest['name']): outdated_items.append(manifest['name']) if not outdated_items: return terminal_width, _ = click.get_terminal_size() click.echo("") click.echo("*" * terminal_width) click.secho("There are the new updates for %s (%s)" % (what, ", ".join(outdated_items)), fg="yellow") if not app.get_setting("auto_update_" + what): click.secho("Please update them via ", fg="yellow", nl=False) click.secho("`platformio %s update`" % ("lib --global" if what == "libraries" else "platform"), fg="cyan", nl=False) click.secho(" command.\n", fg="yellow") click.secho( "If you want to manually check for the new versions " "without updating, please use ", fg="yellow", nl=False) click.secho("`platformio %s update --only-check`" % ("lib --global" if what == "libraries" else "platform"), fg="cyan", nl=False) click.secho(" command.", fg="yellow") else: click.secho("Please wait while updating %s ..." % what, fg="yellow") if what == "platforms": ctx.invoke(cmd_platform_update, platforms=outdated_items) elif what == "libraries": ctx.obj = pm ctx.invoke(cmd_lib_update, libraries=outdated_items) click.echo() telemetry.on_event(category="Auto", action="Update", label=what.title()) click.echo("*" * terminal_width) click.echo("")
def after_upgrade(ctx): last_version = app.get_state_item("last_version", "0.0.0") if last_version == __version__: return if last_version == "0.0.0": app.set_state_item("last_version", __version__) else: click.secho("Please wait while upgrading PlatformIO ...", fg="yellow") clean_cache() u = Upgrader(last_version, __version__) if u.run(ctx): app.set_state_item("last_version", __version__) # update development platforms pm = PlatformManager() for manifest in pm.get_installed(): # pm.update(manifest['name'], "^" + manifest['version']) pm.update(manifest['name']) # update PlatformIO Plus tool if installed pioplus_update() click.secho("PlatformIO has been successfully upgraded to %s!\n" % __version__, fg="green") telemetry.on_event(category="Auto", action="Upgrade", label="%s > %s" % (last_version, __version__)) else: raise exception.UpgradeError("Auto upgrading...") click.echo("") # PlatformIO banner terminal_width, _ = click.get_terminal_size() click.echo("*" * terminal_width) click.echo("If you like %s, please:" % (click.style("PlatformIO", fg="cyan"))) click.echo("- %s us on Twitter to stay up-to-date " "on the latest project news > %s" % (click.style("follow", fg="cyan"), click.style("https://twitter.com/PlatformIO_Org", fg="cyan"))) click.echo( "- %s it on GitHub > %s" % (click.style("star", fg="cyan"), click.style("https://github.com/platformio/platformio", fg="cyan"))) if not getenv("PLATFORMIO_IDE"): click.echo( "- %s PlatformIO IDE for IoT development > %s" % (click.style("try", fg="cyan"), click.style("http://platformio.org/platformio-ide", fg="cyan"))) if not util.is_ci(): click.echo("- %s us with PlatformIO Plus > %s" % (click.style("support", fg="cyan"), click.style("https://pioplus.com", fg="cyan"))) click.echo("*" * terminal_width) click.echo("")
def platform_update(platforms, only_packages, only_check): pm = PlatformManager() if not platforms: platforms = set([m['name'] for m in pm.get_installed()]) for platform in platforms: click.echo("Platform %s" % click.style(platform, fg="cyan")) click.echo("--------") pm.update(platform, only_packages=only_packages, only_check=only_check) click.echo()
def validate_boards(ctx, param, value): # pylint: disable=W0613 pm = PlatformManager() for id_ in value: try: pm.board_config(id_) except exception.UnknownBoard: raise click.BadParameter( "`%s`. Please search for board ID using `platformio boards` " "command" % id_) return value
def _get_installed_platform_data(platform, with_boards=True, expose_packages=True): p = PlatformFactory.newPlatform(platform) data = dict( name=p.name, title=p.title, description=p.description, version=p.version, homepage=p.homepage, repository=p.repository_url, url=p.vendor_url, docs=p.docs_url, license=p.license, forDesktop=not p.is_embedded(), frameworks=sorted(list(p.frameworks) if p.frameworks else []), packages=list(p.packages) if p.packages else [], ) # if dump to API # del data['version'] # return data # overwrite VCS version and add extra fields manifest = PlatformManager().load_manifest(dirname(p.manifest_path)) assert manifest for key in manifest: if key == "version" or key.startswith("__"): data[key] = manifest[key] if with_boards: data["boards"] = [c.get_brief_data() for c in p.get_boards().values()] if not data["packages"] or not expose_packages: return data data["packages"] = [] installed_pkgs = p.get_installed_packages() for name, opts in p.packages.items(): item = dict( name=name, type=p.get_package_type(name), requirements=opts.get("version"), optional=opts.get("optional") is True, ) if name in installed_pkgs: for key, value in installed_pkgs[name].items(): if key not in ("url", "version", "description"): continue item[key] = value if key == "version": item["originalVersion"] = util.get_original_version(value) data["packages"].append(item) return data
def platform_install(platforms, with_package, without_package, skip_default_package): pm = PlatformManager() for platform in platforms: if pm.install(name=platform, with_packages=with_package, without_packages=without_package, skip_default_package=skip_default_package): click.secho("The platform '%s' has been successfully installed!\n" "The rest of packages will be installed automatically " "depending on your build environment." % platform, fg="green")
def fill_project_envs( # pylint: disable=too-many-arguments,too-many-locals ctx, project_dir, board_ids, project_option, env_prefix, force_download): installed_boards = PlatformManager().get_installed_boards() content = [] used_boards = [] used_platforms = [] config = util.load_project_config(project_dir) for section in config.sections(): if not all( [section.startswith("env:"), config.has_option(section, "board")]): continue used_boards.append(config.get(section, "board")) for id_ in board_ids: manifest = None for boards in (installed_boards, PlatformManager.get_registered_boards()): for b in boards: if b['id'] == id_: manifest = b break assert manifest is not None used_platforms.append(manifest['platform']) if id_ in used_boards: continue used_boards.append(id_) content.append("") content.append("[env:%s%s]" % (env_prefix, id_)) content.append("platform = %s" % manifest['platform']) # find default framework for board frameworks = manifest.get("frameworks") if frameworks: content.append("framework = %s" % frameworks[0]) content.append("board = %s" % id_) if project_option: content.extend(project_option) if force_download and used_platforms: _install_dependent_platforms(ctx, used_platforms) if not content: return with open(join(project_dir, "platformio.ini"), "a") as f: content.append("") f.write("\n".join(content))
def platform_list(json_output): platforms = [] pm = PlatformManager() for manifest in pm.get_installed(): platforms.append( _get_installed_platform_data(manifest['__pkg_dir'], with_boards=False, expose_packages=False)) if json_output: click.echo(json.dumps(platforms)) else: _print_platforms(platforms)
def platform_list(json_output): platforms = [] pm = PlatformManager() for manifest in pm.get_installed(): platforms.append( _get_installed_platform_data(manifest["__pkg_dir"], with_boards=False, expose_packages=False)) platforms = sorted(platforms, key=lambda manifest: manifest["name"]) if json_output: click.echo(dump_json_to_unicode(platforms)) else: _print_platforms(platforms)
def fill_project_envs(ctx, project_dir, board_ids, project_option, env_prefix, force_download): content = [] used_boards = [] used_platforms = [] config = util.load_project_config(project_dir) for section in config.sections(): cond = [ section.startswith("env:"), config.has_option(section, "board") ] if all(cond): used_boards.append(config.get(section, "board")) pm = PlatformManager() for id_ in board_ids: board_config = pm.board_config(id_) used_platforms.append(board_config['platform']) if id_ in used_boards: continue used_boards.append(id_) envopts = {"platform": board_config['platform'], "board": id_} # find default framework for board frameworks = board_config.get("frameworks") if frameworks: envopts['framework'] = frameworks[0] for item in project_option: if "=" not in item: continue _name, _value = item.split("=", 1) envopts[_name.strip()] = _value.strip() content.append("") content.append("[env:%s%s]" % (env_prefix, id_)) for name, value in envopts.items(): content.append("%s = %s" % (name, value)) if force_download and used_platforms: _install_dependent_platforms(ctx, used_platforms) if not content: return with open(join(project_dir, "platformio.ini"), "a") as f: content.append("") f.write("\n".join(content))
def validate_boards(ctx, param, value): # pylint: disable=W0613 pm = PlatformManager() # check installed boards known_boards = set([b['id'] for b in pm.get_installed_boards()]) # if boards are not listed as installed, check registered boards if set(value) - known_boards: known_boards = set([b['id'] for b in pm.get_registered_boards()]) unknown_boards = set(value) - known_boards try: assert not unknown_boards return value except AssertionError: raise click.BadParameter("%s. Please search for the board ID using " "`platformio boards` command" % ", ".join(unknown_boards))
def fill_project_envs(ctx, project_dir, board_ids, project_option, env_prefix, force_download): config = ProjectConfig(join(project_dir, "platformio.ini"), parse_extra=False) used_boards = [] for section in config.sections(): cond = [ section.startswith("env:"), config.has_option(section, "board") ] if all(cond): used_boards.append(config.get(section, "board")) pm = PlatformManager() used_platforms = [] modified = False for id_ in board_ids: board_config = pm.board_config(id_) used_platforms.append(board_config['platform']) if id_ in used_boards: continue used_boards.append(id_) modified = True envopts = {"platform": board_config['platform'], "board": id_} # find default framework for board frameworks = board_config.get("frameworks") if frameworks: envopts['framework'] = frameworks[0] for item in project_option: if "=" not in item: continue _name, _value = item.split("=", 1) envopts[_name.strip()] = _value.strip() section = "env:%s%s" % (env_prefix, id_) config.add_section(section) for option, value in envopts.items(): config.set(section, option, value) if force_download and used_platforms: _install_dependent_platforms(ctx, used_platforms) if modified: config.save() config.reset_instances()
def get_builtin_libs(storage_names=None): items = [] storage_names = storage_names or [] pm = PlatformManager() for manifest in pm.get_installed(): p = PlatformFactory.newPlatform(manifest['__pkg_dir']) for storage in p.get_lib_storages(): if storage_names and storage['name'] not in storage_names: continue lm = LibraryManager(storage['path']) items.append({ "name": storage['name'], "path": storage['path'], "items": lm.get_installed() }) return items
def platform_update( # pylint: disable=too-many-locals platforms, only_packages, only_check, dry_run, json_output): pm = PlatformManager() pkg_dir_to_name = {} if not platforms: platforms = [] for manifest in pm.get_installed(): platforms.append(manifest["__pkg_dir"]) pkg_dir_to_name[manifest["__pkg_dir"]] = manifest.get( "title", manifest["name"]) only_check = dry_run or only_check if only_check and json_output: result = [] for platform in platforms: pkg_dir = platform if isdir(platform) else None requirements = None url = None if not pkg_dir: name, requirements, url = pm.parse_pkg_uri(platform) pkg_dir = pm.get_package_dir(name, requirements, url) if not pkg_dir: continue latest = pm.outdated(pkg_dir, requirements) if (not latest and not PlatformFactory.newPlatform( pkg_dir).are_outdated_packages()): continue data = _get_installed_platform_data(pkg_dir, with_boards=False, expose_packages=False) if latest: data["versionLatest"] = latest result.append(data) return click.echo(dump_json_to_unicode(result)) # cleanup cached board and platform lists app.clean_cache() for platform in platforms: click.echo( "Platform %s" % click.style(pkg_dir_to_name.get(platform, platform), fg="cyan")) click.echo("--------") pm.update(platform, only_packages=only_packages, only_check=only_check) click.echo() return True
def pytest_generate_tests(metafunc): if "pioproject_dir" not in metafunc.fixturenames: return examples_dirs = [] # repo examples examples_dirs.append(normpath(join(dirname(__file__), "..", "examples"))) # dev/platforms for manifest in PlatformManager().get_installed(): p = PlatformFactory.newPlatform(manifest["__pkg_dir"]) ignore_conds = [ not p.is_embedded(), p.name == "ststm8", # issue with "version `CXXABI_1.3.9' not found (required by sdcc)" "linux" in util.get_systype() and p.name == "intel_mcs51", ] if any(ignore_conds): continue examples_dir = join(p.get_dir(), "examples") assert isdir(examples_dir) examples_dirs.append(examples_dir) project_dirs = [] for examples_dir in examples_dirs: candidates = {} for root, _, files in walk(examples_dir): if "platformio.ini" not in files or ".skiptest" in files: continue if "zephyr-" in root and PY2: continue group = basename(root) if "-" in group: group = group.split("-", 1)[0] if group not in candidates: candidates[group] = [] candidates[group].append(root) project_dirs.extend([ random.choice(examples) for examples in candidates.values() if examples ]) metafunc.parametrize("pioproject_dir", sorted(project_dirs))
def platform_update(platforms, only_packages, only_check, json_output): pm = PlatformManager() pkg_dir_to_name = {} if not platforms: platforms = [] for manifest in pm.get_installed(): platforms.append(manifest['__pkg_dir']) pkg_dir_to_name[manifest['__pkg_dir']] = manifest.get( "title", manifest['name']) if only_check and json_output: result = [] for platform in platforms: pkg_dir = platform if isdir(platform) else None requirements = None url = None if not pkg_dir: name, requirements, url = pm.parse_pkg_input(platform) pkg_dir = pm.get_package_dir(name, requirements, url) if not pkg_dir: continue latest = pm.outdated(pkg_dir, requirements) if (not latest and not PlatformFactory.newPlatform( pkg_dir).are_outdated_packages()): continue data = _get_installed_platform_data(pkg_dir, with_boards=False, expose_packages=False) if latest: data['versionLatest'] = latest result.append(data) return click.echo(json.dumps(result)) else: # cleanup cached board and platform lists app.clean_cache() for platform in platforms: click.echo("Platform %s" % click.style( pkg_dir_to_name.get(platform, platform), fg="cyan")) click.echo("--------") pm.update(platform, only_packages=only_packages, only_check=only_check) click.echo()
def test_check_platform_updates(clirunner, validate_cliresult, isolated_pio_home): # install obsolete platform result = clirunner.invoke(cli_pio, ["platform", "install", "native"]) validate_cliresult(result) manifest_path = isolated_pio_home.join("platforms", "native", "platform.json") manifest = json.loads(manifest_path.read()) manifest['version'] = "0.0.0" manifest_path.write(json.dumps(manifest)) # reset cached manifests PlatformManager().cache_reset() # reset check time interval = int(app.get_setting("check_platforms_interval")) * 3600 * 24 last_check = {"platforms_update": time() - interval - 1} app.set_state_item("last_check", last_check) result = clirunner.invoke(cli_pio, ["platform", "list"]) validate_cliresult(result) assert "There are the new updates for platforms (native)" in result.output
def get_project_examples(): result = [] for manifest in PlatformManager().get_installed(): examples_dir = os.path.join(manifest["__pkg_dir"], "examples") if not os.path.isdir(examples_dir): continue items = [] for project_dir, _, __ in os.walk(examples_dir): project_description = None try: config = ProjectConfig( os.path.join(project_dir, "platformio.ini")) config.validate(silent=True) project_description = config.get("platformio", "description") except ProjectError: continue path_tokens = project_dir.split(os.path.sep) items.append({ "name": "/".join(path_tokens[path_tokens.index("examples") + 1:]), "path": project_dir, "description": project_description, }) result.append({ "platform": { "title": manifest["title"], "version": manifest["version"], }, "items": sorted(items, key=lambda item: item["name"]), }) return sorted(result, key=lambda data: data["platform"]["title"])
def platform_install( # pylint: disable=too-many-arguments platforms, with_package, without_package, skip_default_package, with_all_packages, force, ): pm = PlatformManager() for platform in platforms: if pm.install( name=platform, with_packages=with_package, without_packages=without_package, skip_default_package=skip_default_package, with_all_packages=with_all_packages, force=force, ): click.secho( "The platform '%s' has been successfully installed!\n" "The rest of packages will be installed automatically " "depending on your build environment." % platform, fg="green", )