semvec/pypi-packages huggingface dataset:
ffbancheck 0.1.0
A package to check if a Free Fire account is banned.
Requires Python: >=3.6

# ffbancheck

This Python package allows you to check if a Free Fire account is banned using the `check` method.

## Installation

To install the package, run:

\`\`\`bash
pip install ffbancheck
\`\`\`

## Usage

\`\`\`python
import ffbancheck

account_id = "12345678"
ffbancheck.check(account_id)
\`\`\`
cascadia 0.0.7
De novo sequencing for DIA mass spectrometry data
Requires Python: >=3.8

# Cascadia


**A transformer model for de novo sequencing of data-independent acquisition mass spectrometry data**

![image](docs/source/cascadia-graphical-abstract.png)

If you use Cascadia in your work, please cite the following publication:

Sanders, Justin, et al. ‘A Transformer Model for de Novo Sequencing of Data-Independent Acquisition Mass Spectrometry Data’. bioRxiv, Cold Spring Harbor Laboratory, 2024, [https://doi.org/10.1101/2024.06.03.597251](https://doi.org/10.1101/2024.06.03.597251).

## Documentation

Documentation for Cascadia is avaialable at:
[https://cascadia.readthedocs.io/en/latest/index.html](https://cascadia.readthedocs.io/en/latest/index.html)
verifai 2.1.2
A toolkit for the formal design and analysis of systems that include artificial intelligence (AI) and machine learning (ML) components.
Requires Python: >=3.8

[![Documentation Status](https://readthedocs.org/projects/verifai/badge/?version=latest)](https://verifai.readthedocs.io/en/latest/?badge=latest)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)


# VerifAI

**VerifAI** is a software toolkit for the formal design and analysis of 
systems that include artificial intelligence (AI) and machine learning (ML)
components.
VerifAI particularly seeks to address challenges with applying formal methods to perception and ML components, including those based on neural networks, and to model and analyze system behavior in the presence of environment uncertainty.
The current version of the toolkit performs intelligent simulation guided by formal models and specifications, enabling a variety of use cases including temporal-logic falsification (bug-finding), model-based systematic fuzz testing, parameter synthesis, counterexample analysis, and data set augmentation. Further details may be found in our [CAV 2019 paper](https://people.eecs.berkeley.edu/~sseshia/pubs/b2hd-verifai-cav19.html).

Please see the [documentation](https://verifai.readthedocs.io/) for installation instructions, tutorials, publications using VerifAI, and more.

VerifAI was designed and implemented by Tommaso Dreossi, Daniel J. Fremont, Shromona Ghosh, Edward Kim, Hadi Ravanbakhsh, Marcell Vazquez-Chanlatte, and Sanjit A. Seshia. 

If you use VerifAI in your work, please cite our [CAV 2019 paper](https://people.eecs.berkeley.edu/~sseshia/pubs/b2hd-verifai-cav19.html) and this website.

If you have any problems using VerifAI, please submit an issue to the GitHub repository or contact Daniel Fremont at [dfremont@ucsc.edu](mailto:dfremont@ucsc.edu) or Edward Kim at [ek65@berkeley.edu](mailto:ek65@berkeley.edu).

### Repository Structure

* _docs_: sources for the [documentation](https://verifai.readthedocs.io/);

* _examples_: examples and additional documentation for particular simulators, including CARLA, Webots, X-Plane, and OpenAI Gym;

* _src/verifai_: the source for the `verifai` package proper;

* _tests_: the VerifAI test suite.
viriback2misp 0.10
Upload Viriback C2 Track data to MISP events
Keywords: C2, command and control, C2 Tracker, command & control, feed c2, infostealer, bot, malware

# Viriback to MISP

This project aims to get the detection generated for the project [C2 Tracker](https://tracker.viriback.com/), and create events in MISP. 

The events will be distributed by month/year and malware family, like the example below. In each event will be created objects for each IOC detected in the C2 Tracker.


|![](https://github.com/santiag02/viriback2misp/blob/main/media/misp.png)|
|:---:|
|MISP Events|

## How install

```bash
pip install viriback2misp
```

## Commands

```bash
viriback2misp -h
usage: viriback2misp [-h] [-i] [-u] [-d {0,1,2,3,4}]

Viriback C2 data to MISP events

