import os

import sys

from typing import Any, Dict, List, Optional

from urllib.request import urlretrieve

class VirtualEnvError(Exception):

"""

Exception raised by the function implemented in this file.

"""

pass

class NotImplementedErrorFromVirtualEnvironment(NotImplementedError):

"""

Defines an exception when a function does not work

in a virtual environment.

"""

pass

def is_virtual_environment() -> bool:

"""

Tells if the script is run from a virtual environment.

"""

return (

getattr(sys, "base_exec_prefix", sys.exec_prefix) != sys.exec_prefix

) or hasattr(sys, "real_prefix")

def build_venv_cmd(params: Dict[str, Any], posparams: List[Any]) -> str:

"""

Builds the command line for virtual env.

:param params: dictionary of parameters

:param posparams: positional arguments

:return: string

"""

import venv

v = venv.__file__

if v is None:

raise ImportError("module venv should have a version number")

exe = sys.executable.replace("w.exe", "").replace(".exe", "")

cmd = [exe, "-m", "venv"]

for k, v in params.items():

if v is None:

cmd.append("--" + k)

else:

cmd.append("--" + k + "=" + v)

cmd.extend(posparams)

return " ".join(cmd)

def create_virtual_env(

where: str,

symlinks: bool = False,

system_site_packages: bool = False,

clear: bool = True,

packages: Optional[List[str]] = None,

verbose: int = 0,

temp_folder: Optional[str] = None,

platform: Optional[str] = None,

) -> str:

"""

Creates a virtual environment.

:param where: location of this virtual environment

:param symlinks: attempt to symlink rather than copy

:param system_site_packages: Give the virtual environment

access to the system site-packages dir

:param clear: Delete the environment directory if it already exists.

If not specified and the directory exists, an error is raised.

:param packages: list of packages to install

:param temp_folder: temporary folder (to download module if needed),

by default ``<where>/download``

:param platform: platform to use

:param verbose: verbosity

:return: standard output

.. faqref::

:title: How to create a virtual environment?

The following example creates a virtual environment.

Packages can be added by specifying the parameter *package*.

::

import os

from sphinx_runpython.readme import create_virtual_env

fold = "my_env"

if not os.path.exists(fold):

os.mkdir(fold)

create_virtual_env(fold)

The function does not work from a virtual environment.

"""

from .runpython import run_cmd

if is_virtual_environment():

raise NotImplementedErrorFromVirtualEnvironment()

if verbose > 0:

print(f"[create_virtual_env] create virtual environment at {where!r}")

params = {}

if symlinks:

params["symlinks"] = None

if system_site_packages:

params["system-site-packages"] = None

if clear:

params["clear"] = None

cmd = build_venv_cmd(params, [where])

out, err = run_cmd(cmd, wait=True, logf=print if verbose else None)

if len(err) > 0:

raise VirtualEnvError(

f"Unable to create virtual environement at {where!r}"

f"\nCMD:\n{cmd}\nOUT:\n{out}\n[pyqerror]\n{err}"

)

if platform is None:

platform = sys.platform

if platform.startswith("win"):

scripts = os.path.join(where, "Scripts")

else:

scripts = os.path.join(where, "bin")

if not os.path.exists(scripts):

files = "\n ".join(os.listdir(where))

raise FileNotFoundError(f"Unable to find {files}, content:\n {scripts}")

in_scripts = os.listdir(scripts)

pips = [_ for _ in in_scripts if _.startswith("pip")]

if len(pips) == 0:

out += venv_install(

where, "pip", verbose=verbose, temp_folder=temp_folder, platform=platform

)

in_scripts = os.listdir(scripts)

pips = [_ for _ in in_scripts if _.startswith("pip")]

if len(pips) == 0:

raise FileNotFoundError(

f"Unable to find pip in {in_scripts!r}, content:\n {scripts}"

)

out += venv_install(

where, "pip", verbose=verbose, temp_folder=temp_folder, platform=platform

)

if packages is not None and len(packages) > 0:

if verbose > 0:

print(f"[create_virtual_env] install packages in {where}")

packages = [_ for _ in packages if _ not in ("pip",)]

if len(packages) > 0:

out += venv_install(

where,

packages,

verbose=verbose,

temp_folder=temp_folder,

platform=platform,

)

return out

def venv_install(

venv: str,

packages: List[str],

verbose: int = 0,

temp_folder: Optional[str] = None,

platform: Optional[str] = None,

) -> str:

