semvec/pypi-packages huggingface dataset:
hypigu 2.0.1
A SageMath package that provides functions to compute the Igusa local zeta function associated with hyperplane arrangements.
Keywords: SageMath, hyperplane arrangements, Igusa zeta functions, topological zeta functions, Flag Hilbert--Poincare series

# HypIgu

**HypIgu** (**HYP**erplane **IGU**sa) is a [SageMath](https://www.sagemath.org/) package that provides functions to compute the Igusa local zeta function associated with hyperplane arrangements. It further contains various constructions of hyperplane arrangements and functions to compute their flag Hilbert&ndash;Poincaré series and other zeta functions. 

## Install, Setup, and Update

The simplest way to install HypIgu in SageMath is by running 

```bash
$ sage --pip install hypigu
```

If you already have HypIgu installed via `pip`, then you can update it by running 

```bash
$ sage --pip install hypigu --upgrade
```

HypIgu source files can be downloaded here: [Latest version](https://github.com/joshmaglione/hypigu/releases/latest)

This package is compatible with SageMath version 9.6 and later and has no external dependencies. It may work just fine with earlier versions of SageMath, but these have not been tested.

## Documentation

Found [online](https://joshmaglione.github.io/hypigu/) at

[joshmaglione.github.io/hypigu](https://joshmaglione.github.io/hypigu/)

HTML files are also found in the repo in `docs/` folder: 
- Home: `./docs/index.html`
    - Constructors: `./docs/constructors/index.html`
    - Lattices: `./docs/lattices/index.html`
    - Rational Functions: `./docs/rational-functions/index.html`

## Funding 

This package was funded in part by DFG grant [373111162](https://gepris.dfg.de/gepris/projekt/373111162?language=en).

## Copyright & License

Copyright 2020&ndash;2024 Joshua Maglione.

HypIgu is distributed with the MIT License.

## References 

1. [Joshua Maglione](https://joshmaglione.com/) and [Christopher Voll](https://www.math.uni-bielefeld.de/~voll/). Flag Hilbert&ndash;Poincar&#233; series of hyperplane arrangements and Igusa zeta functions, to appear in Israel J. Math. 2021. [arXiv:2103:03640](https://arxiv.org/abs/2103.03640).
pymfna 1.0.0
MFNA Python Client library
Requires Python: >=3.9
Keywords: MFNA

PyMFNA
======

PyMFNA is a Python client wrapper for connecting to and performing actions against MFNA appliances.

Install
-------

Python3 Install from pip3::
```bash
pip3 install pymnfa
```

Or you can run build this locally::

```bash
git clone https://github.com/andy-shady-org/pymfna.git
cd pymnfa
pip install -r requirements.txt 
python setup.py install
```

How to Use
----------

###### Example Usage

This package makes connections to MFNA appliances for provisioning and obtaining data. 
All MFNA API calls can be regenerated on demand from an initial WSDL file as show below.
This will generate a full client class. This class can then be installed and used in the following way.
Note that an example WSDL file has been included, however this should be replaced by the WSDL file supplied by your MFNA 
appliance.

```bash
git clone https://github.com/andy-shady-org/pymfna.git
cd pymnfa/pymnfa
python mnfa.py -v -o mnfaclient.py ../wsdl/api.wsdl.soappy
cd ..
python setup.py install
```

In the above step, the class MFNAClient was created within the 'mnfaclient.py' file as specified by the '-o' flag for output.
The class, after the package containing the new class file has been installed, can be easily imported and used.

```python
from mnfaclient import MFNAClient

mfna = MFNAClient('<MFNA Host>', '<username>', '<password>')
mfna.login()
result = mfna.list_device(host='<your host in MFNA>')            
```


Building Sphinx Documentation
-----------------------------
Sphinx can be used to generate technical documentation for this project.


How to build Sphinx documentation::

```bash
git clone https://github.com/andy-shady-org/pymfna.git
pip install sphinx_rtd_theme
cd pymnfa/docs
make html
```

Documentation will be built into the docs/build/html folder
bb-core 0.3.12
Core package for the brickblock library.
Requires Python: >=3.10


# Example Pipeline with brickblock [bb-core]

## Overview

This project demonstrates how to build a flexible data processing pipeline using the `bb-core` library. The pipeline is designed to process data through a series of functions or modules, supporting both synchronous and asynchronous execution, with real-time updates via server-sent events (SSE).

## Installation

1. **Install the repository:**

   ```bash
   pip install bb-core
   ```

2. **Set up a virtual environment (optional but recommended):**

   ```bash
   python -m venv venv
   ```

   Activate the virtual environment:

   - **Windows**: 
     ```bash
     .env\Scriptsctivate
     ```
   - **macOS/Linux**: 
     ```bash
     source venv/bin/activate
     ```


## Project Structure

- **Pipeline Class**: Manages the flow of data through a series of functions.
- **BaseModule Class**: Abstract base class that all modules should inherit from. Modules must implement the following methods:
  - `run()`: The main processing function.
  - `onProgressStartMessage()`: Sends a progress start message.
  - `onProgressEndMessage()`: Sends a progress end message.
- **SSE Generator**: Asynchronous generator that sends real-time updates to clients.

## Example Usage

```python
from your_module import Pipeline, BModule, InputModel2

# Initialize the pipeline
pipeline = Pipeline.init(name="example_pipeline", sse=True)

# Add a module to the pipeline
bmodule = BModule()
pipeline.modules([bmodule])

# Input data for the pipeline
input_data = {"c": 5.0}

# Asynchronously run the pipeline and get SSE events
async def test_sse():
    async for event in pipeline.sse_generator(InputModel2(**input_data)):
        print(event)

# Run the asynchronous SSE generator
asyncio.run(test_sse())
```


This project is licensed under the MIT License.
bladesight 0.17.0
Bladesight provides comprehensive tools for introductory Blade Tip Timing analysis.
Requires Python: <3.13,>=3.9

[![Bladesight - This package contains helps you follow along with the bladesight tutorials](https://intro-to-btt-using-python-assets.s3.amazonaws.com/bladesight_logo_horizontal_ORIGINAL.jpg)](https://github.com/Bladesight)

------------------------------------------------------------------------

[![PyPI version](https://badge.fury.io/py/bladesight.svg)](https://badge.fury.io/py/bladesight)
[![Downloads](https://static.pepy.tech/badge/bladesight)](https://static.pepy.tech/badge/bladesight)
[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://img.shields.io/badge/python-3.9+-blue.svg)
_________________

This package contains utilities to help you follow along with the Bladesight tutorials.

## Installation

```bash
pip install bladesight
```

## Usage

### Datasets

All the datasets used in the tutorials are hosted on AWS on a public S3 bucket. This package makes it seamless to download and use these datasets. First import the Datasets object.

```python
from bladesight import Datasets
```

You can list the available datasets by printing the using the `list_datasets` method.

```python
>>> print(Datasets.online_datasets)
['bladesight-datasets/intro_to_btt/intro_to_btt_ch02']
```
You can then load a dataset by selecting the dataset like you would have selected a dictionary key, just by using the 'data/' prefix:

```python
>>> my_dataset = Datasets['data/intro_to_btt/intro_to_btt_ch02']
```
![Example Usage](https://intro-to-btt-using-python-assets.s3.amazonaws.com/load_dataset.gif)


You can then load the table by selecting the table like you would have selected a dictionary key, just by using the 'table/' prefix:

```python 
>>> df_proximity_probe = my_dataset['table/aluminium_blisk_1200_rpm']
```
![Example Usage](https://intro-to-btt-using-python-assets.s3.amazonaws.com/load_table.gif)

The datasets have been downloaded to your local machine. You can find them in the following directory:

```console
~/.bladesight/data
```

### Citations

You'll see an attribution every time you open a dataset. This attribution is a link to the dataset's citation. 

![Example Usage](https://intro-to-btt-using-python-assets.s3.amazonaws.com/citation_example.png)

### Uploading your data

If you'd like your datasets to be accessible through this package, I'd be more than willing to convert it to the appropriate format and upload it.

Please email me at <a href="mailto:dawie.diamond@bladesight.com">dawie.diamond@bladesight.com </a> to get the ball rolling.

## Functions and methods

I include all the functions that are used frequently throughout the tutorials in the bladesight package. This is to avoid cluttering the tutorials with code that is not relevant to the tutorial's objective.

```python
from bladesight.btt.triggering_criteria import threshold_crossing_hysteresis_rising
```

## License

This project is licensed under the terms of the MIT license.
trspectrometer 1.2.4
Software for running a time-resolved spectrometer.
Requires Python: >=3.7

TRSpectrometer
==============

TRSpectrometer is a platform for time-resolved spectroscopy, encompassing both software and hardware
designs. It can be used for both data acquisition, as well as viewing data and basic analysis.

Features:

- Completely open source hardware and software designs. Don't get stuck with inflexible and buggy
  proprietary software!

- Plugin architecture to ease modifications and integration of new hardware devices or experimental methods.
 
- Supports the latest rapid-acquisition techniques.

- Cross platform python - Linux, Windows, MacOS.

The aim of the software is to be as open and flexible as possible, using a plugin system for the
addition and customisation of features and functionality. For example, the same software that runs
on a Windows machine acquiring data can be installed on a Linux or Mac OS computer and used for data
viewing and analysis without restriction. The majority of the code base is written in Python, making
development and modifications (hopefully!) more accessible to students and researchers who lack
specific programming backgrounds.

The initial 1.0 version includes a reference hardware design for a transient absorption
(pump--probe) spectrometer and a cross-platform software application for data acquisition and basic
data exploration and analysis. In time, it is hoped that the platform will support a wider variety
of hardware and additional time-resolved experimental techniques, as well as adding more advanced
data exploration, analysis, and plotting tools. This will only truly be possible through
contributions by users and other interested parties. See the Contributing page in the documentation
for more information.

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

The latest release can be downloaded and installed using the Package Installer for Python (pip):

.. code-block:: sh

    pip install --upgrade trspectrometer

On Linux, a launcher icon should be installed in your menus (this feature is not yet implemented on Windows or MacOS).
On all operating systems, the application can be launched from the command line:

.. code-block:: sh

    trspectrometer

Further details can be found in the `Getting Started <https://ptapping.gitlab.io/trspectrometer/gettingstarted.html>`__ section of the documentation.


Support
-------

Documentation can be read online at `<https://ptapping.gitlab.io/trspectrometer>`__.

Bug reports, feature requests and suggestions can be submitted to the `issue tracker <https://gitlab.com/ptapping/trspectrometer/-/issues>`__.


License
-------

All original work is free and open source, licensed under the GNU Public License.
See the `LICENSE.txt <https://gitlab.com/ptapping/trspectrometer/-/blob/main/LICENSE.txt>`__ for details.
bostorchconnector 1.0.1
bostorchconnector, a Python package with a precompiled shared library
Requires Python: >=3.8

# bostorchconnector
专为PyTorch训练存储在Bos上的数据集而设计的高吞吐插件，使用bostorchconnector可以高效地访问云上数据集和读写checkpoint。

bostorchconnector是实现PyTorch的[dataset primitives](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) 接口。
同时支持两种dataset：
- 随机读取[map-style datasets](https://pytorch.org/docs/stable/data.html#map-style-datasets)
- 流式顺序读[iterable-style datasets](https://pytorch.org/docs/stable/data.html#iterable-style-datasets)

支持checkpoint接口，可以直读/写云上Bos，无需落盘。

## 开始

### 前置环境

- Linux
- Python 3.8 or greater is installed 
- PyTorch >= 2.0

### 安装

```shell
pip install bostorchconnector
```

### 配置
配置访问凭证，以下方式配置一种即可，优先级有先后。
- 特定配置文件`~/.baidubce/credentials`
- 安装且配置过bcecmd，默认配置路径是`~/.go-bcecli/credentials`
- 设置环境变量：`BCE_ACCESS_KEY_ID`和`BCE_SECRET_ACCESS_KEY`

其中credentials文件的格式是
```
[Defaults]
Ak= 
Sk= 
Sts=
```

### Examples

[API docs](http://)

#### 示例

使用from_prefix方法构建BosIterableDataset:
```py
from bostorchconnector import BosIterableDataset

# You need to update <BUCKET> and <PREFIX>
DATASET_URI="bos://<BUCKET>/<PREFIX>"
ENDPOINT="http://bj.bcebos.com"

iterable_dataset = BosIterableDataset.from_prefix(DATASET_URI, endpoint=ENDPOINT)

# Datasets are also iterators. 
for item in iterable_dataset:
    data = item.read()
    print(len(data))
    print(item.key)
```

使用from_prefix方法构建BosMapDataset:
```py
from bostorchconnector import BosMapDataset

# You need to update <BUCKET> and <PREFIX>
DATASET_URI="bos://<BUCKET>/<PREFIX>"
ENDPOINT="http://bj.bcebos.com"

map_dataset = BosMapDataset.from_prefix(DATASET_URI, endpoint=ENDPOINT)

# Randomly access to an item in map_dataset.
item = map_dataset[0]

# Learn about bucket, key, and content of the object
bucket = item.bucket
key = item.key
content = item.read()
len(content)
```

直接读写model checkpoint:
```py
from bostorchconnector import BosCheckpoint

import torchvision
import torch

CHECKPOINT_URI="bos://<BUCKET>/<KEY>/"
ENDPOINT="http://bj.bcebos.com"
checkpoint = BosCheckpoint(endpoint=ENDPOINT)

model = torchvision.models.resnet18()

# Save checkpoint to Bos
with checkpoint.writer(CHECKPOINT_URI + "epoch0.ckpt") as writer:
    torch.save(model.state_dict(), writer)

# Load checkpoint from Bos
with checkpoint.reader(CHECKPOINT_URI + "epoch0.ckpt") as reader:
    state_dict = torch.load(reader)

model.load_state_dict(state_dict)
```