semvec/pypi-packages huggingface dataset:
openmc-post-processor 0.1.1
Convert OpenMC tallies into user friendly units
Requires Python: >=3.6


This Python package aims to help convert OpenMC tallies to user specified units.

OpenMC tally results are save into at statepoint.h5 file without units.

This package ascertains the units of common tallies using the tally filters and scores.

The package then allows users to scale the base tally units to different units. For example the package can easily convert cm to meters or electron volts to joules.

Additional inputs can be applied to normalise the the tallies. by the source strength of the source. For example if ```strength_strength``` is provided then tallies can converted from the base units to user friendly units. For example heating tallies are recorded in electron volts per source particle. However this can be converted to Watts.

Scaling by the volume of the cell or mesh is also possible by ```volume``` and requesting  units that require normalising with volume. Follow on from the previous example with would allow converion of heating tallies in thier base units of electron volts per source particle to be converted to Watts per cm3.

:point_right: [Examples](https://github.com/fusion-energy/openmc_post_processor/tree/main/examples)
selenium-logging 0.0.6
Log messages and images in HTML file
Keywords: log,selenium,automation,screenshot,message,HTML

Explanation on youtube: https://www.youtube.com/watch?v=b5XPHqWT94s


Logging of screenshot and messages to HTML file. Can be used with selenium, but not necessary.
How to use it:

from LoggingSelenium.LogHTML import LogHTML

LogHTML.set_log_path(r"C:\pathToFolderForLogs")
LogHTML.set_logging_level(LogHTML.INFO, use_screenshot=True)

LogHTML.screenshot("Screenshot is taken")
LogHTML.debug("Random message")
LogHTML.info("Random message")



Logging levels:
-debug
-info
-warning
-error
-critical
ophac-cpp 0.4.1
C++ implementation of parts of ophac to improve performance.
Requires Python: >=3.0

# ophac-cpp

This python module contains a c++ extension to `ophac` for
performance enhancements, and should be accessed 
through the API of `ophac`.

See the documentation of [ophac](https://pypi.org/project/ophac/) for details.

## Licensing

The software in this package is released under the [GNU Lesser General Public License](https://www.gnu.org/licenses/lgpl-3.0.en.html).

## Installation

This package is supposed to install automatically when installing `ophac`. However, if you suspect that something has gone wrong, you can install this package manually via

```python
python -m pip install ophac-cpp [--user]
```

## Platform requirements
redunet 0.0.1
A performant implementation of the white-box deep network ReduNet.
Requires Python: >=3.6

# Deep Networks from the Principle of Rate Reduction
This repository is a host for a Pip package hosting a PyTorch implementation of the paper [Deep Networks from the Principle of Rate Reduction](https://arxiv.org/abs/2010.14765) (2021) by [Kwan Ho Ryan Chan](https://ryanchankh.github.io)* (UC Berkeley), [Yaodong Yu](https://yaodongyu.github.io/)* (UC Berkeley), [Chong You](https://sites.google.com/view/cyou)* (UC Berkeley), [Haozhi Qi](https://haozhi.io/) (UC Berkeley), John Wright (Columbia), and Yi Ma (UC Berkeley). For the official version of ReduNet, please go checkout: [https://github.com/ryanchankh/redunet](https://github.com/ryanchankh/redunet).

## What is ReduNet?
ReduNet is a deep neural network construcuted naturally by deriving the gradients of the Maximal Coding Rate Reduction (MCR<sup>2</sup>) [1] objective. Every layer of this network can be interpreted based on its mathematical operations and the network collectively is trained in a feed-forward manner only. In addition, by imposing shift invariant properties to our network, the convolutional operator can be derived using only the data and MCR<sup>2</sup> objective function, hence making our network design principled and interpretable. 

[1] Yu, Yaodong, Kwan Ho Ryan Chan, Chong You, Chaobing Song, and Yi Ma. "[Learning diverse and discriminative representations via the principle of maximal coding rate reduction](https://proceedings.neurips.cc/paper/2020/file/6ad4174eba19ecb5fed17411a34ff5e6-Paper.pdf)" Advances in Neural Information Processing Systems 33 (2020).
thestorygraph-client 0.1.6
A Simple Python Client for TheStoryGraph
Requires Python: >=3.9
Keywords: thestorygraph,books,client

# thestorygraph-client

A Simple Python Client for TheStoryGraph.com

Sync and async clients as well as a model abstraction layer for the website.

Since no public API is available, this library parses HTML via `BeautifulSoup4`
and loads the data into model objects.


## Installation

```bash
pip install thestorygraph-client
```

## Examples

### Search for books (sync)

Find and print books related to `'SPQR'`:

```python
from tsg.client import SyncTSGClient

def print_search_result(search_text: str) -> None:
    client = SyncTSGClient()
    book_list = client.search(text=search_text)
    for book in book_list:
        print(f'{book.authors[0].name} - {book.title}')

print_search_result('SPQR')
```

### Search for books (async)

Same as above, but using the asynchronous client:

```python
import asyncio
from tsg.client import AsyncTSGClient

async def print_search_result(search_text: str) -> None:
    client = AsyncTSGClient()
    book_list = await client.get_browse(text=search_text)
    for book in book_list:
        print(f'{", ".join(book.author_names)} - {book.title}')

asyncio.run(print_search_result('SPQR'))
```

The two clients have identical APIs (beside the fact that the latter is async).

### Get a book by ID

```python
import asyncio
from tsg.client import AsyncTSGClient

async def print_book_by_id(book_id: str) -> None:
    client = AsyncTSGClient()
    book = await client.get_book(id=book_id)
    print(f'{book.title} by {", ".join(book.author_names)}')

asyncio.run(print_book_by_id('79b894b0-df12-4bb6-89d7-40288f28acc1'))
```

## Development and Testing

### Configuring the test environment

Install

```bash
pip install -Ue .[testing]
```

### Testing

Run the tests:

```bash
pytest tests
```

And always validate typing:

```bash
mypy src/tsg
```

Or simply

```bash
make test
```

(it will run all test commands)

## Links

Homepage on GitHub: https://github.com/altvod/thestorygraph-client

Project's page on PyPi: https://pypi.org/project/thestorygraph-client/

TheStoryGraph: https://thestorygraph.com/
limber 0.1.9
Serverless DAGs orchestrated via Python

Create a file called `limber.yaml` with the following configuration:

```
cloud:
    provider: google
    project: "<project name>"
    region: "europe-west1"
    key_file: "<path to key_file>"
    default_bucket: "<gcp cloud storage bucket name>"
```
    
In the main directory run:
1. python -m limber init
2. python -m limber terraform login
3. python -m limber plan
4. python -m limber apply

Google Cloud APIs enabled
1. CloudFunctions API
2. PubSub API
3. CloudScheduler API
4. Cloud Build API
5. Secret manager API

Other
1. Create app engine in your project: https://console.cloud.google.com/appengine

Service account needed roles:
1. Pub/Sub Editor
2. Service Account User
3. Cloud Scheduler Admin
4. Cloud Functions Developer
5. Storage Admin
6. Secret Manager Admin
vbgcp-hs 0.0.1
Probabilistic Tensor Decomposition of Count Data (Neural Population Spiking Activity)
Requires Python: >=3.6

# Probabilistic Tensor Decomposition of Neural Population Spiking Activity

[license-img]: https://img.shields.io/badge/license-MIT-green
[license-url]: https://github.com/hugosou/vbgcp/blob/main/LICENSE.md

[python-img]:https://img.shields.io/badge/python-v3.8-blue
[python-url]: https://github.com/hugosou/vbgcp/tree/main/python

[matlab-img]:https://img.shields.io/badge/matlab-R2020-orange
[matlab-url]: https://github.com/hugosou/vbgcp/tree/main/python

[![][license-img]][license-url] [![][python-img]][python-url] 

Python implementations (in development, see [../matlab/](https://github.com/hugosou/vbgcp/tree/main/matlab/)) of [Soulat et al. (2021)](https://arxiv.org/abs/2030.12345)

![alt text](../model_summary.png "Model")

The model (A) decomposes an observed count tensor (eg. binned spikes) using a Negative Binomial distribution that depends on a shape parameter, a constrained offset (B) and low rank tensor (C). 
Variational inference is implemented using a Pólya-Gamma augmentation scheme. 

![alt text](../model_graphical.png "Model")

## Demo


To train the model(s) on the toydataset described in the paper open:
```
python/examples/demo_tensor_variational_inference.ipynb
```