semvec/pypi-packages huggingface dataset:
pyftg 2.3
An interface for implementing python AI in DareFightingICE
Requires Python: >=3.10

# pyftg

An interface for implementing python AI in DareFightingICE

First, install `pyftg` with pip.
```sh
pip install pyftg
```

Initiate `Gateway` for connecting to DareFightingICE platform.
```py
from pyftg.socket.aio.gateway import Gateway
gateway = Gateway(port=31415)
```

Construct an agent and register it to gateway and then run the game by using following code.
```py
agent1 = KickAI()
agent2 = DisplayInfo()
gateway.register_ai("KickAI", agent1)
gateway.register_ai("DisplayInfo", agent2)
await gateway.run_game(["ZEN", "ZEN"], ["KickAI", "DisplayInfo"], game_num)
```

After all the process are done, please also close the gateway.
```py
await gateway.close()
```

Please refer to the examples provided in the `examples` directory for more information.

# For developer only
Please refer to this [link](https://twine.readthedocs.io/en/stable/).

1. Increase version number in pyproject.toml

1. Build project
```sh
python -m build
```
if the above command doesn't work due to ```no module named build``` error, install ```build``` library then try again
```sh
pip install build
```
3. Push project to pypi
```sh
twine upload dist/*
```
hf-kernels 0.1.6
Download cuda kernels
Requires Python: >=3.9

# hf-kernels

Make sure you have `torch==2.5.1+cu124` installed.

```python
import torch

from hf_kernels import get_kernel

# Download optimized kernels from the Hugging Face hub
activation = get_kernel("kernels-community/activation")

# Random tensor
x = torch.randn((10, 10), dtype=torch.float16, device="cuda")

# Run the kernel
y = torch.empty_like(x)
activation.gelu_fast(y, x)

print(y)
```

## Docker Reference

build and run the reference [example/basic.py](example/basic.py) in a Docker container with the following commands:

```bash
docker build --platform linux/amd64 -t kernels-reference -f docker/Dockerfile.reference .
docker run --gpus all -it --rm -e HF_TOKEN=$HF_TOKEN kernels-reference
```

## Locking kernel versions

Projects that use `setuptools` can lock the kernel versions that should be
used. First specify the accepted versions in `pyproject.toml` and make
sure that `hf-kernels` is a build dependency:

```toml
[build-system]
requires = ["hf-kernels", "setuptools"]
build-backend = "setuptools.build_meta"

[tool.kernels.dependencies]
"kernels-community/activation" = ">=0.0.1"
```

Then run `hf-kernel lock .` in the project directory. This generates a `kernels.lock` file with
the locked revisions. The locked revision will be used when loading a kernel with
`get_locked_kernel`:

```python
from hf_kernels import get_locked_kernel

activation = get_locked_kernel("kernels-community/activation")
```

**Note:** the lock file is included in the package metadata, so it will only be visible
to `hf-kernels` after doing an (editable or regular) installation of your project.

## Pre-downloading locked kernels

Locked kernels can be pre-downloaded by running `hf-kernel download .` in your
project directory. This will download the kernels to your local Hugging Face
Hub cache.

The pre-downloaded kernels are used by the `get_locked_kernel` function.
`get_locked_kernel` will download a kernel when it is not pre-downloaded. If you
want kernel loading to error when a kernel is not pre-downloaded, you can use
the `load_kernel` function instead:

````python
```python
from hf_kernels import load_kernel

activation = load_kernel("kernels-community/activation")
````
feapack 0.1.1
A finite element analysis package for solids using Python.
Requires Python: >=3.12

# FEAPACK

### A finite element analysis package for solids using Python.

###### Copyright © 2024, Carlos Souto. All rights reserved.

Learn more about FEAPACK here: [FEAPACK Home Page](https://carlos-souto.github.io/FEAPACK/).

![Example](https://github.com/carlos-souto/FEAPACK/blob/master/docs/resources/example_c.gif)
aesFileEncryptionManager 1.0.5
A simple encryption manager to encrypt and decrypt files using AES encryption.

# aesFileEncryptionManager Project
A simple project to encrypt and decrypt files using AES algorithm.
Functionalities are provided by the pycryptodome library.

## How to use
1. Clone the repository
2. Install the pycryptodome library
```bash
pip install pycryptodome
```
3. Run the main.py file
```bash
python main.py
```
movemeter 0.7.2
A motion analysis tool
Requires Python: >=3.6

<h1>Movemeter</h1>

Movemeter is a motion analysis tool to quantify how much arbitrary
*image features* move in pixels over time. It currently uses template matching
from the OpenCV library (cv2.matchTemplate)
on upscaled images to reach subpixel resolution.

*The features* are selected by drawing regions of interest (ROIs),
which consist of small rectangular *windows*, on the images.
These analysis *windows* can be set to

1. follow the selected feature
to quantify how much and where it moves
2. to stay stationary
to quantify overal movement within that image area.

Results are reported in the units of pixels in x and y,
in square root displacement values sqrt(x^2+y^2),
or as heatmap images, and they can be exported as CSV
files for easy import into external plotting and further analysis software.


<h2>Installing</h2>

The latest version from [PyPi](https://pypi.org/)
can be installed with the command

```
pip install movemeter
```


<h2>How to use</h2>

To open the graphical user interface, simply

```
python -m movemeter.tkgui
```

For further details, please see our [Online Documentation](https://musaprog.github.io/docs/movemeter/)

<h2>Other</h2>
Movemeter is still a rather early and unfinished program.
There may be bugs and some parts can be better optimized,
especially the motion analysis calculation can be faster.