semvec/pypi-packages huggingface dataset:
synthetic-data-samples-generator 0.0.1
Generates synthetic data samples on the fly for test cases.
Requires Python: <4.0,>=3.11


<!-- <p align='center'>
    <img src='./.docs/cctv.png' width='20%' height='20%'>
</p> -->

<h1 align='center'>
    <strong> Synthetic Data Generator </strong>
</h1>

<p align='center'>
    Designed to generate synthetic data on the fly so you can stress test your pipelines with ease.
</p>

<div align="center">

  <a href="code coverage">![coverage](https://img.shields.io/badge/coverage-99%25-brightgreen)</a>
  <a href="tests">![tests](https://img.shields.io/badge/tests-34%20passed%2C%200%20failed-brightgreen)</a>
  <a href="python version">![sbt_version](https://img.shields.io/badge/python-3.11.4-blue?logo=python&logoColor=white)</a>

</div>

### **1. Intro**

The Synthetic Data Generator is a powerful tool designed to help developers and data engineers stress test their data pipelines with ease. By generating realistic, customizable synthetic data on the fly, this project enables thorough testing of data processing systems under various conditions and loads.

Key features of the Synthetic Data Generator include:

- **On-demand data generation**: Create large volumes of synthetic data as needed;
- **Scalability**: Suitable for testing small to large-scale data pipelines;
- **Integration-friendly**: Designed to work seamlessly with various data processing frameworks.

Whether you're developing a new data pipeline, optimizing an existing one, or conducting performance testing, the Synthetic Data Generator provides the flexible, controllable data source you need to ensure your systems are robust and reliable under real-world conditions.

### **2. How to Use - _high level_**

- if you want to generate samples to all the file type handled by the project:
````python
generator = SyntheticDataGenerator(
    target_size_mb=10,
    num_columns=10,
    sample_rows_num=1000,
)

generator.generate_all_file_types("test_data", "test_folder")
````

- if you want to generate samples to a specific file type:

````python
generator = SyntheticDataGenerator(target_size_mb=100)

generator.generate_file(
    values_type=ValuesType.STRING,
    file_name="test_data_100mb",
    file_type=FileType.CSV,
    landing_path="test_folder"
)
````

### **A1. Future Work**

There are still some points that we should tackle:

- It's hard to scale the size of the generated data for the ttl files up to the target size, since it's not proportional to the records number - *something that needs to be explored*;
llama3.2-token-counter 0.5.0
A simple token counter for Llama 3.2 models.
Requires Python: >=3.11

# Llama 3.2 Token Counter

![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
![License](https://img.shields.io/badge/license-MIT-green)

A simple and efficient token counter for Llama 3.2 models.

## Description

The Llama 3.2 Token Counter is a Python package that provides an easy way to count tokens generated by Llama 3.2 models. This tool is essential for developers and researchers working with large language models, helping them manage token limits and optimize their use of the Llama 3.2 architecture.

## Features

- Accurate token counting for Llama 3.2 models
- Easy-to-use Python API
- Supports both string and list of strings inputs
- Asynchronous token counting support
- Batch processing for large inputs
- Lightweight and efficient

## Installation

You can install the Llama 3.2 Token Counter using pip:

```bash
pip install llama3.2-token-counter
```

## Usage

Here's a quick example of how to use the Llama 3.2 Token Counter:

```python
from llama_token_counter import LlamaTokenCounter
import asyncio

# Initialize the token counter
counter = LlamaTokenCounter()

# Synchronous token counting
text = "Hello, world! This is a sample text for token counting."
token_count = counter.count_tokens(text)
print(f"The text contains {token_count} tokens.")

# Asynchronous token counting
async def count_async():
    text = "This is an async token counting example."
    token_count = await counter.count_tokens(text)
    print(f"The async text contains {token_count} tokens.")

asyncio.run(count_async())

# Count tokens in a list of strings
texts = ["Hello, world!", "This is another sample.", "Multiple strings can be processed."]
token_count = counter.count_tokens(texts)
print(f"The list of texts contains {token_count} tokens in total.")

# Get the maximum token limit
max_tokens = counter.get_max_tokens()
print(f"The maximum token limit is {max_tokens}.")

# Batch processing for large lists
large_list = ["Text " + str(i) for i in range(10000)]
token_count = counter.count_tokens(large_list, batch_size=500)
print(f"The large list contains {token_count} tokens in total.")
```

## Contributing

We welcome contributions to the Llama 3.2 Token Counter! If you'd like to contribute, please look at [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contact

Anthony - [@anthoeknee](https://github.com/anthoeknee)

Project Link: [https://github.com/anthoeknee/llama3.2-token-counter](https://github.com/anthoeknee/llama3.2-token-counter)

## Running Tests

To run the tests, follow these steps:

1. Clone the repository:
   ```
   git clone https://github.com/yourusername/llama3.2-token-counter.git
   cd llama3.2-token-counter
   ```

2. Install the development dependencies:
   ```
   pip install -r requirements.txt
   ```

3. Run the tests:
   ```
   pytest tests
   ```

Make sure you have the necessary tokenizer files in the `src/llama_token_counter/tokenizer` directory before running the tests.
pyfmc 0.1.6
Finance Monte-Carlo Simulation using PyTorch

# Finance Monte-Carlo Simulation using PyTorch

- An easy-to-use python package to do Monte-Carlo Simulation on stock prices
- GPU accelerated Monte-Carlo simulation, that could allow simulation more random walkers without a large time penalty

## Installation

```bash
pip install pyfmc
```

## Geometric Brownian Motion Simulation

### Configure the simulation

```python
import pandas as pd
import matplotlib.pyplot as plt
from pyfmc.simulations.gbm import GBM

data_path = "./tests/data/AAPL.csv" # Replace with one's desired data
simulation = GBM(
        df=pd.read_csv(data_path),
        n_walkers=500_000,
        n_steps=100,
        n_trajectories=50,
        open_index="Open",  # Make sure the DataFrame has column index specified here
        close_index="Close", # Make sure the DataFrame has column index specified here
    )
result = simulation.simulate()
```

### Simulation Results

#### Price Distribution

```python
price_dist = result.price_distribution()
price_dist.plot(bins=500)
plt.show()
```

![Price Distribution](./images/price_dist.png)

#### Return Distribution

```python
return_dist = result.return_distribution()
return_dist.plot(kde=True)
plt.show()
```

![Return Distribution](./images/return_dist.png)

### Walkers Trajectories

```python
trajectories = result.trajectories()
trajectories.plot()
plt.show()
```

![Trajectories](./images/trajectory.png)

### Value at Risk (VaR)

```python
var = result.VaR(alpha=5)
# output: -0.2515...
# The worst 5% chance -> -25% return
```

## For Development

Python virtual environment:

```bash
python3 -m venv .venv
source .venv/bin/activate
pip3 install -r requirements.txt
```

## Reference

- [How to Use Monte Carlo Simulation With GBM (Investopedia)](https://www.investopedia.com/articles/07/montecarlo.asp)
- [Understanding Value at Risk (VaR) and How It’s Computed (Investopedia)](https://www.investopedia.com/terms/v/var.asp)
undidPyjl 0.1.2
Python wrapper for Undid.jl.
Requires Python: >=3.6

# undidPyjl
Difference-in-differences for unpoolable data. Python wrapper for Undid.jl.

## Installation
```bash
pip install undidPyjl
```

For more information see: https://github.com/ebjamieson97/undidPyjl