semvec/pypi-packages huggingface dataset:
random-renormalization-group 0.1.1
The package for random renormalization group
Requires Python: >=3.6

# Overview
This is the code implementation of the random renormalization group presented in the paper entitled as "Fast renormalizing the structures and dynamics of ultra-large systems via random renormalization group". 

# Instructions
example.py can be run directly over simulated data.  To run the codes with real data, one only needs to change the input of the function Renormalization_Flow. We refer to “Fast_renormalizing_the_structures_and_dynamics_of_ultra_large_systems_via_random_renormalization_group_SM_.pdf” for detailed descriptions and usages of other functions.

# System requirements
## Hardware requirements
Our codes only require a modest size computer with enough RAM to support in-memory operations. All the computations are implemented in a CPU environment. To date, our codes have been implemented in a 256GB environment with two Intel Xeon Gold 5218 processors and a 32GB environment with a Intel Core i7-8750H CPU for testing.

## OS requirements
Our codes have been tested on the following system:
+ windows 10

## Python dependencies
Our codes mainly depends on following packages:
```python
numpy
scipy
faiss
networkx
datasketch
statsmodels
```

# Installation guide:
```python
pip install random_renormalization_group
```

# License
This project is covered under the **MIT License**.
pandas-ollama 1.0.3
Natural language interface for pandas DataFrame analysis using Ollama models
Requires Python: >=3.8
Keywords: pandas, ollama, ai, dataframe, analysis, visualization, natural language

# pandas-ollama

Natural language interface for pandas DataFrame analysis using Ollama models.

## Installation

```bash
pip install pandas-ollama
```

## Requirements

- Python 3.7+
- Ollama server running locally or remotely
- Required packages: pandas, matplotlib, seaborn, requests

## Quick Start

```python
import pandas as pd
from pandas_ollama import MyPandasAI

# Create a DataFrame
df = pd.DataFrame({
    'Product': ['Laptop', 'Phone', 'Tablet'],
    'Price': [1000, 800, 500],
    'Stock': [50, 100, 75]
})

# Create PandasOllama instance
panoll = MyPandasAI(df, model="llama3:latest")

# Ask a question about your data
result = panoll.ask("What is the average price of products?")
print(result.content)

# Create a visualization
result = panoll.plot("Show the distribution of prices", viz_type="bar")

# Display the visualization in a notebook
if result.visualization:
    import base64
    from IPython.display import Image
    image_data = base64.b64decode(result.visualization)
    Image(data=image_data)
```

## Features

- Natural language querying of pandas DataFrames
- Automatic visualization generation
- Support for various chart types: bar, line, scatter, hist, pie, heatmap, and more
- Intelligent data type detection
- Data transformation through natural language commands

## License

MIT License
taskiq-aiopg 0.2.0
Aiopg and PostgreSQL integration for taskiq
Requires Python: >=3.9
Keywords: taskiq, tasks, distributed, async, aiopg

# taskiq + aiopg