"""

Installs a package or a list of packages in a virtual environment.

:param venv: location of the virtual environment

:param packages: a package (str) or a list of packages(list[str])

:param temp_folder: temporary folder (to download module if needed),

by default ``<where>/download``

:param platform: platform (``sys.platform`` by default)

:param verbose: verbosity

:return: standard output

The function does not work from a virtual environment.

"""

from .runpython import run_cmd

if is_virtual_environment():

raise NotImplementedErrorFromVirtualEnvironment()

if temp_folder is None:

temp_folder = os.path.join(venv, "download")

if isinstance(packages, str):

packages = [packages]

if platform is None:

platform = sys.platform

exe = os.path.join(venv, "bin", "python")

get_pip = os.path.join(venv, "get_pip.py")

if packages == "pip" or packages == ["pip"]:

if not os.path.exists(get_pip):

if verbose > 2:

print("[bench_virtual] install pip")

urlretrieve("https://bootstrap.pypa.io/get-pip.py", get_pip)

cmd = [exe, get_pip]

out, err = run_cmd([exe, get_pip], wait=True)

else:

pcks = " ".join(packages)

cmd = f"{exe} -m pip install {pcks}"

out, err = run_cmd(cmd, wait=True)

lines = [

_

for _ in err.split("\n")

if "requires" not in _

and "pip's dependency resolver does not currently " not in _

]

err = "\n".join(lines)

if len(err) > 0:

raise RuntimeError(

f"Unable to run cmd={cmd!r} in {venv!r} "

f"(path={get_pip!r}) due to\n{err}"

)

if verbose > 2:

print(out)

return out

def run_venv_script(

venv: str,

script: str,

verbose: int = 0,

is_file: bool = False,

is_cmd: bool = False,

skip_err_if: Optional[bool] = None,

platform: Optional[str] = None,

**kwargs: Dict[str, Any],

) -> str:

"""

Runs a script on a vritual environment (the script should be simple).

:param venv: virtual environment

:param script: script as a string (not a file)

:param is_file: is script a file or a string to execute

:param is_cmd: if True, script is a command line to run

(as a list) for python executable

:param skip_err_if: do not pay attention to standard

error if this string was found in standard output

:param platform: platform (``sys.platform`` by default)

:param verbose: verbosity

:param kwargs: others arguments for function @see fn run_cmd.

:return: output

The function does not work from a virtual environment.

"""

from .runpython import run_cmd

def filter_err(err):

lis = err.split("\n")

lines = []

for li in lis:

if "missing dependencies" in li:

continue

if "' misses '" in li:

continue

lines.append(li)

return "\n".join(lines).strip(" \r\n\t")

if is_virtual_environment():

raise NotImplementedErrorFromVirtualEnvironment()

if platform is None:

platform = sys.platform

if platform.startswith("win"):

exe = os.path.join(venv, "Scripts", "python")

else:

exe = os.path.join(venv, "bin", "python")

if is_cmd:

cmd = " ".join([exe] + script)

out, err = run_cmd(cmd, wait=True, logf=print if verbose else None, **kwargs)

err = filter_err(err)

if len(err) > 0 and (skip_err_if is None or skip_err_if not in out):

raise VirtualEnvError(

"unable to run cmd at {2}\n--CMD--\n{3}\n--OUT--\n{0}\n[pyqerror]"

"\n{1}".format(out, err, venv, cmd)

)

return out

script = ";".join(script.split("\n"))

if is_file:

if not os.path.exists(script):

raise FileNotFoundError(script)

cmd = " ".join([exe, "-u", '"{0}"'.format(script)])

else:

cmd = " ".join([exe, "-u", "-c", '"{0}"'.format(script)])

out, err = run_cmd(cmd, wait=True, logf=print if verbose else None, **kwargs)

err = filter_err(err)

if len(err) > 0:

raise VirtualEnvError(

f"Unable to run script at {venv!r}\n--CMD--\n{cmd}\n--OUT--\n{out}\n"

f"[pyqerror]\n{err}"

)

return out

def run_base_script(

script: str,

is_file: bool = False,

is_cmd: bool = False,

verbose: int = 0,

skip_err_if: Optional[bool] = None,

argv: Optional[List[str]] = None,

platform: Optional[str] = None,

**kwargs: Dict[str, Any],

) -> str:

