Add windows support

drubinstein · drubinstein · commit ad3ef24b5daf · 2023-04-01T20:24:13.000-04:00
diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
@@ -10,8 +10,10 @@ jobs:
       matrix:
         os:
           - Ubuntu
+          - Windows
+          - MacOs
         py:
-          - "3.8"
+          - 3.8
 
     steps:
       - name: Setup python for test ${{ matrix.py }}
@@ -21,11 +23,12 @@ jobs:
       - uses: conda-incubator/setup-miniconda@v2
         with:
           auto-update-conda: true
+          auto-activate-base: false
           python-version: ${{ matrix.python-version}}
       - uses: actions/checkout@v3
       - name: Upgrade pip
-        run: python -m pip install -U pip
+        run: python3 -m pip install -U pip
       - name: Install dependencies
-        run: python -m pip install -e '.[test]'
+        run: python3 -m pip install -e '.[test]'
       - name: Run pytest
-        run: pytest
+        run: python3 -m pytest
diff --git a/.github/workflows/pyenv.yml b/.github/workflows/pyenv.yml
@@ -3,23 +3,27 @@ on: [push, pull_request]
 
 jobs:
   job:
-    name: "Pytest with pyenv"
-    runs-on: ubuntu-latest
+    name: test ${{ matrix.py }} - ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}-latest
     strategy:
       matrix:
         python:
           - 3.9
+        os:
+          - Ubuntu
+          - Windows
+          - MacOs
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Install python version
-      uses: gabrielfalcao/pyenv-action@v13
-      with:
-        default: "${{ matrix.python }}"
-        command: pip install -U pip  # upgrade pip after installing python
-    - name: Install pyenv-virtualenv
-      run: git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
-    - name: Install dependencies
-      run: pip install -e '.[test]'
-    - name: Run tests
-      run: pytest
+      - uses: actions/checkout@v3
+      - name: Install python version
+        uses: gabrielfalcao/pyenv-action@v13
+        with:
+          default: "${{ matrix.python }}"
+          command: pip3 install -U pip # upgrade pip after installing python
+      - name: Install pyenv-virtualenv
+        run: git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
+      - name: Install dependencies
+        run: pip3 install -e '.[test]'
+      - name: Run tests
+        run: python3 -m pytest
diff --git a/.github/workflows/venv.yml b/.github/workflows/venv.yml
@@ -10,7 +10,7 @@ jobs:
       matrix:
         os:
           - Ubuntu
-#          - Windows
+          - Windows
           - MacOs
         py:
           - "3.11"
@@ -25,8 +25,8 @@ jobs:
           python-version: ${{ matrix.py }}
       - uses: actions/checkout@v3
       - name: Upgrade pip
-        run: python -m pip install -U pip
+        run: python3 -m pip install -U pip
       - name: Install dependencies
-        run: python -m pip install -e '.[test]'
+        run: python3 -m pip install -e '.[test]'
       - name: Run pytest
