def write_script(self, name: str, module: str, attr: str,
section: "ScriptSection") -> RecordEntry:
"""Write a script to invoke an entrypoint.
:param name: name of the script
:param module: module path, to load the entry point from
:param attr: final attribute access, for the entry point
:param section: Denotes the "entry point section" where this was specified.
Valid values are ``"gui"`` and ``"console"``.
:type section: str
- Generates a launcher using :any:`Script.generate`.
- Writes to the "scripts" scheme.
- Uses :py:meth:`SchemeDictionaryDestination.write_to_fs` for the
filesystem interaction.
"""
script = Script(name, module, attr, section)
script_name, data = script.generate(self.interpreter, self.script_kind)
with io.BytesIO(data) as stream:
entry = self.write_to_fs(Scheme("scripts"),
script_name,
stream,
is_executable=True)
path = self._path_with_destdir(Scheme("scripts"), script_name)
mode = os.stat(path).st_mode
mode |= (mode & 0o444) >> 2
os.chmod(path, mode)
return entry
def test_script_generate_simple():
script = Script("foo", "foo.bar", "baz.qux", section="console")
name, data = script.generate("/path/to/my/python", kind="posix")
assert name == "foo"
assert data.startswith(b"#!/path/to/my/python\n")
assert b"\nfrom foo.bar import baz\n" in data
assert b"baz.qux()" in data
def test_script_generate_space_in_executable():
script = Script("foo", "foo.bar", "baz.qux", section="console")
name, data = script.generate("/path to my/python", kind="posix")
assert name == "foo"
assert data.startswith(b"#!/bin/sh\n")
assert b" '/path to my/python'" in data
assert b"\nfrom foo.bar import baz\n" in data
assert b"baz.qux()" in data
def test_script_generate_launcher(section, kind):
launcher_data = _read_launcher_data(section, kind)
script = Script("foo", "foo.bar", "baz.qux", section=section)
name, data = script.generate("#!C:\\path to my\\python.exe\n", kind=kind)
prefix_len = len(launcher_data) + len(b"#!C:\\path to my\\python.exe\n")
stream = io.BytesIO(data[prefix_len:])
with zipfile.ZipFile(stream) as zf:
code = zf.read("__main__.py")
assert name == "foo.exe"
assert data.startswith(launcher_data)
assert b"#!C:\\path to my\\python.exe\n" in data
assert b"\nfrom foo.bar import baz\n" in code
assert b"baz.qux()" in code
def test_write_script(self, destination):
script_args = ("my_entrypoint", "my_module", "my_function", "console")
record = destination.write_script(*script_args)
file_path = os.path.join(destination.scheme_dict["scripts"],
"my_entrypoint")
assert os.path.isfile(file_path)
with open(file_path, "rb") as f:
file_data = f.read()
name, expected_data = Script(*script_args).generate(
"/my/python", "posix")
assert file_data == expected_data
assert record.path == "my_entrypoint"
def test_script_generate_launcher_error(section, kind):
script = Script("foo", "foo.bar", "baz.qux", section=section)
with pytest.raises(InvalidScript):
script.generate("#!C:\\path to my\\python.exe\n", kind=kind)