semvec/pypi-packages huggingface dataset:
pratix-nelog 0.2.4
A library to analyze network logs in multiple formats and consolidate them into JSON.
Requires Python: >=3.6

# pratix-nelog

`pratix-nelog` is a Python library to analyze network logs in multiple formats (CSV, JSON, TXT) and consolidate them into a standardized JSON format.

## Features
- Parse logs in various formats.
- Extract key information like timestamps, IP addresses, and actions.
- Consolidate logs into JSON.

## Installation
```bash
pip install pratix-nelog


from pratix_nelog.parser import LogParser
from pratix_nelog.consolidator import LogConsolidator

# Example usage
logs = LogParser.parse_csv("sample_logs.csv")
consolidated_logs = LogConsolidator.consolidate(logs, "csv")
LogConsolidator.save_to_json(consolidated_logs, "output.json")

print("Logs processed and saved to output.json")
clipreplace 0.1.5
Replace a section of text in a file with clipboard content.
Requires Python: >=3.8

# ClipReplace
[![Test](https://github.com/l-lumin/clipreplace/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/l-lumin/clipreplace/actions/workflows/test.yml)

**ClipReplace** is a simple command-line tool to replace a section of text in a file with clipboard content.

## Installation

Install `clipreplace` using `pipx`:

```sh
pipx install clipreplace
```

## Usage

1. Copy text to your clipboard
2. Run the command:

```sh
clipreplace --file <file_path>
```

3. If the first line of the clipboard matches a line in the file, the match section will be replaced with the clipboard content.

## License

This project is licensed under the MIT License.
exec-python 0.1.6
Minimal engine to execute python code generated by LLMs, with a lot of customisation options.
Requires Python: >=3.10

# exec-python

Minimal engine to execute python code generated by LLMs, with a lot of customisation options.

## Requirements

- Python 3.13+
- [uv](https://docs.astral.sh/uv/) (for development & testing)

## Installation

```bash
pip install exec-python 
```

## Running the tests

```bash
uv run test_engine.py
```


## Usage

### Quick Start 

```python
from exec_python import execute_python_code

def pair_sum(x: list[int], y: list[int]) -> list[int]:
    assert isinstance(x, list)
    assert isinstance(y, list)
    assert len(x) == len(y)
    return [x[i] + y[i] for i in range(len(x))]

code = """
x = [1, 2]
y = [2, 3]
z = pair_sum(x, y)
k = pair_sum(z, z)
"""

results = execute_python_code(
    code = code,
    functions=[pair_sum]
)
print(results)
```
Running the above code will output:

```
{
  "function_results": {
    "pair_sum": ["z","k"]
  },
  "variables": {
    "x": [1,2],
    "y": [2,3],
    "z": [3,5],
    "k": [6,10]
  },
  "errors": []
}
```
genml 0.4.1
A Python package for generating Mittag-Leffler correlated noise
Requires Python: >=3.6

# GenML: A Python Library to Generate the Mittag-Leffler Correlated Noise

> Xiang Qu, Hui Zhao, Wenjie Cai, Gongyi Wang, and [Zihan Huang](https://grzy.hnu.edu.cn/site/index/huangzihan)

*School of Physics and Electronics, Hunan University, Changsha 410082, China*

E-mail: huangzih@hnu.edu.cn

GenML is a Python library designed for generating Mittag-Leffler correlated noise, which is crucial for modeling a wide range of phenomena in complex systems. This document provides a brief overview of how to install and use GenML to generate M-L noise and compute its autocorrelation functions.

This work is supported by the National Natural Science Foundation of China (Grant No. 12104147) and the Fundamental Research Funds for the Central Universities.

##### Documentation website: [https://genml.readthedocs.io](https://genml.readthedocs.io)

## Installation

To install GenML, simply run the following command in your Python environment:

```bash
pip install -U genml
```

## Basic Usage

The core functionalities of GenML include generating sequences of Mittag-Leffler correlated noise and calculating their autocorrelation functions. Here's how you can get started:

### Generating Mittag-Leffler Correlated Noise

To generate sequences of Mittag-Leffler correlated noise , use the `mln` function with the desired parameters:

```python
import genml

# Parameters
N = 10  # Number of sequences
T = 500  # Length of each sequence
C = 1.0  # Amplitude coefficient
lamda = 0.5  # Mittag-Leffler exponent
tau = 10  # Characteristic memory time
seed = 42 # Random seed

# Generate M-L noise sequences
xi = genml.mln(N, T, C, lamda, tau, seed)
```

### Calculating Autocorrelation Function

To calculate the autocorrelation function (ACF) values of the generated noise sequences, you can use the `acf` function for actual ACF values and the `acft` function for theoretical ACF values:

```python
tmax = 100  # Max lag for ACF calculation
dt = 1  # Step size between lags
nc = 4  # Number of CPU cores for parallel processing

# Calculate actual ACF values
acfv = genml.acf(xi, tmax, dt, nc)

# Calculate theoretical ACF values
acftv = genml.acft(tmax, dt, C, lamda, tau)
```

### Examples

The repository includes detailed examples illustrating the generation of Mittag-Leffler correlated noise and the calculation of its autocorrelation function. These examples demonstrate the library's capability to replicate theoretical noise properties.