options:
  -h, --help            show this help message and exit
  -i, --init            First step. Pass your API key and URL.
  -u, --update          Update MISP events.
  -d {0,1,2,3,4}, --distribution {0,1,2,3,4}
                        The common distribution levels in MISP are as follows: 0: Your organization only - Default; 1: This community only; 2: Connected communities; 3: All communities; 4: Sharing
                        group.
  -a, --azure           Retrieve misp key directly from Azure key vault.
```
celery-redis-poll 0.1.12
A Redis Backend for Celery with polling instead of pub/sub
Requires Python: >=3.8

# Celery Redis Poll Backend

A specialized Redis backend for Celery that replaces the default pub/sub mechanism for task result retrieval with a polling-based approach.

## Why Polling Instead of Pub/Sub?

The default Celery Redis backend uses Redis pub/sub for real-time task result notifications. While pub/sub provides immediate updates, it can face challenges in certain scenarios:

- Deadlocks in highly concurrent/multi-threaded workloads due to single-threaded nature of Redis and Celery clients.
- Higher overhead with `SUBSCRIBE` channels.

This backend provides a more robust alternative by using a polling mechanism instead.

## Features

- **Polling-Based Results**: Replaces pub/sub with a polling mechanism for task result retrieval
- **Compatible with Existing Code**: Drop-in replacement for the standard Redis backend
- **Configurable Polling**: Adjust polling intervals and timeouts to match your needs
- **Resource Efficient**: Reduces Redis memory usage by eliminating pub/sub channels

## Installation

```bash
pip install celery-redis-poll
```

After installation new backends are automatically registered with Celery:
- `redis+poll`
- `rediss+poll`
- `redis+cluster_poll`
- `rediss+cluster_poll`

## Usage

Configure your Celery application to use the polling backend:

```python
from celery import Celery

app = Celery('your_app',
             broker='redis://localhost:6379/0',
             backend='redis+poll://localhost:6379/0')
```

For clustered Redis, use `redis+cluster_poll`.

## Requirements

- Python >= 3.7
- Celery >= 5.0.0
- Redis >= 4.5.0
- celery-redis-cluster >= 0.1.6

## Development

For development, install extra dependencies:

```bash
pip install celery-redis-poll[dev]
```

## License

This project is licensed under the MIT License.

## Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.
celery-redis-cluster 0.2.3
A Redis Cluster backend for Celery
Requires Python: >=3.8

# Celery Redis Cluster

A Redis Cluster backend implementation for Celery. This package extends Celery's Redis backend to work with Redis Cluster, providing better scalability and high availability through Redis Cluster's sharding and replication capabilities.

## Installation

```bash
pip install celery-redis-cluster
```

After installation new backends are automatically registered with Celery:
- `redis+cluster`
- `rediss+cluster`

## Usage

To use the Redis Cluster backend in your Celery application:

```python
from celery import Celery

from celery_redis_cluster_backend import install_redis_cluster_backend


app = Celery('your_app',
             broker='redis://localhost:6379/0',
             backend='redis+cluster://localhost:6379/0')
```

### Configuration

The backend inherits all configuration options from Celery's Redis backend, with the addition of Redis Cluster specific handling. Here's an example configuration:

```python
app.conf.update(
    result_backend='redis+cluster://localhost:6379/0',
    redis_backend_use_ssl={
        'ssl_cert_reqs': None,
        'ssl_ca_certs': None,
        'ssl_certfile': None,
        'ssl_keyfile': None
    },
    redis_max_connections=None,
    redis_socket_timeout=120.0,
    redis_socket_connect_timeout=120.0,
    redis_cluster_retry_on_timeout=True,
    redis_cluster_max_retry_on_timeout=3,
)
```

## Requirements

- Python >= 3.8
- Celery >= 5.3.0
- redis >= 4.5.0

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
rfproximity 0.0.3
RFProximity
Requires Python: >=3.7

# **RFProximity**
<TODO>
## Introduction

RFProximity is a python package which computes proximity matrix for any Random Forest model. Package includes three specific implementations of proximity. Additionally, using the proximity matrix, package includes methods to perform missing value imputaion, outlier detection and prototype identification. 

## Table of Contents

- [Installation](#installation)
- [Background](#background)
- [Usage/Configurations](#usage)
- [Contributing](#contributing)
- [License](#license)
- [Credits](#credits)
- [Contact](#contact)

## Background

Reference Material:
- Leo Brieman and Adele Cutler's [blog](https://www.stat.berkeley.edu/~breiman/RandomForests/cc_papers.htm) on Random Forest
- Geometry and Accuracy Preserving (GAP) Proximities [Arxiv Link](https://arxiv.org/abs/2201.12682)


## Usage

```python
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from rfproximity import TreeProximity, SimilarityExplainer
import matplotlib.pyplot as plt
import pandas as pd

# Using Iris dataset 
# using the function `sklearn.datasets.load_iris` from
# scikit-learn. The dataset will contain:
# - 3 classes 
# - n samples

data = load_iris()
X,y = data['data'], data['target']
print(X.shape)


# Using the dataset we now train a random forest classifier first
model = RandomForestClassifier().fit(X,y)
leaf_nodes = model.apply(X)


# After training the model, initialize the TreeProximity module
prox = TreeProximity(leaf_nodes)

# Using TreeProximity module calculate proximity matrix
proximity_matrix = prox.proximity_matrix()
print(proximity_matrix)

# Using TreeProximity module calculate out-of-bag proximity matrix
proximity_matrix_oob = prox.proximity_matrix_oob(model,X.shape[0])
print(proximity_matrix_oob)


# Using TreeProximity module calculate geometry and accuracy preserving
# proximity matrix
proximity_matrix_gap = prox.proximity_matrix_gap(model,X.shape[0])
print(proximity_matrix_gap)


# Using TreeProximity module to identify prototype samples

SimEx = SimilarityExplainer(proximity_matrix, y)
prototypes = SimEx.get_prototype(top_k=20, total_prototypes=3, return_neighbors=True)
print(prototypes)


# Using TreeProximity module to identify class-wise outlier samples
raw_outlier_measure = SimEx.raw_outlier_measure()
outlier_measure = SimEx.get_classwise_outlier_measure()
df_outlier_measure = pd.DataFrame({'raw_outlier_measure':raw_outlier_measure,
                                    'outlier_measure':outlier_measure,
                                    'class_label':y}
                                  )
plt.figure()
plt.scatter(x=y,y=outlier_measure)
plt.xlabel('Class Label')
plt.ylabel('Outlier Measure')  
plt.title('Class-wise Outlier Measure')
plt.show()
```

## Contributing

Guidelines for contributing to the project:
  - [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md)
  - [CONTRIBUTING.md](./CONTRIBUTING.md)

## License

The license for the project:
  - [LICENSE](./LICENSE)

## Credits

Initial code contributions:
- Dhruv Desai
- Dhagash Mehta
- Julio Urquidi
- Lucas Ou
metronome-extractor 0.1.6
A package to generate metronome tracks from Guitar Pro files.
Requires Python: >=3.6

# Guitar Pro Metronome Extractor

  

A Python package that generates a metronome track from Guitar Pro files.

  

## Features

  

- Extracts tempo information from Guitar Pro (`.gp`) files.

- Generates a WAV file containing metronome clicks.

- Supports variable tempo changes throughout the piece.

- Supports tempo changes in the middle of a bar.

  

## Installation

  

You can install the package directly from PyPI using `pip`:

  

```bash

pip  install  metronome_extractor

```

  

## Usage

### As a Python Package

  

    from metronome_extractor import create_metronome_track, save_as_wav

  

#### Example: Generate a metronome track from a Guitar Pro file

    input_file = "input.gp"
    
    output_file = "output.wav"

  

##### Extract tempo information and generate the metronome track

    tempos, total_bars = parse_tempo_changes(extract_gpif(input_file))
    
    metronome_audio = create_metronome_track(tempos, bars=total_bars)
    
    save_as_wav(output_file, metronome_audio)

  

### As a Command-Line Tool

  

```

metronome_extractor input.gp output.wav

```

  

## How it works

1. Extracts the score.gpif file from the Guitar Pro file (XML format).

2. Parses the XML to find tempo changes and their positions.

3. Generates click sounds at appropriate intervals.

4. Creates a WAV file with the metronome track.

  

## Technical Details

* Sample rate: 44100 Hz

* Audio format: 16-bit mono WAV

* Click duration: 0.02 seconds

* Click frequency: 1000 Hz

* Default time signature: 4/4 (four beats per bar)

  

## Future Work

  

- **Customizable click sounds**  
  - Allow users to select custom sound sources for metronome clicks.  
  - Support different sounds for the first beat of each bar (accent beat).  

- **Extended format support**  
  - Add support for `.mp3` export.  
  - Add compatibility with legacy Guitar Pro formats (`.gpx`, `.gp5`).  
  - Implement broader Guitar Pro version compatibility.  

  

## Contributing

  

Feel free to submit issues and enhancement requests! Contributions are welcome.

  

1. Fork the repository.

2. Create a new branch for your feature or bugfix.

3. Submit a pull request.

  

## License

  

This project is open source and available under the [MIT License](LICENSE).
my-funded-grpc-api 0.1.50
gRPC API for My Funded trading
Requires Python: >=3.7

# MyFunded gRPC API Proto Python Package

This package contains the Python-generated code from the Protocol Buffer definitions for the MyFunded gRPC API.

## Installation

You can install this package using pip:

```bash
pip install my-funded-grpc-api
```

## Usage

After installation, you can import and use the generated classes in your Python code. Here's a basic example:

```python
import time

from google.protobuf.timestamp_pb2 import Timestamp
from my_funded_grpc_api.trading_account import cash_balance_pb2

message = cash_balance_pb2.TradingAccountCashBalanceMessage(
    event=cash_balance_pb2.TradingAccountCashBalanceEvent(
        event_type=cash_balance_pb2.EVENT_TYPE_CREATED,
        entity_type=cash_balance_pb2.ENTITY_TYPE_TRADING_ACCOUNT_CASH_BALANCE,
        environment=cash_balance_pb2.ENVIRONMENT_LIVE,
        stage=cash_balance_pb2.STAGE_EVALUATION,
        entity=cash_balance_pb2.TradingAccountCashBalance(
            trading_account_id="acc123",
            balance=10000.50,
            date=Timestamp().FromSeconds(int(time.time())),
            realized_pnl=500.75,
            environment=cash_balance_pb2.ENVIRONMENT_LIVE,
            stage=cash_balance_pb2.STAGE_EVALUATION,
            broker="TestBroker"
        ),
    ),
    topic="trading/cash_balance"
)

print(message)
```
```shell
event {
  event_type: EVENT_TYPE_CREATED
  entity_type: ENTITY_TYPE_TRADING_ACCOUNT_CASH_BALANCE
  environment: ENVIRONMENT_LIVE
  stage: STAGE_EVALUATION
  entity {
    trading_account_id: "acc123"
    balance: 10000.5
    realized_pnl: 500.75
    environment: ENVIRONMENT_LIVE
    stage: STAGE_EVALUATION
    broker: "TestBroker"
  }
}
topic: "trading/cash_balance"
```

## Development

This package is automatically generated from the Protocol Buffer definitions in the [MyFunded gRPC API Proto repository](https://github.com/MyFunded/my-funded-grpc-api-proto). If you need to make changes, please submit a pull request to that repository.

## License

[Specify your license here]

## Contact

For any questions or issues, please [open an issue](https://github.com/MyFunded/my-funded-grpc-api-proto/issues) on the GitHub repository.
aigct 0.1a1.dev3
AI Genomics CollecTive (AIGCT) is a platform for systematically evaluating ML/AI models of variant effects across the spectrum of genomics-based precision medicine
Requires Python: >=3.8

AI Genomics CollecTive (AIGCT) is a platform for systematically 
evaluating ML/AI models of variant effects across the spectrum of 
genomics-based precision medicine.
pypubmech 0.1
A Python package for fetching PubMed articles with MeSH support
Requires Python: >=3.8

# pypubmech

A Python package for fetching and processing PubMed articles with comprehensive metadata extraction and MeSH term support.

## Features

- Search PubMed articles by keyword or MeSH terms
- Extract comprehensive article metadata including:
  - Title, Abstract, Authors
  - Volume, Issue, Journal
  - Citations and Links
  - MeSH terms
- Export results to CSV
- Compare different sets of PMIDs

## Installation

```bash
pip install pypubmech
```

## Quick Start

```python
from pypubmech import PubMedClient

# Initialize client
client = PubMedClient(email="your.email@example.com")

# Search by keyword
pmids = client.search_by_keyword("cancer", 100)

# Fetch metadata
client.fetch_article_metadata()

# Export to CSV
client.export_to_csv("cancer_articles.csv")
```

## MeSH Search Example

```python
# Search using MeSH terms
mesh_query = "Neoplasms[MeSH] AND Genetics[MeSH]"
pmids = client.search_by_mesh(mesh_query)
client.fetch_article_metadata()
client.export_to_csv("cancer_genetics.csv")
```

## Development

### Setup

1. Clone the repository:
```bash
git clone https://github.com/yourusername/pypubmech.git
cd pypubmech
```

2. Create a virtual environment:
```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

3. Install development dependencies:
```bash
pip install -e ".[dev]"
```

### Running Tests

```bash
pytest tests/
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.