meerschaum.utils.venv

  1#! /usr/bin/env python3
  2# -*- coding: utf-8 -*-
  3# vim:fenc=utf-8
  4
  5"""
  6Manage virtual environments.
  7"""
  8
  9from __future__ import annotations
 10
 11from meerschaum.utils.typing import Optional, Union, Dict, List, Tuple
 12from meerschaum.utils.threading import RLock, get_ident
 13
 14__all__ = sorted([
 15    'activate_venv', 'deactivate_venv', 'init_venv',
 16    'inside_venv', 'is_venv_active', 'venv_exec',
 17    'venv_executable', 'venv_exists', 'venv_target_path',
 18    'Venv', 'get_venvs', 'verify_venv', 'get_module_venv',
 19])
 20__pdoc__ = {'Venv': True}
 21
 22LOCKS = {
 23    'sys.path': RLock(),
 24    'active_venvs': RLock(),
 25    'venvs_active_counts': RLock(),
 26}
 27
 28active_venvs = set()
 29active_venvs_counts: Dict[str, int] = {}
 30active_venvs_order: List[Optional[str]] = []
 31threads_active_venvs: Dict[int, 'set[str]'] = {}
 32CREATE_NEW_PROCESS_GROUP = 0x00000200
 33
 34
 35def activate_venv(
 36    venv: Optional[str] = 'mrsm',
 37    color: bool = True,
 38    force: bool = False,
 39    debug: bool = False,
 40    **kw
 41) -> bool:
 42    """
 43    Create a virtual environment (if it doesn't exist) and add it to `sys.path` if necessary.
 44
 45    Parameters
 46    ----------
 47    venv: Optional[str], default 'mrsm'
 48        The virtual environment to activate.
 49
 50    color: bool, default True
 51        If `True`, include color in debug text.
 52
 53    force: bool, default False
 54        If `True`, do not exit early even if the venv is currently active.
 55
 56    debug: bool, default False
 57        Verbosity toggle.
 58
 59    Returns
 60    -------
 61    A bool indicating whether the virtual environment was successfully activated.
 62
 63    """
 64    thread_id = get_ident()
 65    if active_venvs_order and active_venvs_order[0] == venv:
 66        if not force:
 67            return True
 68    import sys
 69    import os
 70    if venv is not None:
 71        init_venv(venv=venv, debug=debug)
 72    with LOCKS['active_venvs']:
 73        if thread_id not in threads_active_venvs:
 74            threads_active_venvs[thread_id] = {}
 75        active_venvs.add(venv)
 76        if venv not in threads_active_venvs[thread_id]:
 77            threads_active_venvs[thread_id][venv] = 1
 78        else:
 79            threads_active_venvs[thread_id][venv] += 1
 80
 81        target_path = venv_target_path(venv, debug=debug, allow_nonexistent=True)
 82        if not target_path.exists():
 83            init_venv(venv=venv, force=True, debug=debug)
 84        if not target_path.exists():
 85            raise EnvironmentError(f"Could not activate virtual environment '{venv}'.")
 86        target = target_path.as_posix()
 87
 88        if venv in active_venvs_order:
 89            try:
 90                sys.path.remove(target)
 91            except Exception:
 92                pass
 93            try:
 94                active_venvs_order.remove(venv)
 95            except Exception:
 96                pass
 97        if venv is not None:
 98            sys.path.insert(0, target)
 99        else:
