3518784377

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/MilesCranmer/PySR/commit/<a class=hub.com/MilesCranmer/PySR/commit/<a class="double-link" href="https://git"><a class=hub.com/MilesCranmer/PySR/commit/<a class="double-link" href="https://git"><a class=hub.com/MilesCranmer/PySR/commit/<a class="double-link" href="https://git"><a class=hub.com/MilesCranmer/PySR/commit/<a class="double-link" href="https://git"><a class=hub.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2">68e0f6b94">&lt;a href=&quot;https://github.com/MilesCranmer/PySR/commit/</a><a class="double-link" href="https://github.com/MilesCranmer/PySR/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MilesCranmer/PySR/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MilesCranmer/PySR/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MilesCranmer/PySR/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MilesCranmer/PySR/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2">68e0f6b94</a><a href="https://github.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/MilesCranmer/PySR/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MilesCranmer/PySR/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MilesCranmer/PySR/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MilesCranmer/PySR/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2&quot;&gt;68e0f6b94&lt;/a&gt;&lt;a href=&quot;https://github.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/MilesCranmer/PySR/commit/68e0f6b9419becc16198456716d21df22be546e2&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;lt;a href=&amp;amp;amp;quot;https://github.com/MilesCranmer/PySR/commit/&amp;amp;lt;/a&amp;amp;gt;&amp... (continued)

Pull Request Pull Request #228: Make Julia startup options configurable

Run Details

27 of 31 new or added lines in 3 files covered. (87.1%)