"""

Runs a script with the original intepreter even if this function

is run from a virtual environment.

:param script: script as a string (not a file)

:param is_file: is script a file or a string to execute

:param is_cmd: if True, script is a command line to run

(as a list) for python executable

:param skip_err_if: do not pay attention to standard error

if this string was found in standard output

:param argv: list of arguments to add on the command line

:param platform: platform (``sys.platform`` by default)

:param kwargs: others arguments for function @see fn run_cmd.

:param verbose: verbosity

:return: output

The function does not work from a virtual environment.

The function does not raise an exception if the standard error

contains something like::

----------------------------------------------------------------------

Ran 1 test in 0.281s

OK

"""

from ..loghelper import run_cmd

def true_err(err):

if "Ran 1 test" in err and "OK" in err:

return False

return True

if platform is None:

platform = sys.platform

if hasattr(sys, "real_prefix"):

exe = sys.base_prefix

elif hasattr(sys, "base_exec_prefix"):

exe = sys.base_exec_prefix

else:

exe = sys.exec_prefix

if platform.startswith("win"):

exe = os.path.join(exe, "python")

else:

exe = os.path.join(exe, "bin", "python%d.%d" % sys.version_info[:2])

if not os.path.exists(exe):

exe = os.path.join(exe, "bin", "python")

if is_cmd:

cmd = " ".join([exe] + script)

if argv is not None:

cmd += " " + " ".join(argv)

out, err = run_cmd(cmd, wait=True, verbose=verbose, **kwargs)

if (

len(err) > 0

and (skip_err_if is None or skip_err_if not in out)

and true_err(err)

):

p = sys.base_prefix if hasattr(sys, "base_prefix") else sys.prefix

raise VirtualEnvError(

f"Unable to run cmd at {p!r}\nCMD:\n{cmd}"

f"\nOUT:\n{out}\n[pyqerror]\n{err}"

)

return out

script = ";".join(script.split("\n"))

if is_file:

if not os.path.exists(script):

raise FileNotFoundError(script)

cmd = " ".join([exe, "-u", '"{0}"'.format(script)])

else:

cmd = " ".join([exe, "-u", "-c", '"{0}"'.format(script)])

if argv is not None:

cmd += " " + " ".join(argv)

out, err = run_cmd(cmd, wait=True, verbose=verbose, **kwargs)

if len(err) > 0 and true_err(err):

p = sys.base_prefix if hasattr(sys, "base_prefix") else sys.prefix

raise VirtualEnvError(

f"Unable to run script at {p!r}\nCMD:\n{cmd}"

f"\nOUT:\n{out}\n[pyqerror]\n{err}"

)

return out

def check_readme_syntax(

readme: str, folder: str, version: Optional[str] = None, verbose: int = 0

) -> str:

"""

Checks the syntax of the file ``readme.rst``

which describes a python project.

:param readme: file to check

:param folder: location for the virtual environment

:param version: version of docutils

:param verbose: verbosity

:return: output or SyntaxError exception

"""

if is_virtual_environment():

raise NotImplementedErrorFromVirtualEnvironment()

if not os.path.exists(folder):

os.makedirs(folder)

out = create_virtual_env(

folder,

verbose=verbose,

packages=["docutils" if version is None else f"docutils=={version}"],

)

outfile = os.path.join(folder, "conv_readme.html")

script = [

"from docutils import core",

"import io",

"from docutils.readers.standalone import Reader",

"from docutils.parsers.rst import Parser",

"from docutils.parsers.rst.directives.images import Image",

"from docutils.parsers.rst.directives import _directives",

"from docutils.writers.html4css1 import Writer",

"_directives['image'] = Image",

"with open('{0}', 'r', encoding='utf8') as g: s = g.read()".format(

readme.replace("\\", "\\\\")

),

"settings_overrides = {'output_encoding': 'unicode', 'doctitle_xform': True,",

" 'initial_header_level': 2, 'warning_stream': io.StringIO()}",

"parts = core.publish_parts(source=s, parser=Parser(), "

" reader=Reader(), source_path=None,",

" destination_path=None, writer=Writer(),",

" settings_overrides=settings_overrides)",

"with open('{0}', 'w', encoding='utf8') as f: f.write(parts['whole'])".format(

outfile.replace("\\", "\\\\")

),

]

file_script = os.path.join(folder, "test_" + os.path.split(readme)[-1])

with open(file_script, "w") as f:

f.write("\n".join(script))

out = run_venv_script(folder, file_script, verbose=verbose, is_file=True)

with open(outfile, "r", encoding="utf8") as h:

content = h.read()

if "System Message" in content:

raise SyntaxError(

f"Unable to parse a file with docutils=={version!r}"

f"\n------\n{out}\n------\nCONTENT:\n{content}"

)

return out