semvec/pypi-packages huggingface dataset:
finops-cli 0.1.3
FinOps CLI - Tool for analyzing AWS costs.
Requires Python: >=3.7

# FinOps CLI

FinOps CLI is a command-line tool for analyzing and optimizing costs.

## 📊 Features

- *Cost Analysis*: Get detailed cost breakdown by instance type and lifecycle
- *Reserved Instances*: Identify potential savings from Reserved Instances
- *Cost Optimization*: Get recommendations for cost optimization
- *Interactive Interface*: Colorful and user-friendly CLI output
- *Export*: Export cost analysis to CSV

## 🛠️ AWS Configuration

You can configure AWS credentials in two ways:

### Environment variables:

```bash
export AWS_ACCESS_KEY_ID=your_access_key_id
export AWS_SECRET_ACCESS_KEY=your_secret_access_key
export AWS_DEFAULT_REGION=us-east-1
```

### Or you can create a `~/.aws/credentials` file with the following content:

```ini
[default]
aws_access_key_id = your_access_key_id
aws_secret_access_key = your_secret_access_key
aws_region = us-east-1
```

## 📦 Installation

### From source
```bash
git clone https://github.com/helmcode/finops-cli.git
cd finops-cli
pip install -e .
```

### From PyPI
```bash
pip install finops-cli
```

## 📚 Usage

```bash
finops --help
```

### EC2 Cost analysis for specific region
```bash
finops analyze --region eu-west-1
```

### Estimate Reserved Instance savings
```bash
finops analyze --region eu-west-1 --show-reserved-savings
```

### Generate CSV report
```bash
finops export ec2-savings --region eu-west-1 --output savings.csv
```

## 🤝 Contributing
Contributions are welcome! Please open an issue or submit a PR.

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Open a Pull Request

## 📄 License
MIT - See [LICENSE](LICENSE) for details.

## 👷 Support
If you encounter any issues or have questions:

1. Check the troubleshooting section
2. Search existing GitHub Issues
3. Create a new issue with detailed information about your problem

---
Made with ❤️ for the FinOps community
discrete_pmf 0.1.4
Compute and plot PMFs for Binomial, Geometric, Negative Binomial and Poisson distributions.
Requires Python: <4.0,>=3.12

# Discrete PMF — Python Module for Plotting PMFs of Discrete Distributions

**Discrete PMF** is a lightweight and easy-to-use Python module for computing and visualizing **Probability Mass Functions (PMFs)** of common discrete probability distributions. It is ideal for educators, data scientists, statisticians, and learners who want to visualize and interact with probability distributions in Python.

---

## Supported Distributions

- **Binomial Distribution**
- **Geometric Distribution**
- **Negative Binomial Distribution**
- **Poisson Distribution**

Each function:
- Computes the PMF for a given distribution
- Optionally generates a matplotlib stem plot
- Returns the PMF values as a dictionary for further processing

---

## Requirements

- **Python ≥ 3.6**
- **matplotlib** (for plotting)
- Standard Library: `math`

Install dependencies with:

```bash
pip install matplotlib
```

Or if you're using [Poetry](https://python-poetry.org/):

```bash
poetry add matplotlib
```


## Function Overview

### 🔹 `binom_pmf(x_values, n, p_list, plot=True)`
Compute and (optionally) plot the **Binomial** PMF.

**Parameters:**
- `x_values (List[int])`: Values of the random variable X (e.g., [0, 1, 2, ..., n])
- `n (int)`: Number of trials
- `p_list (List[float])`: List of success probabilities (e.g., [0.3, 0.7])
- `plot (bool)`: If True, displays a matplotlib stem plot (default: `True`)

**Returns:**
- `Dict[float, List[float]]`: Mapping from each `p` to its list of PMF values.

**Example:**
```python
from discrete_pmf import binom_pmf

x = list(range(0, 6))
n = 5
p_values = [0.3, 0.7]

binom_pmf(x_values=x, n=n, p_list=p_values, plot=True)
```


## 📚 Documentation

Each function includes Python docstrings explaining:
- Function purpose
- Parameters and types
- Return values
- Example usage


