semvec/pypi-packages huggingface dataset:
fastdf 0.1.3
A high-performance DataFrame implementation built on top of NumPy
Requires Python: >=3.7

# FastDF: High-Performance DataFrame for Python

FastDF is a lightning-fast, memory-efficient DataFrame implementation built on top of NumPy, designed to overcome the performance limitations of pandas for basic data operations.

## 🚀 Key Features

- **Blazing Fast**: Up to 126x faster data access compared to pandas
- **Memory Efficient**: Optimized memory usage with NumPy 2D arrays
- **Pandas-Compatible**: Seamless integration with existing pandas-based projects
- **Minimalist**: Focuses on core functionality for maximum performance

## 🎯 Motivation

FastDF was born out of frustration with the sluggish performance of pandas, especially when dealing with large datasets. After exploring various alternatives that either didn't work as expected or introduced complex syntax changes, we realized that for many data analysis tasks, we only need a handful of core features:

- Named columns
- Efficient slicing
- Basic operations like `shift` and `any`

By leveraging the power of NumPy's 2D arrays and implementing only the essential features, FastDF achieves remarkable performance improvements without sacrificing ease of use.

## ⚡ Performance

In our benchmarks, FastDF has shown:

- 40x faster data access compared to pandas
- Significantly faster slicing operations
- Reduced memory footprint

## 🛠 Installation

   You can install FastDF using pip:

   ```bash
   pip install fastdf
   ```

   For the latest development version, you can install directly from GitHub:

   ```bash
   pip install git+https://github.com/stwrn/fastdf.git
   ```

## 🚦 Quick Start

```python
from fastdf import fdf
import pandas as pd
import numpy as np

# Create a pandas DataFrame
pdf = pd.DataFrame({'A': np.random.rand(1000000), 'B': np.random.rand(1000000)})

# Convert to FastDF
fast_df = fdf.from_pandas(pdf)

# Use FastDF with familiar pandas-like syntax
print(fast_df.loc[0:5, 'A'])
print(fast_df['B'].shift(1))
print(fast_df.any())
```

## 🔄 Compatibility

FastDF is designed to be a drop-in replacement for basic pandas operations. You can easily convert your pandas DataFrame to FastDF and continue using the familiar syntax:

```python
# Your existing pandas code
result = pandas_df.loc[1000:2000]['B']
print(f"Pandas result {result}")

# With FastDF from pandas
fast_df = fdf.from_pandas(pandas_df)
result_fdf = fast_df.loc[1000:2000]['B']
print(f"FastDF result {result_fdf}")

# With FastDF
data = np.random.rand(1000, 5)
columns = ['A', 'B', 'C', 'D', 'E']
fast_df = fdf(data, columns)
print(f"FastDF {fast_df}")
```

## 🤝 Contributing

We welcome contributions to FastDF! Whether it's bug reports, feature requests, or code contributions, please feel free to make a pull request or open an issue.

## 📜 License

FastDF is released under the MIT License. See the LICENSE file for more details.

## 🙏 Acknowledgements

Special thanks to the NumPy and pandas teams for their incredible work, which laid the foundation for this project.

---

FastDF is still in active development. We're excited to see how it can help accelerate your data analysis workflows!
lampe 0.9.0
Likelihood-free AMortized Posterior Estimation with PyTorch
Requires Python: >=3.8
Keywords: torch, simulation, inference, amortized, bayesian, posterior, likelihood, mcmc

![LAMPE's banner](https://raw.githubusercontent.com/probabilists/lampe/master/docs/images/banner.svg)

# LAMPE

LAMPE is a simulation-based inference (SBI) package that focuses on amortized estimation of posterior distributions, without relying on explicit likelihood functions; hence the name *Likelihood-free AMortized Posterior Estimation* (LAMPE). The package provides [PyTorch](https://pytorch.org) implementations of modern amortized simulation-based inference algorithms like neural ratio estimation (NRE), neural posterior estimation (NPE) and more. Similar to PyTorch, the philosophy of LAMPE is to avoid obfuscation and expose all components, from network architecture to optimizer, to the user such that they are free to modify or replace anything they like.

As part of the inference pipeline, `lampe` provides components to efficiently [store and load data](lampe/data.py) from disk, [diagnose predictions](lampe/diagnostics.py) and [display results](lampe/plots.py) graphically.

## Installation

The `lampe` package is available on [PyPI](https://pypi.org/project/lampe), which means it is installable via `pip`.

```
pip install lampe
```

Alternatively, if you need the latest features, you can install it from the repository.

```
pip install git+https://github.com/probabilists/lampe
```

## Documentation

The documentation is made with [Sphinx](https://www.sphinx-doc.org) and [Furo](https://github.com/pradyunsg/furo) and is hosted at [lampe.readthedocs.io](https://lampe.readthedocs.io).

## Contributing

If you have a question, an issue or would like to contribute, please read our [contributing guidelines](https://github.com/probabilists/lampe/blob/master/CONTRIBUTING.md).
ArtexSTT 0.0.1
A python speech to text library
Requires Python: >=3.6

# Speech to Text (STT) Project

This project leverages `Selenium` and `webdriver_manager` to utilize Chrome's built-in text-to-speech feature. It's designed for simplicity and ease of use, allowing you to configure continuous text-to-speech functionality and optional English translation.

## Features

- **Continuous Speech-to-Speech**: Decide if you want the text-to-speech functionality to run continuously.
- **Optional English Translation**: Choose whether to translate text to English before speaking.
- **100% accuracy**: Gives you the 100% accuracy in listening by google chrome's algorithm.

## Prerequisites

- `Selenium`
- `webdriver_manager`

## Setup

1. **Install dependencies**:
    ```sh
    pip install selenium webdriver_manager mtranslate
    ```

2. **Create Configuration Files**:
    - `write_text_file_path.txt`: This file will be the file in which the text is written by converting from speech.

## Parameters

* `write_text_file_path.txt`: This file will be the file in which the text is written by converting from speech.
* `translate` (bool): Set to True to translate the text to English before speaking, False otherwise.

## Usage

To use the text-to-speech functionality, import the `Listener` class from `ArtexSTT` and initialize it with the appropriate parameters.

If you want the speech-to-text functionality to run continuously, it is recommended to use threading. This will prevent the function from blocking the execution of further code until it is stopped.

Example with Threading

```python
import os
import threading
from ArtexSTT import Listener

a = Listener(os.path.join(os.getcwd(), "text.txt"))

listener_thread = threading.Thread(target=a.listen) # It is compulsory to use threading or it will just block the execution of other code and also won't stop if needed.
listener_thread.start() # start the thread

# Now for stop listening

a.StopRecognition()
listener_thread.join() # wait until the thread finishes
```

To make the program listen properly, speak a bit loud and clear words.

**This project is managed by Artex AI. Soon an improved and stable version will roll out**