Merge branch 'release/v1.1.0'

Author: ivankravets

.github/workflows/main.yml

@@ -9,6 +9,9 @@ jobs:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
         python-version: [3.6, 3.7, 3.8, 3.9]
+        exclude:
+          - os: macos-latest
+            python-version: "3.6"
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2

get-platformio.py

@@ -14,7 +14,7 @@
 
 import logging.config
 
-VERSION = (1, 0, 4)
+VERSION = (1, 1, 0)
 __version__ = ".".join([str(s) for s in VERSION])
 
 __title__ = "platformio-installer"

pioinstaller/__init__.py

@@ -99,6 +99,7 @@ def python():
 
 @check.command("core")
 @click.option("--auto-upgrade/--no-auto-upgrade", is_flag=True, default=True)
+@click.option("--global", is_flag=True, default=False)
 @click.option("--version-spec", default=None)
 @click.option(
     "--dump-state",
@@ -107,15 +108,16 @@ def python():
     ),
 )
 @click.pass_context
-def core_check(ctx, auto_upgrade, version_spec, dump_state):
+def core_check(ctx, **kwargs):
     try:
         state = core.check(
-            dev=ctx.obj.get("dev", False),
-            auto_upgrade=auto_upgrade,
-            version_spec=version_spec,
+            develop=ctx.obj.get("dev", False),
+            global_=kwargs.get("global"),
+            auto_upgrade=kwargs.get("auto_upgrade"),
+            version_spec=kwargs.get("version_spec"),
         )