---


## 📝 License

MIT License. See `LICENSE` file for details.

---

## 🤝 Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change or add.
atar 1.0.15
A CLI tool for AI tasks such as dataset handling, training, and validation.
Requires Python: >=3.6

# ATAR CLI

ATAR CLI is a command line interface that wraps common tasks for training and
running YOLOv8 based fire detection models. It provides a simple interactive
menu to download datasets, start and resume training, validate models and run
live or video based detection.

## Installation

The project can be installed from source using `pip`:

```bash
pip install -e .
```

The tool requires Python 3.7+ and depends on packages such as `ultralytics`,
`roboflow` and `supervision`.

## Usage

After installation run the CLI with:

```bash
atar-cli
```

The following menu options are available:

1. **Download RoboFlow training dataset** – Fetch a dataset from Roboflow.
2. **Train** – Start a new training run using a selected model and dataset.
3. **Resume existing training** – Continue a previous training run.
4. **Validate** – Evaluate a trained model on a validation dataset.
5. **Live Test** – Run detection on frames from a webcam.
6. **Test on an existing file** – Perform detection on a saved video file.
7. **Quit** – Exit the CLI.

Select an option by entering the corresponding number. Some options will ask for
additional input such as dataset paths or model names.

## Development

Install the development requirements and run the test suite with `pytest` to
ensure everything works as expected.

```bash
pip install -r requirements.txt  # if available
pytest -q
```