901 of 1007 relevant lines covered (89.47%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.28

/pysr/julia_helpers.py

"""Functions for initializing the Julia environment and installing deps."""
import sys
import subprocess
import warnings
from pathlib import Path
import os
from julia.api import JuliaError

from .version import __version__, __symbolic_regression_jl_version__

juliainfo = None
julia_initialized = False
julia_kwargs_at_initialization = None


def _load_juliainfo():
    """Execute julia.core.JuliaInfo.load(), and store as juliainfo."""
    global juliainfo

    if juliainfo is None:
        from julia.core import JuliaInfo

        try:
            juliainfo = JuliaInfo.load(julia="julia")
        except FileNotFoundError:
            env_path = os.environ["PATH"]
            raise FileNotFoundError(
                f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
            )

    return juliainfo


def _get_julia_env_dir():
    # Have to manually get env dir:
    try:
        julia_env_dir_str = subprocess.run(
            ["julia", "-e using Pkg; print(Pkg.envdir())"],
            capture_output=True,
            env=os.environ,
        ).stdout.decode()
    except FileNotFoundError:
        env_path = os.environ["PATH"]
        raise FileNotFoundError(
            f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
        )
    return Path(julia_env_dir_str)


def _set_julia_project_env(julia_project, is_shared):
    if is_shared:
        if is_julia_version_greater_eq(version=(1, 7, 0)):
            os.environ["JULIA_PROJECT"] = "@" + str(julia_project)
        else:
            julia_env_dir = _get_julia_env_dir()
            os.environ["JULIA_PROJECT"] = str(julia_env_dir / julia_project)
    else:
        os.environ["JULIA_PROJECT"] = str(julia_project)


def _get_io_arg(quiet):
    io = "devnull" if quiet else "stderr"
    io_arg = f"io={io}" if is_julia_version_greater_eq(version=(1, 6, 0)) else ""
    return io_arg


def install(julia_project=None, quiet=False):  # pragma: no cover
    """
    Install PyCall.jl and all required dependencies for SymbolicRegression.jl.

    Also updates the local Julia registry.
    """
    import julia

    _julia_version_assertion()
    # Set JULIA_PROJECT so that we install in the pysr environment
    processed_julia_project, is_shared = _process_julia_project(julia_project)
    _set_julia_project_env(processed_julia_project, is_shared)

    julia.install(quiet=quiet)
    Main = init_julia(julia_project, quiet=quiet)
    io_arg = _get_io_arg(quiet)

    if is_shared:
        # Install SymbolicRegression.jl:
        _add_sr_to_julia_project(Main, io_arg)

    Main.eval("using Pkg")
    Main.eval(f"Pkg.instantiate({io_arg})")
    Main.eval(f"Pkg.precompile({io_arg})")
    if not quiet:
        warnings.warn(
            "It is recommended to restart Python after installing PySR's dependencies,"
            " so that the Julia environment is properly initialized."
        )


def _import_error():
    return """
    Required dependencies are not installed or built.  Run the following code in the Python REPL:

        >>> import pysr
        >>> pysr.install()
    """


def _process_julia_project(julia_project):
    if julia_project is None:
        is_shared = True
        processed_julia_project = f"pysr-{__version__}"
    elif julia_project[0] == "@":
        is_shared = True
        processed_julia_project = julia_project[1:]
    else:
        is_shared = False
        processed_julia_project = Path(julia_project)
    return processed_julia_project, is_shared


def is_julia_version_greater_eq(juliainfo=None, version=(1, 6, 0)):
    """Check if Julia version is greater than specified version."""
    if juliainfo is None:
        juliainfo = _load_juliainfo()
    current_version = (
        juliainfo.version_major,
        juliainfo.version_minor,
        juliainfo.version_patch,
    )
    return current_version >= version


def _check_for_conflicting_libraries():  # pragma: no cover
    """Check whether there are conflicting modules, and display warnings."""
    # See https://github.com/pytorch/pytorch/issues/78829: importing
    # pytorch before running `pysr.fit` causes a segfault.
    torch_is_loaded = "torch" in sys.modules
    if torch_is_loaded:
        warnings.warn(
            "`torch` was loaded before the Julia instance started. "
            "This may cause a segfault when running `PySRRegressor.fit`. "
            "To avoid this, please run `pysr.julia_helpers.init_julia()` *before* "
            "importing `torch`. "
            "For updates, see https://github.com/pytorch/pytorch/issues/78829"
        )


def init_julia(julia_project=None, quiet=False, julia_kwargs=None):
    """Initialize julia binary, turning off compiled modules if needed."""
    global julia_initialized
    global julia_kwargs_at_initialization

    if not julia_initialized:
        _check_for_conflicting_libraries()

    if julia_kwargs is None:
        julia_kwargs = {}

    from julia.core import JuliaInfo, UnsupportedPythonError

    _julia_version_assertion()
    processed_julia_project, is_shared = _process_julia_project(julia_project)
    _set_julia_project_env(processed_julia_project, is_shared)

    try:
        info = JuliaInfo.load(julia="julia")
    except FileNotFoundError:
        env_path = os.environ["PATH"]
        raise FileNotFoundError(
            f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
        )

    if not info.is_pycall_built():
        raise ImportError(_import_error())

    from julia.core import Julia

    Main = None
    try:
        jl = Julia(**julia_kwargs)
        from julia import Main as _Main

        Main = _Main
    except UnsupportedPythonError:
        # Static python binary, so we turn off pre-compiled modules.
        julia_kwargs = {**julia_kwargs, "compiled_modules": False}
        jl = Julia(**julia_kwargs)
        from julia import Main as _Main

        Main = _Main

    if julia_initialized and julia_kwargs_at_initialization is not None:
        # Check if the kwargs are the same as the previous initialization
        if julia_kwargs_at_initialization != julia_kwargs:
            # Record different kwargs:
            init_set = set(julia_kwargs_at_initialization.items())
            new_set = set(julia_kwargs.items())
            set_diff = new_set - init_set
            # Remove the `compiled_modules` key, since it is not a user-specified kwarg:
            set_diff = {k: v for k, v in set_diff if k != "compiled_modules"}
            if len(set_diff) > 0:
                warnings.warn(
                    "Julia has already started. The new Julia options "
                    + str(set_diff)
                    + " will be ignored."
                )

    if julia_initialized:
        Main.eval("using Pkg")

        io_arg = _get_io_arg(quiet)
        # Can't pass IO to Julia call as it evaluates to PyObject, so just directly
        # use Main.eval:
        Main.eval(
            f'Pkg.activate("{_escape_filename(processed_julia_project)}",'
            f"shared = Bool({int(is_shared)}), "
            f"{io_arg})"
        )

    if not julia_initialized:
        julia_kwargs_at_initialization = julia_kwargs

    julia_initialized = True
    return Main


def _add_sr_to_julia_project(Main, io_arg):
    Main.eval("using Pkg")
    Main.sr_spec = Main.PackageSpec(
        name="SymbolicRegression",
        url="https://github.com/MilesCranmer/SymbolicRegression.jl",
        rev="v" + __symbolic_regression_jl_version__,
    )
    Main.clustermanagers_spec = Main.PackageSpec(
        name="ClusterManagers",
        url="https://github.com/JuliaParallel/ClusterManagers.jl",
        rev="14e7302f068794099344d5d93f71979aaf4fbeb3",
    )
    Main.eval(f"Pkg.add([sr_spec, clustermanagers_spec], {io_arg})")


def _escape_filename(filename):
    """Turn a path into a string with correctly escaped backslashes."""
    str_repr = str(filename)
    str_repr = str_repr.replace("\\", "\\\\")
    return str_repr


def _julia_version_assertion():
    if not is_julia_version_greater_eq(version=(1, 6, 0)):
        raise NotImplementedError(
            "PySR requires Julia 1.6.0 or greater. "
            "Please update your Julia installation."
        )


def _backend_version_assertion(Main):
    try:
        backend_version = Main.eval("string(SymbolicRegression.PACKAGE_VERSION)")
        expected_backend_version = __symbolic_regression_jl_version__
        if backend_version != expected_backend_version:  # pragma: no cover
            warnings.warn(
                f"PySR backend (SymbolicRegression.jl) version {backend_version} "
                f"does not match expected version {expected_backend_version}. "
                "Things may break. "
                "Please update your PySR installation with "
                "`python -c 'import pysr; pysr.install()'`."
            )
    except JuliaError:  # pragma: no cover
        warnings.warn(
            "You seem to have an outdated version of SymbolicRegression.jl. "
            "Things may break. "
            "Please update your PySR installation with "
            "`python -c 'import pysr; pysr.install()'`."
        )


def _load_cluster_manager(Main, cluster_manager):
    Main.eval(f"import ClusterManagers: addprocs_{cluster_manager}")
    return Main.eval(f"addprocs_{cluster_manager}")


def _update_julia_project(Main, is_shared, io_arg):
    try:
        if is_shared:
            _add_sr_to_julia_project(Main, io_arg)
        Main.eval(f"Pkg.resolve({io_arg})")
    except (JuliaError, RuntimeError) as e:
        raise ImportError(_import_error()) from e


def _load_backend(Main):
    try:
        # Load namespace, so that various internal operators work:
        Main.eval("using SymbolicRegression")
    except (JuliaError, RuntimeError) as e:
        raise ImportError(_import_error()) from e

    _backend_version_assertion(Main)

    # Load Julia package SymbolicRegression.jl
    from julia import SymbolicRegression

    return SymbolicRegression

1	"""Functions for initializing the Julia environment and installing deps."""
2	import sys	1✔
3	import subprocess	1✔
4	import warnings	1✔
5	from pathlib import Path	1✔
6	import os	1✔
7	from julia.api import JuliaError	1✔
8
9	from .version import __version__, __symbolic_regression_jl_version__	1✔
10
11	juliainfo = None	1✔
12	julia_initialized = False	1✔
13	julia_kwargs_at_initialization = None	1✔
14
15
16	def _load_juliainfo():	1✔
17	"""Execute julia.core.JuliaInfo.load(), and store as juliainfo."""
18	global juliainfo
19
20	if juliainfo is None:	1✔
21	from julia.core import JuliaInfo	1✔
22
23	try:	1✔
24	juliainfo = JuliaInfo.load(julia="julia")	1✔
25	except FileNotFoundError:	×
26	env_path = os.environ["PATH"]	×
27	raise FileNotFoundError(	×
28	f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
29	)
30
31	return juliainfo	1✔
32
33
34	def _get_julia_env_dir():	1✔
35	# Have to manually get env dir:
36	try:	×
37	julia_env_dir_str = subprocess.run(	×
38	["julia", "-e using Pkg; print(Pkg.envdir())"],
39	capture_output=True,
40	env=os.environ,
41	).stdout.decode()
42	except FileNotFoundError:	×
43	env_path = os.environ["PATH"]	×
44	raise FileNotFoundError(	×
45	f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
46	)
47	return Path(julia_env_dir_str)	×
48
49
50	def _set_julia_project_env(julia_project, is_shared):	1✔
51	if is_shared:	1✔
52	if is_julia_version_greater_eq(version=(1, 7, 0)):	1✔
53	os.environ["JULIA_PROJECT"] = "@" + str(julia_project)	1✔
54	else:
55	julia_env_dir = _get_julia_env_dir()	×
56	os.environ["JULIA_PROJECT"] = str(julia_env_dir / julia_project)	×
57	else:
58	os.environ["JULIA_PROJECT"] = str(julia_project)	×
59
60
61	def _get_io_arg(quiet):	1✔
62	io = "devnull" if quiet else "stderr"	1✔
63	io_arg = f"io={io}" if is_julia_version_greater_eq(version=(1, 6, 0)) else ""	1✔
64	return io_arg	1✔
65
66
67	def install(julia_project=None, quiet=False): # pragma: no cover
68	"""
69	Install PyCall.jl and all required dependencies for SymbolicRegression.jl.
70
71	Also updates the local Julia registry.
72	"""
73	import julia
74
75	_julia_version_assertion()
76	# Set JULIA_PROJECT so that we install in the pysr environment
77	processed_julia_project, is_shared = _process_julia_project(julia_project)
78	_set_julia_project_env(processed_julia_project, is_shared)
79
80	julia.install(quiet=quiet)
81	Main = init_julia(julia_project, quiet=quiet)
82	io_arg = _get_io_arg(quiet)
83
84	if is_shared:
85	# Install SymbolicRegression.jl:
86	_add_sr_to_julia_project(Main, io_arg)
87
88	Main.eval("using Pkg")
89	Main.eval(f"Pkg.instantiate({io_arg})")
90	Main.eval(f"Pkg.precompile({io_arg})")
91	if not quiet:
92	warnings.warn(
93	"It is recommended to restart Python after installing PySR's dependencies,"
94	" so that the Julia environment is properly initialized."
95	)
96
97
98	def _import_error():	1✔
99	return """	×
100	Required dependencies are not installed or built. Run the following code in the Python REPL:
101
102	>>> import pysr
103	>>> pysr.install()
104	"""
105
106
107	def _process_julia_project(julia_project):	1✔
108	if julia_project is None:	1✔
109	is_shared = True	1✔
110	processed_julia_project = f"pysr-{__version__}"	1✔
111	elif julia_project[0] == "@":	1✔
112	is_shared = True	1✔
113	processed_julia_project = julia_project[1:]	1✔
114	else:
115	is_shared = False	×
116	processed_julia_project = Path(julia_project)	×
117	return processed_julia_project, is_shared	1✔
118
119
120	def is_julia_version_greater_eq(juliainfo=None, version=(1, 6, 0)):	1✔
121	"""Check if Julia version is greater than specified version."""
122	if juliainfo is None:	1✔
123	juliainfo = _load_juliainfo()	1✔
124	current_version = (	1✔
125	juliainfo.version_major,
126	juliainfo.version_minor,
127	juliainfo.version_patch,
128	)
129	return current_version >= version	1✔
130
131
132	def _check_for_conflicting_libraries(): # pragma: no cover
133	"""Check whether there are conflicting modules, and display warnings."""
134	# See https://github.com/pytorch/pytorch/issues/78829: importing
135	# pytorch before running `pysr.fit` causes a segfault.
136	torch_is_loaded = "torch" in sys.modules
137	if torch_is_loaded:
138	warnings.warn(
139	"`torch` was loaded before the Julia instance started. "
140	"This may cause a segfault when running `PySRRegressor.fit`. "
141	"To avoid this, please run `pysr.julia_helpers.init_julia()` before "
142	"importing `torch`. "
143	"For updates, see https://github.com/pytorch/pytorch/issues/78829"
144	)
145
146
147	def init_julia(julia_project=None, quiet=False, julia_kwargs=None):	1✔
148	"""Initialize julia binary, turning off compiled modules if needed."""
149	global julia_initialized
150	global julia_kwargs_at_initialization
151
152	if not julia_initialized:	1✔
153	_check_for_conflicting_libraries()	1✔
154
155	if julia_kwargs is None:	1✔
156	julia_kwargs = {}	1✔
157
158	from julia.core import JuliaInfo, UnsupportedPythonError	1✔
159
160	_julia_version_assertion()	1✔
161	processed_julia_project, is_shared = _process_julia_project(julia_project)	1✔
162	_set_julia_project_env(processed_julia_project, is_shared)	1✔
163
164	try:	1✔
165	info = JuliaInfo.load(julia="julia")	1✔
166	except FileNotFoundError:	×
167	env_path = os.environ["PATH"]	×
168	raise FileNotFoundError(	×
169	f"Julia is not installed in your PATH. Please install Julia and add it to your PATH.\n\nCurrent PATH: {env_path}",
170	)
171
172	if not info.is_pycall_built():	1✔
173	raise ImportError(_import_error())	×
174
175	from julia.core import Julia	1✔
176
177	Main = None	1✔
178	try:	1✔
179	jl = Julia(**julia_kwargs)	1✔
180	from julia import Main as _Main	1✔
181
182	Main = _Main	1✔
183	except UnsupportedPythonError:	×
184	# Static python binary, so we turn off pre-compiled modules.
NEW 185	julia_kwargs = {**julia_kwargs, "compiled_modules": False}	×
NEW 186	jl = Julia(**julia_kwargs)	×
187	from julia import Main as _Main	×
188
189	Main = _Main	×
190
191	if julia_initialized and julia_kwargs_at_initialization is not None:	1✔
192	# Check if the kwargs are the same as the previous initialization
193	if julia_kwargs_at_initialization != julia_kwargs:	1✔
194	# Record different kwargs:
195	init_set = set(julia_kwargs_at_initialization.items())	1✔
196	new_set = set(julia_kwargs.items())	1✔
197	set_diff = new_set - init_set	1✔
198	# Remove the `compiled_modules` key, since it is not a user-specified kwarg:
199	set_diff = {k: v for k, v in set_diff if k != "compiled_modules"}	1✔
200	if len(set_diff) > 0:	1✔
201	warnings.warn(	1✔
202	"Julia has already started. The new Julia options "
203	+ str(set_diff)
204	+ " will be ignored."
205	)
206
207	if julia_initialized:	1✔
208	Main.eval("using Pkg")	1✔
209
210	io_arg = _get_io_arg(quiet)	1✔
211	# Can't pass IO to Julia call as it evaluates to PyObject, so just directly
212	# use Main.eval:
213	Main.eval(	1✔
214	f'Pkg.activate("{_escape_filename(processed_julia_project)}",'
215	f"shared = Bool({int(is_shared)}), "
216	f"{io_arg})"
217	)
218
219	if not julia_initialized:	1✔
220	julia_kwargs_at_initialization = julia_kwargs	1✔
221
222	julia_initialized = True	1✔
223	return Main	1✔
224
225
226	def _add_sr_to_julia_project(Main, io_arg):	1✔
227	Main.eval("using Pkg")	1✔
228	Main.sr_spec = Main.PackageSpec(	1✔
229	name="SymbolicRegression",
230	url="https://github.com/MilesCranmer/SymbolicRegression.jl",
231	rev="v" + __symbolic_regression_jl_version__,
232	)
233	Main.clustermanagers_spec = Main.PackageSpec(	1✔
234	name="ClusterManagers",
235	url="https://github.com/JuliaParallel/ClusterManagers.jl",
236	rev="14e7302f068794099344d5d93f71979aaf4fbeb3",
237	)
238	Main.eval(f"Pkg.add([sr_spec, clustermanagers_spec], {io_arg})")	1✔
239
240
241	def _escape_filename(filename):	1✔
242	"""Turn a path into a string with correctly escaped backslashes."""
243	str_repr = str(filename)	1✔
244	str_repr = str_repr.replace("\\", "\\\\")	1✔
245	return str_repr	1✔
246
247
248	def _julia_version_assertion():	1✔
249	if not is_julia_version_greater_eq(version=(1, 6, 0)):	1✔
250	raise NotImplementedError(	×
251	"PySR requires Julia 1.6.0 or greater. "
252	"Please update your Julia installation."
253	)
254
255
256	def _backend_version_assertion(Main):	1✔
257	try:	1✔
258	backend_version = Main.eval("string(SymbolicRegression.PACKAGE_VERSION)")	1✔
259	expected_backend_version = __symbolic_regression_jl_version__	1✔
260	if backend_version != expected_backend_version: # pragma: no cover
261	warnings.warn(
262	f"PySR backend (SymbolicRegression.jl) version {backend_version} "
263	f"does not match expected version {expected_backend_version}. "
264	"Things may break. "
265	"Please update your PySR installation with "
266	"`python -c 'import pysr; pysr.install()'`."
267	)
268	except JuliaError: # pragma: no cover
269	warnings.warn(
270	"You seem to have an outdated version of SymbolicRegression.jl. "
271	"Things may break. "
272	"Please update your PySR installation with "
273	"`python -c 'import pysr; pysr.install()'`."
274	)
275
276
277	def _load_cluster_manager(Main, cluster_manager):	1✔
278	Main.eval(f"import ClusterManagers: addprocs_{cluster_manager}")	×
279	return Main.eval(f"addprocs_{cluster_manager}")	×
280
281
282	def _update_julia_project(Main, is_shared, io_arg):	1✔
283	try:	×
284	if is_shared:	×
285	_add_sr_to_julia_project(Main, io_arg)	×
286	Main.eval(f"Pkg.resolve({io_arg})")	×
287	except (JuliaError, RuntimeError) as e:	×
288	raise ImportError(_import_error()) from e	×
289
290
291	def _load_backend(Main):	1✔
292	try:	1✔
293	# Load namespace, so that various internal operators work:
294	Main.eval("using SymbolicRegression")	1✔
295	except (JuliaError, RuntimeError) as e:	×
296	raise ImportError(_import_error()) from e	×
297
298	_backend_version_assertion(Main)	1✔
299
300	# Load Julia package SymbolicRegression.jl
301	from julia import SymbolicRegression	1✔
302
303	return SymbolicRegression	1✔

MilesCranmer / PySR / 3518784377

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous