semvec/pypi-packages huggingface dataset:
truncnorm 0.0.2
Moments for doubly truncated multivariate normal distributions

# TruncNorm

Arbitrary order moments for truncated multivariate normal distributions.

## Introduction

Given

```
X ~ N(m, C), a <= X <= b
```

with mean vector `m`, covariance matrix `C`, lower limit vector `a` and upper
limit vector `b`,

``` python
import truncnorm
truncnorm.moments(m, C, a, b, 4)
```

returns all the following moments of total order less or equal to 4 as a list:

```
[
  P(a<=X<=b),           (scalar)
  E[X_i],               (N vector)
  E[X_i*X_j],           (NxN matrix)
  E[X_i*X_j*X_k],       (NxNxN array)
  E[X_i*X_j*X_k*X_l],   (NxNxNxN array)
]
```

for all `i`, `j`, `k` and `l`. Note that the first element in the list is a bit
of a special case. That's because `E[1]` is trivially `1` so giving the
normalisation constant instead is much more useful.

## TODO

- Double truncation
- Numerical stability could probably be increased by using logarithic scale in
  critical places of the algorithm
- Sampling (see Gessner et al below)
- Folded distribution
- Optimize recurrent integrals by using vector and index-mapping representation
  instead of arrays. Using arrays makes computations efficient and simple, but
  same elements are computed multiple times because of symmetry in the moments.

## References

- "On Moments of Folded and Truncated Multivariate Normal Distributions" by
Raymond Kan & Cesare Robotti, 2016

- "Integrals over Gaussians under Linear Domain Constraints" by Alexandra Gessner
& Oindrila Kanjilal & Philipp Hennig, 2020
qotto-auth-client 2.2.4
Qotto/QottoAuthClient
Requires Python: >=3.7,<4.0

# Qotto Auth Client

The python package `qotto-auth-client` is a client for the API `qotto-auth` which will soon be open sourced.

It allows to manage a scoped permission and authentication system.

More information coming soon...

## Quickstart

The `QottoAuthService` class allows to interact with a `qotto-auth` GraphQL server.

```python
from qottoauth import *

# Initialize the service
qotto_auth_service = QottoAuthService(QottoAuthGqlApi(QOTTO_AUTH_URL)) 

# Register this application
application = qotto_auth_service.register_application(
    name=APPLICATION_NAME,
    description=APPLICATION_DESCRIPTION,
)

# Register permission
permission_1 = qotto_auth_service.register_permission(
    name=PERMISSION_1_NAME,
    description=PERMISSION_1_DESCRIPTION,
    application=application,
)

# Fetch current user or member
def handle(request)
    actor = qotto_auth_service.actor(
        token=request.COOKIES.get(TOKEN_COOKIE_NAME),
        secret=request.COOKIES.get(SECRET_COOKIE_NAME),
    )
    if qotto_auth_service.is_authorized(
        actor=actor,
        permission=permission_1,
    ):
        # Do something
    else:
        # Do something else
```

You can instantiate a `QottoAuthService` with a `QottoAuthTestApi` for testing purposes. In that case you might want to
extend the test api class if you extended service using direct api calls.
bunnet 1.3.0
Synchronous Python ODM for MongoDB
Requires Python: >=3.7,<4.0
Keywords: mongodb,odm,orm,pydantic,mongo,async,python