Contributions are welcome! Feel free to open issues or pull requests on the
[GitHub repository](https://github.com/otman-dev/atar-cli).
webexpythonsdk-async 0.1.3
An async Webex SDK for Python using httpx and JWT.
Requires Python: >=3.11

# WebexPythonSDK-async

Basic functionalities are derived from [WebexPythonSDK](https://github.com/WebexCommunity/WebexPythonSDK), but modified to use asynchronous HTTP calls.

## Examples

```python
from webexpythonsdk_async import AsyncWebexAPI
import asyncio

token = "YOUR_TOKEN"
persion_email = "YOUR_EMAIL"

api = AsyncWebexAPI(access_token=token)

async def main():
    async for webhook in api.webhooks.list():
        print(f"type: {type(webhook)}, {webhook}")

    resp = await api.messages.create(toPersonEmail=persion_email, text="Hello World")
    print(f"type: {type(resp)}, {resp}")

if __name__ == "__main__":
    asyncio.run(main())
```

## Installation

```bash
python -m pip install webexpythonsdk-async
```

## Todo

- [ ] Support synchronous calls.
- [ ] Add more examples.
- [ ] Remove Python 2 style code.
- [ ] Add type annotations.
aqora-cli 0.15.1
The aqora command line interface
Requires Python: >=3.8

# Installation

To install the CLI, you can use pip. Note that the CLI requires Python 3.9 or greater

```bash
# with pip
pip install aqora-cli

# with pipx
pipx install aqora-cli

# on Windows with Python installed from python.org
py -m pip install aqora-cli

# on Windows with Python installed from the Windows Store
python -m pip install aqora-cli
```

## Notes for Windows users

If pip gives you a warning that the script is not on your PATH, you can copy the
directory in the warning and add it to your path by [following the instructions
here](https://www.java.com/en/download/help/path.html)

You may also need to install the latest Visual C++ Redistributable Version. You
can find [the latest version here](https://learn.microsoft.com/cpp/windows/latest-supported-vc-redist?view=msvc-170#latest-microsoft-visual-c-redistributable-version)

# Getting Started

To verify the installation, the following should output helpful information

```bash
aqora help
```

Once the CLI has installed you can login to your account with the following command

```bash
aqora login
```

Browse the competitions on [aqora.io](https://aqora.io) and climb the leaderboards!

# Contributing

We strongly recommend you to install a stable Rust toolchain using [Rustup](https://rustup.rs/), and a
[stable Python](https://www.python.org/downloads/) runtime through official distributions.

Our main branch is called `main`. Please open a pull-request up-to-date to that branch
when you request our feedback.

Please follow [Conventional
Commits](https://www.conventionalcommits.org/en/v1.0.0/), which allows our
project to have beautiful changelogs based on your commit messages. We strongly
encourage you to install [Cocogitto](https://docs.cocogitto.io/):

```bash
$ cargo install cocogitto cargo-edit
$ cog install-hook --all
jsm-learn 0.2.2
A Python library for data analysis using JSM-method
Requires Python: >=3.11.9

# jsm_learn
### A Python library for data analysis using JSM-method 
## Introduction
### The JSM-method
**The JSM-method for automatised hypothesis forming** (Rus. *ДСМ-метод автоматического порождения гипотез, ДСМ-АПГ*) is a data analysis method first introduced by a group of researchers lead by Viktor Finn (Виктор Константинович Финн) in 1983. The JSM-method is not a probability-based data analysis method; instead it is based on mathematical logic. This allows the JSM-method to not only predict values based on reasoning-like procedures, but also to provide explanations on why those predictions where made. It has been successfully used in many studies, proving itself particularly useful in fields like sociology, medicine, pharmacology and criminology.
### The `jsm_learn` package
The `jsm_learn` package provides a version of the JSM-method using set theory. This package contains a `JSM` class which can be used to instantiate a model applying the JSM-method. The package was designed to be easy to approach for users familiar with the `scikit-learn` package.
## Quick-start guide
1. Import the module:
    ```python
    import jsm_learn as jl
    ```
2. Instantiate a new model:
    ```python
    my_jsm = jl.JSM()
    ```
3. Fit the model to your data:
    ```python
    my_jsm.fit(training_data, target_data)
    ```
4. Run the model:
    ```python
    my_jsm.predict()
    ```
5. View the results as a `pandas` dataframe:
    ```python
    results = my_jsm.to_df()
    ```
    
## Acknowledgments
This package was developed by Mikhail Torkanovskiy for his bachelor's degree. The author would like to thank the following people:
* **Oleg Mikhaylovich Anshakov** for his help and support as the research supervisor;
* **Viktor Konstantinovich Finn** for his belief in the author and for inspiring him and many others with his neverending scientific vigor.
gdevtools 0.1.0
Common developer utilities for local development
Requires Python: >=3.12

# gdevtools

A collection of developer tools to make local development easier.

## Installation

`uvx install gdevtools`

## Usage

Get help with: `gdevtools --help`.

You can also request help for any nested commands: `gdevtools gitlab --help`

## Load gitlab variables into environment

Used to load gitlab variables into environment variables. By default, it even loads all your parent group gitlab variables, recursively.

Default usage, which fetches variables recursively:
```bash
gdevtools gitlab variables load_to_env --project-id 1234 # Creates a .env file with the values of all variables
. ./.env                                               # Load environment variables into current shell
```

Additional options:
```bash
gdevtools gitlab variables load_to_env --project-id 1234 --environment-scope dev --prefix TF_VAR_ --suffix _HURRAY --file-name .my-env
. ./.my-env
```
pymetagen 0.4.1
Metadata generator using polars as backend.
Requires Python: <4.0,>=3.9

# PyMetaGen
[![PyMetaGen tests](https://github.com/itsbigspark/pymetagen/actions/workflows/pypi-release.yml/badge.svg)](https://github.com/itsbigspark/pymetagen/actions/workflows/pypi-release.yml)

<!-- image of pyMetaGen -->

<p align="center">
    <img src="./docs/img/pyMetaGenLogo.png" alt="pymetagenlogo"
    style="width:500px;">
</p>

**PyMetaGen** is a powerful and fast data quality tool base on [Polars](https://pola.rs/#) designed for generating metadata and extracting useful information from various data file formats. It provides both a Python API and a command-line interface (CLI) to inspect, filter, and extract data from files such as CSV, JSON, Parquet, and Excel.

## Key Features

- **Metadata Generation**: Automatically generates metadata for your datasets, including statistics such as min, max, standard deviation, and more.
- **Data Extraction**: Easily extract specific rows from your datasets using head, tail, or random sampling.
- **Command Line Interface**: Perform operations like metadata generation, data inspection, and filtering using an intuitive CLI.
- **Multiple File Format Support**: Import and export data in various formats, including CSV, Parquet, Excel, and JSON.
- **SQL Query Support**: Filter data using SQL queries directly on the command line.

## Installation

To install the package, use the following command:

```bash
pip install pymetagen
```

## Local Installation

To install the package locally, use the following command:

```bash
python -m pip install -U git+ssh://git@github.com/itsbigspark/dotdda.git@dev/main
```

## Usage

### Python API

You can use the Python API to load a data file and generate metadata:

```python
from pymetagen import MetaGen

# Create an instance of the MetaGen class reading a data file

metagen = MetaGen.from_path("tests/data/testdata.csv", loading_mode="eager")

# Display the first few rows of the data

metagen.data.head()
```

```python
# Generate metadata and reset the index

metadata = metagen.compute_metadata().reset_index()

```

```python
# Save the metadata to a file

metagen.write_metadata("tests/data/testdata_metadata.csv")
```

### Command Line Interface

- **Metadata Generation** Generate metadata for a tabular data file:

```bash
$ metagen metadata -i tests/data/testdata.csv -o tests/data/testdata_metadata.csv

>>> Generating metadata for tests/data/testdata.csv...
```

- **Data Inspection** Inspect a data file (e.g., a partitioned Parquet file):

```bash
metagen inspect -i tests/data/input_ab_partition.parquet
```

- **Data Filtering** Filter a data set using an SQL query:

```bash
metagen filter -i tests/data/testdata.csv -q "SELECT * FROM data WHERE imdb_score > 9"
```

- **Data Extraction** Extract a specific number of rows from a data set:

```bash
$ metagen extracts -i tests/data/testdata.csv -o tests.csv -n 3

>>> Writing extract in: tests-head.csv
>>> Writing extract in: tests-tail.csv
>>> Writing extract in: tests-sample.csv
```

### Available Output Formats

- **CSV**
- **Parquet**
- **JSON**
- **Excel**
qandle-ai 0.0.1
Python SDK for Qandle AI API
Requires Python: >=3.7
Keywords: qandle ai llm stock market technical fundamental analysis data finance api sdk

# Qandle AI Python SDK

A Python client for interacting with the Qandle AI API.

## Installation

Install the package from PyPI:

```bash
pip install qandle-ai
```

## Configuration

The client can be configured using environment variables:

- `QANDLE_API_KEY`: Your Qandle AI API key (required)
- `QANDLE_API_URL`: The base URL for the Qandle AI API (optional, defaults to `https://api.qandle.ai`)

## Usage

### Basic Usage

```python
from qandle_ai import QandleClient

# Initialize the client (uses QANDLE_API_KEY environment variable)
client = QandleClient()

# Get stock summary
summary = client.get("AAPL")
print(summary)
```

### Custom Configuration

```python
from qandle_ai import QandleClient

# Initialize with custom API key and base URL
client = QandleClient(
    api_key="your-api-key-here",
    base_url="https://custom-api.qandle.ai"
)

# Get stock summary
summary = client.get("TSLA")
print(summary)
```

## API Reference

### QandleClient

#### `__init__(api_key=None, base_url=None)`

Initialize the Qandle AI client.

**Parameters:**
- `api_key` (str, optional): The API key for Qandle AI. If not provided, will attempt to get from `QANDLE_API_KEY` environment variable.
- `base_url` (str, optional): The base URL for the Qandle AI API. If not provided, will use the default `https://api.qandle.ai` or `QANDLE_API_URL` environment variable.

#### `get(symbol)`

Retrieve the current action summary for a stock using the Qandle AI API.

**Parameters:**
- `symbol` (str): The stock symbol for which to obtain the current action summary.

**Returns:**
- `str`: The stock summary message or error message.

## Error Handling

The client handles various types of errors and returns descriptive error messages:

- Missing API key: Raises `ValueError` during initialization
- Network errors: Returns error message with details
- JSON parsing errors: Returns error message with details
- Other unexpected errors: Returns generic error message