[![Python](https://img.shields.io/badge/python-3.10_|_3.11_|_3.12_|_3.13-blue)](https://www.python.org/)
[![Linters](https://github.com/danfimov/taskiq-aiopg/actions/workflows/code-check.yml/badge.svg)](https://github.com/danfimov/taskiq-aiopg/actions/workflows/code-check.yml)


Plugin for taskiq that adds a new result backend based on PostgreSQL and [aiopg](https://github.com/aio-libs/aiopg).

## Installation

This project can be installed using pip/poetry/uv (choose your preferred package manager):

```bash
pip install taskiq-aiopg
```

## Usage

Let's see the example with the redis broker and PostgreSQL aiopg result backend (run as is):

```python
# broker.py
import asyncio

import taskiq_redis

from taskiq_aiopg import AiopgResultBackend

result_backend = AiopgResultBackend(
    dsn="postgres://postgres:postgres@localhost:5432/postgres",
)

# Or you can use PubSubBroker if you need broadcasting
broker = taskiq_redis.ListQueueBroker(
    url="redis://localhost:6379",
).with_result_backend(result_backend)


@broker.task(task_name="best_task_ever")
async def best_task_ever() -> None:
    """Solve all problems in the world."""
    print("Start to solve all problems...")
    await asyncio.sleep(2.0)
    print("All problems are solved!")


async def main():
    print("Starting the application")
    await broker.startup()
    task = await best_task_ever.kiq()
    print(await task.wait_result())
    await broker.shutdown()


if __name__ == "__main__":
    asyncio.run(main())
```

## Configuration

- `dsn`: connection string to PostgreSQL;
- `keep_results`: flag to not remove results from Redis after reading;
- `table_name`: name of the table in PostgreSQL to store TaskIQ results;
- `field_for_task_id`: type of a field for `task_id`, you may need it if you want to have length of task_id more than 255 symbols;
- `serializer`: type of `TaskiqSerializer` default is `PickleSerializer`;
- `**connect_kwargs`: additional connection parameters, you can read more about it in [aiopg repository](https://github.com/aio-libs/aiopg).
multiset-key-dict 0.2.1
A simple library for executing BLAST searches with ncbi-blast+
Requires Python: >=3.12

# multiset-key-dict

This small library implements a mapping-like object whose keys are taken to be
unordered multisets (Counters, bags), regardless of the type of the actual
indexes used.

## Example

Create a `MultisetKeyDict` and insert an element for the set {1, 3, 5}.

```python
from multiset_key_dict import MultisetKeyDict
mskd = MultisetKeyDict()
mskd[[1, 3, 5]] = 19
```

Access the element just added.

```python
# In a different order.
print(mskd[[3, 5, 1]]) # 19
# With a different type of collection.
print(mskd[{3, 5, 1}]) # 19
```

`__iter__` iterates over items in the `MultisetKeyDict`, *viewed as frozensets*
(i.e., not accounting for multiplicity).

```python
# Add more data.
mskd[[1]] = 9
mskd[[5, 6]] = 12
print(list(mskd)) # [(frozenset({1, 3, 5}), 19), (frozenset({1}), 9), (frozenset({5, 6}), 12)]
```

To iterate over key-value pairs where the keys are the `FrozenMultiset` objects
that act as the true keys in the structure, use `multiset_iter` or `items`
methods instead.

```python
msked[[1, 1]] = 90
print(list(mskd))
# [(frozenset({1, 3, 5}), 19), (frozenset({1}), 9), (frozenset({5, 6}), 12),
# (frozenset({1}), 90)]

print(list(mskd.multiset_iter()))
# [(FrozenMultiset({(3, 1), (1, 1), (5, 1)}), 19), 
#  (FrozenMultiset({(1, 1)}), 9),
#  (FrozenMultiset({(6, 1), (5, 1)}), 12),
#  (FrozenMultiset({(1, 2)}), 90)]
```

To get the keys as `frozenset` objects, use `set_keys`. To get the keys as
`FrozenMultiset` objects, use `multiset_keys` or `keys`.

It's sometimes useful to get the set of *elements* of the keys. For that, you
can use the `key_elements` method.

```python
print(mskd.key_elements()) # frozenset({1, 3, 5, 6})
```
scope 0.6.3
Metrics logging and analysis

# 🔬 Scope

Scalable metrics logging and analysis.

## Features

- 🚀 **Scalable:** Quickly log and view petabytes of metrics, thousands of keys, and large videos.
- 🎞️ **Formats:** Log and view scalars, text, images, and videos. Easy to extend with custom formats.
- 🧑🏻‍🔬 **Productivity:** Metrics viewer with focus on power users with full keyboard support.
- ☁️ **Cloud support:** Directly write to and read from Cloud storage via pathlib interface.
- 🍃 **Lightweight:** The writer and reader measure only ~400 lines of Python code.
- 🧱 **Reliable:** Unit tested and used across diverse research projects.

## Usage

### Installation

```sh
pip install scope
```

### Writing

```python
import scope

writer = scope.Writer(logdir)

for step in range(3):
  writer.add(step, {
      'foo': 42,
      'bar': np.zeros((100, 640, 360, 3), np.uint8),
      'baz': 'Hello World',
  })
  writer.flush()
```

### Viewing

```sh
python -m scope.viewer --basedir ... --port 8000
```

### Reading

```python
import scope

reader = scope.Reader(logdir)
print(reader.keys())               # ('foo', 'bar', 'baz')

print(reader.length('foo'))        # 3
steps, values = reader['foo']
print(steps)                       # np.array([0, 1, 2], np.int64)
print(values)                      # np.array([42, 42, 42], np.float64)

steps, filenames = reader['bar']
reader.load('bar', filenames[-1])  # np.zeros((100, 640, 360, 3), np.uint8)
```