semvec/pypi-packages huggingface dataset:
sandstone-spawner 0.1.1
Sandstone JupyterHub Spawner

# sandstone-spawner
JupyterHub Spawner class for starting Sandstone HPC user instances

## Installation
**This module requires the JupyterHub Login Handler for Sandstone, found at https://github.com/SandstoneHPC/sandstone-jupyterhub-login**

Install the module with
```
python setup.py install
```

Set the `SANDSTONE_SETTINGS` environment variable to the absolute path of your Sandstone settings file, and then set the `SANDSTONE_APP_PATH` environment variable to the absolute path of the `sandstone-jupyterhub` executable. This executable is provided by `sandstone-jupyterhub-login`.
```
export SANDSTONE_APP_PATH=/path/to/sandstone-jupyterhub
```

## JupyterHub Config
Modify your JupyterHub config file to set the default spawner as `SandstoneSpawner`.
```python
c.JupyterHub.spawner_class = 'sandstone_spawner.spawner.SandstoneSpawner'
```

### Spawn Jupyter Notebooks and Sandstone
If you would like JupyterHub to be able to spawn Sandstone as well as Jupyter Notebooks, configure the _ProfilesSpawner_ to wrap the _SandstoneSpawner_:
```python
c.JupyterHub.spawner_class = 'wrapspawner.ProfilesSpawner'
c.Spawner.http_timeout = 120

c.ProfilesSpawner.profiles = [( "Host process",
    'local','jupyterhub.spawner.LocalProcessSpawner', {'ip':'0.0.0.0'} ),
    ('Sandstone', 'sandstone','sandstone_spawner.spawner.SandstoneSpawner', {}),
]
```

## Running the Docker Image
The Docker image included in this repo provides an example setup of a JupyterHub instance that can spawn either a Jupyter Notebook or Sandstone instance. The image has two example users _(username:password)_:
* sandstone1:sandstone1
* sandstone2:sandstone2

To build and run this image:
```
docker build -t sandstone-jupyterhub .
docker run -p 8000:8000 -d sandstone-jupyterhub
```

JupyterHub will be accessible on http://localhost:8000/.
calysto_processing 2.0.3
A ProcessingJS kernel for Jupyter

**Calysto Processing** is the merging of [ProcessingJS](http://processingjs.org/) with [Project Jupyter](http://jupyter.org/) (aka IPython). Processing Sketches are entered into Jupyter notebook cells, and even run in rendered notebooks. Sketches can be paused, and stepped one draw() at a time. 

Because Calysto Processing uses [MetaKernel](https://github.com/Calysto/metakernel/blob/master/README.rst), it has a fully-supported set of "magics"---meta-commands for additional functionality. A list of magics can be seen at [MetaKernel Magics](https://github.com/Calysto/metakernel/blob/master/metakernel/magics/README.md).

Calysto Processing in use:

* [CS110: Introduction to Computing](http://jupyter.cs.brynmawr.edu/hub/dblank/public/CS110%20Intro%20to%20Computing/2015/Syllabus.ipynb)
* [Video](https://www.youtube.com/watch?v=V4TzARh-ClY)

You can install Calysto Processing with:

```
pip install --upgrade calysto-processing
```

or in the system kernels with:

```
sudo pip install --upgrade calysto-processing
```

Next, install Processing 2 from https://processing.org/download/

You will need to make sure that you have installed and access to the `processing_java` command. Mac users will need to install it from Processing by selecting 'Install "processing_java"' under the Tools menu.

Finally, edit the installed `calysto_processing/kernel.js` to include the full path to the `processing_java` command. That might look like:

```javascript
{
 "argv": 
    ["/usr/bin/python3", 
     "-m", "calysto_processing", 
     "-f", "{connection_file}"], 
 "display_name": "Calysto Processing", 
 "env": {"PROCESSING_JAVA": "/home/dblank/Desktop/processing-2.2.1/processing-java"}, 
 "language": "java", 
 "name": "calysto_processing"
}
```

Use it in the notebook with:

```
ipython notebook
```

and then select `Calysto Processing` for a new notebook.

Calysto Processing also has an enhancement: Tables, and some related functions:

```java
/* @pjs includeTable="true"; */

Table table;

void setup() {
    table = loadTable("test.csv", "header");
    println(table.getRowCount() + " total rows in table"); 
}

long findMax() {
    int retval = 0;
    for (TableRow row : table.rows()) {
        int pop = row.getInt("Population");
        if (pop > retval)
            retval = pop;
    }
    return retval;
}
```

Table-related classes and methods:

* loadTable(CSV_FILNAME, "header");
* Table class
* TableRow class
* table.rows() - returns iterator for use with for(TableRow row : table.rows()) {...}
* row.getInt(COLUMN_NAME)
* row.getString(COLUMN_NAME)
* row.getFloat(COLUMN_NAME)

See source for more details.

Example notebooks can be found in https://github.com/Calysto/calysto_processing/tree/master/notebooks

Requires:

* ipython-3.0
* Python2 or Python3
* metakernel (installed with pip)
* calysto (installed with pip)

Calysto Processing supports:

* MetaKernel Magics
* All of ProcessingJS, plus pause/restart and stepper
FFC 2017.1.0
The FEniCS Form Compiler

=============================
FFC: The FEniCS Form Compiler
=============================

FFC is a compiler for finite element variational forms. From a
high-level description of the form, it generates efficient low-level
C++ code that can be used to assemble the corresponding discrete
operator (tensor). In particular, a bilinear form may be assembled
into a matrix and a linear form may be assembled into a vector.  FFC
may be used either from the command line (by invoking the ``ffc``
command) or as a Python module (``import ffc``).

FFC is part of the FEniCS Project.

For more information, visit http://www.fenicsproject.org


Documentation
=============

Documentation can be viewed at http://fenics-ffc.readthedocs.org/.

.. image:: https://readthedocs.org/projects/fenics-ffc/badge/?version=latest
   :target: http://fenics.readthedocs.io/projects/ffc/en/latest/?badge=latest
   :alt: Documentation Status


Automated Testing
=================

We use Bitbucket Pipelines and Atlassian Bamboo to perform automated
testing.

.. image:: https://bitbucket-badges.useast.atlassian.io/badge/fenics-project/ffc.svg
   :target: https://bitbucket.org/fenics-project/ffc/addon/pipelines/home
   :alt: Pipelines Build Status

.. image:: http://fenics-bamboo.simula.no:8085/plugins/servlet/wittified/build-status/FFC-FD
   :target: http://fenics-bamboo.simula.no:8085/browse/FFC-FD/latest
   :alt: Bamboo Build Status


Code Coverage
=============

Code coverage reports can be viewed at
https://coveralls.io/bitbucket/fenics-project/ffc.

.. image:: https://coveralls.io/repos/bitbucket/fenics-project/ffc/badge.svg?branch=master
   :target: https://coveralls.io/bitbucket/fenics-project/ffc?branch=master
   :alt: Coverage Status


License
=======

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with this program. If not, see <http://www.gnu.org/licenses/>.