[![shields badge](https://shields.io/badge/-docs-blue)](https://roman-right.github.io/bunnet/)
[![pypi](https://img.shields.io/pypi/v/bunnet.svg)](https://pypi.python.org/pypi/bunnet)

[![Bunnet](https://github.com/roman-right/bunnet/raw/main/docs/assets/1.png)](https://github.com/roman-right/bunnet)

*The logo is generated by [WOMBO Dream](https://www.wombo.art)*

## Overview

[Bunnet](https://github.com/roman-right/bunnet) - is a Python object-document mapper (ODM) for MongoDB. It is a synchronous fork of [Beanie ODM](https://github.com/roman-right/beanie).

When using Bunnet each database collection has a corresponding `Document` that
is used to interact with that collection. In addition to retrieving data,
Bunnet allows you to add, update, or delete documents from the collection as
well.

Bunnet saves you time by removing boilerplate code, and it helps you focus on
the parts of your app that actually matter.

## Installation

### PIP

```shell
pip install bunnet
```

### Poetry

```shell
poetry add bunnet
```
## Example

```python
from typing import Optional

from pymongo import MongoClient
from pydantic import BaseModel

from bunnet import Document, Indexed, init_bunnet


class Category(BaseModel):
    name: str
    description: str


class Product(Document):
    name: str                          # You can use normal types just like in pydantic
    description: Optional[str] = None
    price: Indexed(float)              # You can also specify that a field should correspond to an index
    category: Category                 # You can include pydantic models as well



# Bunnet uses Pymongo client under the hood 
client = MongoClient("mongodb://user:pass@host:27017")

# Initialize bunnet with the Product document class
init_bunnet(database=client.db_name, document_models=[Product])

chocolate = Category(name="Chocolate", description="A preparation of roasted and ground cacao seeds.")
# Bunnet documents work just like pydantic models
tonybar = Product(name="Tony's", price=5.95, category=chocolate)
# And can be inserted into the database
tonybar.insert() 

# You can find documents with pythonic syntax
product = Product.find_one(Product.price < 10).run()

# And update them
product.set({Product.name:"Gold bar"})

```

## Links

### Documentation

- **[Doc](https://roman-right.github.io/bunnet/)** - Tutorial, API documentation, and development guidelines.

### Resources

- **[GitHub](https://github.com/roman-right/bunnet)** - GitHub page of the
  project
- **[Changelog](https://roman-right.github.io/bunnet/changelog)** - list of all
  the valuable changes
- **[Discord](https://discord.gg/29mMrEBvr4)** - ask your questions, share
  ideas or just say `Hello!!`

----
Supported by [JetBrains](https://jb.gg/OpenSource)

[![JetBrains](https://raw.githubusercontent.com/roman-right/beanie/main/assets/logo/jetbrains.svg)](https://jb.gg/OpenSource)
print-package 1.1.10
A simple Python package for printing messages.



```markdown
# print_package

print_package is a simple Python package for printing messages to the console.

## Installation

You can install print_package using pip:

```bash
pip install print_package
```

## Usage

After installation, you can use the `print_message()` function in your Python code as follows:

```python
from print_package.print_package import print_message

print_message("Hello, world!")
```

## License

This project is licensed under the MIT License - see the [MIT](LICENSE) file for details.

## Contact

For questions or feedback, please contact [Tanvir-yzu](mailto:2020tanvir1971@gmail.com).
crc-bank 0.2.10
Banking application for resource allocation in Slurm based HPC systems.
Requires Python: >=3.8,<4.0
Keywords: Pitt,CRC,HPC,banking,slurm

# A Banking and Proposal System For Slurm

[![](https://app.codacy.com/project/badge/Grade/e964afceb32c4f6ea10425e8cabd0d44)](https://www.codacy.com/gh/pitt-crc/bank/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=pitt-crc/bank&amp;utm_campaign=Badge_Grade)
[![](https://app.codacy.com/project/badge/Coverage/e964afceb32c4f6ea10425e8cabd0d44)](https://www.codacy.com/gh/pitt-crc/bank/dashboard?utm_source=github.com&utm_medium=referral&utm_content=pitt-crc/bank&utm_campaign=Badge_Coverage)

See the online docs: [https://pitt-crc.github.io/bank](https://pitt-crc.github.io/bank)
embed-text-reducer 0.0.4
A simple text simplification tool using advanced NLP techniques.
Keywords: text,simplification,NLP

# EmbedTextReducer

TextReducer is a Python library for simplifying text content using advanced Natural Language Processing (NLP) techniques. It filters and summarizes text based on relevance to a given query, making it easier to extract meaningful information from large texts.

## Features

- Split text into sentences.
- Filter sentences based on token count.
- Compute cosine similarity between sentences and a given query.
- Summarize text by relevance to the query.

## Installation

Install TextReducer using pip:

```bash
pip install embed-text-reducer
```

## Usage
Here's a quick example to get you started:

```python
from embed_text_reducer import TextReducer

# Initialize the simplifier with default models
simplifier = TextReducer()

# Fit the text
text = "Your long text here. It will be split into sentences, filtered, and summarized."
simplifier.fit(text)

# Find relevant sentences to your query
query = "specific information"
summary, tokens = simplifier.find_relevant(query, max_tokens=100)

print("Summary:", summary)
print("Tokens used:", tokens)
```
text-reducer 0.0.1
A simple text simplification tool using advanced NLP techniques.
Keywords: text,simplification,NLP

# EmbedTextReducer

TextReducer is a Python library for simplifying text content using advanced Natural Language Processing (NLP) techniques. It filters and summarizes text based on relevance to a given query, making it easier to extract meaningful information from large texts.

## Features

- Split text into sentences.
- Filter sentences based on token count.
- Compute cosine similarity between sentences and a given query.
- Summarize text by relevance to the query.

## Installation

Install TextReducer using pip:

```bash
pip install text-simplifier
```

## Usage
Here's a quick example to get you started:

```python
from text_simplifier import TextReducer

# Initialize the simplifier with default models
simplifier = TextReducer()

# Fit the text
text = "Your long text here. It will be split into sentences, filtered, and summarized."
simplifier.fit(text)

# Find relevant sentences to your query
query = "specific information"
summary, tokens = simplifier.find_relevant(query, max_tokens=100)

print("Summary:", summary)
print("Tokens used:", tokens)
```
pro-video-ferramentas-gleison 1.0
Este produto é de teste para envio de módulos para o pypi.org
Keywords: teste,Python,student

# Pro Video Ferramentas

Pacote de teste para envio de mÃ³dulos para o pypi.org

Esse arquivo deve conter informaÃ§Ãµes como:

- Passos para instalaÃ§Ã£o
- Criadores
- informaÃ§Ãµes necessÃ¡rias
mrsqm 0.0.7
MrSQM: Fast Time Series Classification with Symbolic Representations
Requires Python: >=3.7

# MrSQM: Fast Time Series Classification with Symbolic Representations

MrSQM (Multiple Representations Sequence Miner) is a time series classifier. The 
MrSQM method can quickly extract features from multiple symbolic representations of time series and train a linear classification model with logistic regression. The method has four variants with four different feature selection strategies:

  * MrSQM-R: Random feature selection.
  * MrSQM-RS: MrSQM-R with a follow-up Chi2 test to filter less important features.
  * MrSQM-S: Pruning the all-subsequence feature space with a Chi2 bound and selecting the optimal set of top *k* subsequences.
  * MrSQM-SR: Random sampling of the features from the output of MrSQM-S.

## Installation

Dependencies
```
cython >= 0.29
numpy >= 1.18
pandas >= 1.0.3
scikit-learn >= 0.22
fftw3 (http://www.fftw.org/)
```
## Installation using pip
pip install mrsqm


## Installation from source
Download the repository: 
```
git clone https://github.com/mlgig/mrsqm.git
```
Move into the code directory of the repository: 
```
cd mrsqm/mrsqm
```
Build package from source using: 
```
pip install .
```
## Example

Load data from arff files
```
X_train,y_train = util.load_from_arff_to_dataframe("data/Coffee/Coffee_TRAIN.arff")
X_test,y_test = util.load_from_arff_to_dataframe("data/Coffee/Coffee_TEST.arff")
```
Train with MrSQM
```
clf = MrSQMClassifier(nsax=0, nsfa=5)
clf.fit(X_train,y_train)
```

Make predictions
```
predicted = clf.predict(X_test)
```

![Alt](explanation-mrsqm-example.png) 

More examples can be found in the *example* directory, including a [Jupyter Notebook](https://github.com/mlgig/mrsqm/blob/main/example/Time_Series_Classification_and_Explanation_with_MrSQM.ipynb) with detailed steps for training, prediction and 
explanation.
The full UEA and UCR Archive can be downloaded from http://www.timeseriesclassification.com/.


This repository provides supporting code, results and instructions for reproducing the work presented in our publication:

"Fast Time Series Classification with Random Symbolic Subsequences", Thach Le Nguyen and Georgiana Ifrim
https://project.inria.fr/aaltd22/files/2022/08/AALTD22_paper_5778.pdf

"MrSQM: Fast Time Series Classification with Symbolic Representations and Efficient Sequence Mining", Thach Le Nguyen and Georgiana Ifrim
https://arxiv.org/abs/2109.01036

## Citation
If you use this work, please cite as:
```
@article{mrsqm2022,
  title={Fast Time Series Classification with Random Symbolic Subsequences},
  author={Le Nguyen, Thach and Ifrim, Georgiana},
  year={2022},
  booktitle = {AALTD},
  url = {https://project.inria.fr/aaltd22/files/2022/08/AALTD22_paper_5778.pdf},
  publisher={Springer}
}
@article{mrsqm2022-extended,
  title={MrSQM: Fast Time Series Classification with Symbolic Representations and Efficient Sequence Mining},
  author={Le Nguyen, Thach and Ifrim, Georgiana},
  year={2022},
  booktitle = {arxvi},
  url = {https://arxiv.org/abs/2109.01036},
  publisher={}
}
```
Turing-Pi-BMC 1.0.1
Package to manage a Turing Pi 2 cluster using the BMC API
Requires Python: >=3.9

# BMC

WARNING, This package is likely to change dramatically as I learn more about the Turing Pi 2 BMC API.

BMC is a simple package to interact with the Turing Pi 2 BMC API enabling features such as
turning on power to nodes.

Due to a change in how the API works in the Turing Pi 2, this package is not compatible with BMC < 2.0.0.

## Usage

```python
from ipaddress import IPv4Address
from bmc.cluster import Cluster

cluster = Cluster(cluster_ip=IPv4Address('192.168.1.170'), username='root', password='turing', verify=False)
sdcard = cluster.nodes
print(sdcard)
```

## TODO

https://docs.turingpi.com/docs/turing-pi2-bmc-api

- [ ] Add support uart
- [ ] Add support firmware
- [ ] Add support flash
as-async 1.0.1
A simple library for unblocking asynchronous code
Requires Python: >=3.12.0

# as-async

Small python library to unblock sync functions and generators

## Installation

```sh
    pip install as-async
```

## Examples

basic usage

 ```python
    import time
    import asyncio
    from concurrent.futures import ThreadPoolExecutor

    from as_async import as_async

    @as_async()
    def long_running_function():
        time.sleep(5)
        return "Finished"

    async def main():
        result = await long_running_function()
        print(result)

    asyncio.run(main())
```

specify loop and or executor

```python
    import time
    import asyncio
    from concurrent.futures import ThreadPoolExecutor

    from as_async import as_async_generator

    @as_async_generator(loop=asyncio.get_event_loop(), executor=ThreadPoolExecutor(max_workers=5))
    def long_running_generator():
        for i in range(5):
            time.sleep(1)  # Simulate a long-running operation
            yield i

    async def main():
        async for value in long_running_generator():
            print(value)

    asyncio.run(main())
```

equivalents to the above without the decorator also exists

 ```python
    import time
    import asyncio
    from concurrent.futures import ThreadPoolExecutor

    def long_running_function():
        time.sleep(5)
        return "Finished"


    async def main():
        async_func = to_async(long_running_function)
        result = await async_func()
        print(result)

    asyncio.run(main())
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
overseerr-api 1.0.1
Overseerr API
Keywords: OpenAPI,OpenAPI-Generator,Overseerr API

    This is the documentation for the Overseerr API backend.  Two primary authentication methods are supported:  - **Cookie Authentication**: A valid sign-in to the &#x60;/auth/plex&#x60; or &#x60;/auth/local&#x60; will generate a valid authentication cookie. - **API Key Authentication**: Sign-in is also possible by passing an &#x60;X-Api-Key&#x60; header along with a valid API Key generated by Overseerr.