-        run: pytest
+        run: python3 -m pytest
diff --git a/python_compose/unit/conda.py b/python_compose/unit/conda.py
@@ -32,24 +32,32 @@ def __init__(
 
     def create(self) -> None:
         """Function for creating a virtual environment."""
-        envs = [
-            row.split()[0]
-            for row in subprocess.check_output(["conda", "env", "list"]).decode().split("\n")[2:]
-            if row
-        ]
+        conda_env_list = subprocess.check_output(
+            ["conda", "env", "list"]).decode().splitlines()
+        envs = []
+        print(conda_env_list)
+        if len(conda_env_list) >= 2:
+            envs = [
+                row.split()[0]
+                for row in conda_env_list[2:]
+                if row
+            ]
         if self.name in envs:
-            warnings.warn(f"Skipping pyenv venv creation for {self.name}. Venv already exists.")
+            warnings.warn(
+                f"Skipping pyenv venv creation for {self.name}. Venv already exists.")
         else:
             subprocess.check_call(["conda", "create", "-n", self.name, "-y"])
 
     def install_requirements(self) -> None:
         """Function to install any and all requirements for running a script in the virtual
         environment."""
         if isinstance(self.requirements, list) and self.requirements:
-            subprocess.check_call(["conda", "install", "-n", self.name] + self.requirements)
+            subprocess.check_call(
+                ["conda", "install", "-n", self.name] + self.requirements)
         elif isinstance(self.requirements, pathlib.Path):
             subprocess.check_call(
-                ["conda", "install", "-n", self.name, "-f", str(self.requirements)]
+                ["conda", "install", "-n", self.name,
+                    "-f", str(self.requirements)]
             )
 
     def start(self) -> None:
diff --git a/python_compose/unit/pyenv_virtualenv.py b/python_compose/unit/pyenv_virtualenv.py
@@ -1,5 +1,6 @@
 import os
 import pathlib
+import platform
 import shutil
 import subprocess
 import warnings
@@ -37,32 +38,44 @@ def __init__(
 
     def create(self) -> None:
         """Function for creating a virtual environment."""
-        self.pyenv_root = pathlib.Path(subprocess.check_output(["pyenv", "root"]).decode().strip())
+        self.pyenv_root = pathlib.Path(
+            subprocess.check_output(["pyenv", "root"]).decode().strip())
         self.env_path = self.pyenv_root / "versions" / self.name
-        self.python_path = self.pyenv_root / "versions" / self.name / "bin" / "python"
+        if platform.system == "Windows":
+            self.python_path = self.pyenv_root / "versions" / \
+                self.name / "Scripts" / "python.exe"
+        else:
+            self.python_path = self.pyenv_root / "versions" / self.name / "bin" / "python"
 
-        subprocess.check_call(["pyenv", "install", self.py_version, "--skip-existing"])
+        subprocess.check_call(
+            ["pyenv", "install", self.py_version, "--skip-existing"])
         if os.path.exists(self.env_path):
-            warnings.warn(f"Skipping pyenv venv creation for {self.name}. Venv already exists.")
+            warnings.warn(
+                f"Skipping pyenv venv creation for {self.name}. Venv already exists.")
         else:
-            subprocess.check_call(["pyenv", "virtualenv", self.py_version, self.name])
+            subprocess.check_call(
+                ["pyenv", "virtualenv", self.py_version, self.name])
 
     def install_requirements(self) -> None:
         """Function to install any and all requirements for running a script in the virtual
         environment."""
-        subprocess.check_call([str(self.python_path), "-m", "pip", "install", "-U", "pip"])
+        subprocess.check_call(
+            [str(self.python_path), "-m", "pip", "install", "-U", "pip"])
         if isinstance(self.requirements, list) and self.requirements:
             subprocess.check_call(
-                [str(self.python_path), "-m", "pip", "install"] + self.requirements
+                [str(self.python_path), "-m", "pip",
+                 "install"] + self.requirements
             )
         elif isinstance(self.requirements, pathlib.Path):
             subprocess.check_call(
-                [str(self.python_path), "-m", "pip", "install", "-r", str(self.requirements)]
+                [str(self.python_path), "-m", "pip",
+                 "install", "-r", str(self.requirements)]
             )
 
     def start(self) -> None:
         """Function to start a script in the previously created virtual environment"""
-        p = subprocess.Popen([str(self.python_path), str(self.script_path)] + self.script_args)
+        p = subprocess.Popen([str(self.python_path), str(
+            self.script_path)] + self.script_args)
         p.communicate()
 
     def clean(self) -> None:
diff --git a/python_compose/unit/venv.py b/python_compose/unit/venv.py
@@ -1,4 +1,6 @@
+import os
 import pathlib
+import platform
 import shutil
 import subprocess
 from typing import List, Union
@@ -31,31 +33,40 @@ def __init__(
         self.name = name
         self.env_dir = env_dir
         self.env_path = self.env_dir / self.name
-        self.python_path = self.env_path / "bin" / "python"
+        if platform.system() == "Windows":
+            self.python_path = self.env_path / "Scripts" / "python.exe"
+        else:
+            self.python_path = self.env_path / "bin" / "python"
         self.requirements = requirements
         self.script_path = script_path
         self.script_args = script_args
 
     def create(self) -> None:
         """Function for creating a virtual environment."""
-        self.env = EnvBuilder(system_site_packages=True, clear=False, with_pip=True)
+        self.env = EnvBuilder(system_site_packages=True,
+                              clear=False, with_pip=True)
+        if platform.system() == "Windows":
+            os.makedirs(self.env_path)
         self.env.create(self.env_path)
 
     def install_requirements(self) -> None:
         """Function to install any and all requirements for running a script in the virtual
         environment."""
         if isinstance(self.requirements, list) and self.requirements:
             subprocess.check_call(
-                [str(self.python_path), "-m", "pip", "install"] + self.requirements
+                [str(self.python_path), "-m", "pip",
+                 "install"] + self.requirements
             )
         elif isinstance(self.requirements, pathlib.Path):
             subprocess.check_call(
-                [str(self.python_path), "-m", "pip", "install", "-r", str(self.requirements)]
+                [str(self.python_path), "-m", "pip",
+                 "install", "-r", str(self.requirements)]
             )
 
     def start(self) -> None:
         """Function to start a script in the previously created virtual environment."""
-        p = subprocess.Popen([str(self.python_path), str(self.script_path)] + self.script_args)
+        p = subprocess.Popen([str(self.python_path), str(
+            self.script_path)] + self.script_args)
         p.communicate()
 
     def clean(self) -> None:
diff --git a/tests/test_compose.py b/tests/test_compose.py
@@ -1,5 +1,6 @@
 import os
 import pathlib
+import platform
 import random
 import shutil
 import string
@@ -62,7 +63,7 @@ def test_conda(tmp_path: pathlib.Path, random_string: str) -> None:
                 "test",
                 [],
                 [
-                    "python",
+                    "python3",
                     os.path.join("tests", "create_file.py"),
                     str(output_file),
                     random_string,
@@ -84,7 +85,8 @@ def test_yaml_deserialization() -> None:
 
 
 def test_pydantic_to_compose_unit() -> None:
-    units = compose.pydantic_to_units(compose.from_yaml(pathlib.Path("tests") / "config.yaml"))
+    units = compose.pydantic_to_units(
+        compose.from_yaml(pathlib.Path("tests") / "config.yaml"))
     assert len(units) == 3
     counter: Counter[str] = Counter()
     for unit in units:
