platformio/platformio-core
1
0
Fork 1
mirror of https://github.com/platformio/platformio-core.git synced 2025-07-29 17:47:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Refactor platform-related calls to PlatformFactory.from_env

Browse Source
This commit is contained in:
Ivan Kravets
2023-07-12 18:28:20 +03:00
parent 39b61d50e6
commit db8f027f30
12 changed files with 57 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
platformio/builder/main.py
View File

@ -38,7 +38,6 @@ AllowSubstExceptions(NameError)
# append CLI arguments to build environment
clivars = Variables(None)
clivars.AddVariables(
("PLATFORM_MANIFEST",),
("BUILD_SCRIPT",),
("PROJECT_CONFIG",),
("PIOENV",),

4
platformio/builder/tools/pioplatform.py
View File

@ -33,9 +33,7 @@ from platformio.project.config import ProjectOptions
@util.memoized()
def _PioPlatform():
env = DefaultEnvironment()
p = PlatformFactory.new(os.path.dirname(env["PLATFORM_MANIFEST"]))
p.configure_project_packages(env["PIOENV"], COMMAND_LINE_TARGETS)
return p
return PlatformFactory.from_env(env["PIOENV"], targets=COMMAND_LINE_TARGETS)
def PioPlatform(_):

4
platformio/debug/cli.py
View File

@ -109,9 +109,7 @@ def cli(
def _configure(ctx, project_config, env_name, load_mode, verbose, __unprocessed):
platform = PlatformFactory.new(
project_config.get(f"env:{env_name}", "platform"), autoinstall=True
)
platform = PlatformFactory.from_env(env_name, autoinstall=True)
debug_config = DebugConfigFactory.new(
platform,
project_config,

2
platformio/package/commands/install.py
View File

@ -206,7 +206,7 @@ def _install_project_env_libraries(project_env, options):
config = ProjectConfig.get_instance()
compatibility_qualifiers = {}
if config.get(f"env:{project_env}", "platform"):
if config.get(f"env:{project_env}", "platform", None):
try:
p = PlatformFactory.new(config.get(f"env:{project_env}", "platform"))
compatibility_qualifiers["platforms"] = [p.name]

21
platformio/package/commands/list.py
View File

@ -22,6 +22,7 @@ from platformio.package.manager.library import LibraryPackageManager
from platformio.package.manager.platform import PlatformPackageManager
from platformio.package.manager.tool import ToolPackageManager
from platformio.package.meta import PackageItem, PackageSpec
from platformio.platform.exception import UnknownPlatform
from platformio.platform.factory import PlatformFactory
from platformio.project.config import ProjectConfig
@ -187,20 +188,20 @@ def list_project_packages(options):
def print_project_env_platform_packages(project_env, options):
config = ProjectConfig.get_instance()
platform = config.get(f"env:{project_env}", "platform")
if not platform:
return None
pkg = PlatformPackageManager().get_package(platform)
if not pkg:
try:
p = PlatformFactory.from_env(project_env)
except UnknownPlatform:
return None
click.echo(
"Platform %s"
% (humanize_package(pkg, platform, verbose=options.get("verbose")))
% (
humanize_package(
PlatformPackageManager().get_package(p.get_dir()),
p.config.get(f"env:{project_env}", "platform"),
verbose=options.get("verbose"),
)
)
)
p = PlatformFactory.new(pkg)
if project_env:
p.configure_project_packages(project_env)
print_dependency_tree(
p.pm,
specs=[p.get_package_spec(name) for name in p.packages],

42
platformio/package/commands/outdated.py
View File

@ -62,10 +62,9 @@ class OutdatedCandidate:
)
@click.option("-e", "--environment", "environments", multiple=True)
def package_outdated_cmd(project_dir, environments):
candidates = fetch_outdated_candidates(
project_dir, environments, with_progress=True
)
print_outdated_candidates(candidates)
with fs.cd(project_dir):
candidates = fetch_outdated_candidates(environments, with_progress=True)
print_outdated_candidates(candidates)
def print_outdated_candidates(candidates):
@ -126,8 +125,10 @@ def get_candidate_update_color(outdated):
return None
def fetch_outdated_candidates(project_dir, environments, with_progress=False):
def fetch_outdated_candidates(environments, with_progress=False):
candidates = []
config = ProjectConfig.get_instance()
config.validate(environments)
def _add_candidate(data):
new_candidate = OutdatedCandidate(
@ -139,20 +140,16 @@ def fetch_outdated_candidates(project_dir, environments, with_progress=False):
return
candidates.append(new_candidate)
with fs.cd(project_dir):
config = ProjectConfig.get_instance()
config.validate(environments)
# platforms
for item in find_platform_candidates(config, environments):
_add_candidate(item)
# platform package dependencies
for dep_item in find_platform_dependency_candidates(item["env"]):
_add_candidate(dep_item)
# platforms
for item in find_platform_candidates(config, environments):
_add_candidate(item)
# platform package dependencies
for dep_item in find_platform_dependency_candidates(item):
_add_candidate(dep_item)
# libraries
for item in find_library_candidates(config, environments):
_add_candidate(item)
# libraries
for item in find_library_candidates(config, environments):
_add_candidate(item)
result = []
if not with_progress:
@ -172,7 +169,7 @@ def find_platform_candidates(config, environments):
result = []
pm = PlatformPackageManager()
for env in config.envs():
platform = config.get(f"env:{env}", "platform")
platform = config.get(f"env:{env}", "platform", None)
if not platform or (environments and env not in environments):
continue
spec = PackageSpec(platform)
@ -183,14 +180,13 @@ def find_platform_candidates(config, environments):
return result
def find_platform_dependency_candidates(platform_candidate):
def find_platform_dependency_candidates(env):
result = []
p = PlatformFactory.new(platform_candidate["spec"])
p.configure_project_packages(platform_candidate["env"])
p = PlatformFactory.from_env(env)
for pkg in p.get_installed_packages():
result.append(
dict(
env=platform_candidate["env"],
env=env,
pm=p.pm,
pkg=pkg,
spec=p.get_package_spec(pkg.metadata.name),

3
platformio/platform/_run.py
View File

@ -51,13 +51,10 @@ class PlatformRunMixin:
assert isinstance(targets, list)
self.ensure_engine_compatible()
self.configure_project_packages(variables["pioenv"], targets)
self.silent = silent
self.verbose = verbose or app.get_setting("force_verbose")
variables["platform_manifest"] = self.manifest_path
if "build_script" not in variables:
variables["build_script"] = self.get_build_script()
if not os.path.isfile(variables["build_script"]):

1
platformio/platform/base.py
View File

@ -34,6 +34,7 @@ class PlatformBase( # pylint: disable=too-many-instance-attributes,too-many-pub
def __init__(self, manifest_path):
self.manifest_path = manifest_path
self.project_env = None # set by factory.from_env(env)
self.silent = False
self.verbose = False

13
platformio/platform/factory.py
View File

@ -21,6 +21,8 @@ from platformio.compat import load_python_module
from platformio.package.meta import PackageItem
from platformio.platform import base
from platformio.platform.exception import UnknownPlatform
from platformio.project.config import ProjectConfig
from platformio.project.exception import UndefinedEnvPlatformError
class PlatformFactory:
@ -88,3 +90,14 @@ class PlatformFactory:
_instance = platform_cls(os.path.join(platform_dir, "platform.json"))
assert isinstance(_instance, base.PlatformBase)
return _instance
@classmethod
def from_env(cls, env, targets=None, autoinstall=False):
config = ProjectConfig.get_instance()
spec = config.get(f"env:{env}", "platform", None)
if not spec:
raise UndefinedEnvPlatformError(env)
p = cls.new(spec, autoinstall=autoinstall)
p.project_env = env
p.configure_project_packages(env, targets)
return p

8
platformio/project/commands/init.py
View File

@ -26,6 +26,7 @@ from platformio.package.manager.platform import PlatformPackageManager
from platformio.platform.exception import UnknownBoard
from platformio.platform.factory import PlatformFactory
from platformio.project.config import ProjectConfig
from platformio.project.exception import UndefinedEnvPlatformError
from platformio.project.helpers import is_platformio_project
from platformio.project.integration.generator import ProjectGenerator
from platformio.project.options import ProjectOptions
@ -366,13 +367,10 @@ def update_project_env(environment, extra_project_options=None):
def init_sample_code(config, environment):
platform_spec = config.get(f"env:{environment}", "platform", None)
if not platform_spec:
return None
p = PlatformFactory.new(platform_spec)
try:
p = PlatformFactory.from_env(environment)
return p.generate_sample_code(config, environment)
except NotImplementedError:
except (NotImplementedError, UndefinedEnvPlatformError):
pass
framework = config.get(f"env:{environment}", "framework", None)

10
platformio/run/processor.py
View File

@ -72,8 +72,8 @@ class EnvironmentProcessor:
# pre-clean
if is_clean:
result = PlatformFactory.new(
self.options["platform"], autoinstall=True
result = PlatformFactory.from_env(
self.name, targets=self.targets, autoinstall=True
).run(build_vars, self.targets, self.silent, self.verbose, self.jobs)
if not build_targets:
return result["returncode"] == 0
@ -85,7 +85,7 @@ class EnvironmentProcessor:
"piotest_running_name": build_vars.get("piotest_running_name"),
},
)
result = PlatformFactory.new(self.options["platform"], autoinstall=True).run(
build_vars, build_targets, self.silent, self.verbose, self.jobs
)
result = PlatformFactory.from_env(
self.name, targets=build_targets, autoinstall=True
).run(build_vars, build_targets, self.silent, self.verbose, self.jobs)
return result["returncode"] == 0

4
platformio/test/runners/base.py
View File

@ -62,8 +62,8 @@ class TestRunnerBase:
self.test_suite = test_suite
self.options = options
self.project_config = project_config
self.platform = PlatformFactory.new(
self.project_config.get(f"env:{self.test_suite.env_name}", "platform"),
self.platform = PlatformFactory.from_env(
self.test_suite.env_name,
autoinstall=True,
)
self.cmd_ctx = None