semvec/pypi-packages huggingface dataset:
hairyBH 0.1.2
A package to calculate some important parameters of hairy black holes
License: MIT
Keywords: blackholes,hairy,geodesics

# Hairy Black Hole

Este es un paquete que usa numpy, math y scipy para calcular algunos parametros importantes de un agujero negro con pelo estático. Los parámetros que calculo por ejemplo son: la masa, la posicion del horizonte, tanto en x como en r coordenadas. 

Algunas cosas a tomar en cuenta
- No utiliza el sistema internacional de unidades. 
- La distancia se mide en unidades astronómicas, la masa en masas solares, y el tiempo en años. 

Tambien calcula las geodésicas siguiendo un metodo de RK4, las geodésicas tipo tiempo y tipo null.

Para instanciar un agujero negro importamos black_hole y le damos los 3 parámetros necesarios que son nu, eta y alpha.

Para instanciar una geodésica importamos particula_time_like y le damos los 5 parametros necesarios que son nu, eta, alpha, la energia, el momentum angular (todo en las unidades antes mencionadas). En el caso null importamos particula_null y le damos los 4 parametros necesarios que son nu, eta, alpha, b (parámetro de impacto).

Esta es una primera versión que se ira mejorando, seguramente presentara varios errores con ciertos parámetros.
zerochan 0.5.0
Python library and download cli util for https://www.zerochan.net
License: MIT
Requires Python: >=3.9,<4.0
Keywords: zerochan,booru,parser,util,pics 

# Zerochan

Library for Zerochan.net with pics parsing and downloader included!

## Features
* CLI utility for pics downloading from zerochan.net
* Library for create custom downloader (you can write own) or data analyze.
* Strong typed!

## Installation:

### Using pip
`pip install zerochan`
### Using poetry
`poetry add zerochan`

## Using as downloader tool:

After install you can call zerochan by command `python -m zerochan`


## Using as library: 

First, you should create `Zerochan` instance:
```python
from zerochan import ZeroChan

zerochan_instance = ZeroChan()
```

Now, you can set some args for request

```python
from zerochan import ZeroChan, PictureSize, SortBy

zerochan = ZeroChan()

zerochan.search("Spain")  # Set title to search
zerochan.size(PictureSize.BIGGER_AND_BETTER) # Set quality and pic size
zerochan.sort(SortBy.POPULAR) # Set sorting (now only popular)
zerochan.page(1) # Page to parse
zerochan.authorize("hjsaf7afkjsaf78", "127364") # Authorize by z_hash and z_id in cookies
```

...or set args like this:

```python
zerochan.search("Spain")\
    .size(PictureSize.BIGGER_AND_BETTER)\
    .sort(SortBy.POPULAR)
```

After all settings, you should call `.pics()` to get pics:

```python
data = zerochan.pics()
for img in data.images:
    print(img.url)
```
opt-einsum-fx 0.1.4
Einsum optimization using opt_einsum and PyTorch FX
License: MIT
Requires Python: >=3.6

# opt_einsum_fx

[![Documentation Status](https://readthedocs.org/projects/opt-einsum-fx/badge/?version=latest)](https://opt-einsum-fx.readthedocs.io/en/latest/?badge=latest)

Optimizing einsums and functions involving them using [`opt_einsum`](https://optimized-einsum.readthedocs.io/en/stable/) and PyTorch [FX](https://pytorch.org/docs/stable/fx.html) compute graphs.

Issues, questions, PRs, and any thoughts about further optimizing these kinds of operations are welcome!

For more information please see [the docs](https://opt-einsum-fx.readthedocs.io/en/stable/).

## Installation

### PyPI

The latest release can be installed from PyPI:
```bash
$ pip install opt_einsum_fx
```

### Source

To get the latest code, run:

```bash
$ git clone https://github.com/Linux-cpp-lisp/opt_einsum_fx.git
```
and install it by running
```bash
$ cd opt_einsum_fx/
$ pip install .
```

You can run the tests with
```bash
$ pytest tests/
```

## Minimal example

```python
import torch
import torch.fx
import opt_einsum_fx

def einmatvecmul(a, b, vec):
    """Batched matrix-matrix-vector product using einsum"""
    return torch.einsum("zij,zjk,zk->zi", a, b, vec)

graph_mod = torch.fx.symbolic_trace(einmatvecmul)
print("Original code:\n", graph_mod.code)
graph_opt = opt_einsum_fx.optimize_einsums_full(
    model=graph_mod,
    example_inputs=(
        torch.randn(7, 4, 5),
        torch.randn(7, 5, 3),
        torch.randn(7, 3)
    )
)
print("Optimized code:\n", graph_opt.code)
```
outputs
```
Original code:
import torch
def forward(self, a, b, vec):
    einsum_1 = torch.functional.einsum('zij,zjk,zk->zi', a, b, vec);  a = b = vec = None
    return einsum_1

Optimized code:
import torch
def forward(self, a, b, vec):
    einsum_1 = torch.functional.einsum('cb,cab->ca', vec, b);  vec = b = None
    einsum_2 = torch.functional.einsum('cb,cab->ca', einsum_1, a);  einsum_1 = a = None
    return einsum_2
```

We can measure the performance improvement (this is on a CPU):
```python
from torch.utils.benchmark import Timer

batch = 1000
a, b, vec = torch.randn(batch, 4, 5), torch.randn(batch, 5, 8), torch.randn(batch, 8)

g = {"f": graph_mod, "a": a, "b": b, "vec": vec}
t_orig = Timer("f(a, b, vec)", globals=g)
print(t_orig.timeit(10_000))

g["f"] = graph_opt
t_opt = Timer("f(a, b, vec)", globals=g)
print(t_opt.timeit(10_000))
```
gives ~2x improvement:
```
f(a, b, vec)
  276.58 us
  1 measurement, 10000 runs , 1 thread

f(a, b, vec)
  118.84 us
  1 measurement, 10000 runs , 1 thread
```
Depending on your function and dimensions you may see even larger improvements.

## License

`opt_einsum_fx` is distributed under an [MIT license](LICENSE).