Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
beat
beat.core
Commits
894990a6
Commit
894990a6
authored
Apr 23, 2018
by
André Anjos
💬
Browse files
Fix all doc warnings
parent
a7d31b98
Changes
19
Hide whitespace changes
Inline
Side-by-side
beat/core/algorithm.py
View file @
894990a6
...
...
@@ -54,31 +54,31 @@ class Algorithm(BackendAlgorithm):
and output declaration, grouping, synchronization details, parameters and
splittability). The actual algorithm is not directly treated by this class -
it can, however, provide you with a loader for actually running the
algorithmic code (see :py:meth:`
Algorithm
.runner`).
algorithmic code (see :py:meth:`.runner`).
Parameters:
prefix (str): Establishes the prefix of your installation.
data (object,
o
ptional): The piece of data representing the
algorithm. It
must validate against the schema defined for algorithms.
If a string is
passed, it is supposed to be a valid path to an
algorithm in the
designated prefix area. If a tuple is passed (or a
list), then we
consider that the first element represents the algorithm
declaration,
while the second, the code for the algorithm (either in
its source format
or as a binary blob). If ``None`` is passed, loads
our default prototype
for algorithms (source code will be in Python).
dataformat_cache (dict,
o
ptional): A dictionary mapping
dataformat names to
loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up algorithm loading times as dataformats
that are already
loaded may be re-used.
library_cache (dict,
o
ptional): A dictionary mapping library
names to
loaded libraries. This parameter is optional and, if passed,
may greatly
speed-up library loading times as libraries that are
already loaded may
be re-used.
data (
:py:class:`
object
`
,
O
ptional): The piece of data representing the
algorithm. It
must validate against the schema defined for algorithms.
If a string is
passed, it is supposed to be a valid path to an
algorithm in the
designated prefix area. If a tuple is passed (or a
list), then we
consider that the first element represents the algorithm
declaration,
while the second, the code for the algorithm (either in
its source format
or as a binary blob). If ``None`` is passed, loads
our default prototype
for algorithms (source code will be in Python).
dataformat_cache (
:py:class:`
dict
`
,
O
ptional): A dictionary mapping
dataformat names to
loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up algorithm loading times as dataformats
that are already
loaded may be re-used.
library_cache (
:py:class:`
dict
`
,
O
ptional): A dictionary mapping library
names to
loaded libraries. This parameter is optional and, if passed,
may greatly
speed-up library loading times as libraries that are
already loaded may
be re-used.
Attributes:
...
...
beat/core/database.py
View file @
894990a6
...
...
@@ -62,12 +62,12 @@ class Database(BackendDatabase):
it is supposed to be a valid path to an database in the designated prefix
area.
dataformat_cache (dict,
o
ptional): A dictionary mapping
dataformat names
to loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up database loading times as dataformats
that are already
loaded may be re-used. If you use this parameter, you
must guarantee
that the cache is refreshed as appropriate in case the
underlying
dataformats change.
dataformat_cache (
:py:class:`
dict
`
,
O
ptional): A dictionary mapping
dataformat names
to loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up database loading times as dataformats
that are already
loaded may be re-used. If you use this parameter, you
must guarantee
that the cache is refreshed as appropriate in case the
underlying
dataformats change.
Attributes:
...
...
beat/core/dataformat.py
View file @
894990a6
...
...
@@ -51,25 +51,25 @@ class DataFormat(BackendDataFormat):
prefix (str): Establishes the prefix of your installation.
data (object,
o
ptional): The piece of data representing the
data format. It
must validate against the schema defined for data
formats. If a string is
passed, it is supposed to be a valid path to an
data format in the
designated prefix area. If ``None`` is passed, loads
our default
prototype for data formats.
parent (tuple,
o
ptional): The parent DataFormat for this
format. If set to
``None``, this means this dataformat is the first one
on the hierarchy
tree. If set to a tuple, the contents are
``(format-instance,
field-name)``, which indicates the originating
object that is this
object's parent and the name of the field on that
object that points to
this one.
dataformat_cache (dict,
o
ptional): A dictionary mapping
dataformat names to
loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up data format loading times as
dataformats that are already
loaded may be re-used. If you use this
parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying dataformat
s
change.
data (
:py:class:`
object
`
,
O
ptional): The piece of data representing the
data format. It
must validate against the schema defined for data
formats. If a string is
passed, it is supposed to be a valid path to an
data format in the
designated prefix area. If ``None`` is passed, loads
our default
prototype for data formats.
parent (
:py:class:`
tuple
`
,
O
ptional): The parent DataFormat for this
format. If set to
``None``, this means this dataformat is the first one
on the hierarchy
tree. If set to a tuple, the contents are
``(format-instance,
field-name)``, which indicates the originating
object that is this
object's parent and the name of the field on that
object that points to
this one.
dataformat_cache (
:py:class:`
dict
`
,
O
ptional): A dictionary mapping
dataformat names to
loaded dataformats. This parameter is optional and,
if passed, may
greatly speed-up data format loading times as
dataformats that are already
loaded may be re-used. If you use this
parameter, you must guarantee that the cache is refreshed a
s
appropriate in case the underlying dataformats
change.
Attributes:
...
...
beat/core/dock.py
View file @
894990a6
...
...
@@ -135,9 +135,9 @@ class Host(object):
Parameters:
raise_on_errors (bool, Optional): If we should raise an
exception
(`
`RuntimeError`
`
) in case installed environments
override each other
and we can't know which to use.
raise_on_errors (
:py:class:`
bool
`
, Optional): If we should raise an
exception (:py:exc:
`RuntimeError`) in case installed environments
override each other
and we can't know which to use.
Raises:
...
...
@@ -317,14 +317,14 @@ class Host(object):
container (:py:class:`Container`): The container.
virtual_memory_in_megabytes (int, Optional): The maximum
amount of memory
the user process can consume on the host. If not
specified, a memory
limit is not set.
virtual_memory_in_megabytes (
:py:class:`
int
`
, Optional): The maximum
amount of memory
the user process can consume on the host. If not
specified, a memory
limit is not set.
max_cpu_percent (float, Optional): The maximum amount of
CPU the user
process may consume on the host. The value ``100``
equals to using 100%
of a single core. If not specified, then a CPU
limitation is not put in
place.
max_cpu_percent (
:py:class:`
float
`
, Optional): The maximum amount of
CPU the user
process may consume on the host. The value ``100``
equals to using 100%
of a single core. If not specified, then a CPU
limitation is not put in
place.
"""
...
...
@@ -420,8 +420,9 @@ class Host(object):
Parameters:
timeout (float, Optional): A timeout in seconds to wait for the user
process to finish. If a timeout value is not given, waits forever.
timeout (:py:class:`float`, Optional): A timeout in seconds to wait
for the user process to finish. If a timeout value is not given,
waits forever.
'''
(
status
,
stdout
,
stderr
)
=
self
.
_exec
([
'docker'
,
'wait'
,
container
.
id
],
timeout
=
timeout
)
...
...
beat/core/execution/base.py
View file @
894990a6
...
...
@@ -59,36 +59,37 @@ class BaseExecutor(object):
string is passed, it is supposed to be a fully qualified absolute path to
a JSON file containing the block execution information.
cache (str,
o
ptional): If your cache is not located under
cache (
:py:class:`
str
`
,
O
ptional): If your cache is not located under
``<prefix>/cache``, then specify a full path here. It will be used
instead.
dataformat_cache (dict, optional): A dictionary mapping dataformat names to
loaded dataformats. This parameter is optional and, if passed, may
greatly speed-up database loading times as dataformats that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying dataformats
change.
database_cache (dict, optional): A dictionary mapping database names to
loaded databases. This parameter is optional and, if passed, may
greatly speed-up database loading times as databases that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying databases
change.
algorithm_cache (dict, optional): A dictionary mapping algorithm names to
loaded algorithms. This parameter is optional and, if passed, may
greatly speed-up database loading times as algorithms that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying algorithms
change.
library_cache (dict, optional): A dictionary mapping library names to
loaded libraries. This parameter is optional and, if passed, may greatly
speed-up library loading times as libraries that are already loaded may
be re-used. If you use this parameter, you must guarantee that the cache
is refreshed as appropriate in case the underlying libraries change.
dataformat_cache (:py:class:`dict`, Optional): A dictionary mapping
dataformat names to loaded dataformats. This parameter is optional and,
if passed, may greatly speed-up database loading times as dataformats
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying dataformats change.
database_cache (:py:class:`dict`, Optional): A dictionary mapping
database names to loaded databases. This parameter is optional and, if
passed, may greatly speed-up database loading times as databases that
are already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying databases change.
algorithm_cache (:py:class:`dict`, Optional): A dictionary mapping
algorithm names to loaded algorithms. This parameter is optional and,
if passed, may greatly speed-up database loading times as algorithms
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying algorithms change.
library_cache (:py:class:`dict`, Optional): A dictionary mapping library
names to loaded libraries. This parameter is optional and, if passed,
may greatly speed-up library loading times as libraries that are
already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying libraries change.
Attributes:
...
...
@@ -105,7 +106,7 @@ class BaseExecutor(object):
algorithm to be run.
databases (dict): A dictionary in which keys are strings with database
names and values are :py:class:`database.Database`, representing the
names and values are :py:class:`
.
database.Database`, representing the
databases required for running this block. The dictionary may be empty
in case all inputs are taken from the file cache.
...
...
@@ -277,20 +278,20 @@ class BaseExecutor(object):
Parameters:
virtual_memory_in_megabytes (int, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
virtual_memory_in_megabytes (
:py:class:`
int
`
, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
max_cpu_percent (int, Optional): The maximum amount of
CPU usage allowed
in a system. This number must be an integer
number between 0 and
``100*number_of_cores`` in your system. For
instance, if your system
has 2 cores, this number can go between 0
and 200. If it is <= 0, then
we don't track CPU usage.
max_cpu_percent (
:py:class:`
int
`
, Optional): The maximum amount of
CPU usage allowed
in a system. This number must be an integer
number between 0 and
``100*number_of_cores`` in your system. For
instance, if your system
has 2 cores, this number can go between 0
and 200. If it is <= 0, then
we don't track CPU usage.
timeout_in_minutes (int): The number of minutes to wait for the user
process to execute. After this amount of time, the user process is
killed with
:py:attr:
`signal.SIGKILL`. If set to zero, no timeout will
be
applied.
killed with
`
`signal.SIGKILL`
`
. If set to zero, no timeout will
be
applied.
Returns:
...
...
beat/core/execution/docker.py
View file @
894990a6
...
...
@@ -50,9 +50,9 @@ class DockerExecutor(RemoteExecutor):
Parameters:
host (:py:class:Host): A configured docker host that will
execute the
user process. If the host does not have access to the
required
environment, an exception will be raised.
host (:py:class:
`.dock.
Host
`
): A configured docker host that will
execute the
user process. If the host does not have access to the
required
environment, an exception will be raised.
prefix (str): Establishes the prefix of your installation.
...
...
@@ -61,36 +61,37 @@ class DockerExecutor(RemoteExecutor):
string is passed, it is supposed to be a fully qualified absolute path to
a JSON file containing the block execution information.
cache (str,
o
ptional): If your cache is not located under
cache (
:py:class:`
str
`
,
O
ptional): If your cache is not located under
``<prefix>/cache``, then specify a full path here. It will be used
instead.
dataformat_cache (dict, optional): A dictionary mapping dataformat names to
loaded dataformats. This parameter is optional and, if passed, may
greatly speed-up database loading times as dataformats that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying dataformats
change.
database_cache (dict, optional): A dictionary mapping database names to
loaded databases. This parameter is optional and, if passed, may
greatly speed-up database loading times as databases that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying databases
change.
algorithm_cache (dict, optional): A dictionary mapping algorithm names to
loaded algorithms. This parameter is optional and, if passed, may
greatly speed-up database loading times as algorithms that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying algorithms
change.
library_cache (dict, optional): A dictionary mapping library names to
loaded libraries. This parameter is optional and, if passed, may greatly
speed-up library loading times as libraries that are already loaded may
be re-used. If you use this parameter, you must guarantee that the cache
is refreshed as appropriate in case the underlying libraries change.
dataformat_cache (:py:class:`dict`, Optional): A dictionary mapping
dataformat names to loaded dataformats. This parameter is optional and,
if passed, may greatly speed-up database loading times as dataformats
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying dataformats change.
database_cache (:py:class:`dict`, Optional): A dictionary mapping
database names to loaded databases. This parameter is optional and, if
passed, may greatly speed-up database loading times as databases that
are already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying databases change.
algorithm_cache (:py:class:`dict`, Optional): A dictionary mapping
algorithm names to loaded algorithms. This parameter is optional and,
if passed, may greatly speed-up database loading times as algorithms
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying algorithms change.
library_cache (:py:class:`dict`, Optional): A dictionary mapping library
names to loaded libraries. This parameter is optional and, if passed,
may greatly speed-up library loading times as libraries that are
already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying libraries change.
Attributes:
...
...
@@ -103,11 +104,11 @@ class DockerExecutor(RemoteExecutor):
data (dict): The original data for this executor, as loaded by our JSON
decoder.
algorithm (
beat.core
.algorithm.Algorithm): An object representing the
algorithm to
be run.
algorithm (.algorithm.Algorithm): An object representing the
algorithm to
be run.
databases (dict): A dictionary in which keys are strings with database
names and values are :py:class:`database.Database`, representing the
names and values are :py:class:`
.
database.Database`, representing the
databases required for running this block. The dictionary may be empty
in case all inputs are taken from the file cache.
...
...
@@ -116,11 +117,11 @@ class DockerExecutor(RemoteExecutor):
for that particular combination of details. The dictionary may be empty
in case all inputs are taken from the file cache.
input_list (beat.
core
.inputs.InputList): A list of inputs that
will be
served to the algorithm.
input_list (beat.
backend.python
.inputs.InputList): A list of inputs that
will be
served to the algorithm.
output_list (beat.
core
.outputs.OutputList): A list of outputs
that the
algorithm will produce.
output_list (beat.
backend.python
.outputs.OutputList): A list of outputs
that the
algorithm will produce.
data_sources (list): A list with all data-sources created by our execution
loader.
...
...
@@ -152,40 +153,42 @@ class DockerExecutor(RemoteExecutor):
The execution interface follows the backend API as described in our
documentation.
We use green subprocesses this implementation. Each co-process is linked
to us via 2 uni-directional pipes which work as datain and dataout
end-points. The parent process (i.e. the current one) establishes the
connection to the child and then can pass/receive commands, data and logs.
We use green subprocesses this implementation. Each co-process is
linked to us via 2 uni-directional pipes which work as datain and
dataout end-points. The parent process (i.e. the current one)
establishes the connection to the child and then can pass/receive
commands, data and logs.
Usage of the data pipes (datain, dataout) is **synchronous** - you send
a
command and block for an answer. The co-process is normally
controlled by
the current process, except for data requests, which are
user-code driven.
The nature of our problem does not require an
*asynchronous* implementation
which, in turn, would require a much more
complex set of dependencies (on
asyncio or Twisted for example).
Usage of the data pipes (datain, dataout) is **synchronous** - you send
a
command and block for an answer. The co-process is normally
controlled by
the current process, except for data requests, which are
user-code driven.
The nature of our problem does not require an
*asynchronous* implementation
which, in turn, would require a much more
complex set of dependencies (on
asyncio or Twisted for example).
Parameters:
virtual_memory_in_megabytes (int, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
virtual_memory_in_megabytes (
:py:class:`
int
`
, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
max_cpu_percent (int, Optional): The maximum amount of CPU usage allowed
in a system. This number must be an integer number between 0 and
``100*number_of_cores`` in your system. For instance, if your system
has 2 cores, this number can go between 0 and 200. If it is <= 0, then
we don't track CPU usage.
max_cpu_percent (:py:class:`int`, Optional): The maximum amount of
CPU usage allowed in a system. This number must be an integer
number between 0 and ``100*number_of_cores`` in your system. For
instance, if your system has 2 cores, this number can go between 0
and 200. If it is <= 0, then we don't track CPU usage.
timeout_in_minutes (:py:class:`int`, Optional): The number of minutes
to wait for the user process to execute. After this amount of time,
the user process is killed with ``signal.SIGKILL``. If set to zero,
no timeout will be applied.
timeout_in_minutes (int): The number of minutes to wait for the user
process to execute. After this amount of time, the user process is
killed with :py:attr:`signal.SIGKILL`. If set to zero, no timeout will
be applied.
Returns:
dict: A dictionary which is JSON formattable containing the summary
of
this block execution.
dict: A dictionary which is JSON formattable containing the summary
of
this block execution.
"""
...
...
beat/core/execution/local.py
View file @
894990a6
...
...
@@ -70,41 +70,42 @@ class LocalExecutor(BaseExecutor):
string is passed, it is supposed to be a fully qualified absolute path to
a JSON file containing the block execution information.
cache (str,
o
ptional): If your cache is not located under
cache (
:py:class:`
str
`
,
O
ptional): If your cache is not located under
``<prefix>/cache``, then specify a full path here. It will be used
instead.
dataformat_cache (dict, optional): A dictionary mapping dataformat names to
loaded dataformats. This parameter is optional and, if passed, may
greatly speed-up database loading times as dataformats that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying dataformats
change.
database_cache (dict, optional): A dictionary mapping database names to
loaded databases. This parameter is optional and, if passed, may
greatly speed-up database loading times as databases that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying databases
change.
algorithm_cache (dict, optional): A dictionary mapping algorithm names to
loaded algorithms. This parameter is optional and, if passed, may
greatly speed-up database loading times as algorithms that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying algorithms
change.
library_cache (dict, optional): A dictionary mapping library names to
loaded libraries. This parameter is optional and, if passed, may greatly
speed-up library loading times as libraries that are already loaded may
be re-used. If you use this parameter, you must guarantee that the cache
is refreshed as appropriate in case the underlying libraries change.
custom_root_folders (dict, optional): A dictionary where the keys are database
identifiers (`<db_name>/<version>`) and the values are paths to the
given database's files. These values will override the value found
in the database's metadata.
dataformat_cache (:py:class:`dict`, Optional): A dictionary mapping
dataformat names to loaded dataformats. This parameter is optional and,
if passed, may greatly speed-up database loading times as dataformats
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying dataformats change.
database_cache (:py:class:`dict`, Optional): A dictionary mapping
database names to loaded databases. This parameter is optional and, if
passed, may greatly speed-up database loading times as databases that
are already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying databases change.
algorithm_cache (:py:class:`dict`, Optional): A dictionary mapping
algorithm names to loaded algorithms. This parameter is optional and,
if passed, may greatly speed-up database loading times as algorithms
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying algorithms change.
library_cache (:py:class:`dict`, Optional): A dictionary mapping library
names to loaded libraries. This parameter is optional and, if passed,
may greatly speed-up library loading times as libraries that are
already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying libraries change.
custom_root_folders (:py:class:`dict`, Optional): A dictionary where the
keys are database identifiers (``<db_name>/<version>``) and the values
are paths to the given database's files. These values will override the
value found in the database's metadata.
Attributes:
...
...
@@ -117,11 +118,11 @@ class LocalExecutor(BaseExecutor):
data (dict): The original data for this executor, as loaded by our JSON
decoder.
algorithm (
beat.core
.algorithm.Algorithm): An object representing the
algorithm (.algorithm.Algorithm): An object representing the
algorithm to be run.
databases (dict): A dictionary in which keys are strings with database
names and values are :py:class:`database.Database`, representing the
names and values are :py:class:`
.
database.Database`, representing the
databases required for running this block. The dictionary may be empty
in case all inputs are taken from the file cache.
...
...
@@ -130,11 +131,11 @@ class LocalExecutor(BaseExecutor):
for that particular combination of details. The dictionary may be empty
in case all inputs are taken from the file cache.
input_list (beat.
core
.inputs.InputList): A list of inputs that
will be
served to the algorithm.
input_list (beat.
backend.python
.inputs.InputList): A list of inputs that
will be
served to the algorithm.
output_list (beat.
core
.outputs.OutputList): A list of outputs
that the
algorithm will produce.
output_list (beat.
backend.python
.outputs.OutputList): A list of outputs
that the
algorithm will produce.
data_sources (list): A list with all data-sources created by our execution
loader.
...
...
@@ -203,20 +204,20 @@ class LocalExecutor(BaseExecutor):
Parameters:
virtual_memory_in_megabytes (int, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
virtual_memory_in_megabytes (
:py:class:`
int
`
, Optional): The amount
of virtual memory
(in Megabytes) available for the job. If set to
zero, no limit will be
applied.
max_cpu_percent (int, Optional): The maximum amount of
CPU usage allowed
in a system. This number must be an integer
number between 0 and
``100*number_of_cores`` in your system. For
instance, if your system
has 2 cores, this number can go between 0
and 200. If it is <= 0, then
we don't track CPU usage.
max_cpu_percent (
:py:class:`
int
`
, Optional): The maximum amount of
CPU usage allowed
in a system. This number must be an integer
number between 0 and
``100*number_of_cores`` in your system. For
instance, if your system
has 2 cores, this number can go between 0
and 200. If it is <= 0, then
we don't track CPU usage.
timeout_in_minutes (int): The number of minutes to wait for the user
process to execute. After this amount of time, the user process is
killed with
:py:attr:
`signal.SIGKILL`. If set to zero, no timeout will
be
applied.
killed with
`
`signal.SIGKILL`
`
. If set to zero, no timeout will
be
applied.
Returns:
...
...
beat/core/execution/remote.py
View file @
894990a6
...
...
@@ -53,36 +53,37 @@ class RemoteExecutor(BaseExecutor):
string is passed, it is supposed to be a fully qualified absolute path to
a JSON file containing the block execution information.
cache (str,
o
ptional): If your cache is not located under
cache (
:py:class:`
str
`
,
O
ptional): If your cache is not located under
``<prefix>/cache``, then specify a full path here. It will be used
instead.
dataformat_cache (dict, optional): A dictionary mapping dataformat names to
loaded dataformats. This parameter is optional and, if passed, may
greatly speed-up database loading times as dataformats that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying dataformats
change.
database_cache (dict, optional): A dictionary mapping database names to
loaded databases. This parameter is optional and, if passed, may
greatly speed-up database loading times as databases that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying databases
change.
algorithm_cache (dict, optional): A dictionary mapping algorithm names to
loaded algorithms. This parameter is optional and, if passed, may
greatly speed-up database loading times as algorithms that are already
loaded may be re-used. If you use this parameter, you must guarantee that
the cache is refreshed as appropriate in case the underlying algorithms
change.
library_cache (dict, optional): A dictionary mapping library names to
loaded libraries. This parameter is optional and, if passed, may greatly
speed-up library loading times as libraries that are already loaded may
be re-used. If you use this parameter, you must guarantee that the cache
is refreshed as appropriate in case the underlying libraries change.
dataformat_cache (:py:class:`dict`, Optional): A dictionary mapping
dataformat names to loaded dataformats. This parameter is optional and,
if passed, may greatly speed-up database loading times as dataformats
that are already loaded may be re-used. If you use this parameter, you
must guarantee that the cache is refreshed as appropriate in case the
underlying dataformats change.
database_cache (:py:class:`dict`, Optional): A dictionary mapping
database names to loaded databases. This parameter is optional and, if
passed, may greatly speed-up database loading times as databases that
are already loaded may be re-used. If you use this parameter, you must
guarantee that the cache is refreshed as appropriate in case the
underlying databases change.
algorithm_cache (:py:class:`dict`, Optional): A dictionary mapping
algorithm names to loaded algorithms. This parameter is optional and,
if passed, may greatly speed-up database loading times as algorithms