-        if dump_state:
-            core.dump_state(target=str(dump_state), state=state)
+        if kwargs.get("dump_state"):
+            core.dump_state(target=str(kwargs.get("dump_state")), state=state)
         click.secho(
             "Found compatible PlatformIO Core %s -> %s"
             % (state.get("core_version"), state.get("platformio_exe")),

pioinstaller/__main__.py

@@ -12,11 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# pylint: disable=import-outside-toplevel
+
 import json
 import logging
 import os
 import platform
 import subprocess
+import sys
 import time
 
 import click
@@ -140,40 +143,46 @@ def _install_platformio_core(shutdown_piohome=True, develop=False, ignore_python
     return True
 
 
-def check(dev=False, auto_upgrade=False, version_spec=None):
-    # pylint: disable=bad-option-value, import-outside-toplevel, unused-import, import-error, unused-variable, cyclic-import, too-many-branches
+def check(develop=False, global_=False, auto_upgrade=False, version_spec=None):
     from pioinstaller import penv
 
-    platformio_exe = os.path.join(
-        penv.get_penv_bin_dir(),
-        "platformio.exe" if util.IS_WINDOWS else "platformio",
+    python_exe = (
+        os.path.normpath(sys.executable)
+        if global_
+        else os.path.join(
+            penv.get_penv_bin_dir(), "python.exe" if util.IS_WINDOWS else "python"
+        )
     )
-    python_exe = os.path.join(
-        penv.get_penv_bin_dir(), "python.exe" if util.IS_WINDOWS else "python"
+    platformio_exe = (
+        util.where_is_program("platformio")
+        if global_
+        else os.path.join(
+            penv.get_penv_bin_dir(),
+            "platformio.exe" if util.IS_WINDOWS else "platformio",
+        )
     )
-    result = {}
-
     if not os.path.isfile(platformio_exe):
         raise exception.InvalidPlatformIOCore(
             "PlatformIO executable not found in `%s`" % penv.get_penv_bin_dir()
         )
-
-    if not os.path.isfile(os.path.join(penv.get_penv_dir(), "state.json")):
+    try:
+        subprocess.check_output([platformio_exe, "--version"], stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError as e:
+        error = e.output.decode()
         raise exception.InvalidPlatformIOCore(
-            "Could not found state.json file in `%s`"
-            % os.path.join(penv.get_penv_dir(), "state.json")
+            "Could not run `%s --version`.\nError: %s" % (platformio_exe, str(error))
         )
 
+    result = {}
     try:
-        result.update(fetch_python_state(python_exe))
+        result = fetch_python_state(python_exe)
     except subprocess.CalledProcessError as e:
         error = e.output.decode()
         raise exception.InvalidPlatformIOCore(
             "Could not import PlatformIO module. Error: %s" % error
         )
-
     piocore_version = convert_version(result.get("core_version"))
-    dev = dev or bool(piocore_version.prerelease if piocore_version else False)
+    develop = develop or bool(piocore_version.prerelease if piocore_version else False)
     result.update(
         {
             "core_dir": get_core_dir(),
@@ -184,71 +193,52 @@ def check(dev=False, auto_upgrade=False, version_spec=None):
             "installer_version": __version__,
             "python_exe": python_exe,
             "system": util.get_systype(),
-            "is_develop_core": dev,
+            "is_develop_core": develop,
         }
     )
 
     if version_spec:
+        _check_core_version(piocore_version, version_spec)
+    if not global_:
+        _check_platform_version()
+    if auto_upgrade and not global_:
         try:
-            if piocore_version not in semantic_version.Spec(version_spec):
-                raise exception.InvalidPlatformIOCore(
-                    "PlatformIO Core version %s does not match version requirements %s."
-                    % (str(piocore_version), version_spec)
-                )
-        except ValueError:
-            click.secho(
-                "Invalid version requirements format: %s. "
-                "More about Semantic Versioning: https://semver.org/" % version_spec
-            )
+            auto_upgrade_core(platformio_exe, develop)
+        except:  # pylint:disable=bare-except
+            pass
+        # re-fetch Pyrhon state
+        try:
+            result.update(fetch_python_state(python_exe))
+        except:  # pylint:disable=bare-except
+            raise exception.InvalidPlatformIOCore("Could not import PlatformIO module")
 
-    with open(os.path.join(penv.get_penv_dir(), "state.json")) as fp:
-        penv_state = json.load(fp)
-        if penv_state.get("platform") != platform.platform(terse=True):
-            raise exception.InvalidPlatformIOCore(
-                "PlatformIO Core was installed using another platform `%s`. "
-                "Your current platform: %s"
-                % (penv_state.get("platform"), platform.platform(terse=True))
-            )
+    return result
 
+
+def _check_core_version(piocore_version, version_spec):
     try:
-        subprocess.check_output([platformio_exe, "--version"], stderr=subprocess.STDOUT)
-    except subprocess.CalledProcessError as e:
-        error = e.output.decode()
-        raise exception.InvalidPlatformIOCore(
-            "Could not run `%s --version`.\nError: %s" % (platformio_exe, str(error))
+        if piocore_version not in semantic_version.Spec(version_spec):
+            raise exception.InvalidPlatformIOCore(
+                "PlatformIO Core version %s does not match version requirements %s."
+                % (str(piocore_version), version_spec)
+            )
+    except ValueError:
+        click.secho(
+            "Invalid version requirements format: %s. "
+            "More about Semantic Versioning: https://semver.org/" % version_spec
         )
 
-    if not auto_upgrade:
-        return result
-
-    time_now = int(round(time.time()))
-
-    last_piocore_version_check = penv_state.get("last_piocore_version_check")
-
-    if (
-        last_piocore_version_check
-        and (time_now - int(last_piocore_version_check)) < UPDATE_INTERVAL
-    ):
-        return result
-
-    with open(os.path.join(penv.get_penv_dir(), "state.json"), "w") as fp:
-        penv_state["last_piocore_version_check"] = time_now
-        json.dump(penv_state, fp)
 
-    if not last_piocore_version_check:
-        return result
-
-    # capture exception when Internet is off-line
-    try:
-        upgrade_core(platformio_exe, dev)
-    except:  # pylint:disable=bare-except
-        return result
+def _check_platform_version():
+    from pioinstaller import penv
 
-    try:
-        result.update(fetch_python_state(python_exe))
-    except:  # pylint:disable=bare-except
-        raise exception.InvalidPlatformIOCore("Could not import PlatformIO module")
-    return result
+    state = penv.load_state()
+    if state.get("platform") != platform.platform(terse=True):
+        raise exception.InvalidPlatformIOCore(
+            "PlatformIO Core was installed using another platform `%s`. "
+            "Your current platform: %s"
+            % (state.get("platform"), platform.platform(terse=True))
+        )
 
 
 def fetch_python_state(python_exe):
@@ -290,9 +280,25 @@ def convert_version(version):
         return None
 
 
-def upgrade_core(platformio_exe, dev=False):
+def auto_upgrade_core(platformio_exe, develop=False):
+    from pioinstaller import penv
+
+    state = penv.load_state()
+    time_now = int(round(time.time()))
+    last_piocore_version_check = state.get("last_piocore_version_check")
+    if (
+        last_piocore_version_check
+        and (time_now - int(last_piocore_version_check)) < UPDATE_INTERVAL
+    ):
+        return None
+
+    state["last_piocore_version_check"] = time_now
+    penv.save_state(state)
+    if not last_piocore_version_check:
+        return None
+
     command = [platformio_exe, "upgrade"]
-    if dev:
+    if develop:
         command.append("--dev")
     try:
         subprocess.check_output(
@@ -304,6 +310,7 @@ def upgrade_core(platformio_exe, dev=False):
         raise exception.PIOInstallerException(
             "Could not upgrade PlatformIO Core: %s" % str(e)
         )
+    return False
 
 
 def dump_state(target, state):

pioinstaller/core.py

@@ -68,7 +68,7 @@ def create_core_penv(penv_dir=None, ignore_pythons=None):
     python_exe = os.path.join(
         get_penv_bin_dir(penv_dir), "python.exe" if util.IS_WINDOWS else "python"
     )
-    add_state_info(python_exe, penv_dir)
+    init_state(python_exe, penv_dir)
     install_pip(python_exe, penv_dir)
     click.echo("Virtual environment has been successfully created!")
     return result_dir
@@ -132,7 +132,7 @@ def create_with_remote_venv(python_exe, penv_dir):
     return penv_dir
 
 
-def add_state_info(python_exe, penv_dir):
+def init_state(python_exe, penv_dir):
     version_code = (
         "import sys; version=sys.version_info; "
         "print('%d.%d.%d'%(version[0],version[1],version[2]))"
@@ -153,9 +153,26 @@ def add_state_info(python_exe, penv_dir):
         "installer_version": __version__,
         "platform": platform.platform(terse=True),
     }
-    with open(os.path.join(penv_dir, "state.json"), "w") as fp:
+    return save_state(state, penv_dir)
+
+
+def load_state(penv_dir=None):
+    penv_dir = penv_dir or get_penv_dir()
+    state_path = os.path.join(penv_dir, "state.json")
+    if not os.path.isfile(state_path):
+        raise exception.PIOInstallerException(
+            "Could not found state.json file in `%s`" % state_path
+        )
+    with open(state_path) as fp:
+        return json.load(fp)
+
+
+def save_state(state, penv_dir=None):
+    penv_dir = penv_dir or get_penv_dir()
+    state_path = os.path.join(penv_dir, "state.json")
+    with open(state_path, "w") as fp:
         json.dump(state, fp)
-    return os.path.join(penv_dir, "state.json")
+    return state_path
 
 
 def install_pip(python_exe, penv_dir):

pioinstaller/penv.py

@@ -19,6 +19,7 @@
 import re
 import shutil
 import stat
+import subprocess
 import sys
 import tarfile
 
@@ -133,3 +134,32 @@ def safe_remove_dir(path, raise_exception=False):
 
 def pepver_to_semver(pepver):
     return re.sub(r"(\.\d+)\.?(dev|a|b|rc|post)", r"\1-\2.", pepver, 1)
+
+
+def where_is_program(program, envpath=None):
+    env = os.environ
+    if envpath:
+        env["PATH"] = envpath
+
+    # try OS's built-in commands
+    try:
+        result = (
+            subprocess.check_output(
+                ["where" if IS_WINDOWS else "which", program], env=env
+            )
+            .decode()
+            .strip()
+        )
+        if os.path.isfile(result):
+            return result
+    except (subprocess.CalledProcessError, OSError):
+        pass
+
+    # look up in $PATH
+    for bin_dir in env.get("PATH", "").split(os.pathsep):
+        if os.path.isfile(os.path.join(bin_dir, program)):
+            return os.path.join(bin_dir, program)
+        if os.path.isfile(os.path.join(bin_dir, "%s.exe" % program)):
+            return os.path.join(bin_dir, "%s.exe" % program)
+
+    return program