semvec/pypi-packages huggingface dataset:
xverif 0.1.0
Xarray-based package for forecasts/simulations verification
Requires Python: >=3.9,<4.0

# xverif - A package to perform forecast verification builds upon xarray.

The code in this repository provides a scalable and flexible framework to perform forecast verification.
It principally builds upon xarray, dask and flox libraries.

ATTENTION: The code is subject to changes in the coming months.

The folder `tutorials` (will) provide jupyter notebooks describing various features of xverif.

The folder `docs` (will) contains slides and notebooks explaining the x-forecasting framework.

## Installation

For a local installation, follow the below instructions.

1. Clone this repository.
   ```sh
   git clone https://github.com/ghiggi/xverif.git
   cd xverif
   ```

2. Install manually the following dependencies:
   ```sh
   conda create --name xverif-dev python=3.8
   conda install xarray dask cdo h5py h5netcdf netcdf4 zarr numcodecs rechunker
   conda install notebook jupyterlab
   conda install numpy pandas numba scipy bottleneck
   ```

2. Alternatively install the dependencies using one of the appropriate below
   environment.yml files:
   ```sh
   conda env create -f TODO.yml
   ```

## Tutorials

## Reproducing our results

## Contributors

* [Gionata Ghiggi](https://people.epfl.ch/gionata.ghiggi)
* [Yann Yasser Haddad](https://www.linkedin.com/in/yann-yasser-haddad)

## License

The content of this repository is released under the terms of the [MIT license](LICENSE.txt).
pybpg400-tspspi 0.0.2
Unofficial library to control and read the BPG400 pressure gauge via RS232C interface
Requires Python: >=3.6

# ```pybpg400```: Unofficial Python library to control and access the INFICON BPG400 pressure gauge (via RS232C)

This is an unofficial Python library (and a mini CLI utility)
to control and access the INFICON BPG400 pressure gauge via
it's RS232C serial port.

## Installation

This library (and the CLI utility) is provided via PyPi:

```
pip install pybpg400-tspspi
```

## Usage

More elaborate examples can be found in the ```examples``` folder.

The device can be simply opened via context management routines (in
addition to imperative ```connect()``` and ```disconnect()``` routines):

```
from bpg400.bpg400 import RPG400_RS232
from labdevices.pressuregauge import PressureGaugeUnit

with BPG400_RS232("/dev/ttyUSB0") as pg:
	# Perform your operations
```

The library starts an background thread that continuously
parses the datastream received by the BPG400 pressure gauge.
To query the latest pressure reading one can simply use
the ```get_pressure``` method. This method also allows one to
supply the unit - it defaults to ```mbar```:

```
print(pg.get_pressure())
```

or

```
print(pg.get_pressure(PressureGaugeUnit.TORR))
```

One can simply change the display unit using the ```set_unit```
method:

```
pg.set_unit(PressureGaugeUnit.MBAR)
pg.set_unit(PressureGaugeUnit.TORR)
pg.set_unit(PressureGaugeUnit.PASCAL)
```

## The CLI utility

The package also comes with a simple command line utility
called ```bpg400```.

One can for example simply query the current pressure
using a single shell command:

```
bpg400 --port /dev/ttyU0``` query
```

```
Usage: bpg400 [OPTIONS] command

Controls or queries the BPG400 pressure gauge via a RS232C
serial interface.

Options:

	--port PORTNAME
		Specifies the serial port device to use
	--json
		Sets output format to JSON for further processing
	--debug
		Run in debug mode (dump RX and TX packets)

Supported commands:

	query
		Query the current pressure in the set unit
	setmbar
		Set display unit to millibar
	settorr
		Set display unit to torr
	setpa
		Set display unit to pascal
	degas
		Enable degas mode
	nodegas
		Stop degas mode
	sleep N
		Sleep N seconds before performing next command
```
pyneweb 0.5.4
Web Boilerplate for Pynecone
Keywords: python web template,web application,development

Pyneweb is a Python web boilerplate project designed to provide a solid foundation for building web applications with Python and Pynecone. The project comes pre-configured with a range of tools and features to make it easy for developers to get started building their web applications, without the need to spend time setting up infrastructure or configuration.
scipion-em-pwperformance 0.0.5
Python module to provide performance analysis tools and storage of the metrics for a further comparison
Keywords: scipion cryoem imageprocessing scipion-3.0

=============
pwperformance
=============

**pwperformance** is a Scipion plugin with tests to measure performance and send benchmarks to a Codespeed server

Plugin installation
-------------------

.. code-block::

    git clone https://github.com/scipion-em/scipion-em-pwperformance.git
    scipion3 installp -p /path/to/scipion-em-pwperformance --devel

Environment variables
---------------------

Define the following environment vars:

.. code-block::

    CODESPEED_URL = Codespeed server URL to send benchmarks to. Defaults to "http://localhost:8000"
    CODESPEED_ENV = Environment name. Environment describes your testing PC configuration. Defaults to "unknown"
    CODESPEED_PROJECT = This should be the plugin you want to test. Defaults to "pyworkflow"
    CODESPEED_BRANCH = Git branch of your project. Defaults to "devel"
    CODESPEED_COMMIT = Git commit id of your project. Defaults to "1"

Codespeed server installation
-----------------------------

    #. conda create -y -n codespeed python=3.6
    #. conda activate codespeed
    #. pip3 install pypandoc==1.7.5 setuptools==57.5.0 gunicorn
    #. git clone https://github.com/tobami/codespeed
    #. cd codespeed
    #. pip3 install -e .
    #. pip3 install "django<2.2,>=1.11"
    #. python manage.py migrate
    #. python manage.py createsuperuser
    #. python manage.py runserver 8000
    #. Go to http://localhost:8000/admin
        #. create an environment (your CODESPEED_ENV)
        #. create a Github-type project (name = CODESPEED_PROJECT) with a correct url (e.g. https://github.com/scipion-em/scipion-pyworkflow), branch (e.g. "devel" or your own CODESPEED_BRANCH) and tick "Track changes"
        #. create a "devel" (or your own CODESPEED_BRANCH) branch

Example run
-----------

Run any of the following plugin tests to save the data on the codespeed server, e.g.:

.. code-block::

    scipion3 tests pwperformance.tests.test_profiling_load.TestProfilingLoadGUI
    scipion3 tests pwperformance.tests.test_set_performance.TestSetPerformanceSteps
    scipion3 tests pwperformance.tests.test_exportsteps.TestExportSteps
phyper 1.1.7
Package for managing (hyper)spectral datasets
Requires Python: >=3.6,<4.0
Keywords: hyperspectral,chemometrics

A Python toolbox for hYPERspectral data. This toolbox includes methods for reading hyperspectral images and provides an interface for basic machine learning algorithms like decomposition and clustering.

## Installation

>**NOTE** Before being able to clone the code from this repository (either editable or non-editable), you will have to set a GitLab password (Preferences>Password) to authenticate yourself and your device. 

### Non-editable installation

0. (Optional) create virtual environment  
`conda create -n my_env python=3.8`  
`conda activate my_env`

1.a Directly install from PyPi directory where pyper is saved as 'phyper' (WITH h!)
`pip install phyper`

OR  

1.b Directly intall from gitlab repostiory
`pip install git+https://gitlab.kuleuven.be/u0123403/pyper.git`

### Editable installation 

Use this installation if you want to make changes to the code yourself.

0. (Optional) create virtual environment   
`conda create -n my_env python=3.8`  
`conda activate my_env`

1. Clone the repository to your local machine  
`git clone https://gitlab.kuleuven.be/u0123403/pyper.git`  
`cd pyper`

2. Use pip to install the package in editable format  
`pip install -e .`


## Acknowledgements

Written by Remi Van Belleghem. Based on Matlab toolbox from Niels Wouters.
bert-dot-config 4.4.0
Module for reading configuration files
Requires Python: >=3.4
Keywords: yaml,configuration,config,file,python,settings

<a name="top"></a>
<a name="overview"></a>

# Overview

This is a module for reading configuration files.

Currently, the module only supports YAML-formatted files.

Features:
- Retrieve deeply nested values using dot notation, e.g. `section1.key1`
- Retrieve values using wildcards, e.g. `section1.*.key2`
- Configuration files can be templated (Jinja)

# Prerequisites:

- Python 3.4+

# Installation

* From pypi: `pip3 install bertdotconfig`
* From this git repo: `pip3 install git+https://github.com/berttejeda/bert.config.git`<br />
  Note: To install a specific version of the library from this git repo, <br />
  suffix the git URL in the above command with @{ tag name }, e.g.: <br />
  git+https://github.com/berttejeda/bert.config.git@3.0.0

# Usage Examples

## Load a configuration file and retrieve specified key value

Given:
- Config file at `/home/myuser/myconfig.yaml`
- with contents:<br />
```yaml
section1:
  key1: value1
  key2: value2
  key3: value3
```

```python
from bertdotconfig import Config
# Initialize App Config
config = Config(config_file_uri='~/myconfig.yaml').read()
value = config.get('section1.key')
print(value)
```

The above should return `value1`

## Load a configuration file and retrieve a deeply nested value

Given:
- Config file at `/home/myuser/myconfig.yaml`
- with contents:<br />
```yaml
section1:
  subsection1:
    item1:
      subitem1: value1
    item2: value2
    item3: value3
  subsection2:
    item1: value1
    item2: value2
    item3: value3
  key1: value1
  key2: value2
  key3: value3
section2:
  item1: value1
```

```python
from bertdotconfig import Config
# Initialize App Config
config = Config(config_file_uri='~/myconfig.yaml').read()
value = config.get('section1.subsection1.item2')
print(value)
```

The above should return `value2`

## Load a configuration file and retrieve specified key value using wildcard notation

Given:
- Config file at `/home/myuser/myconfig.yaml`
- with contents:<br />
```yaml
section1:
  subsection1:
    item1:
      subitem1: value1
    item2: value2
    item3: value3
  subsection2:
    item1: value1
    item2: value2
    item3: value3
  key1: value1
  key2: value2
  key3: value3
section2:
  item1: value1
```

```python
from bertdotconfig import Config
# Initialize App Config
config = Config(config_file_uri='~/myconfig.yaml').read()
value = config.get('section1.*.item1')
print(value)
```

The above should return `[{'subitem1': 'value1'}, 'value1']`

Note: When retrieving values via wildcard, the return value is a list object.

## Load a configuration file as a python object

Same as the above examples, just invoke the Config object
with `as_object=True`, as with 
`config = Config('~/myconfig.yaml', as_object=True).read()`

In this case, retrieving values from the object can be done via dot-notation, 
as with: `print(config.section1.subsection1.item2)`, or via `get` method, as with
`print(settings.section1.subsection1.item2)`

Note: This approach does not support retrieving values via wildcard reference.
neurencoding 0.1.8
Neural encoding models made easy. Describe neuronal activity as a function of other variables
Requires Python: >=3.9

# Neurencoding

Neurencoding is a python package for implementing encoding models of single-unit activity for (at the moment) units recorded using electrophysiology. This package provides tools for expressing single-unit firing as a function of many external variables, such as task-related events and values.

This is the package used for the International Brain Lab (IBL) brain-wide map paper.

## Getting started

### Installation

In order to install `neurencoding`, please use pip to install the package in your choice of python environment (e.g. using virtualenv or Anaconda):

```
pip install neurencoding
```

### Loading in data

TBD

## Source work

All work based on code from pillowlab/neuroGLM, translated and extended.