A system for assigning and grading notebooks
Subcommands
===========
Subcommands are launched as `nbgrader cmd [args]`. For information on using
subcommand 'cmd', do: `nbgrader cmd -h`.
assign
DEPRECATED, please use generate_assignment instead.
generate_assignment
Create the student version of an assignment. Intended for use by
instructors only.
autograde
Autograde submitted assignments. Intended for use by instructors
only.
formgrade
Manually grade assignments (after autograding). Intended for use
by instructors only.
feedback
DEPRECATED: use generate_feedback instead.
generate_feedback
Generate feedback (after autograding and manual grading).
Intended for use by instructors only.
validate
Validate a notebook in an assignment. Intended for use by
instructors and students.
release
DEPRECATED: use release_assignment instead.
release_assignment
Release an assignment to students through the nbgrader exchange.
Intended for use by instructors only.
release_feedback
Release assignment feedback to students through the nbgrader exchange.
Intended for use by instructors only.
collect
Collect an assignment from students through the nbgrader exchange.
Intended for use by instructors only.
zip_collect
Collect assignment submissions from files and/or archives (zip
files) manually downloaded from a LMS.
Intended for use by instructors only.
fetch
DEPRECATED: use fetch_assignment instead.
fetch_assignment
Fetch an assignment from an instructor through the nbgrader exchange.
Intended for use by students only.
fetch_feedback
Fetch feedback for an assignment from an instructor through the nbgrader exchange.
Intended for use by students only.
submit
Submit an assignment to an instructor through the nbgrader exchange.
Intended for use by students only.
list
List inbound or outbound assignments in the nbgrader exchange.
Intended for use by instructors and students.
extension
Install and activate the "Create Assignment" notebook extension.
quickstart
Create an example class files directory with an example
config file and assignment.
export
Export grades from the database to another format.
db
Perform operations on the nbgrader database, such as adding,
removing, importing, and listing assignments or students.
update
Update nbgrader cell metadata to the most recent version.
generate_config
Generates a default nbgrader_config.py file.
generate_solution
Generates the solution for the given assignment.
Options
=======
The options below are convenience aliases to configurable class-options,
as listed in the "Equivalent to" description-line of the aliases.
To see all configurable class-options for some <cmd>, use:
<cmd> --help-all
--debug
set log level to DEBUG (maximize logging output)
Equivalent to: [--Application.log_level=DEBUG]
--quiet
set log level to CRITICAL (minimize logging output)
Equivalent to: [--Application.log_level=CRITICAL]
--log-level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
Equivalent to: [--Application.log_level]
--student=<Unicode>
File glob to match student IDs. This can be changed to filter by student.
Note: this is always changed to '.' when running `nbgrader assign`, as the
assign step doesn't have any student ID associated with it. With `nbgrader
submit`, this instead forces the use of an alternative student ID for the
submission. See `nbgrader submit --help`.
If the ID is purely numeric and you are passing it as a flag on the command
line, you will need to escape the quotes in order to have it detected as a
string, for example `--student=""12345""`. See:
https://github.com/jupyter/nbgrader/issues/743
for more details.
Default: '*'
Equivalent to: [--CourseDirectory.student_id]
--assignment=<Unicode>
The assignment name. This MUST be specified, either by setting the config
option, passing an argument on the command line, or using the --assignment
option on the command line.
Default: ''
Equivalent to: [--CourseDirectory.assignment_id]
--notebook=<Unicode>
File glob to match notebook names, excluding the '.ipynb' extension. This
can be changed to filter by notebook.
Default: '*'
Equivalent to: [--CourseDirectory.notebook_id]
--db=<Unicode>
URL to the database. Defaults to sqlite:///<root>/gradebook.db, where <root>
is another configurable variable.
Default: ''
Equivalent to: [--CourseDirectory.db_url]
--course-dir=<Unicode>
The root directory for the course files (that includes the `source`,
`release`, `submitted`, `autograded`, etc. directories). Defaults to the
current working directory.
Default: ''
Equivalent to: [--CourseDirectory.root]
Class options
=============
The command-line option below sets the respective configurable class-parameter:
--Class.parameter=value
This line is evaluated in Python, so simple expressions are allowed.
For instance, to set `C.a=[0,1,2]`, you may type this:
--C.a='range(3)'
Application(SingletonConfigurable) options
------------------------------------------
--Application.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--Application.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--Application.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--Application.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--Application.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--Application.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
JupyterApp(Application) options
-------------------------------
--JupyterApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--JupyterApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--JupyterApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--JupyterApp.generate_config=<Bool>
Generate default config file.
Default: False
--JupyterApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--JupyterApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--JupyterApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--JupyterApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--JupyterApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--JupyterApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
NbGrader(JupyterApp) options
----------------------------
--NbGrader.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--NbGrader.config_file=<Unicode>
Full path of a config file.
Default: ''
--NbGrader.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--NbGrader.generate_config=<Bool>
Generate default config file.
Default: False
--NbGrader.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--NbGrader.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--NbGrader.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--NbGrader.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--NbGrader.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--NbGrader.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--NbGrader.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
NbGraderApp(NbGrader) options
-----------------------------
--NbGraderApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--NbGraderApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--NbGraderApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--NbGraderApp.generate_config=<Bool>
Generate default config file.
Default: False
--NbGraderApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--NbGraderApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--NbGraderApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--NbGraderApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--NbGraderApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--NbGraderApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--NbGraderApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ExchangeFactory(LoggingConfigurable) options
--------------------------------------------
--ExchangeFactory.collect=<Type>
A plugin for collecting assignments.
Default: 'nbgrader.exchange.default.collect.ExchangeCollect'
--ExchangeFactory.exchange=<Type>
A plugin for exchange.
Default: 'nbgrader.exchange.default.exchange.Exchange'
--ExchangeFactory.fetch_assignment=<Type>
A plugin for fetching assignments.
Default: 'nbgrader.exchange.default.fetch_assignment.ExchangeFetchAssi...
--ExchangeFactory.fetch_feedback=<Type>
A plugin for fetching feedback.
Default: 'nbgrader.exchange.default.fetch_feedback.ExchangeFetchFeedback'
--ExchangeFactory.list=<Type>
A plugin for listing exchange files.
Default: 'nbgrader.exchange.default.list.ExchangeList'
--ExchangeFactory.release_assignment=<Type>
A plugin for releasing assignments.
Default: 'nbgrader.exchange.default.release_assignment.ExchangeRelease...
--ExchangeFactory.release_feedback=<Type>
A plugin for releasing feedback.
Default: 'nbgrader.exchange.default.release_feedback.ExchangeReleaseFe...
--ExchangeFactory.submit=<Type>
A plugin for submitting assignments.
Default: 'nbgrader.exchange.default.submit.ExchangeSubmit'
CourseDirectory(LoggingConfigurable) options
--------------------------------------------
--CourseDirectory.assignment_id=<Unicode>
The assignment name. This MUST be specified, either by setting the config
option, passing an argument on the command line, or using the --assignment
option on the command line.
Default: ''
--CourseDirectory.autograded_directory=<Unicode>
The name of the directory that contains assignment submissions after they
have been autograded. This corresponds to the `nbgrader_step` variable in
the `directory_structure` config option.
Default: 'autograded'
--CourseDirectory.course_id=<Unicode>
A key that is unique per instructor and course. This can be specified,
either by setting the config option, or using the --course option on the
command line.
Default: ''
--CourseDirectory.db_url=<Unicode>
URL to the database. Defaults to sqlite:///<root>/gradebook.db, where <root>
is another configurable variable.
Default: ''
--CourseDirectory.directory_structure=<Unicode>
Format string for the directory structure that nbgrader works over during
the grading process. This MUST contain named keys for 'nbgrader_step',
'student_id', and 'assignment_id'. It SHOULD NOT contain a key for
'notebook_id', as this will be automatically joined with the rest of the
path.
Default: '{nbgrader_step}/{student_id}/{assignment_id}'
--CourseDirectory.feedback_directory=<Unicode>
The name of the directory that contains assignment feedback after grading
has been completed. This corresponds to the `nbgrader_step` variable in the
`directory_structure` config option.
Default: 'feedback'
--CourseDirectory.groupshared=<Bool>
Make all instructor files group writeable (g+ws, default g+r only) and
exchange directories group readable/writeable (g+rws, default g=nothing only
) by default. This should only be used if you carefully set the primary
groups of your notebook servers and fully understand the unix permission
model. This changes the default permissions from 444 (unwriteable) to 664
(writeable), so that other instructors are able to delete/overwrite files.
Default: False
--CourseDirectory.ignore=<list-item-1>...
List of file names or file globs. Upon copying directories recursively,
matching files and directories will be ignored with a debug message.
Default: ['.ipynb_checkpoints', '*.pyc', '__pycache__', 'feedback']
--CourseDirectory.include=<list-item-1>...
List of file names or file globs. Upon copying directories recursively, non
matching files will be ignored with a debug message.
Default: ['*']
--CourseDirectory.max_dir_size=<Int>
Maximum size of directories (in kilobytes; default: 100Mb). Upon copying
directories recursively, larger files will be ignored with a warning.
Default: 100000
--CourseDirectory.max_file_size=<Int>
Maximum size of files (in kilobytes; default: 100Mb). Upon copying
directories recursively, larger files will be ignored with a warning.
Default: 100000
--CourseDirectory.notebook_id=<Unicode>
File glob to match notebook names, excluding the '.ipynb' extension. This
can be changed to filter by notebook.
Default: '*'
--CourseDirectory.release_directory=<Unicode>
The name of the directory that contains the version of the assignment that
will be released to students. This corresponds to the `nbgrader_step`
variable in the `directory_structure` config option.
Default: 'release'
--CourseDirectory.root=<Unicode>
The root directory for the course files (that includes the `source`,
`release`, `submitted`, `autograded`, etc. directories). Defaults to the
current working directory.
Default: ''
--CourseDirectory.solution_directory=<Unicode>
The name of the directory that contains the assignment solution after
grading has been completed. This corresponds to the `nbgrader_step` variable
in the `directory_structure` config option.
Default: 'solution'
--CourseDirectory.source_directory=<Unicode>
The name of the directory that contains the master/instructor version of
assignments. This corresponds to the `nbgrader_step` variable in the
`directory_structure` config option.
Default: 'source'
--CourseDirectory.source_with_tests_directory=<Unicode>
The name of the directory that contains notebooks with both solutions and
instantiated test code (i.e., all AUTOTEST directives are removed and
replaced by actual test code). This corresponds to the `nbgrader_step`
variable in the `directory_structure` config option.
Default: 'source_with_tests'
--CourseDirectory.student_id=<Unicode>
File glob to match student IDs. This can be changed to filter by student.
Note: this is always changed to '.' when running `nbgrader assign`, as the
assign step doesn't have any student ID associated with it. With `nbgrader
submit`, this instead forces the use of an alternative student ID for the
submission. See `nbgrader submit --help`.
If the ID is purely numeric and you are passing it as a flag on the command
line, you will need to escape the quotes in order to have it detected as a
string, for example `--student=""12345""`. See:
https://github.com/jupyter/nbgrader/issues/743
for more details.
Default: '*'
--CourseDirectory.student_id_exclude=<Unicode>
Comma-separated list of student IDs to exclude. Counterpart of student_id.
This is useful when running commands on all students, but certain students
cause errors or otherwise must be left out. Works at least for autograde,
generate_feedback, and release_feedback.
Default: ''
--CourseDirectory.submitted_directory=<Unicode>
The name of the directory that contains assignments that have been submitted
by students for grading. This corresponds to the `nbgrader_step` variable in
the `directory_structure` config option.
Default: 'submitted'
Authenticator(LoggingConfigurable) options
------------------------------------------
--Authenticator.plugin_class=<Type>
A plugin for different authentication methods.
Default: 'nbgrader.auth.base.NoAuthPlugin'
GenerateAssignmentApp(NbGrader) options
---------------------------------------
--GenerateAssignmentApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--GenerateAssignmentApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--GenerateAssignmentApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--GenerateAssignmentApp.generate_config=<Bool>
Generate default config file.
Default: False
--GenerateAssignmentApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--GenerateAssignmentApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--GenerateAssignmentApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--GenerateAssignmentApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--GenerateAssignmentApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--GenerateAssignmentApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--GenerateAssignmentApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
--GenerateAssignmentApp.source_with_tests=<Bool>
Generate intermediate notebooks that contain both the autogenerated test
code and the solutions. Results will be saved in the source_with_tests/
folder. This is useful for instructors to debug issues in autogenerated test
code.
Default: False
AssignApp(GenerateAssignmentApp) options
----------------------------------------
--AssignApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--AssignApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--AssignApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--AssignApp.generate_config=<Bool>
Generate default config file.
Default: False
--AssignApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--AssignApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--AssignApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--AssignApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--AssignApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--AssignApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--AssignApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
--AssignApp.source_with_tests=<Bool>
Generate intermediate notebooks that contain both the autogenerated test
code and the solutions. Results will be saved in the source_with_tests/
folder. This is useful for instructors to debug issues in autogenerated test
code.
Default: False
AutogradeApp(NbGrader) options
------------------------------
--AutogradeApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--AutogradeApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--AutogradeApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--AutogradeApp.generate_config=<Bool>
Generate default config file.
Default: False
--AutogradeApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--AutogradeApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--AutogradeApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--AutogradeApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--AutogradeApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--AutogradeApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--AutogradeApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
FormgradeApp(NbGrader) options
------------------------------
--FormgradeApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--FormgradeApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--FormgradeApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--FormgradeApp.generate_config=<Bool>
Generate default config file.
Default: False
--FormgradeApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--FormgradeApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--FormgradeApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--FormgradeApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--FormgradeApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--FormgradeApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--FormgradeApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
GenerateFeedbackApp(NbGrader) options
-------------------------------------
--GenerateFeedbackApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--GenerateFeedbackApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--GenerateFeedbackApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--GenerateFeedbackApp.generate_config=<Bool>
Generate default config file.
Default: False
--GenerateFeedbackApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--GenerateFeedbackApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--GenerateFeedbackApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--GenerateFeedbackApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--GenerateFeedbackApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--GenerateFeedbackApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--GenerateFeedbackApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
FeedbackApp(GenerateFeedbackApp) options
----------------------------------------
--FeedbackApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--FeedbackApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--FeedbackApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--FeedbackApp.generate_config=<Bool>
Generate default config file.
Default: False
--FeedbackApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--FeedbackApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--FeedbackApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--FeedbackApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--FeedbackApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--FeedbackApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--FeedbackApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ValidateApp(NbGrader) options
-----------------------------
--ValidateApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ValidateApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ValidateApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ValidateApp.generate_config=<Bool>
Generate default config file.
Default: False
--ValidateApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ValidateApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ValidateApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ValidateApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ValidateApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ValidateApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ValidateApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ReleaseAssignmentApp(NbGrader) options
--------------------------------------
--ReleaseAssignmentApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ReleaseAssignmentApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ReleaseAssignmentApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ReleaseAssignmentApp.generate_config=<Bool>
Generate default config file.
Default: False
--ReleaseAssignmentApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ReleaseAssignmentApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ReleaseAssignmentApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ReleaseAssignmentApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ReleaseAssignmentApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ReleaseAssignmentApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ReleaseAssignmentApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ReleaseApp(ReleaseAssignmentApp) options
----------------------------------------
--ReleaseApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ReleaseApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ReleaseApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ReleaseApp.generate_config=<Bool>
Generate default config file.
Default: False
--ReleaseApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ReleaseApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ReleaseApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ReleaseApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ReleaseApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ReleaseApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ReleaseApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ReleaseFeedbackApp(NbGrader) options
------------------------------------
--ReleaseFeedbackApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ReleaseFeedbackApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ReleaseFeedbackApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ReleaseFeedbackApp.generate_config=<Bool>
Generate default config file.
Default: False
--ReleaseFeedbackApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ReleaseFeedbackApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ReleaseFeedbackApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ReleaseFeedbackApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ReleaseFeedbackApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ReleaseFeedbackApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ReleaseFeedbackApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
CollectApp(NbGrader) options
----------------------------
--CollectApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--CollectApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--CollectApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--CollectApp.generate_config=<Bool>
Generate default config file.
Default: False
--CollectApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--CollectApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--CollectApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--CollectApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--CollectApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--CollectApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--CollectApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ZipCollectApp(NbGrader) options
-------------------------------
--ZipCollectApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ZipCollectApp.archive_directory=<Unicode>
The name of the directory that contains assignment submission files and/or
archives (zip) files manually downloaded from a LMS. This corresponds to the
`collect_step` variable in the `collect_structure` config option.
Default: 'archive'
--ZipCollectApp.collect_directory_structure=<Unicode>
Format string for the directory structure that nbgrader works over during
the zip collect process. This MUST contain named keys for 'downloaded',
'assignment_id', and 'collect_step'.
Default: '{downloaded}/{assignment_id}/{collect_step}'
--ZipCollectApp.collector_plugin=<Type>
The plugin class for processing the submitted file names after they have
been extracted into the `extracted_directory`.
Default: 'nbgrader.plugins.zipcollect.FileNameCollectorPlugin'
--ZipCollectApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ZipCollectApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ZipCollectApp.downloaded_directory=<Unicode>
The main directory that corresponds to the `downloaded` variable in the
`collect_structure` config option.
Default: 'downloaded'
--ZipCollectApp.extracted_directory=<Unicode>
The name of the directory that contains assignment submission files
extracted or copied from the `archive_directory`. This corresponds to the
`collect_step` variable in the `collect_structure` config option.
Default: 'extracted'
--ZipCollectApp.extractor_plugin=<Type>
The plugin class for extracting the archive files in the
`archive_directory`.
Default: 'nbgrader.plugins.zipcollect.ExtractorPlugin'
--ZipCollectApp.force=<Bool>
Force overwrite of existing files.
Default: False
--ZipCollectApp.generate_config=<Bool>
Generate default config file.
Default: False
--ZipCollectApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ZipCollectApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ZipCollectApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ZipCollectApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ZipCollectApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ZipCollectApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ZipCollectApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
--ZipCollectApp.strict=<Bool>
Skip submitted notebooks with invalid names.
Default: False
FetchAssignmentApp(NbGrader) options
------------------------------------
--FetchAssignmentApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--FetchAssignmentApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--FetchAssignmentApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--FetchAssignmentApp.generate_config=<Bool>
Generate default config file.
Default: False
--FetchAssignmentApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--FetchAssignmentApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--FetchAssignmentApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--FetchAssignmentApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--FetchAssignmentApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--FetchAssignmentApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--FetchAssignmentApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
FetchApp(FetchAssignmentApp) options
------------------------------------
--FetchApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--FetchApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--FetchApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--FetchApp.generate_config=<Bool>
Generate default config file.
Default: False
--FetchApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--FetchApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--FetchApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--FetchApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--FetchApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--FetchApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--FetchApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
FetchFeedbackApp(NbGrader) options
----------------------------------
--FetchFeedbackApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--FetchFeedbackApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--FetchFeedbackApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--FetchFeedbackApp.generate_config=<Bool>
Generate default config file.
Default: False
--FetchFeedbackApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--FetchFeedbackApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--FetchFeedbackApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--FetchFeedbackApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--FetchFeedbackApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--FetchFeedbackApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--FetchFeedbackApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
SubmitApp(NbGrader) options
---------------------------
--SubmitApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--SubmitApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--SubmitApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--SubmitApp.generate_config=<Bool>
Generate default config file.
Default: False
--SubmitApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--SubmitApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--SubmitApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--SubmitApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--SubmitApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--SubmitApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--SubmitApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ListApp(NbGrader) options
-------------------------
--ListApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ListApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ListApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ListApp.generate_config=<Bool>
Generate default config file.
Default: False
--ListApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ListApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ListApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ListApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ListApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ListApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ListApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ExtensionApp(NbGrader) options
------------------------------
--ExtensionApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ExtensionApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ExtensionApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ExtensionApp.generate_config=<Bool>
Generate default config file.
Default: False
--ExtensionApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ExtensionApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ExtensionApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ExtensionApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ExtensionApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ExtensionApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ExtensionApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
QuickStartApp(NbGrader) options
-------------------------------
--QuickStartApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--QuickStartApp.autotest=<Bool>
Whether to use automatic test generation in example files
Default: False
--QuickStartApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--QuickStartApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--QuickStartApp.force=<Bool>
Whether to overwrite existing files
Default: False
--QuickStartApp.generate_config=<Bool>
Generate default config file.
Default: False
--QuickStartApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--QuickStartApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--QuickStartApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--QuickStartApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--QuickStartApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--QuickStartApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--QuickStartApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ExportApp(NbGrader) options
---------------------------
--ExportApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--ExportApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--ExportApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--ExportApp.generate_config=<Bool>
Generate default config file.
Default: False
--ExportApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--ExportApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--ExportApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--ExportApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--ExportApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--ExportApp.plugin_class=<Type>
The plugin class for exporting the grades.
Default: 'nbgrader.plugins.export.CsvExportPlugin'
--ExportApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--ExportApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
DbBaseApp(NbGrader) options
---------------------------
--DbBaseApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--DbBaseApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--DbBaseApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--DbBaseApp.generate_config=<Bool>
Generate default config file.
Default: False
--DbBaseApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--DbBaseApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--DbBaseApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--DbBaseApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--DbBaseApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--DbBaseApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--DbBaseApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
DbApp(DbBaseApp) options
------------------------
--DbApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--DbApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--DbApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--DbApp.generate_config=<Bool>
Generate default config file.
Default: False
--DbApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--DbApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--DbApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--DbApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--DbApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--DbApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--DbApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
UpdateApp(NbGrader) options
---------------------------
--UpdateApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--UpdateApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--UpdateApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--UpdateApp.generate_config=<Bool>
Generate default config file.
Default: False
--UpdateApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--UpdateApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--UpdateApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--UpdateApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--UpdateApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--UpdateApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--UpdateApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
--UpdateApp.validate=<Bool>
whether to validate metadata after updating it
Default: True
GenerateConfigApp(NbGrader) options
-----------------------------------
--GenerateConfigApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--GenerateConfigApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--GenerateConfigApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--GenerateConfigApp.filename=<Unicode>
The name of the configuration file to generate.
Default: 'nbgrader_config.py'
--GenerateConfigApp.generate_config=<Bool>
Generate default config file.
Default: False
--GenerateConfigApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--GenerateConfigApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--GenerateConfigApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--GenerateConfigApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--GenerateConfigApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--GenerateConfigApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--GenerateConfigApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
GenerateSolutionApp(NbGrader) options
-------------------------------------
--GenerateSolutionApp.answer_yes=<Bool>
Answer yes to any prompts.
Default: False
--GenerateSolutionApp.config_file=<Unicode>
Full path of a config file.
Default: ''
--GenerateSolutionApp.config_file_name=<Unicode>
Specify a config file to load.
Default: ''
--GenerateSolutionApp.generate_config=<Bool>
Generate default config file.
Default: False
--GenerateSolutionApp.log_datefmt=<Unicode>
The date format used by logging formatters for %(asctime)s
Default: '%Y-%m-%d %H:%M:%S'
--GenerateSolutionApp.log_format=<Unicode>
The Logging format template
Default: '[%(name)s]%(highlevel)s %(message)s'
--GenerateSolutionApp.log_level=<Enum>
Set the log level by value or name.
Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
Default: 30
--GenerateSolutionApp.logfile=<Unicode>
Name of the logfile to log to. By default, log output is not written to any
file.
Default: ''
--GenerateSolutionApp.logging_config=<key-1>=<value-1>...
Configure additional log handlers.
The default stderr logs handler is configured by the log_level, log_datefmt
and log_format settings.
This configuration can be used to configure additional handlers (e.g. to
output the log to a file) or for finer control over the default handlers.
If provided this should be a logging configuration dictionary, for more
information see:
https://docs.python.org/3/library/logging.config.html#logging-config-
dictschema
This dictionary is merged with the base logging configuration which defines
the following:
* A logging formatter intended for interactive use called
``console``.
* A logging handler that writes to stderr called
``console`` which uses the formatter ``console``.
* A logger with the name of this application set to ``DEBUG``
level.
This example adds a new handler that writes to a file:
.. code-block:: python
c.Application.logging_config = {
"handlers": {
"file": {
"class": "logging.FileHandler",
"level": "DEBUG",
"filename": "<path/to/file>",
}
},
"loggers": {
"<application-name>": {
"level": "DEBUG",
# NOTE: if you don't list the default "console"
# handler here then it will be disabled
"handlers": ["console", "file"],
},
},
}
Default: {}
--GenerateSolutionApp.show_config=<Bool>
Instead of starting the Application, dump configuration to stdout
Default: False
--GenerateSolutionApp.show_config_json=<Bool>
Instead of starting the Application, dump configuration to stdout (as JSON)
Default: False
ExportPlugin(BasePlugin) options
--------------------------------
--ExportPlugin.assignment=<list-item-1>...
list of assignments to export
Default: []
--ExportPlugin.student=<list-item-1>...
list of students to export
Default: []
--ExportPlugin.to=<Unicode>
destination to export to
Default: ''
CsvExportPlugin(ExportPlugin) options
-------------------------------------
--CsvExportPlugin.assignment=<list-item-1>...
list of assignments to export
Default: []
--CsvExportPlugin.student=<list-item-1>...
list of students to export
Default: []
--CsvExportPlugin.to=<Unicode>
destination to export to
Default: ''
ExtractorPlugin(BasePlugin) options
-----------------------------------
--ExtractorPlugin.force=<Bool>
Force overwrite of existing files.
Default: False
--ExtractorPlugin.zip_ext=<list-item-1>...
List of valid archive (zip) filename extensions to extract. Any archive
(zip) files with an extension not in this list are copied to the
`extracted_directory`.
Default: ['.zip', '.gz']
FileNameCollectorPlugin(BasePlugin) options
-------------------------------------------
--FileNameCollectorPlugin.named_regexp=<Unicode>
This regular expression is applied to each submission filename and MUST be
supplied by the instructor. This regular expression MUST provide the
`(?P<student_id>...)` and `(?P<file_id>...)` named group expressions.
Optionally this regular expression can also provide the
`(?P<first_name>...)`, `(?P<last_name>...)`, `(?P<email>...)`, and
`(?P<timestamp>...)` named group expressions. For example if the filename
is:
`ps1_bitdiddle_attempt_2016-01-30-15-00-00_problem1.ipynb`
then this `named_regexp` could be:
".*_(?P<student_id>\w+)_attempt_(?P<timestamp>[0-9\-]+)_(?P<file_id>\w+)"
For named group regular expression examples see
https://docs.python.org/3/howto/regex.html
Default: ''
--FileNameCollectorPlugin.valid_ext=<list-item-1>...
List of valid submission filename extensions to collect. Any submitted file
with an extension not in this list is skipped.
Default: ['.ipynb']
LateSubmissionPlugin(BasePlugin) options
----------------------------------------
--LateSubmissionPlugin.penalty_method=<Enum>
The method for assigning late submission penalties:
'none': do nothing (no penalty assigned)
'zero': assign an overall score of zero (penalty = score)
Choices: any of ['none', 'zero']
Default: 'none'
NbConvertBase(LoggingConfigurable) options
------------------------------------------
--NbConvertBase.default_language=<Unicode>
Deprecated default highlight language as of 5.0, please use language_info
metadata instead
Default: 'ipython'
--NbConvertBase.display_data_priority=<list-item-1>...
An ordered list of preferred output type, the first encountered will usually
be used when converting discarding the others.
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
Preprocessor(NbConvertBase) options
-----------------------------------
--Preprocessor.default_language=<Unicode>
Deprecated default highlight language as of 5.0, please use language_info
metadata instead
Default: 'ipython'
--Preprocessor.display_data_priority=<list-item-1>...
An ordered list of preferred output type, the first encountered will usually
be used when converting discarding the others.
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
--Preprocessor.enabled=<Bool>
Default: False
NbGraderPreprocessor(Preprocessor) options
------------------------------------------
--NbGraderPreprocessor.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
AssignLatePenalties(NbGraderPreprocessor) options
-------------------------------------------------
--AssignLatePenalties.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--AssignLatePenalties.plugin_class=<Type>
The plugin class for assigning the late penalty for each notebook.
Default: 'nbgrader.plugins.latesubmission.LateSubmissionPlugin'
IncludeHeaderFooter(NbGraderPreprocessor) options
-------------------------------------------------
--IncludeHeaderFooter.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--IncludeHeaderFooter.footer=<Unicode>
Path to footer notebook, relative to the root of the course directory
Default: ''
--IncludeHeaderFooter.header=<Unicode>
Path to header notebook, relative to the root of the course directory
Default: ''
LockCells(NbGraderPreprocessor) options
---------------------------------------
--LockCells.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--LockCells.lock_all_cells=<Bool>
Whether all assignment cells are locked (non-deletable and non-editable)
Default: False
--LockCells.lock_grade_cells=<Bool>
Whether grade cells are locked (non-deletable)
Default: True
--LockCells.lock_readonly_cells=<Bool>
Whether readonly cells are locked (non-deletable and non-editable)
Default: True
--LockCells.lock_solution_cells=<Bool>
Whether solution cells are locked (non-deletable and non-editable)
Default: True
ClearSolutions(NbGraderPreprocessor) options
--------------------------------------------
--ClearSolutions.begin_solution_delimeter=<Unicode>
The delimiter marking the beginning of a solution
Default: 'BEGIN SOLUTION'
--ClearSolutions.code_stub=<key-1>=<value-1>...
The code snippet that will replace code solutions
Default: {'python': '# YOUR CODE HERE\nraise NotImplementedError()', '...
--ClearSolutions.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--ClearSolutions.end_solution_delimeter=<Unicode>
The delimiter marking the end of a solution
Default: 'END SOLUTION'
--ClearSolutions.enforce_metadata=<Bool>
Whether or not to complain if cells containing solutions regions are not
marked as solution cells. WARNING: this will potentially cause things to
break if you are using the full nbgrader pipeline. ONLY disable this option
if you are only ever planning to use nbgrader assign.
Default: True
--ClearSolutions.text_stub=<Unicode>
The text snippet that will replace written solutions
Default: 'YOUR ANSWER HERE'
SaveAutoGrades(NbGraderPreprocessor) options
--------------------------------------------
--SaveAutoGrades.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
ComputeChecksums(NbGraderPreprocessor) options
----------------------------------------------
--ComputeChecksums.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
SaveCells(NbGraderPreprocessor) options
---------------------------------------
--SaveCells.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
OverwriteCells(NbGraderPreprocessor) options
--------------------------------------------
--OverwriteCells.add_missing_cells=<Bool>
Whether or not missing grade_cells should be added back to the notebooks
being graded.
Default: False
--OverwriteCells.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--OverwriteCells.missing_cell_notification=<Unicode>
A text to add at the beginning of every missing cell re-added to the
notebook during autograding.
Default: 'This cell (id:{cell_id}) was missing from the submission. It...
CheckCellMetadata(NbGraderPreprocessor) options
-----------------------------------------------
--CheckCellMetadata.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
NotebookClient(LoggingConfigurable) options
-------------------------------------------
--NotebookClient.allow_error_names=<list-item-1>...
List of error names which won't stop the execution. Use this if the
``allow_errors`` option it too general and you want to allow only specific
kinds of errors.
Default: []
--NotebookClient.allow_errors=<Bool>
If ``False`` (default), when a cell raises an error the execution is stopped
and a ``CellExecutionError`` is raised, except if the error name is in
``allow_error_names``. If ``True``, execution errors are ignored and the
execution is continued until the end of the notebook. Output from exceptions
is included in the cell output in both cases.
Default: False
--NotebookClient.display_data_priority=<list-item-1>...
An ordered list of preferred output type, the first encountered will usually
be used when converting discarding the others.
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
--NotebookClient.error_on_timeout=<key-1>=<value-1>...
If a cell execution was interrupted after a timeout, don't wait for the
execute_reply from the kernel (e.g. KeyboardInterrupt error). Instead,
return an execute_reply with the given error, which should be of the
following form::
{
'ename': str, # Exception name, as a string
'evalue': str, # Exception value, as a string
'traceback': list(str), # traceback frames, as strings
}
Default: None
--NotebookClient.extra_arguments=<list-item-1>...
Default: []
--NotebookClient.force_raise_errors=<Bool>
If False (default), errors from executing the notebook can be allowed with a
``raises-exception`` tag on a single cell, or the ``allow_errors`` or
``allow_error_names`` configurable options for all cells. An allowed error
will be recorded in notebook output, and execution will continue. If an
error occurs when it is not explicitly allowed, a ``CellExecutionError``
will be raised. If True, ``CellExecutionError`` will be raised for any error
that occurs while executing the notebook. This overrides the
``allow_errors`` and ``allow_error_names`` options and the ``raises-
exception`` cell tag.
Default: False
--NotebookClient.interrupt_on_timeout=<Bool>
If execution of a cell times out, interrupt the kernel and continue
executing other cells rather than throwing an error and stopping.
Default: False
--NotebookClient.iopub_timeout=<Int>
The time to wait (in seconds) for IOPub output. This generally doesn't need
to be set, but on some slow networks (such as CI systems) the default
timeout might not be long enough to get all messages.
Default: 4
--NotebookClient.ipython_hist_file=<Unicode>
Path to file to use for SQLite history database for an IPython kernel.
The specific value ``:memory:`` (including the colon
at both end but not the back ticks), avoids creating a history file. Otherwise, IPython
will create a history file for each kernel.
When running kernels simultaneously (e.g. via multiprocessing) saving history a single
SQLite file can result in database errors, so using ``:memory:`` is recommended in
non-interactive contexts.
Default: ':memory:'
--NotebookClient.kernel_manager_class=<Type>
The kernel manager class to use.
Default: 'jupyter_client.manager.KernelManager'
--NotebookClient.kernel_name=<Unicode>
Name of kernel to use to execute the cells. If not set, use the kernel_spec
embedded in the notebook.
Default: ''
--NotebookClient.on_cell_complete=<Callable>
A callable which executes after a cell execution is complete. It is called
even when a cell results in a failure. Called with kwargs ``cell`` and
``cell_index``.
Default: None
--NotebookClient.on_cell_error=<Callable>
A callable which executes when a cell execution results in an error. This is
executed even if errors are suppressed with ``cell_allows_errors``. Called
with kwargs ``cell`, ``cell_index`` and ``execute_reply``.
Default: None
--NotebookClient.on_cell_execute=<Callable>
A callable which executes just before a code cell is executed. Called with
kwargs ``cell`` and ``cell_index``.
Default: None
--NotebookClient.on_cell_executed=<Callable>
A callable which executes just after a code cell is executed, whether or not
it results in an error. Called with kwargs ``cell``, ``cell_index`` and
``execute_reply``.
Default: None
--NotebookClient.on_cell_start=<Callable>
A callable which executes before a cell is executed and before non-executing
cells are skipped. Called with kwargs ``cell`` and ``cell_index``.
Default: None
--NotebookClient.on_notebook_complete=<Callable>
A callable which executes after the kernel is cleaned up. Called with kwargs
``notebook``.
Default: None
--NotebookClient.on_notebook_error=<Callable>
A callable which executes when the notebook encounters an error. Called with
kwargs ``notebook``.
Default: None
--NotebookClient.on_notebook_start=<Callable>
A callable which executes after the kernel manager and kernel client are
setup, and cells are about to execute. Called with kwargs ``notebook``.
Default: None
--NotebookClient.raise_on_iopub_timeout=<Bool>
If ``False`` (default), then the kernel will continue waiting for iopub
messages until it receives a kernel idle message, or until a timeout occurs,
at which point the currently executing cell will be skipped. If ``True``,
then an error will be raised after the first timeout. This option generally
does not need to be used, but may be useful in contexts where there is the
possibility of executing notebooks with memory-consuming infinite loops.
Default: False
--NotebookClient.record_timing=<Bool>
If ``True`` (default), then the execution timings of each cell will be
stored in the metadata of the notebook.
Default: True
--NotebookClient.shell_timeout_interval=<Int>
The time to wait (in seconds) for Shell output before retrying. This
generally doesn't need to be set, but if one needs to check for dead kernels
at a faster rate this can help.
Default: 5
--NotebookClient.shutdown_kernel=<Enum>
If ``graceful`` (default), then the kernel is given time to clean up after
executing all cells, e.g., to execute its ``atexit`` hooks. If
``immediate``, then the kernel is signaled to immediately terminate.
Choices: any of ['graceful', 'immediate']
Default: 'graceful'
--NotebookClient.skip_cells_with_tag=<Unicode>
Name of the cell tag to use to denote a cell that should be skipped.
Default: 'skip-execution'
--NotebookClient.startup_timeout=<Int>
The time to wait (in seconds) for the kernel to start. If kernel startup
takes longer, a RuntimeError is raised.
Default: 60
--NotebookClient.store_widget_state=<Bool>
If ``True`` (default), then the state of the Jupyter widgets created at the
kernel will be stored in the metadata of the notebook.
Default: True
--NotebookClient.timeout=<Int>
The time to wait (in seconds) for output from executions. If a cell
execution takes longer, a TimeoutError is raised.
``None`` or ``-1`` will disable the timeout. If ``timeout_func`` is set, it
overrides ``timeout``.
Default: None
--NotebookClient.timeout_func=<Any>
A callable which, when given the cell source as input, returns the time to
wait (in seconds) for output from cell executions. If a cell execution takes
longer, a TimeoutError is raised.
Returning ``None`` or ``-1`` will disable the timeout for the cell. Not
setting ``timeout_func`` will cause the client to default to using the
``timeout`` trait for all cells. The ``timeout_func`` trait overrides
``timeout`` if it is not ``None``.
Default: None
ExecutePreprocessor(Preprocessor, NotebookClient) options
---------------------------------------------------------
--ExecutePreprocessor.allow_error_names=<list-item-1>...
List of error names which won't stop the execution. Use this if the
``allow_errors`` option it too general and you want to allow only specific
kinds of errors.
Default: []
--ExecutePreprocessor.allow_errors=<Bool>
If ``False`` (default), when a cell raises an error the execution is stopped
and a ``CellExecutionError`` is raised, except if the error name is in
``allow_error_names``. If ``True``, execution errors are ignored and the
execution is continued until the end of the notebook. Output from exceptions
is included in the cell output in both cases.
Default: False
--ExecutePreprocessor.default_language=<Unicode>
Deprecated default highlight language as of 5.0, please use language_info
metadata instead
Default: 'ipython'
--ExecutePreprocessor.display_data_priority=<list-item-1>...
An ordered list of preferred output type, the first encountered will usually
be used when converting discarding the others.
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
--ExecutePreprocessor.enabled=<Bool>
Default: False
--ExecutePreprocessor.error_on_timeout=<key-1>=<value-1>...
If a cell execution was interrupted after a timeout, don't wait for the
execute_reply from the kernel (e.g. KeyboardInterrupt error). Instead,
return an execute_reply with the given error, which should be of the
following form::
{
'ename': str, # Exception name, as a string
'evalue': str, # Exception value, as a string
'traceback': list(str), # traceback frames, as strings
}
Default: None
--ExecutePreprocessor.extra_arguments=<list-item-1>...
Default: []
--ExecutePreprocessor.force_raise_errors=<Bool>
If False (default), errors from executing the notebook can be allowed with a
``raises-exception`` tag on a single cell, or the ``allow_errors`` or
``allow_error_names`` configurable options for all cells. An allowed error
will be recorded in notebook output, and execution will continue. If an
error occurs when it is not explicitly allowed, a ``CellExecutionError``
will be raised. If True, ``CellExecutionError`` will be raised for any error
that occurs while executing the notebook. This overrides the
``allow_errors`` and ``allow_error_names`` options and the ``raises-
exception`` cell tag.
Default: False
--ExecutePreprocessor.interrupt_on_timeout=<Bool>
If execution of a cell times out, interrupt the kernel and continue
executing other cells rather than throwing an error and stopping.
Default: False
--ExecutePreprocessor.iopub_timeout=<Int>
The time to wait (in seconds) for IOPub output. This generally doesn't need
to be set, but on some slow networks (such as CI systems) the default
timeout might not be long enough to get all messages.
Default: 4
--ExecutePreprocessor.ipython_hist_file=<Unicode>
Path to file to use for SQLite history database for an IPython kernel.
The specific value ``:memory:`` (including the colon
at both end but not the back ticks), avoids creating a history file. Otherwise, IPython
will create a history file for each kernel.
When running kernels simultaneously (e.g. via multiprocessing) saving history a single
SQLite file can result in database errors, so using ``:memory:`` is recommended in
non-interactive contexts.
Default: ':memory:'
--ExecutePreprocessor.kernel_manager_class=<Type>
The kernel manager class to use.
Default: 'jupyter_client.manager.KernelManager'
--ExecutePreprocessor.kernel_name=<Unicode>
Name of kernel to use to execute the cells. If not set, use the kernel_spec
embedded in the notebook.
Default: ''
--ExecutePreprocessor.on_cell_complete=<Callable>
A callable which executes after a cell execution is complete. It is called
even when a cell results in a failure. Called with kwargs ``cell`` and
``cell_index``.
Default: None
--ExecutePreprocessor.on_cell_error=<Callable>
A callable which executes when a cell execution results in an error. This is
executed even if errors are suppressed with ``cell_allows_errors``. Called
with kwargs ``cell`, ``cell_index`` and ``execute_reply``.
Default: None
--ExecutePreprocessor.on_cell_execute=<Callable>
A callable which executes just before a code cell is executed. Called with
kwargs ``cell`` and ``cell_index``.
Default: None
--ExecutePreprocessor.on_cell_executed=<Callable>
A callable which executes just after a code cell is executed, whether or not
it results in an error. Called with kwargs ``cell``, ``cell_index`` and
``execute_reply``.
Default: None
--ExecutePreprocessor.on_cell_start=<Callable>
A callable which executes before a cell is executed and before non-executing
cells are skipped. Called with kwargs ``cell`` and ``cell_index``.
Default: None
--ExecutePreprocessor.on_notebook_complete=<Callable>
A callable which executes after the kernel is cleaned up. Called with kwargs
``notebook``.
Default: None
--ExecutePreprocessor.on_notebook_error=<Callable>
A callable which executes when the notebook encounters an error. Called with
kwargs ``notebook``.
Default: None
--ExecutePreprocessor.on_notebook_start=<Callable>
A callable which executes after the kernel manager and kernel client are
setup, and cells are about to execute. Called with kwargs ``notebook``.
Default: None
--ExecutePreprocessor.raise_on_iopub_timeout=<Bool>
If ``False`` (default), then the kernel will continue waiting for iopub
messages until it receives a kernel idle message, or until a timeout occurs,
at which point the currently executing cell will be skipped. If ``True``,
then an error will be raised after the first timeout. This option generally
does not need to be used, but may be useful in contexts where there is the
possibility of executing notebooks with memory-consuming infinite loops.
Default: False
--ExecutePreprocessor.record_timing=<Bool>
If ``True`` (default), then the execution timings of each cell will be
stored in the metadata of the notebook.
Default: True
--ExecutePreprocessor.shell_timeout_interval=<Int>
The time to wait (in seconds) for Shell output before retrying. This
generally doesn't need to be set, but if one needs to check for dead kernels
at a faster rate this can help.
Default: 5
--ExecutePreprocessor.shutdown_kernel=<Enum>
If ``graceful`` (default), then the kernel is given time to clean up after
executing all cells, e.g., to execute its ``atexit`` hooks. If
``immediate``, then the kernel is signaled to immediately terminate.
Choices: any of ['graceful', 'immediate']
Default: 'graceful'
--ExecutePreprocessor.skip_cells_with_tag=<Unicode>
Name of the cell tag to use to denote a cell that should be skipped.
Default: 'skip-execution'
--ExecutePreprocessor.startup_timeout=<Int>
The time to wait (in seconds) for the kernel to start. If kernel startup
takes longer, a RuntimeError is raised.
Default: 60
--ExecutePreprocessor.store_widget_state=<Bool>
If ``True`` (default), then the state of the Jupyter widgets created at the
kernel will be stored in the metadata of the notebook.
Default: True
--ExecutePreprocessor.timeout=<Int>
The time to wait (in seconds) for output from executions. If a cell
execution takes longer, a TimeoutError is raised.
``None`` or ``-1`` will disable the timeout. If ``timeout_func`` is set, it
overrides ``timeout``.
Default: None
--ExecutePreprocessor.timeout_func=<Any>
A callable which, when given the cell source as input, returns the time to
wait (in seconds) for output from cell executions. If a cell execution takes
longer, a TimeoutError is raised.
Returning ``None`` or ``-1`` will disable the timeout for the cell. Not
setting ``timeout_func`` will cause the client to default to using the
``timeout`` trait for all cells. The ``timeout_func`` trait overrides
``timeout`` if it is not ``None``.
Default: None
Execute(NbGraderPreprocessor, ExecutePreprocessor) options
----------------------------------------------------------
--Execute.allow_error_names=<list-item-1>...
List of error names which won't stop the execution. Use this if the
``allow_errors`` option it too general and you want to allow only specific
kinds of errors.
Default: []
--Execute.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--Execute.error_on_timeout=<key-1>=<value-1>...
If a cell execution was interrupted after a timeout, don't wait for the
execute_reply from the kernel (e.g. KeyboardInterrupt error). Instead,
return an execute_reply with the given error, which should be of the
following form::
{
'ename': str, # Exception name, as a string
'evalue': str, # Exception value, as a string
'traceback': list(str), # traceback frames, as strings
}
Default: {'ename': 'CellTimeoutError', 'evalue': '', 'traceback': ['\x...
--Execute.execute_retries=<Int>
The number of times to try re-executing the notebook before throwing an
error. Generally, this shouldn't need to be set, but might be useful for CI
environments when tests are flaky.
Default: 0
--Execute.extra_arguments=<list-item-1>...
A list of extra arguments to pass to the kernel. For python kernels, this
defaults to ``--HistoryManager.hist_file=:memory:``. For other kernels this
is just an empty list.
Default: []
--Execute.force_raise_errors=<Bool>
If False (default), errors from executing the notebook can be allowed with a
``raises-exception`` tag on a single cell, or the ``allow_errors`` or
``allow_error_names`` configurable options for all cells. An allowed error
will be recorded in notebook output, and execution will continue. If an
error occurs when it is not explicitly allowed, a ``CellExecutionError``
will be raised. If True, ``CellExecutionError`` will be raised for any error
that occurs while executing the notebook. This overrides the
``allow_errors`` and ``allow_error_names`` options and the ``raises-
exception`` cell tag.
Default: False
--Execute.interrupt_on_timeout=<Bool>
If execution of a cell times out, interrupt the kernel and continue
executing other cells rather than throwing an error and stopping.
Default: True
--Execute.iopub_timeout=<Int>
The time to wait (in seconds) for IOPub output. This generally doesn't need
to be set, but on some slow networks (such as CI systems) the default
timeout might not be long enough to get all messages.
Default: 4
--Execute.ipython_hist_file=<Unicode>
Path to file to use for SQLite history database for an IPython kernel.
The specific value ``:memory:`` (including the colon
at both end but not the back ticks), avoids creating a history file. Otherwise, IPython
will create a history file for each kernel.
When running kernels simultaneously (e.g. via multiprocessing) saving history a single
SQLite file can result in database errors, so using ``:memory:`` is recommended in
non-interactive contexts.
Default: ':memory:'
--Execute.kernel_manager_class=<Type>
The kernel manager class to use.
Default: 'jupyter_client.manager.KernelManager'
--Execute.kernel_name=<Unicode>
Name of kernel to use to execute the cells. If not set, use the kernel_spec
embedded in the notebook.
Default: ''
--Execute.on_cell_complete=<Callable>
A callable which executes after a cell execution is complete. It is called
even when a cell results in a failure. Called with kwargs ``cell`` and
``cell_index``.
Default: None
--Execute.on_cell_error=<Callable>
A callable which executes when a cell execution results in an error. This is
executed even if errors are suppressed with ``cell_allows_errors``. Called
with kwargs ``cell`, ``cell_index`` and ``execute_reply``.
Default: None
--Execute.on_cell_execute=<Callable>
A callable which executes just before a code cell is executed. Called with
kwargs ``cell`` and ``cell_index``.
Default: None
--Execute.on_cell_start=<Callable>
A callable which executes before a cell is executed and before non-executing
cells are skipped. Called with kwargs ``cell`` and ``cell_index``.
Default: None
--Execute.on_notebook_complete=<Callable>
A callable which executes after the kernel is cleaned up. Called with kwargs
``notebook``.
Default: None
--Execute.on_notebook_error=<Callable>
A callable which executes when the notebook encounters an error. Called with
kwargs ``notebook``.
Default: None
--Execute.on_notebook_start=<Callable>
A callable which executes after the kernel manager and kernel client are
setup, and cells are about to execute. Called with kwargs ``notebook``.
Default: None
--Execute.raise_on_iopub_timeout=<Bool>
If ``False`` (default), then the kernel will continue waiting for iopub
messages until it receives a kernel idle message, or until a timeout occurs,
at which point the currently executing cell will be skipped. If ``True``,
then an error will be raised after the first timeout. This option generally
does not need to be used, but may be useful in contexts where there is the
possibility of executing notebooks with memory-consuming infinite loops.
Default: True
--Execute.record_timing=<Bool>
If ``True`` (default), then the execution timings of each cell will be
stored in the metadata of the notebook.
Default: True
--Execute.shell_timeout_interval=<Int>
The time to wait (in seconds) for Shell output before retrying. This
generally doesn't need to be set, but if one needs to check for dead kernels
at a faster rate this can help.
Default: 5
--Execute.shutdown_kernel=<Enum>
If ``graceful`` (default), then the kernel is given time to clean up after
executing all cells, e.g., to execute its ``atexit`` hooks. If
``immediate``, then the kernel is signaled to immediately terminate.
Choices: any of ['graceful', 'immediate']
Default: 'graceful'
--Execute.skip_cells_with_tag=<Unicode>
Name of the cell tag to use to denote a cell that should be skipped.
Default: 'skip-execution'
--Execute.startup_timeout=<Int>
The time to wait (in seconds) for the kernel to start. If kernel startup
takes longer, a RuntimeError is raised.
Default: 60
--Execute.store_widget_state=<Bool>
If ``True`` (default), then the state of the Jupyter widgets created at the
kernel will be stored in the metadata of the notebook.
Default: True
--Execute.timeout=<Int>
The time to wait (in seconds) for output from executions. If a cell
execution takes longer, a TimeoutError is raised.
``None`` or ``-1`` will disable the timeout. If ``timeout_func`` is set, it
overrides ``timeout``.
Default: 30
--Execute.timeout_func=<Any>
A callable which, when given the cell source as input, returns the time to
wait (in seconds) for output from cell executions. If a cell execution takes
longer, a TimeoutError is raised.
Returning ``None`` or ``-1`` will disable the timeout for the cell. Not
setting ``timeout_func`` will cause the client to default to using the
``timeout`` trait for all cells. The ``timeout_func`` trait overrides
``timeout`` if it is not ``None``.
Default: None
InstantiateTests(NbGraderPreprocessor) options
----------------------------------------------
--InstantiateTests.autotest_delimiter=<Unicode>
The delimiter prior to snippets to be autotested
Default: 'AUTOTEST'
--InstantiateTests.autotest_filename=<Unicode>
The filename where automatic testing code is stored
Default: 'autotests.yml'
--InstantiateTests.comment_strs=<key-1>=<value-1>...
A dictionary mapping each Jupyter kernel's name to the comment string for
that kernel. For an example, one of the entries in this dictionary is
"python" : "#", because # is the comment character in python.
Default: {'ir': '#', 'python': '#', 'python3': '#'}
--InstantiateTests.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--InstantiateTests.enforce_metadata=<Bool>
Whether or not to complain if cells containing autotest delimiters are not
marked as grade cells. WARNING: disabling this will potentially cause things
to break if you are using the full nbgrader pipeline. ONLY disable this
option if you are only ever planning to use nbgrader assign.
Default: True
--InstantiateTests.hashed_delimiter=<Unicode>
The delimiter prior to an autotest block if snippet results should be
protected by a hash function
Default: 'HASHED'
--InstantiateTests.sanitizers=<key-1>=<value-1>...
A dictionary mapping each Jupyter kernel's name to the function that is used
to sanitize the output from the kernel within InstantiateTests.
Default: {'ir': <function InstantiateTests.<lambda> at 0x7f63d6a8c5e0>...
--InstantiateTests.use_salt=<Bool>
Whether to add a salt to digested answers
Default: True
GetGrades(NbGraderPreprocessor) options
---------------------------------------
--GetGrades.display_data_priority=<list-item-1>...
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
--GetGrades.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
ClearOutputPreprocessor(Preprocessor) options
---------------------------------------------
--ClearOutputPreprocessor.default_language=<Unicode>
Deprecated default highlight language as of 5.0, please use language_info
metadata instead
Default: 'ipython'
--ClearOutputPreprocessor.display_data_priority=<list-item-1>...
An ordered list of preferred output type, the first encountered will usually
be used when converting discarding the others.
Default: ['text/html', 'application/pdf', 'text/latex', 'image/svg+xml...
--ClearOutputPreprocessor.enabled=<Bool>
Default: False
--ClearOutputPreprocessor.remove_metadata_fields=<set-item-1>...
Default: {'collapsed', 'scrolled'}
ClearOutput(NbGraderPreprocessor, ClearOutputPreprocessor) options
------------------------------------------------------------------
--ClearOutput.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--ClearOutput.remove_metadata_fields=<set-item-1>...
Default: {'collapsed', 'scrolled'}
LimitOutput(NbGraderPreprocessor) options
-----------------------------------------
--LimitOutput.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--LimitOutput.max_lines=<Int>
maximum number of lines of output (-1 means no limit)
Default: 1000
--LimitOutput.max_traceback=<Int>
maximum number of traceback lines (-1 means no limit)
Default: 100
DeduplicateIds(NbGraderPreprocessor) options
--------------------------------------------
--DeduplicateIds.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
ClearHiddenTests(NbGraderPreprocessor) options
----------------------------------------------
--ClearHiddenTests.begin_test_delimeter=<Unicode>
The delimiter marking the beginning of hidden tests cases
Default: 'BEGIN HIDDEN TESTS'
--ClearHiddenTests.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--ClearHiddenTests.end_test_delimeter=<Unicode>
The delimiter marking the end of hidden tests cases
Default: 'END HIDDEN TESTS'
--ClearHiddenTests.enforce_metadata=<Bool>
Whether or not to complain if cells containing hidden test regions are not
marked as grade cells. WARNING: this will potentially cause things to break
if you are using the full nbgrader pipeline. ONLY disable this option if you
are only ever planning to use nbgrader assign.
Default: True
ClearMarkScheme(NbGraderPreprocessor) options
---------------------------------------------
--ClearMarkScheme.begin_mark_scheme_delimeter=<Unicode>
The delimiter marking the beginning of a marking scheme region
Default: 'BEGIN MARK SCHEME'
--ClearMarkScheme.check_attachment_leakage=<Bool>
Whether or not to check if a marking scheme region contains an attachment,
in order to prevent leakage to student version of notebooks.
Default: True
--ClearMarkScheme.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
--ClearMarkScheme.end_mark_scheme_delimeter=<Unicode>
The delimiter marking the end of a marking scheme region
Default: 'END MARK SCHEME'
--ClearMarkScheme.enforce_metadata=<Bool>
Whether or not to complain if cells containing marking scheme regions are
not marked as task cells. WARNING: this will potentially cause things to
break if you are using the full nbgrader pipeline. ONLY disable this option
if you are only ever planning to use nbgrader assign.
Default: True
OverwriteKernelspec(NbGraderPreprocessor) options
-------------------------------------------------
--OverwriteKernelspec.enabled=<Bool>
Whether to use this preprocessor when running nbgrader
Default: True
Exchange(LoggingConfigurable) options
-------------------------------------
--Exchange.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--Exchange.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--Exchange.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeCollect(Exchange) options
---------------------------------
--ExchangeCollect.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeCollect.before_duedate=<Bool>
Collect the last submission before due date or the last submission if no
submission before due date.
Default: False
--ExchangeCollect.check_owner=<Bool>
Whether to cross-check the student_id with the UNIX-owner of the submitted
directory.
Default: True
--ExchangeCollect.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeCollect.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
--ExchangeCollect.update=<Bool>
Update existing submissions with ones that have newer timestamps.
Default: False
ExchangeFetchAssignment(Exchange) options
-----------------------------------------
--ExchangeFetchAssignment.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeFetchAssignment.replace_missing_files=<Bool>
Whether to replace missing files on fetch
Default: False
--ExchangeFetchAssignment.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeFetchAssignment.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeFetch(ExchangeFetchAssignment) options
----------------------------------------------
--ExchangeFetch.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeFetch.replace_missing_files=<Bool>
Whether to replace missing files on fetch
Default: False
--ExchangeFetch.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeFetch.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeFetchFeedback(Exchange) options
---------------------------------------
--ExchangeFetchFeedback.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeFetchFeedback.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeFetchFeedback.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeList(Exchange) options
------------------------------
--ExchangeList.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeList.cached=<Bool>
List assignments in submission cache.
Default: False
--ExchangeList.inbound=<Bool>
List inbound files rather than outbound.
Default: False
--ExchangeList.remove=<Bool>
Remove, rather than list files.
Default: False
--ExchangeList.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeList.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeReleaseAssignment(Exchange) options
-------------------------------------------
--ExchangeReleaseAssignment.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeReleaseAssignment.force=<Bool>
Force overwrite existing files in the exchange.
Default: False
--ExchangeReleaseAssignment.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeReleaseAssignment.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeRelease(ExchangeReleaseAssignment) options
--------------------------------------------------
--ExchangeRelease.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeRelease.force=<Bool>
Force overwrite existing files in the exchange.
Default: False
--ExchangeRelease.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeRelease.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeReleaseFeedback(Exchange) options
-----------------------------------------
--ExchangeReleaseFeedback.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeReleaseFeedback.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeReleaseFeedback.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
ExchangeSubmit(Exchange) options
--------------------------------
--ExchangeSubmit.assignment_dir=<Unicode>
Local path for storing student assignments. Defaults to '.' which is
normally Jupyter's root_dir.
Default: '.'
--ExchangeSubmit.strict=<Bool>
Whether or not to submit the assignment if there are missing notebooks from
the released assignment notebooks.
Default: False
--ExchangeSubmit.timestamp_format=<Unicode>
Format string for timestamps
Default: '%Y-%m-%d %H:%M:%S.%f %Z'
--ExchangeSubmit.timezone=<Unicode>
Timezone for recording timestamps
Default: 'UTC'
BaseConverter(LoggingConfigurable) options
------------------------------------------
--BaseConverter.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--BaseConverter.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--BaseConverter.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--BaseConverter.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--BaseConverter.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
GenerateAssignment(BaseConverter) options
-----------------------------------------
--GenerateAssignment.create_assignment=<Bool>
Whether to create the assignment at runtime if it does not already exist.
Default: True
--GenerateAssignment.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--GenerateAssignment.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--GenerateAssignment.no_database=<Bool>
Do not save information about the assignment into the database.
Default: False
--GenerateAssignment.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--GenerateAssignment.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateAssignment.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateAssignment.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.headerfooter.IncludeHeaderFoo...
Assign(GenerateAssignment) options
----------------------------------
--Assign.create_assignment=<Bool>
Whether to create the assignment at runtime if it does not already exist.
Default: True
--Assign.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--Assign.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--Assign.no_database=<Bool>
Do not save information about the assignment into the database.
Default: False
--Assign.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--Assign.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Assign.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Assign.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.headerfooter.IncludeHeaderFoo...
Autograde(BaseConverter) options
--------------------------------
--Autograde.autograde_preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.execute.Execute'>, <class 'nb...
--Autograde.create_student=<Bool>
Whether to create the student at runtime if it does not already exist.
Default: True
--Autograde.exclude_overwriting=<key-1>=<value-1>...
A dictionary with keys corresponding to assignment names and values being a
list of filenames (relative to the assignment's source directory) that
should NOT be overwritten with the source version. This is to allow students
to e.g. edit a python file and submit it alongside the notebooks in their
assignment.
Default: {}
--Autograde.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--Autograde.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--Autograde.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--Autograde.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Autograde.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Autograde.sanitize_preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.clearoutput.ClearOutput'>, <c...
GenerateFeedback(BaseConverter) options
---------------------------------------
--GenerateFeedback.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--GenerateFeedback.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--GenerateFeedback.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--GenerateFeedback.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateFeedback.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateFeedback.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.getgrades.GetGrades'>, <class...
Feedback(GenerateFeedback) options
----------------------------------
--Feedback.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--Feedback.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--Feedback.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--Feedback.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Feedback.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--Feedback.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.getgrades.GetGrades'>, <class...
GenerateSolution(BaseConverter) options
---------------------------------------
--GenerateSolution.create_assignment=<Bool>
Whether to create the assignment at runtime if it does not already exist.
Default: True
--GenerateSolution.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--GenerateSolution.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--GenerateSolution.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--GenerateSolution.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateSolution.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateSolution.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.headerfooter.IncludeHeaderFoo...
GenerateSourceWithTests(BaseConverter) options
----------------------------------------------
--GenerateSourceWithTests.exporter_class=<Type>
Default: 'nbconvert.exporters.notebook.NotebookExporter'
--GenerateSourceWithTests.force=<Bool>
Whether to overwrite existing assignments/submissions
Default: False
--GenerateSourceWithTests.permissions=<Int>
Permissions to set on files output by nbgrader. The default is generally
read-only (444), with the exception of nbgrader generate_assignment and
nbgrader generate_feedback, in which case the user also has write
permission.
Default: 0
--GenerateSourceWithTests.post_convert_hook=<Any>
An optional hook function that you can implement to do some work after
converting. This function is called after the notebooks are converted and
should be used for specific converters such as Autograde, GenerateAssignment
or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateSourceWithTests.pre_convert_hook=<Any>
An optional hook function that you can implement to do some bootstrapping
work before converting. This function is called before the notebooks are
converted and should be used for specific converters such as Autograde,
GenerateAssignment or GenerateFeedback.
It will be called as (all arguments are passed as keywords)::
hook(assignment=assignment, student=student, notebooks=notebooks)
Default: None
--GenerateSourceWithTests.preprocessors=<list-item-1>...
Default: [<class 'nbgrader.preprocessors.instantiatetests.InstantiateT...
Examples
--------
The nbgrader application is a system for assigning and grading notebooks.
Each subcommand of this program corresponds to a different step in the
grading process. In order to facilitate the grading pipeline, nbgrader
places some constraints on how the assignments must be structured. By
default, the directory structure for the assignments must look like this:
{nbgrader_step}/{student_id}/{assignment_id}/{notebook_id}.ipynb
where 'nbgrader_step' is the step in the nbgrader pipeline, 'student_id'
is the ID of the student, 'assignment_id' is the name of the assignment,
and 'notebook_id' is the name of the notebook (excluding the extension).
For example, when running `nbgrader autograde "Problem Set 1"`, the
autograder will first look for all notebooks for all students in the
following directories:
submitted/*/Problem Set 1/*.ipynb
and it will write the autograded notebooks to the corresponding directory
and filename for each notebook and each student:
autograded/{student_id}/Problem Set 1/{notebook_id}.ipynb
These variables, as well as the overall directory structure, can be
configured through the `NbGrader` class (run `nbgrader --help-all`
to see these options).
For more details on how each of the subcommands work, please see the help
for that command (e.g. `nbgrader generate_assignment --help-all`).