semvec/pypi-packages huggingface dataset:
jupyter-pyfilesystem 0.0.5
Jupyter Notebook PyFilesystem Contents Manager
License: MIT
Requires Python: >=3.5

# Jupyter Notebook PyFilesystem Contents Manager
[![Build Status](https://travis-ci.com/manics/jupyter-pyfilesystem.svg?branch=master)](https://travis-ci.com/manics/jupyter-pyfilesystem)
[![PyPI](https://img.shields.io/pypi/v/jupyter-pyfilesystem)](https://pypi.org/project/jupyter-pyfilesystem/)

A [Jupyter Notebooks `ContentsManager`](https://jupyter-notebook.readthedocs.io/en/stable/extending/contents.html#writing-a-custom-contentsmanager) that uses [PyFilesystem](https://www.pyfilesystem.org/) for storing files.
Includes a compatible [`Checkpoints`](https://jupyter-notebook.readthedocs.io/en/stable/extending/contents.html#customizing-checkpoints) class.


## Installation

```
pip install jupyter-pyfilesystem
```


## Example

`jupyter_notebook_config.py`:
```python
c.NotebookApp.contents_manager_class = 'jupyter_pyfilesystem.FsContentsManager'

# In-memory temporary filesystem
c.FsContentsManager.fs_url = 'mem://'
```

See https://docs.pyfilesystem.org/en/latest/openers.html for information on how to define `fs_url`, and https://docs.pyfilesystem.org/en/latest/builtin.html for a list of built-in filesystems.
There are also several externally-contributed filesystems that can be used.
Some are listed on https://www.pyfilesystem.org/page/index-of-filesystems/

Note some filesystems may not behave as you expect.
For example, the curent implementations of the `zip://` and `tar://` filesystems do not allow you to update an existing file.
You can only create/overwrite an existing file, or open a file read-only.

For example:
```python
c.FsContentsManager.fs_url = 'zip:///tmp/test.zip'

import os
if os.path.exists(fs_url[6:]):
    c.FsContentsManager.create = False
    c.FsContentsManager.writeable = False
```

If you are using a remote filesystem you may want to enable the `keepalive`.
For example, this will make a remote request to get the details of `/` every 60 seconds:
```python
c.FsContentsManager.keepalive = 60
```

## Acknowledgements

This repository is based on https://github.com/quantopian/pgcontents/tree/5fad3f6840d82e6acde97f8e3abe835765fa824b
djangorestframework-simplejwt-sso 1.0.1
A minimal JSON Web Token authentication to allow sso
License: MIT

Simple JWT SSO
==============

Simple JWT SSO is plugin to Django REST Framework Simple JWT that enables
Single sign-on in a microservice-oriented environment.

Requirements
------------

* Python (3.6, 3.7, 3.8)
* Django (2.0, 2.1, 2.2, 3.0)
* Django REST Framework (3.8, 3.9, 3.10)
* Django Rest Framework Simplejwt

Installation
------------

Simple JWT can be installed with pip::

  pip install djangorestframework_simplejwt_sso
pytest-gitcov 0.1.5
Pytest plugin for reporting on coverage of the last git commit.
License: MIT

# pytest-gitcov
Extension for pytest to report on the coverage for the lines modified in a given commit or commit range. The vision is to be able to run pytests on a code base before submitting a pull request or code review, to see the lines of code that were modified by you but not covered by unit-tests.

## Issues this plugin is trying to resolve
 - Ideally the whole code base will have reasonable coverage. Realistically though this is rarely the case with a legacy code base. The repository wide coverage report means little in terms of one developers merge request. The hope is that using this plugin you can shine a light on the code you have touched. Making it easier to spot gaps in unit tests due to code you have written, or modified and identify a gap someone else left and should really be filled.
 - Just reporting a list of line ranges covered on the terminal is not much help. I can't remember the line numebers for the functions I've just changed, and working out where the gaps are is time consuming. The HTML report is a lot better for this, but I'd like to have something quick and simple for the terminal.

# Install
Nice and easy:
`pip install pytest-gitcov`

# Usage
This is still in very early stages of development and doesn't really do much yet.

After installing, the plugin is automatically found by pytest. At the moment that means that the plugin always runs with each `pytest` run and you have to uninstall to disable it. Soon there should be an extra argument that can be used to temporarily disable this. For example, respect the existing `pytest-cov` flag (`--no-cov`) as well as a new `--no-gitcov` flags.

There is also a standalone script available to generate a git coverage report on previous `.coverage` DB file, for more info see `git-py-coverage --help`. 

# The plan
So far it just dumps a report at the end of a test run. Report contains the raw info available in the .coverage file (SQLLite3 DB) prsed using the `coverage.CoverageData` proxy (https://coverage.readthedocs.io/en/coverage-5.0/api_coveragedata.html#coverage.CoverageData).

The plan is to use `git diff --name-status` or `git diff --name-only` to get a list of files changed. Then use `git blame` to get the lines with line numbers changed for each file in current commit (perhaps with some context as well +/- 3 lines, or maybe later a whole function).

Then show the lines in the commit that are not in the coverage report.

Outcome:
 - plugin for pytest that reports on current HEAD commit
 - stand-alone git-py-coverage script to run on the last .coverage report. This could be used to generate another report, against a differnt commit without having to run the tests again.
gamification-engine 0.4.0
The Gamification-Engine (gengine) provides an API for integrating any kinds of gamification features.
License: MIT
Keywords: web wsgi bfg pylons pyramid gamification

gengine README
==================

Getting Started
---------------

- see https://github.com/ActiDoo/gamification-engine


0.3.0
  * task scheduler
  * extended group features
  * several further minor improvements and fixes

0.2.2
  * Fix several test cases

0.2.1
  * Fix of PyPI packaging

0.2.0
  * Implement new rule syntax
  * Add time-aware / recurring achievements
  * Add optional authentication & authorization
  * Introduce goal triggers
  * Introduce mobile pushes
  * Introduce messages
  * Lots of bugfixes
  * Remove Python 2.x support
lektor-scsscompile 1.3.0
SASS compiler for Lektor, thats based on libsass.
License: MIT
Keywords: Lektor plugin

# SCSScompile
[![PyPI version](https://badge.fury.io/py/lektor-scsscompile.svg)](https://badge.fury.io/py/lektor-scsscompile) [![Downloads](https://pepy.tech/badge/lektor-scsscompile)](https://pepy.tech/project/lektor-scsscompile)

SCSS compiler for Lektor that automatically compiles sass.

Uses [libsass](https://github.com/sass/libsass-python)  and looks for .scss/.sass files (ignores part files that begin with a underscore e.g. '_testfile.scss'),
compiling them as part of the build process. It only rebuilds when it's needed (file changed, a file it imports changed or the config changed). When starting the the development server it watchs the files for changes in the background and rebuilds them when needed.

## Installing

You can install the plugin with Lektor's installer::
```bash
lektor plugins add lektor-scsscompile
```

Or by hand, adding the plugin to the packages section in your lektorproject file::
```bash
[packages]
lektor-scsscompile = 1.3.0
```

## Usage
#####

To enable scsscompile, pass the `scsscompile` flag when starting the development
server or when running a build::
```bash
lektor build -f scsscompile
```
```bash
lektor build -f scsscompile
```

The Plugin has the following settings you can adjust to your needs:

|parameter        |default value      |description                                                                                       |
|-----------------|-------------------|--------------------------------------------------------------------------------------------------|
|source_dir       |asset_sources/scss/| the directory in which the plugin searchs for sass files (subdirectories are included)           |
|output_dir       |assets/css/        | the directory the compiled css files get place at                                                |
|output_style     |compressed         | coding style of the compiled result. choose one of: 'nested', 'expanded', 'compact', 'compressed'|
|source_comments  |False              | whether to add comments about source lines                                                       |
|precision        |5                  | precision for numbers                                                                            |
|output_source_map|False              | whether a source map should be generated                                                         |

An example file with the default config can be found at `configs/scsscompile.ini`
s3os 1.0.0
S3 Object Store. Store and retrieve python objects in s3 simply..
License: MIT
Requires Python: >=3.8,<4.0

S3 Object Store
-------

![badge](https://github.com/MartinHowarth/s3os/workflows/Test/badge.svg)

Simple pythonic wrapper to use s3 as a python object store.

Provides simple object storage methods; and a Dict-like interface for more complicated uses.

Examples
--------
Basic usage:

    from s3os import store_simple, retrieve_simple, delete_simple
    
    my_object = [1, 2, 3]
    
    store_simple("my_key", my_object)
    
    assert retrieve_simple("my_key") == my_object
    
    delete_simple("my_key")

The above example uses a global namespace in the bucket "s3os" - i.e. all the default settings of this package.

You can specify your own namespaces (i.e. buckets) as follows:

    from s3os import store, retrieve, delete, ObjectLocation, Bucket
    
    my_bucket = Bucket("my_bucket")
    my_object_location = ObjectLocation("my_key", bucket=my_bucket)
    my_object = [1, 2, 3]
    
    store(my_object_location, my_object)
    
    assert retrieve(my_object_location) == my_object
    
    delete(my_object_location)


Or simply use s3 like a normal python dictionary:

    from s3os import S3Dict, S3DictConfig, Bucket
    
    my_bucket = Bucket("my_bucket")
    s3dict = S3Dict(_config=S3DictConfig(id="my_dict_id", bucket=my_bucket))
    
    # Store information in s3
    s3dict["apples"] = 5
    s3dict["bananas"] = 2
    
    ...
    
    # Later, or in a different python executable, access the same dictionary again:
    my_bucket = Bucket("my_bucket")
    s3dict = S3Dict(_config=S3DictConfig(id="my_dict_id", bucket=my_bucket))
    
    print(s3dict["apples])  # 5
    print(s3dict.get_all_from_s3())  # {"apples": 5, "bananas": 2}
    


By default, `S3Dict` uses an internal cache to speed up item retrieval. 
Set and Delete operations are always performed synchronously.


Installation
------------
Install the package:

    pip install s3os

Setup your AWS credentials. For example set these environment variables:

    AWS_ACCESS_KEY_ID=...
    AWS_SECRET_ACCESS_KEY=...
    
Also see https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html for more authentication options.

> Note: `boto.client()` and `Session` authentication methods are not currently supported - raise an issue or submit a PR if you want them!


Development installation
------------------------
Install poetry - see https://pypi.org/project/poetry/

The following command should be used to install the dependencies:

    poetry install


Testing
-------
The following command should be used to run the tests:

    poetry run pytest tests

Valid AWS authentication credentials are required to run some of the tests.
See setup instructions.

The tests make a very small number of calls to S3, so the cost of running the tests is negligible.