100            if sys.path and sys.path[0] in (os.getcwd(), ''):
101                sys.path.insert(1, target)
102            else:
103                sys.path.insert(0, target)
104        try:
105            active_venvs_order.insert(0, venv)
106        except Exception:
107            pass
108
109    return True
110
111
112def deactivate_venv(
113    venv: str = 'mrsm',
114    color: bool = True,
115    debug: bool = False,
116    previously_active_venvs: Union['set[str]', List[str], None] = None,
117    force: bool = False,
118    **kw
119) -> bool:
120    """
121    Remove a virtual environment from `sys.path` (if it's been activated).
122
123    Parameters
124    ----------
125    venv: str, default 'mrsm'
126        The virtual environment to deactivate.
127
128    color: bool, default True
129        If `True`, include color in debug text.
130
131    debug: bool, default False
132        Verbosity toggle.
133
134    previously_active_venvs: Union[Set[str], List[str], None]
135        If provided, skip deactivating if a virtual environment is in this iterable.
136
137    force: bool, default False
138        If `True`, forcibly deactivate the virtual environment.
139        This may cause issues with other threads, so be careful!
140
141    Returns
142    -------
143    Return a bool indicating whether the virtual environment was successfully deactivated.
144
145    """
146    import sys
147    thread_id = get_ident()
148    if venv is None:
149        if venv in active_venvs:
150            active_venvs.remove(venv)
151        return True
152
153    if previously_active_venvs and venv in previously_active_venvs and not force:
154        return True
155
156    with LOCKS['active_venvs']:
157        if venv in threads_active_venvs.get(thread_id, {}):
158            new_count = threads_active_venvs[thread_id][venv] - 1
159            if new_count > 0 and not force:
160                threads_active_venvs[thread_id][venv] = new_count
161                return True
162            else:
163                del threads_active_venvs[thread_id][venv]
164
165        if not force:
166            for other_thread_id, other_venvs in threads_active_venvs.items():
167                if other_thread_id == thread_id:
168                    continue
169                if venv in other_venvs:
170                    return True
171        else:
172            to_delete = [other_thread_id for other_thread_id in threads_active_venvs]
173            for other_thread_id in to_delete:
174                del threads_active_venvs[other_thread_id]
175
176        if venv in active_venvs:
177            active_venvs.remove(venv)
178
179    if sys.path is None:
180        return False
181
182    target = venv_target_path(venv, allow_nonexistent=True, debug=debug).as_posix()
183    with LOCKS['sys.path']:
184        if target in sys.path:
185            try:
186                sys.path.remove(target)
187            except Exception:
188                pass
189            try:
190                active_venvs_order.remove(venv)
191            except Exception:
192                pass
193
194    return True
195
196
197def is_venv_active(
198    venv: str = 'mrsm',
199    color : bool = True,
200    debug: bool = False
201) -> bool:
202    """
203    Check if a virtual environment is active.
204
205    Parameters
206    ----------
207    venv: str, default 'mrsm'
208        The virtual environment to check.
209
210    color: bool, default True
211        If `True`, include color in debug text.
212
213    debug: bool, default False
214        Verbosity toggle.
215
216    Returns
217    -------
218    A bool indicating whether the virtual environment `venv` is active.
219
220    """
221    return venv in active_venvs
222
223
224verified_venvs = set()
225def verify_venv(
226    venv: str,
227    debug: bool = False,
228) -> None:
229    """
230    Verify that the virtual environment matches the expected state.
231    """
232    import pathlib
233    import platform
234    import os
235    import shutil
236    import sys
237    from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
238    from meerschaum.utils.process import run_process
239    from meerschaum.utils.misc import make_symlink, is_symlink
240    from meerschaum.utils.warnings import warn
241
242    venv_path = VIRTENV_RESOURCES_PATH / venv
243    bin_path = venv_path / (
244        'bin' if platform.system() != 'Windows' else "Scripts"
245    )
246    current_python_versioned_name = (
247        'python' + str(sys.version_info.major) + '.' + str(sys.version_info.minor)
248        + ('' if platform.system() != 'Windows' else '.exe')
249    )
250
251    if not (bin_path / current_python_versioned_name).exists():
252        init_venv(venv, verify=False, force=True, debug=debug)
253        current_python_in_venv_path = pathlib.Path(venv_executable(venv=venv))
254        current_python_in_sys_path = pathlib.Path(venv_executable(venv=None))
255        if not current_python_in_venv_path.exists():
256            if is_symlink(current_python_in_venv_path):
257                try:
258                    current_python_in_venv_path.unlink()
259                except Exception as e:
260                    print(f"Unable to remove symlink {current_python_in_venv_path}:\n{e}")
261            try:
262                make_symlink(current_python_in_sys_path, current_python_in_venv_path)
263            except Exception:
264                print(
265                    f"Unable to create symlink {current_python_in_venv_path} "
266                    + f"to {current_python_in_sys_path}."
267                )
268        files_to_inspect = sorted(os.listdir(bin_path), reverse=True)
269    else:
270        files_to_inspect = [current_python_versioned_name]
271
272    def get_python_version(python_path: pathlib.Path) -> Union[str, None]:
273        """
274        Return the version for the python binary at the given path.
275        """
276        try:
277            ### It might be a broken symlink, so skip on errors.
278            if debug:
279                print(f"Getting python version for {python_path}")
280            proc = run_process(
281                [str(python_path), '-V'],
282                as_proc=True,
283                capture_output=True,
284            )
285            stdout, stderr = proc.communicate(timeout=1.0)
286        except Exception as e:
287            ### E.g. the symlink may be broken.
288            if is_symlink(python_path):
289                try:
290                    python_path.unlink()
291                except Exception as _e:
292                    print(f"Unable to remove broken symlink {python_path}:\n{e}\n{_e}")
293            return None
294        return stdout.decode('utf-8').strip().replace('Python ', '')
295
296    ### Ensure the versions are symlinked correctly.
297    for filename in files_to_inspect:
298        if not filename.startswith('python'):
299            continue
300        python_path = bin_path / filename
301        version = get_python_version(python_path)
302        if version is None:
303            continue
304        try:
305            major_version = version.split('.', maxsplit=1)[0]
306            minor_version = version.split('.', maxsplit=2)[1]
307        except IndexError:
308            return
309        python_versioned_name = (
310            'python' + major_version + '.' + minor_version
311            + ('' if platform.system() != 'Windows' else '.exe')
312        )
313
314        ### E.g. python3.10 actually links to Python 3.10.
315        if filename == python_versioned_name:
316            real_path = pathlib.Path(os.path.realpath(python_path))
317            if not real_path.exists():
318                try:
319                    python_path.unlink()
320                except Exception:
321                    pass
322                init_venv(venv, verify=False, force=True, debug=debug)
323                if not python_path.exists():
324                    raise FileNotFoundError(f"Unable to verify Python symlink:\n{python_path}")
325
326            if python_path == real_path:
327                continue
328
329            try:
330                python_path.unlink()
331            except Exception:
332                pass
333            success, msg = make_symlink(real_path, python_path)
334            if not success:
335                warn(msg, color=False)
336            continue
337
338        python_versioned_path = bin_path / python_versioned_name
339        if python_versioned_path.exists():
340            ### Avoid circular symlinks.
341            if get_python_version(python_versioned_path) == version:
342                continue
343            python_versioned_path.unlink()
344        shutil.move(python_path, python_versioned_path)
345
346
347tried_virtualenv = False
348def init_venv(
349    venv: str = 'mrsm',
350    verify: bool = True,
351    force: bool = False,
352    debug: bool = False,
353) -> bool:
354    """
355    Initialize the virtual environment.
356
357    Parameters
358    ----------
359    venv: str, default 'mrsm'
360        The name of the virtual environment to create.
361
362    verify: bool, default True
363        If `True`, verify that the virtual environment is in the expected state.
364
365    force: bool, default False
366        If `True`, recreate the virtual environment, even if already initalized.
367
368    Returns
369    -------
370    A `bool` indicating success.
371    """
372    if not force and venv in verified_venvs:
373        return True
374    if not force and venv_exists(venv, debug=debug):
375        if verify:
376            verify_venv(venv, debug=debug)
377            verified_venvs.add(venv)
378        return True
379
380    import io
381    from contextlib import redirect_stdout
382    import sys
383    import platform
384    import os
385    import pathlib
386    import shutil
387    import time
388
389    from meerschaum.config.static import STATIC_CONFIG
390    from meerschaum.config._paths import (
391        VIRTENV_RESOURCES_PATH,
392        VENVS_CACHE_RESOURCES_PATH,
393    )
394    from meerschaum.utils.packages import is_uv_enabled
395
396    venv_path = VIRTENV_RESOURCES_PATH / venv
397    vtp = venv_target_path(venv=venv, allow_nonexistent=True, debug=debug)
398    docker_home_venv_path = pathlib.Path('/home/meerschaum/venvs/mrsm')
399    lock_path = VENVS_CACHE_RESOURCES_PATH / (venv + '.lock')
400    work_dir_env_var = STATIC_CONFIG['environment']['work_dir']
401
402    def update_lock(active: bool):
403        try:
404            if not active:
405                if debug:
406                    print(f"Releasing lock: '{lock_path}'")
407                lock_path.unlink()
408            else:
409                if debug:
410                    print(f"Acquiring lock: '{lock_path}'")
411                lock_path.touch()
412        except Exception:
413            pass
414
415    def wait_for_lock():
416        if platform.system() == 'Windows':
417            return
418        max_lock_seconds = 30.0
419        sleep_message_seconds = 5.0
420        step_sleep_seconds = 0.1
421        init_venv_check_start = time.perf_counter()
422        last_print = init_venv_check_start
423        while ((time.perf_counter() - init_venv_check_start) < max_lock_seconds):
424            if not lock_path.exists():
425                break
426
427            now = time.perf_counter()
428            if debug or (now - last_print) > sleep_message_seconds:
429                print(f"Lock exists for venv '{venv}', sleeping...")
430                last_print = now
431            time.sleep(step_sleep_seconds)
432        update_lock(False)
433
434    if (
435        not force
436        and venv == 'mrsm'
437        and os.environ.get(work_dir_env_var, None) is not None
438        and docker_home_venv_path.exists()
439    ):
440        wait_for_lock()
441        shutil.move(docker_home_venv_path, venv_path)
442        if verify:
443            verify_venv(venv, debug=debug)
444            verified_venvs.add(venv)
445        return True
446
447    from meerschaum.utils.packages import run_python_package, attempt_import, _get_pip_os_env
448    global tried_virtualenv
449    try:
450        import venv as _venv
451        uv = attempt_import('uv', venv=None, debug=debug) if is_uv_enabled() else None
452        virtualenv = None
453    except ImportError:
454        _venv = None
455        uv = None
456        virtualenv = None
457
458    _venv_success = False
459    temp_vtp = VENVS_CACHE_RESOURCES_PATH / str(venv)
460    ### NOTE: Disable site-packages movement for now.
461    rename_vtp = False and vtp.exists() and not temp_vtp.exists()
462
463    wait_for_lock()
464    update_lock(True)
465
466    if rename_vtp:
467        if debug:
468            print(f"Moving '{vtp}' to '{temp_vtp}'...")
469        shutil.move(vtp, temp_vtp)
470
471    if uv is not None:
472        _venv_success = run_python_package(
473            'uv',
474            ['venv', venv_path.as_posix(), '-q', '--no-project', '--allow-existing', '--seed'],
475            venv=None,
476            env=_get_pip_os_env(),
477            debug=debug,
478        ) == 0
479
480    if _venv is not None and not _venv_success:
481        f = io.StringIO()
482        with redirect_stdout(f):
483            _venv_success = run_python_package(
484                'venv',
485                [venv_path.as_posix()] + (
486                    ['--symlinks']
487                    if platform.system() != 'Windows'
488                    else []
489                ),
490                venv=None, debug=debug
491            ) == 0
492        if not _venv_success:
493            print(f"Please install python3-venv.\n{f.getvalue()}\nFalling back to virtualenv...")
494        if not venv_exists(venv, debug=debug):
495            _venv = None
496    if not _venv_success:
497        virtualenv = attempt_import(
498            'virtualenv',
499            venv=None,
500            lazy=False,
501            install=(not tried_virtualenv),
502            warn=False,
503            check_update=False,
504            color=False,
505            debug=debug,
506        )
507        if virtualenv is None:
508            print(
509                "Failed to import `venv` or `virtualenv`! "
510                + "Please install `virtualenv` via pip then restart Meerschaum."
511            )
512            if rename_vtp and temp_vtp.exists():
513                if debug:
514                    print(f"Moving '{temp_vtp}' back to '{vtp}'...")
515                shutil.move(temp_vtp, vtp)
516            update_lock(False)
517            return False
518
519        tried_virtualenv = True
520        try:
521            python_folder = (
522                'python' + str(sys.version_info.major) + '.' + str(sys.version_info.minor)
523            )
524            dist_packages_path = (
525                VIRTENV_RESOURCES_PATH /
526                venv / 'local' / 'lib' / python_folder / 'dist-packages'
527            )
528            local_bin_path = VIRTENV_RESOURCES_PATH / venv / 'local' / 'bin'
529            bin_path = VIRTENV_RESOURCES_PATH / venv / 'bin'
530            vtp = venv_target_path(venv=venv, allow_nonexistent=True, debug=debug)
531            if bin_path.exists():
532                try:
533                    shutil.rmtree(bin_path)
534                except Exception:
535                    import traceback
536                    traceback.print_exc()
537            virtualenv.cli_run([venv_path.as_posix()])
538            if dist_packages_path.exists():
539                vtp.mkdir(exist_ok=True, parents=True)
540                for file_path in dist_packages_path.glob('*'):
541                    shutil.move(file_path, vtp)
542                shutil.rmtree(dist_packages_path)
543                #  shutil.move(dist_packages_path, vtp)
544                bin_path.mkdir(exist_ok=True, parents=True)
545                for file_path in local_bin_path.glob('*'):
546                    shutil.move(file_path, bin_path)
547                #  shutil.move(local_bin_path, bin_path)
548                shutil.rmtree(local_bin_path)
549
550        except Exception:
551            import traceback
552            traceback.print_exc()
553            if rename_vtp and temp_vtp.exists():
554                shutil.move(temp_vtp, vtp)
555            update_lock(False)
556            return False
557    if verify:
558        verify_venv(venv, debug=debug)
559        verified_venvs.add(venv)
560
561    if rename_vtp and temp_vtp.exists():
562        if debug:
563            print(f"Cleanup: move '{temp_vtp}' back to '{vtp}'.")
564        shutil.move(temp_vtp, vtp)
565
566    update_lock(False)
567    return True
568
569
570def venv_executable(venv: Optional[str] = 'mrsm') -> str:
571    """
572    The Python interpreter executable for a given virtual environment.
573    """
574    from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
575    import sys
576    import platform
577    return (
578        sys.executable if venv is None
579        else str(
580            VIRTENV_RESOURCES_PATH
581            / venv
582            / (
583                'bin' if platform.system() != 'Windows'
584                else 'Scripts'
585            ) / (
586                'python'
587                + str(sys.version_info.major)
588                + '.'
589                + str(sys.version_info.minor)
590            )
591        )
592    )
593
594
595def venv_exec(
596    code: str,
597    venv: Optional[str] = 'mrsm',
598    env: Optional[Dict[str, str]] = None,
599    with_extras: bool = False,
600    as_proc: bool = False,
601    capture_output: bool = True,
602    debug: bool = False,
603) -> Union[bool, Tuple[int, bytes, bytes], 'subprocess.Popen']:
604    """
605    Execute Python code in a subprocess via a virtual environment's interpeter.
606    Return `True` if the code successfully executes, `False` on failure.
607
608    Parameters
609    ----------
610    code: str
611        The Python code to excecute.
612
613    venv: str, default 'mrsm'
614        The virtual environment to use to get the path for the Python executable.
615        If `venv` is `None`, use the default `sys.executable` path.
616
617    env: Optional[Dict[str, str]], default None
618        Optionally specify the environment variables for the subprocess.
619        Defaults to `os.environ`.
620
621    with_extras: bool, default False
622        If `True`, return a tuple of the exit code, stdout bytes, and stderr bytes.
623
624    as_proc: bool, default False
625        If `True`, return the `subprocess.Popen` object instead of executing.
626
627    Returns
628    -------
629    By default, return a bool indicating success.
630    If `as_proc` is `True`, return a `subprocess.Popen` object.
631    If `with_extras` is `True`, return a tuple of the exit code, stdout bytes, and stderr bytes.
632
633    """
634    import os
635    import subprocess
636    import platform
637    from meerschaum.utils.debug import dprint
638    from meerschaum.utils.process import _child_processes
639
640    executable = venv_executable(venv=venv)
641    cmd_list = [executable, '-c', code]
642    if env is None:
643        env = os.environ
644    if debug:
645        dprint(str(cmd_list))
646    if not with_extras and not as_proc:
647        return subprocess.call(cmd_list, env=env) == 0
648
649    stdout, stderr = (None, None) if not capture_output else (subprocess.PIPE, subprocess.PIPE)
650    group_kwargs = (
651        {
652            'preexec_fn': os.setsid,
653        } if platform.system() != 'Windows'
654        else {
655            'creationflags': CREATE_NEW_PROCESS_GROUP,
656        }
657    )
658    process = subprocess.Popen(
659        cmd_list,
660        stdout=stdout,
661        stderr=stderr,
662        env=env,
663        **group_kwargs
664    )
665    if as_proc:
666        _child_processes.append(process)
667        return process
668    stdout, stderr = process.communicate()
669    exit_code = process.returncode
670    return exit_code, stdout, stderr
671
672
673def venv_exists(venv: Union[str, None], debug: bool = False) -> bool:
674    """
675    Determine whether a virtual environment has been created.
676    """
677    target_path = venv_target_path(venv, allow_nonexistent=True, debug=debug)
678    return target_path.exists()
679
680
681def venv_target_path(
682    venv: Union[str, None],
683    allow_nonexistent: bool = False,
684    debug: bool = False,
685) -> 'pathlib.Path':
686    """
687    Return a virtual environment's site-package path.
688
689    Parameters
690    ----------
691    venv: Union[str, None]
692        The virtual environment for which a path should be returned.
693
694    allow_nonexistent: bool, default False
695        If `True`, return a path even if it does not exist.
696
697    Returns
698    -------
699    The `pathlib.Path` object for the virtual environment's path.
700
701    """
702    import os
703    import sys
704    import platform
705    import pathlib
706    import site
707    from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
708    from meerschaum.config.static import STATIC_CONFIG
709
710    ### Check sys.path for a user-writable site-packages directory.
711    if venv is None:
712
713        ### Return the known value for the portable environment.
714        environment_runtime = STATIC_CONFIG['environment']['runtime']
715        if os.environ.get(environment_runtime, None) == 'portable':
716            python_version_folder = (
717                'python' + str(sys.version_info.major) + '.' + str(sys.version_info.minor)
718            )
719            executable_path = pathlib.Path(sys.executable)
720            site_packages_path = (
721                (
722                    executable_path.parent.parent / 'lib' / python_version_folder / 'site-packages'
723                ) if platform.system() != 'Windows' else (
724                    executable_path.parent / 'Lib' / 'site-packages'
725                )
726            )
727            if not site_packages_path.exists():
728                raise EnvironmentError(f"Could not find '{site_packages_path}'. Does it exist?")
729            return site_packages_path
730
731        if not inside_venv():
732            user_site_packages = site.getusersitepackages()
733            if user_site_packages is None:
734                raise EnvironmentError("Could not determine user site packages.")
735
736            site_path = pathlib.Path(user_site_packages)
737            if not site_path.exists():
738
739                ### Windows does not have `os.geteuid()`.
740                if platform.system() == 'Windows' or os.geteuid() != 0:
741                    site_path.mkdir(parents=True, exist_ok=True)
742                    return site_path
743
744                ### Allow for dist-level paths (running as root).
745                for possible_dist in site.getsitepackages():
746                    dist_path = pathlib.Path(possible_dist)
747                    if not dist_path.exists():
748                        continue
749                    return dist_path
750                
751                raise EnvironmentError("Could not determine the dist-packages directory.")
752
753            return site_path
754
755    venv_root_path = (
756        (VIRTENV_RESOURCES_PATH / venv)
757        if venv is not None else pathlib.Path(sys.prefix)
758    )
759    target_path = venv_root_path
760
761    ### Ensure 'lib' or 'Lib' exists.
762    lib = 'lib' if platform.system() != 'Windows' else 'Lib'
763    if not allow_nonexistent:
764        if not venv_root_path.exists() or lib not in os.listdir(venv_root_path):
765            print(f"Failed to find lib directory for virtual environment '{venv}'.")
766            import traceback
767            traceback.print_stack()
768            sys.exit(1)
769    target_path = target_path / lib
770
771    ### Check if a 'python3.x' folder exists.
772    python_folder = 'python' + str(sys.version_info.major) + '.' + str(sys.version_info.minor)
773    if target_path.exists():
774        target_path = (
775            (target_path / python_folder) if python_folder in os.listdir(target_path)
776            else target_path
777        )
778    else:
779        target_path = (
780            (target_path / python_folder) if platform.system() != 'Windows'
781            else target_path
782        )
783
784    ### Ensure 'site-packages' exists.
785    if allow_nonexistent or 'site-packages' in os.listdir(target_path): ### Windows
786        target_path = target_path / 'site-packages'
787    else:
788        import traceback
789        traceback.print_stack()
790        print(f"Failed to find site-packages directory for virtual environment '{venv}'.")
791        print("This may be because you are using a different Python version.")
792        print("Try deleting the following directory and restarting Meerschaum:")
793        print(VIRTENV_RESOURCES_PATH)
794        sys.exit(1)
795
796    return target_path
797
798
799def inside_venv() -> bool:
800    """
801    Determine whether current Python interpreter is running inside a virtual environment.
802    """
803    import sys
804    return (
805        hasattr(sys, 'real_prefix') or (
806            hasattr(sys, 'base_prefix')
807                and sys.base_prefix != sys.prefix
808        )
809    )
810
811
812def get_venvs() -> List[str]:
813    """
814    Return a list of all the virtual environments.
815    """
816    import os
817    from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
818    venvs = []
819    for filename in os.listdir(VIRTENV_RESOURCES_PATH):
820        path = VIRTENV_RESOURCES_PATH / filename
821        if not path.is_dir():
822            continue
823        if not venv_exists(filename):
824            continue
825        venvs.append(filename)
826    return venvs
827
828
829def get_module_venv(module) -> Union[str, None]:
830    """
831    Return the virtual environment where an imported module is installed.
832
833    Parameters
834    ----------
835    module: ModuleType
836        The imported module to inspect.
837
838    Returns
839    -------
840    The name of a venv or `None`.
841    """
842    import pathlib
843    from meerschaum.config.paths import VIRTENV_RESOURCES_PATH
844    module_path = pathlib.Path(module.__file__).resolve()
845    try:
846        rel_path = module_path.relative_to(VIRTENV_RESOURCES_PATH)
847    except ValueError:
848        return None
849
850    return rel_path.as_posix().split('/', maxsplit=1)[0]
851
852
853from meerschaum.utils.venv._Venv import Venv