scikit-learn v0.19.1
Please if you use the software.
Simple 1D Kernel Density Estimation
This example uses the
demonstrate the principles of Kernel Density Estimation in one dimension.
The first plot shows one of the problems with using histograms to visualize
the density of points in 1D. Intuitively, a histogram can be thought of as a
scheme in which a unit “block” is stacked above each point on a regular grid.
As the top two panels show, however, the choice of gridding for these blocks
can lead to wildly divergent ideas about the underlying shape of the density
distribution.
If we instead center each block on the point it represents, we
get the estimate shown in the bottom left panel.
This is a kernel density
estimation with a “top hat” kernel.
This idea can be generalized to other
kernel shapes: the bottom-right panel of the first figure shows a Gaussian
kernel density estimate over the same distribution.
Scikit-learn implements efficient kernel density estimation using either
a Ball Tree or KD Tree structure, through the
estimator.
The available kernels
are shown in the second figure of this example.
The third figure compares kernel density estimates for a distribution of 100
samples in 1 dimension.
Though this example uses 1D distributions, kernel
density estimation is easily and efficiently extensible to higher dimensions
# Author: Jake Vanderplas &jakevdp@cs.washington.edu&
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from sklearn.neighbors import
#----------------------------------------------------------------------
# Plot the progression of histograms to kernels
X = (((0, 1, int(0.3 * N)),
(5, 1, int(0.7 * N))))[:, ]
X_plot = (-5, 10, 1000)[:, ]
bins = (-5, 10, 10)
fig, ax = (2, 2, sharex=True, sharey=True)
fig.subplots_adjust(hspace=0.05, wspace=0.05)
# histogram 1
ax[0, 0].hist(X[:, 0], bins=bins, fc='#AAAAFF', normed=True)
ax[0, 0].text(-3.5, 0.31, &Histogram&)
# histogram 2
ax[0, 1].hist(X[:, 0], bins=bins + 0.75, fc='#AAAAFF', normed=True)
ax[0, 1].text(-3.5, 0.31, &Histogram, bins shifted&)
# tophat KDE
kde = (kernel='tophat', bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 0].fill(X_plot[:, 0], (log_dens), fc='#AAAAFF')
ax[1, 0].text(-3.5, 0.31, &Tophat Kernel Density&)
# Gaussian KDE
kde = (kernel='gaussian', bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 1].fill(X_plot[:, 0], (log_dens), fc='#AAAAFF')
ax[1, 1].text(-3.5, 0.31, &Gaussian Kernel Density&)
for axi in ax.ravel():
axi.plot(X[:, 0], (X.shape[0]) - 0.01, '+k')
axi.set_xlim(-4, 9)
axi.set_ylim(-0.02, 0.34)
for axi in ax[:, 0]:
axi.set_ylabel('Normalized Density')
for axi in ax[1, :]:
axi.set_xlabel('x')
#----------------------------------------------------------------------
# Plot all available kernels
X_plot = (-6, 6, 1000)[:, None]
X_src = ((1, 1))
fig, ax = (2, 3, sharex=True, sharey=True)
fig.subplots_adjust(left=0.05, right=0.95, hspace=0.05, wspace=0.05)
def format_func(x, loc):
if x == 0:
return '0'
elif x == 1:
return 'h'
elif x == -1:
return '-h'
return '%ih' % x
for i, kernel in enumerate(['gaussian', 'tophat', 'epanechnikov',
'exponential', 'linear', 'cosine']):
axi = ax.ravel()[i]
log_dens = (kernel=kernel).fit(X_src).score_samples(X_plot)
axi.fill(X_plot[:, 0], (log_dens), '-k', fc='#AAAAFF')
axi.text(-2.6, 0.95, kernel)
axi.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
axi.xaxis.set_major_locator(plt.MultipleLocator(1))
axi.yaxis.set_major_locator(plt.NullLocator())
axi.set_ylim(0, 1.05)
axi.set_xlim(-2.9, 2.9)
ax[0, 1].set_title('Available Kernels')
#----------------------------------------------------------------------
# Plot a 1D density example
X = (((0, 1, int(0.3 * N)),
(5, 1, int(0.7 * N))))[:, ]
X_plot = (-5, 10, 1000)[:, ]
true_dens = (0.3 * norm(0, 1).pdf(X_plot[:, 0])
+ 0.7 * norm(5, 1).pdf(X_plot[:, 0]))
fig, ax = ()
ax.fill(X_plot[:, 0], true_dens, fc='black', alpha=0.2,
label='input distribution')
for kernel in ['gaussian', 'tophat', 'epanechnikov']:
kde = (kernel=kernel, bandwidth=0.5).fit(X)
log_dens = kde.score_samples(X_plot)
ax.plot(X_plot[:, 0], (log_dens), '-',
label=&kernel = '{0}'&.format(kernel))
ax.text(6, 0.38, &N={0} points&.format(N))
ax.legend(loc='upper left')
ax.plot(X[:, 0], -0.005 - 0.01 * (X.shape[0]), '+k')
ax.set_xlim(-4, 9)
ax.set_ylim(-0.02, 0.4)
Total running time of the script: ( 0 minutes
0.467 seconds)Jupyter Notebook Documentation - PDF
Start display at page:
Download "Jupyter Notebook Documentation"
Transcription
1 Jupyter Notebook Documentation Release https://jupyter.org August 03, 20162 3 User Documentation 1 The Jupyter Notebook 1 2 UI Components 7 3 Config file and command line options 11 4 Running a notebook server 19 5 Security in Jupyter notebooks 23 6 Configuring the notebook frontend 27 7 Extending the Notebook 29 8 Installing Javascript machinery 39 9 Developer FAQ Distributing Jupyter Extensions as Python Packages Examples and Tutorials Jupyter notebook changelog 49 i4 ii5 CHAPTER 1 The Jupyter Notebook 1.1 Introduction The notebook extends the console-based approach to interactive computing in a qualitatively new direction, providing a web-based application suitable for capturing the whole computation process: developing, documenting, and executing code, as well as communicating the results. The Jupyter notebook combines two components: A web application: a browser-based tool for interactive authoring of documents which combine explanatory text, mathematics, computations and their rich media output. Notebook documents: a representation of all content visible in the web application, including inputs and outputs of the computations, explanatory text, mathematics, images, and rich media representations of objects. See also: See the installation guide on how to install the notebook and its dependencies Main features of the web application In-browser editing for code, with automatic syntax highlighting, indentation, and tab completion/introspection. The ability to execute code from the browser, with the results of computations attached to the code which generated them. Displaying the result of computation using rich media representations, such as HTML, LaTeX, PNG, SVG, etc. For example, publication-quality figures rendered by the matplotlib library, can be included inline. In-browser editing for rich text using the Markdown markup language, which can provide commentary for the code, is not limited to plain text. The ability to easily include mathematical notation within markdown cells using LaTeX, and rendered natively by MathJax Notebook documents Notebook documents contains the inputs and outputs of a interactive session as well as additional text that accompanies the code but is not meant for execution. In this way, notebook files can serve as a complete computational record of a session, interleaving executable code with explanatory text, mathematics, and rich representations of resulting objects. These documents are internally JSON files and are saved with the.ipynb extension. Since JSON is a plain text format, they can be version-controlled and shared with colleagues. 16 Notebooks may be exported to a range of static formats, including HTML (for example, for blog posts), restructured- Text, LaTeX, PDF, and slide shows, via the nbconvert command. Furthermore, any.ipynb notebook document available from a public URL can be shared via the Jupyter Notebook Viewer (nbviewer). This service loads the notebook document from the URL and renders it as a static web page. The results may thus be shared with a colleague, or as a public blog post, without other users needing to install the Jupyter notebook themselves. In effect, nbviewer is simply nbconvert as a web service, so you can do your own static conversions with nbconvert, without relying on nbviewer. See also: Details on the notebook JSON file format 1.2 Starting the notebook server You can start running a notebook server from the command line using the following command: jupyter notebook This will print some information about the notebook server in your console, and open a web browser to the URL of the web application (by default,
The landing page of the Jupyter notebook web application, the dashboard, shows the notebooks currently available in the notebook directory (by default, the directory from which the notebook server was started). You can create new notebooks from the dashboard with the New Notebook button, or open existing ones by clicking on their name. You can also drag and drop.ipynb notebooks and standard.py Python source code files into the notebook list area. When starting a notebook server from the command line, you can also open a particular notebook directly, bypassing the dashboard, with jupyter notebook my_notebook.ipynb. The.ipynb extension is assumed if no extension is given. When you are inside an open notebook, the File Open... menu option will open the dashboard in a new browser tab, to allow you to open another notebook from the notebook directory or to create a new notebook. Note: You can start more than one notebook server at the same time, if you want to work on notebooks in different directories. By default the first notebook server starts on port 8888, and later notebook servers search for ports near that one. You can also manually specify the port with the --port option Creating a new notebook document A new notebook may be created at any time, either from the dashboard, or using the File New menu option from within an active notebook. The new notebook is created within the same directory and will open in a new browser tab. It will also be reflected as a new entry in the notebook list on the dashboard Opening notebooks An open notebook has exactly one interactive session connected to an IPython kernel, which will execute code sent by the user and communicate back results. This kernel remains active if the web browser window is closed, and reopening the same notebook from the dashboard will reconnect the web application to the same kernel. In the dashboard, notebooks with an active kernel have a Shutdown button next to them, whereas notebooks without an active kernel have a Delete button in its place. 2 Chapter 1. The Jupyter Notebook7 Other clients may connect to the same underlying IPython kernel. The notebook server always prints to the terminal the full details of how to connect to each kernel, with messages such as the following: [NotebookApp] Kernel started: 87f7d2c0-13e3-43df-8bb8-1bd37aaf3373 This long string is the kernel s ID which is sufficient for getting the information necessary to connect to the kernel. You can also request this connection data by running the %connect_info magic. This will print the same ID information as well as the content of the JSON data structure it contains. You can then, for example, manually start a Qt console connected to the same kernel from the command line, by passing a portion of the ID: $ ipython qtconsole --existing 87f7d2c0 Without an ID, --existing will connect to the most recently started kernel. This can also be done by running the %qtconsole magic in the notebook. See also: Decoupled two-process model 1.3 Notebook user interface When you create a new notebook document, you will be presented with the notebook name, a menu bar, a toolbar and an empty code cell. notebook name: The name of the notebook document is displayed at the top of the page, next to the IP[y]: Notebook logo. This name reflects the name of the.ipynb notebook document file. Clicking on the notebook name brings up a dialog which allows you to rename it. Thus, renaming a notebook from Untitled0 to My first notebook in the browser, renames the Untitled0.ipynb file to My first notebook.ipynb. menu bar: The menu bar presents different options that may be used to manipulate the way the notebook functions. toolbar: The tool bar gives a quick way of performing the most-used operations within the notebook, by clicking on an icon. code cell: the default type of cell, read on for an explanation of cells Note: As of notebook version 4.1, the user interface allows for multiple cells to be selected. The quick celltype selector, found in the menubar, will display a dash - when multiple cells are selected to indicate that the type of the cells in the selection might not be unique. The quick selector can still be used to change the type of the selection and will change the type of all the currently selected cells. 1.4 Structure of a notebook document The notebook consists of a sequence of cells. A cell is a multi-line text input field, and its contents can be executed by using Shift-Enter, or by clicking either the Play button the toolbar, or Cell Run in the menu bar. The execution behavior of a cell is determined the cell s type. There are four types of cells: code cells, markdown cells, raw cells and heading cells. Every cell starts off being a code cell, but its type can be changed by using a dropdown on the toolbar (which will be Code, initially), or via keyboard shortcuts. For more information on the different things you can do in a notebook, see the collection of examples Notebook user interface 38 1.4.1 Code cells A code cell allows you to edit and write new code, with full syntax highlighting and tab completion. By default, the language associated to a code cell is Python, but other languages, such as Julia and R, can be handled using cell magic commands. When a code cell is executed, code that it contains is sent to the kernel associated with the notebook. The results that are returned from this computation are then displayed in the notebook as the cell s output. The output is not limited to text, with many other possible forms of output are also possible, including matplotlib figures and HTML tables (as used, for example, in the pandas data analysis package). This is known as IPython s rich display capability. See also: Rich Output example notebook Markdown cells You can document the computational process in a literate way, alternating descriptive text with code, using rich text. In IPython this is accomplished by marking up text with the Markdown language. The corresponding cells are called Markdown cells. The Markdown language provides a simple way to perform this text markup, that is, to specify which parts of the text should be emphasized (italics), bold, form lists, etc. When a Markdown cell is executed, the Markdown code is converted into the corresponding formatted rich text. Markdown allows arbitrary HTML code for formatting. Within Markdown cells, you can also include mathematics in a straightforward way, using standard LaTeX notation: $...$ for inline mathematics and $$...$$ for displayed mathematics. When the Markdown cell is executed, the LaTeX portions are automatically rendered in the HTML output as equations with high quality typography. This is made possible by MathJax, which supports a large subset of LaTeX functionality Standard mathematics environments defined by LaTeX and AMS-LaTeX (the amsmath package) also work, such as \begin{equation}...\end{equation}, and \begin{align}...\end{align}. New LaTeX macros may be defined using standard methods, such as \newcommand, by placing them anywhere between math delimiters in a Markdown cell. These definitions are then available throughout the rest of the IPython session. See also: Markdown Cells example notebook Raw cells Raw cells provide a place in which you can write output directly. Raw cells are not evaluated by the notebook. When passed through nbconvert, raw cells arrive in the destination format unmodified. For example, this allows you to type full LaTeX into a raw cell, which will only be rendered by LaTeX after conversion by nbconvert Heading cells If you want to provide structure for your document, you can use markdown headings. Markdown headings consist of 1 to 6 hash # signs # followed by a space and the title of your section. The markdown heading will be converted to a clickable link for a section of the notebook. It is also used as a hint when exporting to other document formats, like PDF. We recommend using only one markdown header in a cell and limit the cell s content to the header text. For flexibility of text format conversion, we suggest placing additional text in the next notebook cell. 4 Chapter 1. The Jupyter Notebook9 1.5 Basic workflow The normal workflow in a notebook is, then, quite similar to a standard IPython session, with the difference that you can edit cells in-place multiple times until you obtain the desired results, rather than having to rerun separate scripts with the %run magic command. Typically, you will work on a computational problem in pieces, organizing related ideas into cells and moving forward once previous parts work correctly. This is much more convenient for interactive exploration than breaking up a computation into scripts that must be executed together, as was previously necessary, especially if parts of them take a long time to run. At certain moments, it may be necessary to interrupt a calculation which is taking too long to complete. This may be done with the Kernel Interrupt menu option, or the Ctrl-m i keyboard shortcut. Similarly, it may be necessary or desirable to restart the whole computational process, with the Kernel Restart menu option or Ctrl-m. shortcut. A notebook may be downloaded in either a.ipynb or.py file from the menu option File Download as. Choosing the.py option downloads a Python.py script, in which all rich output has been removed and the content of markdown cells have been inserted as comments. See also: Running Code in the Jupyter Notebook example notebook Notebook Basics example notebook a warning about doing roundtrip conversions Keyboard shortcuts All actions in the notebook can be performed with the mouse, but keyboard shortcuts are also available for the most common ones. The essential shortcuts to remember are the following: Shift-Enter: run cell Execute the current cell, show output (if any), and jump to the next cell below. If Shift-Enter is invoked on the last cell, a new code cell will also be created. Note that in the notebook, typing Enter on its own never forces execution, but rather just inserts a new line in the current cell. Shift-Enter is equivalent to clicking the Cell Run menu item. Ctrl-Enter: run cell in-place Execute the current cell as if it were in terminal mode, where any output is shown, but the cursor remains in the current cell. The cell s entire contents are selected after execution, so you can just start typing and only the new input will be in the cell. This is convenient for doing quick experiments in place, or for querying things like filesystem content, without needing to create additional cells that you may not want to be saved in the notebook. Alt-Enter: run cell, insert below Executes the current cell, shows the output, and inserts a new cell between the current cell and the cell below (if one exists). This is thus a shortcut for the sequence Shift-Enter, Ctrl-m a. (Ctrl-m a adds a new cell above the current one.) Esc and Enter: Command mode and edit mode In command mode, you can easily navigate around the notebook using keyboard shortcuts. In edit mode, you can edit text in cells. For the full list of available shortcuts, click Help, Keyboard Shortcuts in the notebook menus. 1.6 Plotting One major feature of the Jupyter notebook is the ability to display plots that are the output of running code cells. The IPython kernel is designed to work seamlessly with the matplotlib plotting library to provide this functionality. Specific plotting library integration is a feature of the kernel Basic workflow 510 1.7 Installing kernels For information on how to install a Python kernel, refer to the IPython install page. Kernels for other languages can be found in the IPython wiki. They usually come with instruction what to run to make the kernel available in the notebook. 1.8 Signing Notebooks To prevent untrusted code from executing on users behalf when notebooks open, we have added a signature to the notebook, stored in metadata. The notebook server verifies this signature when a notebook is opened. If the signature stored in the notebook metadata does not match, javascript and HTML output will not be displayed on load, and must be regenerated by re-executing the cells. Any notebook that you have executed yourself in its entirety will be considered trusted, and its HTML and javascript output will be displayed on load. If you need to see HTML or Javascript output without re-executing, you can explicitly trust notebooks, such as those shared with you, or those that you have written yourself prior to IPython 2.0, at the command-line with: $ jupyter trust mynotebook.ipynb [other notebooks.ipynb] This just generates a new signature stored in each notebook. You can generate a new notebook signing key with: $ jupyter trust --reset 1.9 Browser Compatibility The Jupyter Notebook is officially supported the latest stable version the following browsers: Chrome Safari Firefox The is mainly due to the notebook s usage of WebSockets and the flexible box model. The following browsers are unsupported: Safari & 5 Firefox & 6 Chrome & 13 Opera (any): CSS issues, but execution might work Internet Explorer & 10 Internet Explorer 10 (same as Opera) Using Safari with HTTPS and an untrusted certificate is known to not work (websockets will fail). 6 Chapter 1. The Jupyter Notebook11 CHAPTER 2 UI Components When opening bug reports or sending
s to the Jupyter mailing list, it is useful to know the names of different UI components so that other developers and users have an easier time helping you diagnose your problems. This section will familiarize you with the names of UI elements within the Notebook and the different Notebook modes. 2.1 Notebook Dashboard When you launch jupyter notebook the first page that you encounter is the Notebook Dashboard. 2.2 Notebook Editor Once you ve selected a Notebook to edit, the Notebook will open in the Notebook Editor. 712 2.3 Interactive User Interface Tour of the Notebook If you would like to learn more about the specific elements within the Notebook Editor, you can go through the User Interface Tour by selecting Help in the menubar then selecting User Interface Tour Edit Mode and Notebook Editor When a cell is in edit mode, the Cell Mode Indicator will change to reflect the cell s state. This state is indicated by a small pencil icon on the top right of the interface. When the cell is in command mode, there is no icon in that location. 8 Chapter 2. UI Components
13 2.4 File Editor Now let s say that you ve chosen to open a Markdown file instead of a Notebook file whilst in the Notebook Dashboard. If so, the file will be opened in the File Editor File Editor 914 10 Chapter 2. UI Components15 CHAPTER 3 Config file and command line options The notebook server can be run with a variety of command line arguments. A list of available options can be found below in the options section. Defaults for these options can also be set by creating a file named jupyter_notebook_config.py in your Jupyter folder. The Jupyter folder is in your home directory, ~/.jupyter. To create a jupyter_notebook_config.py file, with all the defaults commented out, you can use the following command line: $ jupyter notebook --generate-config 3.1 Options This list of options can be generated by running the following and hitting enter: $ jupyter notebook --help Application.log_datefmt [Unicode] Default: %Y-%m-%d %H:%M:%S The date format used by logging formatters for %(asctime)s Application.log_format [Unicode] Default: [%(name)s]%(highlevel)s %(message)s The Logging format template Application.log_level [ DEBUG INFO WARN ERROR CRITICAL ] Default: 30 Set the log level by value or name. JupyterApp.answer_yes [Bool] Default: False Answer yes to any prompts. JupyterApp.config_file [Unicode] Default: Full path of a config file. JupyterApp.config_file_name [Unicode] Default: Specify a config file to load. JupyterApp.generate_config [Bool] Default: False Generate default config file. 1116 NotebookApp.allow_credentials [Bool] Default: False Set the Access-Control-Allow-Credentials: true header NotebookApp.allow_origin [Unicode] Default: Set the Access-Control-Allow-Origin header Use * to allow any origin to access your server. Takes precedence over allow_origin_pat. NotebookApp.allow_origin_pat [Unicode] Default: Use a regular expression for the Access-Control-Allow-Origin header Requests from an origin matching the expression will get replies with: Access-Control-Allow-Origin: origin where origin is the origin of the request. Ignored if allow_origin is set. NotebookApp.base_project_url [Unicode] Default: / DEPRECATED use base_url NotebookApp.base_url [Unicode] Default: / The base URL for the notebook server. Leading and trailing slashes can be omitted, and will automatically be added. NotebookApp.browser [Unicode] Default: Specify what command to use to invoke a web browser when opening the notebook. If not specified, the default browser will be determined by the webbrowser standard library module, which allows setting of the BROWSER environment variable to override it. NotebookApp.certfile [Unicode] Default: The full path to an SSL/TLS certificate file. NotebookApp.client_ca [Unicode] Default: The full path to a certificate authority certifificate for SSL/TLS client authentication. NotebookApp.config_manager_class [Type] Default: notebook.services.config.manager.configmanager The config manager class to use NotebookApp.contents_manager_class [Type] Default: notebook.services.contents.filemanager.filecontents The notebook manager class to use. NotebookApp.cookie_options [Dict] Default: {} Extra keyword arguments to pass to set_secure_cookie. See tornado s set_secure_cookie docs for details. NotebookApp.cookie_secret [Bytes] Default: b The random bytes used to secure cookies. By default this is a new random number every time you start the Notebook. Set it to a value in a config file to enable logins to persist across server sessions. Note: Cookie secrets should be kept private, do not share config files with cookie_secret stored in plaintext (you can read the value from a file). 12 Chapter 3. Config file and command line options17 NotebookApp.cookie_secret_file [Unicode] Default: The file where the cookie secret is stored. NotebookApp.default_url [Unicode] Default: /tree The default URL to redirect to from / NotebookApp.enable_mathjax [Bool] Default: True Whether to enable MathJax for typesetting math/tex MathJax is the javascript library Jupyter uses to render math/latex. It is very large, so you may want to disable it if you have a slow internet connection, or for offline use of the notebook. When disabled, equations etc. will appear as their untransformed TeX source. NotebookApp.extra_nbextensions_path [List] Default: [] extra paths to look for Javascript notebook extensions NotebookApp.extra_static_paths [List] Default: [] Extra paths to search for serving static files. This allows adding javascript/css to be available from the notebook server machine, or overriding individual files in the IPython NotebookApp.extra_template_paths [List] Default: [] Extra paths to search for serving jinja templates. Can be used to override templates from notebook.templates. NotebookApp.file_to_run [Unicode] Default: No description NotebookApp.ignore_minified_js [Bool] Default: False Use minified JS file or not, mainly use during dev to avoid JS recompilation NotebookApp.iopub_data_rate_limit [Float] Default: 0 (bytes/sec) Maximum rate at which messages can be sent on iopub before they are limited. NotebookApp.iopub_msg_rate_limit [Float] Default: 0 (msg/sec) Maximum rate at which messages can be sent on iopub before they are limited. NotebookApp.ip [Unicode] Default: localhost The IP address the notebook server will listen on. NotebookApp.jinja_environment_options [Dict] Default: {} Supply extra arguments that will be passed to Jinja environment. NotebookApp.jinja_template_vars [Dict] Default: {} Extra variables to supply to jinja templates when rendering. NotebookApp.kernel_manager_class [Type] Default: notebook.services.kernels.kernelmanager.mappingkerne The kernel manager class to use. NotebookApp.kernel_spec_manager_class [Type] Default: jupyter_client.kernelspec.kernelspecmanager The kernel spec manager class to use. Should be a subclass of jupyter_client.kernelspec.kernelspecmanager Options 1318 The Api of KernelSpecManager is provisional and might change without warning between this version of Jupyter and the next stable one. NotebookApp.keyfile [Unicode] Default: The full path to a private key file for usage with SSL/TLS. NotebookApp.login_handler_class [Type] Default: notebook.auth.login.loginhandler The login handler class to use. NotebookApp.logout_handler_class [Type] Default: notebook.auth.logout.logouthandler The logout handler class to use. NotebookApp.mathjax_url [Unicode] Default: The url for MathJax.js. NotebookApp.nbserver_extensions [Dict] Default: {} Dict of Python modules to load as notebook server extensions.entry values can be used to enable and disable the loading ofthe extensions. NotebookApp.notebook_dir [Unicode] Default: The directory to use for notebooks and kernels. NotebookApp.open_browser [Bool] Default: True Whether to open in a browser after starting. The specific browser used is platform dependent and determined by the python standard library webbrowser module, unless it is overridden using the browser (NotebookApp.browser) configuration option. NotebookApp.password [Unicode] Default: Hashed password to use for web authentication. To generate, type in a python/ipython shell: from notebook. passwd() The string should be of the form type:salt:hashed-password. NotebookApp.port [Int] Default: 8888 The port the notebook server will listen on. NotebookApp.port_retries [Int] Default: 50 The number of additional ports to try if the specified port is not available. NotebookApp.pylab [Unicode] Default: disabled DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib. NotebookApp.rate_limit_window [Float] Default: 1.0 (sec) Time window used to check the message and data rate limits. NotebookApp.reraise_server_extension_failures [Bool] Default: False Reraise exceptions encountered loading server extensions? NotebookApp.server_extensions [List] Default: [] DEPRECATED use the nbserver_extensions dict instead 14 Chapter 3. Config file and command line options19 NotebookApp.session_manager_class [Type] Default: notebook.services.sessions.sessionmanager.sessionman The session manager class to use. NotebookApp.ssl_options [Dict] Default: {} Supply SSL options for the tornado HTTPServer. See the tornado docs for details. NotebookApp.tornado_settings [Dict] Default: {} Supply overrides for the tornado.web.application that the Jupyter notebook uses. NotebookApp.trust_xheaders [Bool] Default: False Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-For headerssent by the upstream reverse proxy. Necessary if the proxy handles SSL NotebookApp.webapp_settings [Dict] Default: {} DEPRECATED, use tornado_settings NotebookApp.websocket_url [Unicode] Default: The base URL for websockets, if it differs from the HTTP server (hint: it almost certainly doesn t). Should be in the form of an HTTP origin: ws[s]://hostname[:port] ConnectionFileMixin.connection_file [Unicode] Default: JSON file in which to store connection info [default: kernel-&pid&.json] This file will contain the IP, ports, and authentication key needed to connect clients to this kernel. By default, this file will be created in the security dir of the current profile, but can be specified by absolute path. ConnectionFileMixin.control_port [Int] Default: 0 set the control (ROUTER) port [default: random] ConnectionFileMixin.hb_port [Int] Default: 0 set the heartbeat port [default: random] ConnectionFileMixin.iopub_port [Int] Default: 0 set the iopub (PUB) port [default: random] ConnectionFileMixin.ip [Unicode] Default: Set the kernel s IP address [default localhost]. If the IP address is something other than localhost, then Consoles on other machines will be able to connect to the Kernel, so be careful! ConnectionFileMixin.shell_port [Int] Default: 0 set the shell (ROUTER) port [default: random] ConnectionFileMixin.stdin_port [Int] Default: 0 set the stdin (ROUTER) port [default: random] ConnectionFileMixin.transport [ tcp ipc ] Default: tcp No description KernelManager.autorestart [Bool] Default: True Should we autorestart the kernel if it dies Options 1520 KernelManager.kernel_cmd [List] Default: [] DEPRECATED: Use kernel_name instead. The Popen Command to launch the kernel. Override this if you have a custom kernel. If kernel_cmd is specified in a configuration file, Jupyter does not pass any arguments to the kernel, because it cannot make any assumptions about the arguments that the kernel understands. In particular, this means that the kernel does not receive the option debug if it given on the Jupyter command line. Session.buffer_threshold [Int] Default: 1024 Threshold (in bytes) beyond which an object s buffer should be extracted to avoid pickling. Session.check_pid [Bool] Default: True Whether to check PID to protect against calls after fork. This check can be disabled if fork-safety is handled elsewhere. Session.copy_threshold [Int] Default: Threshold (in bytes) beyond which a buffer should be sent without copying. Session.debug [Bool] Default: False Debug output in the Session Session.digest_history_size [Int] Default: The maximum number of digests to remember. The digest history will be culled when it exceeds this value. Session.item_threshold [Int] Default: 64 The maximum number of items for a container to be introspected for custom serialization. Containers larger than this are pickled outright. Session.key [CBytes] Default: b execution key, for signing messages. Session.keyfile [Unicode] Default: path to file containing execution key. Session.metadata [Dict] Default: {} Metadata dictionary, which serves as the default top-level metadata dict for each message. Session.packer [DottedObjectName] Default: json The name of the packer for serializing messages. Should be one of json, pickle, or an import name for a custom callable serializer. Session.session [CUnicode] Default: The UUID identifying this session. Session.signature_scheme [Unicode] Default: hmac-sha256 The digest scheme used to construct the message signatures. Must have the form hmac-hash. Session.unpacker [DottedObjectName] Default: json The name of the unpacker for unserializing messages. Only used with custom functions for packer. Session.username [Unicode] Default: username Username for the Session. Default is your system username. 16 Chapter 3. Config file and command line options21 MultiKernelManager.default_kernel_name [Unicode] Default: python3 The name of the default kernel to start MultiKernelManager.kernel_manager_class [DottedObjectName] Default: jupyter_client.ioloop.ioloopkernelman The kernel manager class. This is configurable to allow subclassing of the KernelManager for customized behavior. MappingKernelManager.root_dir [Unicode] Default: No description ContentsManager.checkpoints [Instance] Default: None No description ContentsManager.checkpoints_class [Type] Default: notebook.services.contents.checkpoints.checkpoints No description ContentsManager.checkpoints_kwargs [Dict] Default: {} No description ContentsManager.hide_globs [List] Default: [ pycache, *.pyc, *.pyo,.ds_store, *.so, *.dyl... Glob patterns to hide in file and directory listings. ContentsManager.pre_save_hook [Any] Default: None Python callable or importstring thereof To be called on a contents model prior to save. This can be used to process the structure, such as removing notebook outputs or other side effects that should not be saved. It will be called as (all arguments passed by keyword): hook(path=path, model=model, contents_manager=self) model: the model to be saved. Includes file contents. Modifying this dict will affect the file that is stored. path: the API path of the save destination contents_manager: this ContentsManager instance ContentsManager.untitled_directory [Unicode] Default: Untitled Folder The base name used when creating untitled directories. ContentsManager.untitled_file [Unicode] Default: untitled The base name used when creating untitled files. ContentsManager.untitled_notebook [Unicode] Default: Untitled The base name used when creating untitled notebooks. FileManagerMixin.use_atomic_writing [Bool] Default: True By default notebooks are saved on disk on a temporary file and then if succefully written, it replaces the old ones. This procedure, namely atomic_writing, causes some bugs on file system whitout operation order enforcement (like some networked fs). If set to False, the new notebook is written directly on the old one which could fail (eg: full filesystem or quota ) 3.1. Options 1722 FileContentsManager.post_save_hook [Any] Default: None Python callable or importstring thereof to be called on the path of a file just saved. This can be used to process the file on disk, such as converting the notebook to a script or HTML via nbconvert. It will be called as (all arguments passed by keyword): hook(os_path=os_path, model=model, contents_manager=instance) path: the filesystem path to the file just written model: the model representing the file contents_manager: this ContentsManager instance FileContentsManager.root_dir [Unicode] Default: No description FileContentsManager.save_script [Bool] Default: False DEPRECATED, use post_save_hook. Will be removed in Notebook 5.0 NotebookNotary.algorithm [ sha224 md5 sha1 sha512 sha256 sha384 ] Default: sha256 The hashing algorithm used to sign notebooks. NotebookNotary.cache_size [Int] Default: The number of notebook signatures to cache. When the number of signatures exceeds this value, the oldest 25% of signatures will be culled. NotebookNotary.db_file [Unicode] Default: The sqlite file in which to store notebook signatures. By default, this will be in your Jupyter data directory. You can set it to :memory: to disable sqlite writing to the filesystem. NotebookNotary.secret [Bytes] Default: b The secret key with which notebooks are signed. NotebookNotary.secret_file [Unicode] Default: The file where the secret key is stored. KernelSpecManager.ensure_native_kernel [Bool] Default: True If there is no Python kernelspec registered and the IPython kernel is available, ensure it is added to the spec list. KernelSpecManager.kernel_spec_class [Type] Default: jupyter_client.kernelspec.kernelspec The kernel spec class. This is configurable to allow subclassing of the KernelSpecManager for customized behavior. KernelSpecManager.whitelist [Set] Default: set() Whitelist of allowed kernel names. By default, all installed kernels are allowed. 18 Chapter 3. Config file and command line options23 CHAPTER 4 Running a notebook server The Jupyter notebook web application is based on a server-client structure. The notebook server uses a two-process kernel architecture based on ZeroMQ, as well as Tornado for serving HTTP requests. Note: By default, a notebook server runs locally at :8888 and is accessible only from localhost. You may access the notebook server from the browser using
This document describes how you can secure a notebook server and how to run it on a public interface. 4.1 Securing a notebook server You can protect your notebook server with a simple single password by configuring the NotebookApp.password setting in jupyter_notebook_config.py Prerequisite: A notebook configuration file Check to see if you have a notebook configuration file, jupyter_notebook_config.py. The default location for this file is your Jupyter folder in your home directory, ~/.jupyter. If you don t already have one, create a config file for the notebook using the following command: $ jupyter notebook --generate-config Preparing a hashed password You can prepare a hashed password using the function notebook.auth.security.passwd(): In [1]: from notebook.auth import passwd In [2]: passwd() Enter password: Verify password: Out[2]: 'sha1:67c9e60bb8b6:9ffede b2e042ea597daed' Caution: passwd() when called with no arguments will prompt you to enter and verify your password such as in the above code snippet. Although the function can also be passed a string as an argument such as passwd( mypassword ), please do not pass a string as an argument inside an IPython session, as it will be saved in your input history. 1924 4.1.3 Adding hashed password to your notebook configuration file You can then add the hashed password to your jupyter_notebook_config.py. The default location for this file jupyter_notebook_config.py is in your Jupyter folder in your home directory, ~/.jupyter, e.g.: c.notebookapp.password = u'sha1:67c9e60bb8b6:9ffede b2e042ea597daed' Using SSL for encrypted communication When using a password, it is a good idea to also use SSL with a web certificate, so that your hashed password is not sent unencrypted by your browser. Important: Web security is rapidly changing and evolving. We provide this document as a convenience to the user, and recommend that the user keep current on changes that may impact security, such as new releases of OpenSSL. The Open Web Application Security Project (OWASP) website is a good resource on general security issues and web practices. You can start the notebook to communicate via a secure protocol mode by setting the certfile option to your self-signed certificate, i.e. mycert.pem, with the command: $ jupyter notebook --certfile=mycert.pem --keyfile mykey.key Tip: A self-signed certificate can be generated with openssl. For example, the following command will create a certificate valid for 365 days with both the key and certificate data written to the same file: $ openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout mykey.key -out mycert.pem When starting the notebook server, your browser may warn that your self-signed certificate is insecure or unrecognized. If you wish to have a fully compliant self-signed certificate that will not raise warnings, it is possible (but rather involved) to create one, as explained in detail in this tutorial. 4.2 Running a public notebook server If you want to access your notebook server remotely via a web browser, you can do so by running a public notebook server. For optimal security when running a public notebook server, you should first secure the server with a password and SSL/HTTPS as described in Securing a notebook server. Start by creating a certificate file and a hashed password, as explained in Securing a notebook server. If you don t already have one, create a config file for the notebook using the following command line: $ jupyter notebook --generate-config In the ~/.jupyter directory, edit the notebook config file, jupyter_notebook_config.py. By default, the notebook config file has all fields commented out. The minimum set of configuration options that you should to uncomment and edit in :file:jupyter_notebook_config.py is the following: # Set options for certfile, ip, password, and toggle off browser auto-opening c.notebookapp.certfile = u'/absolute/path/to/your/certificate/mycert.pem' c.notebookapp.keyfile = u'/absolute/path/to/your/certificate/mykey.key' # Set ip to '*' to bind on all interfaces (ips) for the public server c.notebookapp.ip = '*' 20 Chapter 4. Running a notebook server25 c.notebookapp.password = u'sha1:bcd259ccf...&your hashed password here&' c.notebookapp.open_browser = False # It is a good idea to set a known, fixed port for server access c.notebookapp.port = 9999 You can then start the notebook using the jupyter notebook command. Important: Use https. Keep in mind that when you enable SSL support, you must access the notebook server over https://, not over plain
The startup message from the server prints a reminder in the console, but it is easy to overlook this detail and think the server is for some reason non-responsive. When using SSL, always access the notebook server with https://. You may now access the public server by pointing your browser to :9999 where
is your public server s domain Firewall Setup To function correctly, the firewall on the computer running the jupyter notebook server must be configured to allow connections from client machines on the access port c.notebookapp.port set in :file:jupyter_notebook_config.py port to allow connections to the web interface. The firewall must also allow connections from (localhost) on ports from to These ports are used by the server to communicate with the notebook kernels. The kernel communication ports are chosen randomly by ZeroMQ, and may require multiple connections per kernel, so a large range of ports must be accessible. 4.3 Running the notebook with a customized URL prefix The notebook dashboard, which is the landing page with an overview of the notebooks in your working directory, is typically found and accessed at the default URL
If you prefer to customize the URL prefix for the notebook dashboard, you can do so through modifying jupyter_notebook_config.py. For example, if you prefer that the notebook dashboard be located with a sub-directory that contains other ipython files, e.g.
you can do so with configuration options like the following (see above for instructions about modifying jupyter_notebook_config.py): c.notebookapp.base_url = '/ipython/' c.notebookapp.webapp_settings = {'static_url_prefix':'/ipython/static/'} 4.4 Known issues Proxies When behind a proxy, especially if your system or browser is set to autodetect the proxy, the notebook web application might fail to connect to the server s websockets, and present you with a warning at startup. In this case, you need to configure your system not to use the proxy for the server s address. For example, in Firefox, go to the Preferences panel, Advanced section, Network tab, click Settings..., and add the address of the notebook server to the No proxy for field Running the notebook with a customized URL prefix 2126 4.4.2 Docker CMD Using jupyter notebook as a Docker CMD results in kernels repeatedly crashing, likely due to a lack of PID reaping. To avoid this, use the tini init as your Dockerfile ENTRYPOINT: # Add Tini. Tini operates as a process subreaper for jupyter. This prevents # kernel crashes. ENV TINI_VERSION v0.6.0 ADD /krallin/tini/releases/download/${tini_version}/tini /usr/bin/tini RUN chmod +x /usr/bin/tini ENTRYPOINT [&/usr/bin/tini&, &--&] EXPOSE 8888 CMD [&jupyter&, &notebook&, &--port=8888&, &--no-browser&, &--ip= &] 22 Chapter 4. Running a notebook server27 CHAPTER 5 Security in Jupyter notebooks As Jupyter notebooks become more popular for sharing and collaboration, the potential for malicious people to attempt to exploit the notebook for their nefarious purposes increases. IPython 2.0 introduces a security model to prevent execution of untrusted code without explicit user input. 5.1 The problem The whole point of Jupyter is arbitrary code execution. We have no desire to limit what can be done with a notebook, which would negatively impact its utility. Unlike other programs, a Jupyter notebook document includes output. Unlike other documents, that output exists in a context that can execute code (via Javascript). The security problem we need to solve is that no code should execute just because a user has opened a notebook that they did not write. Like any other program, once a user decides to execute code in a notebook, it is considered trusted, and should be allowed to do anything. 5.2 Our security model Untrusted HTML is always sanitized Untrusted Javascript is never executed HTML and Javascript in Markdown cells are never trusted Outputs generated by the user are trusted Any other HTML or Javascript (in Markdown cells, output generated by others) is never trusted The central question of trust is Did the current user do this? 5.3 The details of trust Jupyter notebooks store a signature in metadata, which is used to answer the question Did the current user do this? This signature is a digest of the notebooks contents plus a secret key, known only to the user. The secret key is a user-only readable file in the Jupyter profile s security directory. By default, this is: 2328 ~/.jupyter/profile_default/security/notebook_secret Note: The notebook secret being stored in the profile means that loading a notebook in another profile results in it being untrusted, unless you copy or symlink the notebook secret to share it across profiles. When a notebook is opened by a user, the server computes a signature with the user s key, and compares it with the signature stored in the notebook s metadata. If the signature matches, HTML and Javascript output in the notebook will be trusted at load, otherwise it will be untrusted. Any output generated during an interactive session is trusted Updating trust A notebook s trust is updated when the notebook is saved. If there are any untrusted outputs still in the notebook, the notebook will not be trusted, and no signature will be stored. If all untrusted outputs have been removed (either via Clear Output or re-execution), then the notebook will become trusted. While trust is updated per output, this is only for the duration of a single session. A notebook file on disk is either trusted or not in its entirety Explicit trust Sometimes re-executing a notebook to generate trusted output is not an option, either because dependencies are unavailable, or it would take a long time. Users can explicitly trust a notebook in two ways: At the command-line, with: jupyter trust /path/to/notebook.ipynb After loading the untrusted notebook, with File / Trust Notebook These two methods simply load the notebook, compute a new signature with the user s key, and then store the newly signed notebook. 5.4 Reporting security issues If you find a security vulnerability in Jupyter, either a failure of the code to properly implement the model described here, or a failure of the model itself, please report it to If you prefer to encrypt your security reports, you can use this PGP public key. 5.5 Affected use cases Some use cases that work in Jupyter 1.0 will become less convenient in 2.0 as a result of the security changes. We do our best to minimize these annoyance, but security is always at odds with convenience. 24 Chapter 5. Security in Jupyter notebooks29 5.5.1 Javascript and CSS in Markdown cells While never officially supported, it had become common practice to put hidden Javascript or CSS styling in Markdown cells, so that they would not be visible on the page. Since Markdown cells are now sanitized (by Google Caja), all Javascript (including click event handlers, etc.) and CSS will be stripped. We plan to provide a mechanism for notebook themes, but in the meantime styling the notebook can only be done via either custom.css or CSS in HTML output. The latter only have an effect if the notebook is trusted, because otherwise the output will be sanitized just like Markdown Collaboration When collaborating on a notebook, people probably want to see the outputs produced by their colleagues most recent executions. Since each collaborator s key will differ, this will result in each share starting in an untrusted state. There are three basic approaches to this: re-run notebooks when you get them (not always viable) explicitly trust notebooks via jupyter trust or the notebook menu (annoying, but easy) share a notebook secret, and use a Jupyter profile dedicated to the collaboration while working on the project Multiple profiles or machines Since the notebook secret is stored in a profile directory by default, opening a notebook with a different profile or on a different machine will result in a different key, and thus be untrusted. The only current way to address this is by sharing the notebook secret. This can be facilitated by setting the configurable: c.notebookapp.secret_file = &/path/to/notebook_secret& in each profile, and only sharing the secret once per machine Affected use cases 2530 26 Chapter 5. Security in Jupyter notebooks31 CHAPTER 6 Configuring the notebook frontend Note: The ability to configure the notebook frontend UI and preferences is still a work in progress. This document is a rough explanation on how you can persist some configuration options for the notebook JavaScript. There is no exhaustive list of all the configuration options as most options are passed down to other libraries, which means that non valid configuration can be ignored without any error messages. 6.1 How front end configuration works The frontend configuration system works as follows: get a handle of a configurable JavaScript object. access its configuration attribute. update its configuration attribute with a JSON patch. 6.2 Example - Changing the notebook s default indentation This example explains how to change the default setting indentunit for CodeMirror Code Cells: var cell = Jupyter.notebook.get_selected_cell(); var config = cell. var patch = { CodeCell:{ cm_config:{indentunit:2} } } config.update(patch) You can enter the previous snippet in your browser s JavaScript console once. Then reload the notebook page in your browser. Now, the preferred indent unit should be equal to two spaces. The custom setting persists and you do not need to reissue the patch on new notebooks. indentunit, used in this example, is one of the many CodeMirror options which are available for configuration. 2732 6.3 Example - Restoring the notebook s default indentation If you want to restore a notebook frontend preference to its default value, you will enter a JSON patch with a null value for the preference setting. For example, let s restore the indent setting indentunit to its default of four spaces. Enter the following code snippet in your JavaScript console: var cell = Jupyter.notebook.get_selected_cell(); var config = cell. var patch = { CodeCell:{ cm_config:{indentunit: null} # only change here. } } config.update(patch) Reload the notebook in your browser and the default indent should again be two spaces. 6.4 Persisting configuration settings Under the hood, Jupyter will persist the preferred configuration settings in ~/.jupyter/nbconfig/&section&.json, with &section& taking various value depending on the page where the configuration is issued. &section& can take various values like notebook, tree, and editor. A common section contains configuration settings shared by all pages. 28 Chapter 6. Configuring the notebook frontend
Wakanda Studio Features Discover the many features in Wakanda Studio. The main features each have their own chapters and other features are documented elsewhere: Wakanda Server Administration Data Browser
SysPatrol Server Security Monitor User Manual Version 2.2 Sep 2013
1 Product Overview SysPatrol is a server security monitoring solution allowing one to monitor one or
Chapter 4 How to test and debug an ASP.NET application 113 4 How to test and debug an ASP.NET application If you ve done much programming, you know that testing and debugging are often the most difficult
Administering Jive for Outlook TOC 2 Contents Administering Jive for Outlook...3 System Requirements...3 Installing the Plugin... 3 Installing the Plugin... 3 Client Installation... 4 Resetting the Binaries...4
Editor's Guide to TYPO3 Content Management System 1 Table of Contents Editor's Guide to TYPO3 Content Management System... 1 Table of Contents... 2 Website Overview... 3 Front and Back End Management...
Advanced Event Viewer Manual Document version: 2.2944.01 Download Advanced Event Viewer at:
Page 1 Introduction Advanced Event Viewer is an award winning application
Jupyter/IPython Notebook Quick Start Guide Documentation Release 0.1 Antonino Ingargiola and other contributors November 26, 2016
Contents 1 Contents 3 i ii Jupyter/IPython Notebook Quick Start Guide
EMC Data Protection Search Version 1.0 Security Configuration Guide 302-001-611 REV 01 Copyright
EMC Corporation. All rights reserved. Published in USA. Published April 20, 2015 EMC believes
Umbraco v6 Editors Manual Produced by the Umbraco Community Umbraco // The Friendly CMS Contents 1 Introduction... 3 2 Getting Started with Umbraco... 4 2.1 Logging On... 4 2.2 The Edit Mode Interface...
Query Console User Guide 1 MarkLogic 8 February, 2015 Last Revised: 8.0-1, February, 2015 Copyright 2015 MarkLogic Corporation. All rights reserved. Table of Contents Table of Contents Query Console User
NovaBACKUP Storage Server User Manual NovaStor / April
NovaStor, all rights reserved. All trademarks are the property of their respective owners. Features and specifications are subject to change
DiskPulse DISK CHANGE MONITOR User Manual Version 7.9 Oct 2015
1 1 DiskPulse Overview...3 2 DiskPulse Product Versions...5 3 Using Desktop Product Version...6 3.1 Product
Eucalyptus 3.4.2 User Console Guide
Eucalyptus Systems Eucalyptus Contents 2 Contents User Console Overview...4 Install the Eucalyptus User Console...5 Install on Centos / RHEL 6.3...5 Configure
Content Filtering Client Policy & Reporting Administrator s Guide Notes, Cautions, and Warnings NOTE: A NOTE indicates important information that helps you make better use of your system. CAUTION: A CAUTION
Load testing with WAPT: Quick Start Guide This document describes step by step how to create a simple typical test for a web application, execute it and interpret the results. A brief insight is provided
JupyterHub Documentation Release 0.4.0.dev Project Jupyter team January 26, 2016
User Documentation 1 Getting started with JupyterHub 3 2 Further reading 11 3 How JupyterHub works 13 4 Writing a custom
vtcommander vtcommander provides a local graphical user interface (GUI) to manage Hyper-V R2 server. It supports Hyper-V technology on full and core installations of Windows Server 2008 R2 as well as on
Desktop Surveillance Help Table of Contents About... 9 What s New... 10 System Requirements... 11 Updating from Desktop Surveillance 2.6 to Desktop Surveillance 3.2... 13 Program Structure... 14 Getting
Bitrix Site Manager 4.1 User Guide 2 Contents REGISTRATION AND AUTHORISATION...3 SITE SECTIONS...5 Creating a section...6 Changing the section properties...8 SITE PAGES...9 Creating a page...10 Editing
Xerox EX Print Server, Powered by Fiery, for the Xerox 700 Digital Color Press Printing from Windows 2008 Electronics for Imaging, Inc. The information in this publication is covered under Legal Notices
System Administration Training Guide S100 Installation and Site Management Table of contents System Requirements for Acumatica ERP 4.2... 5 Learning Objects:... 5 Web Browser... 5 Server Software... 5
WebSpy Vantage Ultimate 2.2 Web Module Administrators Guide This document is intended to help you get started using WebSpy Vantage Ultimate and the Web Module. For more detailed information, please see
Table of Contents Welcome... 2 Login... 3 Password Assistance... 4 Self Registration... 5 Secure Mail... 7 Compose... 8 Drafts... 10 Outbox... 11 Sent Items... 12 View Package Details... 12 File Manager...
Load testing with WAPT Cloud Quick Start Guide This document describes step by step how to create a simple typical test for a web application, execute it and interpret the results.
SoftLogica
Hypercosm Studio
Hypercosm Studio Guide 3 Revision: November 2005 Copyright 2005 Hypercosm LLC All rights reserved. Hypercosm, OMAR, Hypercosm 3D Player, and Hypercosm Studio are trademarks
Contents Introduction...2 Overview...2 Security considerations... 2 Installation...3 Server Configuration...4 Management Client Connection...4 General Settings... 4 Enterprise Architect Client Connection
Sharp Remote Device Manager (SRDM) Server Software Setup Guide This Guide explains how to install the software which is required in order to use Sharp Remote Device Manager (SRDM). SRDM is a web-based
Trend Micro Incorporated reserves the right to make changes to this document and to the products described herein without notice. Before installing and using the software, please review the readme files,
SAP BusinessObjects Business Intelligence platform Document Version: 4.0 Support Package 8- Table of Contents 1 About this document...5 1.1 Who should read this document....5 1.2 Document history....5
Reference Guide for WebCDM Application 2013 CEICData. All rights reserved. Version 1.2 Created On February 5, 2007 Last Modified August 27, 2013 Table of Contents 1 SUPPORTED BROWSERS... 3 1.1 INTERNET
Online Backup Client User Manual Mac OS 1. Product Information Product: Online Backup Client for Mac OS X Version: 4.1.7 1.1 System Requirements Operating System Mac OS X Leopard (10.5.0 and higher) (PPC
Online Backup Client User Manual Mac OS 1. Product Information Product: Online Backup Client for Mac OS X Version: 4.1.7 1.1 System Requirements Operating System Mac OS X Leopard (10.5.0 and higher) (PPC
ORIXCLOUD BACKUP CLIENT USER MANUAL LINUX 1. Product Information Product: Orixcloud Backup Client for Linux Version: 4.1.7 1.1 System Requirements Linux (RedHat, SuSE, Debian and Debian based systems such
Ekran System Help File Table of Contents About... 9 What s New... 10 System Requirements... 11 Updating Ekran to version 4.1... 13 Program Structure... 14 Getting Started... 15 Deployment Process... 15
SonicWALL SSL VPN File Shares Applet Document Scope This document describes how to use and manage the SonicWALL SSL VPN File Shares Applet feature. This document contains the following sections: Feature
CommonSpot Content Server Version 6.2 Release Notes Copyright
PaperThin, Inc. All rights reserved. About this Document CommonSpot version 6.2 updates the recent 6.1 release with: Enhancements
TOSHIBA GA-1310 Printing from Windows 2009 Electronics for Imaging, Inc. The information in this publication is covered under Legal Notices for this product.
February 2009 CONTENTS 3 CONTENTS
Blue Coat Security First Steps Solution for Deploying an Explicit Proxy SGOS 6.5 Third Party Copyright Notices 2014 Blue Coat Systems, Inc. All rights reserved. BLUE COAT, PROXYSG, PACKETSHAPER, CACHEFLOW,
Online Backup Client User Manual Linux 1. Product Information Product: Online Backup Client for Linux Version: 4.1.7 1.1 System Requirements Operating System Linux (RedHat, SuSE, Debian and Debian based
orrelogtm Security Correlation Server Quick Installation Guide This guide provides brief information on how to install the CorreLog Server system on a Microsoft Windows platform. This information can also
CLC Server Command Line Tools USER MANUAL Manual for CLC Server Command Line Tools 2.5 Windows, Mac OS X and Linux September 4, 2015 This software is for research purposes only. QIAGEN Aarhus A/S Silkeborgvej
How to Edit Your Website A guide to using your Content Management System Overview 2 Accessing the CMS 2 Choosing Your Language 2 Resetting Your Password 3 Sites 4 Favorites 4 Pages 5 Creating Pages 5 Managing
For Linux distributions Software version 4.1.7 Version 2.0 Disclaimer This document is compiled with the greatest possible care. However, errors might have been introduced caused by human mistakes or by
IBM Information Server Version 8 Release 1 IBM Information Server Administration Guide SC18-9929-01
IBM Information Server Version 8 Release 1 IBM Information Server Administration Guide SC18-9929-01
2016 PTC Inc. All Rights Reserved. 2 Table of Contents 1 Table of Contents 2 4 Overview 4 Server Settings 5 7 Server Endpoints 7 Trusted Clients 9 Discovery Servers 10 Trusted Servers 11 Instance Certificates
Getting Started with the Ed-Fi ODS and Ed-Fi ODS API Ed-Fi ODS and Ed-Fi ODS API Version 2.0 - Technical Preview October
Ed-Fi Alliance, LLC. All rights reserved. Ed-Fi is a registered trademark
Bitrix Site Manager ASP.NET Installation Guide Contents Introduction... 4 Chapter 1. Checking for IIS Installation... 5 Chapter 2. Using An Archive File to Install Bitrix Site Manager ASP.NET... 7 Preliminary
Kaseya Server Installation User Guide June 6, 2008 About Kaseya Kaseya is a global provider of IT automation software for IT Solution Providers and Public and Private Sector IT organizations. Kaseya's
SonicWALL SSL VPN 3.0 HTTP(S) Reverse Proxy Support Document Scope This document describes the implementation of reverse proxy to provide HTTP and HTTPS access to Microsoft Outlook Web Access (OWA) Premium
MailEnable Connector for Microsoft Outlook Version 2.23 This guide describes the installation and functionality of the MailEnable Connector for Microsoft Outlook. Features The MailEnable Connector for
Jive for Outlook TOC 2 Contents Jive for Outlook... 3 Release Notes... 3 System Requirements...3 Installing the Plugin... 3 Installing the Plugin... 3 Client Installation... 4 Resetting the Binaries...4
Online Backup Linux Client User Manual Software version 4.0.x For Linux distributions August 2011 Version 1.0 Disclaimer This document is compiled with the greatest possible care. However, errors might
6.2 Offline Mode - User Guide Contents Colligo Email Manager 1 Benefits 1 Key Features 1 Platforms Supported 1 Installing and Activating Colligo Email Manager 3 Checking for Updates 4 Updating Your License
Umbraco v4 Editors Manua}