semvec/pypi-packages huggingface dataset:
django-socketio-chat 0.1.1
Django SocketIO Chat using python-socketio
Requires Python: <4.0,>=3.10

# Django SocketIO Chat
  
![django-socketio-chat](./django-socketio-chat.gif)  
Simple chat using [python-socketio](https://github.com/miguelgrinberg/python-socketio), 
and using [django-allauth-simple-ui](https://github.com/ThuanD/django-allauth-simple-ui)  
  
## Simple usage
  
Please check the [README.md](https://github.com/ThuanD/django-allauth-simple-ui/blob/main/README.md) to know how to use **django-allauth-simple-ui**
Alternatively, you can check the [testproject](https://github.com/ThuanD/django-socketio-chat/tree/main/testproject) for more details.

1. Install by running the following command
```bash  
pip install django-socketio-chat
```
  
2. Add the following settings to your `settings.py` file
```python
INSTALLED_APPS = [
    "django_socketio_chat",
    # etc
]
ALLAUTH_UI = dict(
    ADAPTER="django_socketio_chat.adapter.CustomUserAdapter",
    # etc
)
```

3. Add the Chat URLs to your `urls.py` file
```python
from django.urls import path, include
urlpatterns = [
   path('chat/', include("django_socketio_chat.urls")),
]
```

4. Config `wsgi.py` to run SocketIO server
```python
import os
import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'testproject.settings')
django.setup()

from socketio import WSGIApp
from django.core.wsgi import get_wsgi_application
from django_socketio_chat.server import ChatServer

application = WSGIApp(ChatServer().sio, get_wsgi_application())
```

5. Collect Static files
```bash
python manage.py collectstatic --no-input
```

6Migrate the database
```bash
python manage.py migrate
```

7. Using wsgi to run the project
```bash
gunicorn testproject.wsgi:application -b 0.0.0.0:8000 -w 1 -k eventlet --reload
```
django-allauth-simple-ui 0.1.2
Simple templates for django-allauth
Requires Python: <4.0,>=3.10

# Django AllAuth Simple UI

![django-allauth-simple-ui](./django-allauth--simple-ui.png)

UI templates for [django-allauth](https://github.com/pennersr/django-allauth)


## Simple usage

1. Install by running the following command
 ```bash
 pip install django-allauth-simple-ui
 ```

2. Add the following settings to your `settings.py` file
 ```python
 INSTALLED_APPS = [
     'allauth_ui',
     'allauth',
     # etc
 ]
 
 # example custom for accounts settings 
ALLAUTH_UI = dict(
    LOGIN_URL="/login/",
    LOGIN_REDIRECT_URL="/",
    LOGOUT_REDIRECT_URL="/",
)
 ```

3. Add the account URLs to your `urls.py` file
 ```python
from django.urls import path, include

urlpatterns = [
    path('', include("allauth_ui.urls")),
]
 ```
bellande-format 0.1.11
Bellande Format is a file format type
Requires Python: >=3.6
Keywords: package, setuptools, bellande, format

# Bellande Format Python Example

```
from bellande_format import Bellande_Format

bellande_formatter = Bellande_Format()

# Parse a Bellande file
parsed_data = bellande_formatter.parse_bellande("path/to/your/file.bellande")

# Write data to a Bellande file
data_to_write = {"key": "value", "list": [1, 2, 3]}
bellande_formatter.write_bellande(data_to_write, "path/to/output/file.bellande")
```

## Website PYPI
- https://pypi.org/project/bellande_format

### Installation
- `$ pip install bellande_format`

### Upgrade (if not upgraded)
- `$ pip install --upgrade bellande_format`

```
Name: bellande_format
Summary: File type Formats
Home-page: github.com/RonaldsonBellande/bellande_format
Author: Ronaldson Bellande
Author-email: ronaldsonbellande@gmail.com
License: GNU General Public License v3.0
```

## License
This Algorithm or Models is distributed under the [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/), see [LICENSE](https://github.com/RonaldsonBellande/bellande_format/blob/main/LICENSE) and [NOTICE](https://github.com/RonaldsonBellande/bellande_format/blob/main/LICENSE) for more information.
ra2mix 1.0.3
ra2mix is a python library for working with Red Alert 2 / Yuri's Revenge *.mix files
Requires Python: >=3.11

# ra2mix
[![PyPI - Version](https://img.shields.io/pypi/v/ra2mix.svg)](https://pypi.org/project/ra2mix)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ra2mix.svg)](https://pypi.org/project/ra2mix)
[![PyPI - License](https://img.shields.io/pypi/l/ra2mix.svg)](https://pypi.org/project/ra2mix)

A python library for working with Red Alert 2 / Yuri's Revenge *.mix files

Mix files are archive files used to store most game files from the games
**Command And Conquer Red Alert 2** and its expansion pack **Yuri's Revenge**.

This library allows you to interact with the mix files much like you'd interact with
zip files using a program like 7-zip -- except programmatically, of course 😎.  You can
create mix files by archiving a list of several files, or read existing mix files
and do something with the archived files contained within it.

## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
    - [Reading a `*.mix` file](#reading-a-mix-file)
    - [Creating a `*.mix` file](#creating-a-mix-file)

## Installation
```bash
pip install ra2mix
```

## Usage
Import the package

```python
import ra2mix
```

### Reading a `*.mix` file

- **Read**:

    The `ra2mix.read` function can take a `*.mix` filepath and return a
    `dict[str, bytes]` object. The keys are filenames and the values are file data as
    bytes.

    ```python
    import ra2mix
    mix_filepath = "path/to/mixfile.mix"

    filemap = ra2mix.read(mix_filepath)
    print(f"filenames: {list(filemap.keys())}")

    for filename, file_data in filemap.items():
        # do something with the file data
    ```

- **Extract**:

    The `ra2mix.extract` function takes a `*.mix` filepath and an extraction folder
    path.  The files contained in the mix file will be written to the folder.

    ```python
    import ra2mix
    mix_filepath = "path/to/mixfile.mix"
    extract_folder = "extract/to/folder"

    ra2mix.extract(mix_filepath, extract_folder)
    ```

---

### Creating a `*.mix` file

The `ra2mix.write` function supports three methods for specifying files to include in a
new `*.mix` file:
- `filemap`: A `dict[str, bytes]` object consisting of filenames and file data
- `folder_path`: A path to a folder; all files in the folder are added to the mix
- `filepaths`: A `list[str]` containing exact filepaths to include in the mix

```python
import ra2mix
mix_filepath = "path/to/mixfile.mix"

target_folder = "read/from/folder"

mix_data = ra2mix.write(mix_filepath, folder_path=target_folder)

# Optionally do something with mix_data if you want; file is already written to
# `mix_filepath`
```
jjtemplate 0.9.0
Jinja2 Templating with JSON files
Requires Python: >=3.9
Keywords: jinja2, json, template, templating

# jjtemplate

Jinja2 Templating with JSON files

## Example

`example.txt.jinja`:

```
Hello, {{ name }}.

```

`example.json`:

```json
{
    "name": "world"
}
```

You run:

```console
$ jjtemplate -o result.txt example.txt.jinja example.json
```

Then you get `result.txt`:

```
Hello, world.

```

## Install

```console
$ pip install jjtemplate
```


## Usage


```
usage: jjtemplate [-h] [-i IMPORT_NAME] [-o OUTPUT] template_file [json_files ...]

positional arguments:
  template_file         Jinja2 template file
  json_files            JSON files loaded to the context (top-level object must
                        be a dictionary)

optional arguments:
  -h, --help            show this help message and exit
  -i IMPORT_NAME, --import IMPORT_NAME
                        import Python module to the context (can be put
                        multiple times)
  -o OUTPUT, --output OUTPUT
                        output file name
```

Installed `jjtemplate` command runs `main` function of `jjtemplate.py`, which
is the sole entire content of the module.

You can copy `jjtemplate.py` and add it to your project freely.  See the
License section bellow.

## References

- [Template Designer Documentation — Jinja Documentation (3.1.x)][1]
- [JSON][2]

[1]:https://jinja.palletsprojects.com/en/3.1.x/templates/
[2]:https://www.json.org/

## License

jjtemplate is marked with CC0 1.0. To view a copy of
this license, visit &lt;https://creativecommons.org/publicdomain/zero/1.0/&gt;.

(In other words, public domain.)
TritonFactory 1.0.1
A collection of Triton-based neural network modules
Requires Python: >=3.7

# TritonFactory

## About
TritonFactory serves as a container for various PyTorch neural network components written in Triton, offering an easy way to access and integrate Triton-based functions from one centralized source. These components include custom implementations of activation functions, normalization layers, and other neural network operations designed for efficient execution on GPUs.

I hope this repository proves helpful to the community, making Triton-based neural network operations more accessible and convenient for developers and researchers alike.

## Installation

You can install **TritonFactory** directly from:

```bash
pip install TritonFactory
```

Alternatively, you can install it from the GitHub repository:

```bash
pip install git+https://github.com/AliYoussef97/Triton-Factory.git
```

Or clone the repository and install manually:

```bash
git clone https://github.com/AliYoussef97/Triton-Factory.git
cd Triton-Factory
python setup.py install
```

TritonFactory requires the following dependencies:
-   Linux
-   CUDA
-   NVIDIA GPU

## Usage Example

```python
import torch
from TritonFactory.Normalization import LayerNorm
from TritonFactory.Activation import GeLU

batch, length, dim = 2, 100, 128
device = "cuda"
dtype = torch.float32  # or torch.float16

x = torch.randn(batch, length, dim, device=device, dtype=dtype).to("cuda")

# Initialize LayerNorm and GeLU modules from TritonFactory
layernorm = LayerNorm(128, eps=1e-6, elementwise_affine=True, bias=True, device=device, dtype=dtype)
gelu = GeLU(approximate='None') # or tanh

# Apply LayerNorm and GeLU on the input tensor
x = layernorm(x)
x = gelu(x)
```

## Contributions

Contributions are welcome! If you'd like to add new functionalities, please:
1. Create a pull request with your implementation.
2. Ensure the pull request includes a unit test for the new module, similar to the tests found in the `UnitTests` folder.

If you encounter any bugs or issues with the current version, please feel free to report them by creating an issue or submitting a pull request.

## TODO
| Feature                         | Status  |
|----------------------------------|---------|
| Linear Layer Backward Pass       | ❌       |
| Include Triton Block Sizes in Autotune | ❌  |
| Convolution Layer                      | ❌       |
| BatchNorm                        | ❌       |
| Different Activation Functions   | ❌       |


## License
This project is licensed under the MIT License. See the [LICENSE](https://github.com/AliYoussef97/Triton-Factory/blob/main/LICENSE) file for more details.

## Acknowledgments
Special thanks to the authors of [Mamba](https://github.com/state-spaces/mamba), as parts of their Triton code was influential or some of the modules in TritonFactory.
profissa-lft 1.0.9
LFT is a framework designed to facilitate the creation of lightweight network topologies with ease. Using Docker containers, it is possible to add any container to the network to provide network services or even emulate network devices, such as switches, controllers (in Software Defined Networking). This project has integration with OpenvSwitch to emulate the network forwarding devices and srsRAN 4G to emulate wireless links for Fog and Edge application scenarios.
Requires Python: >=3.9

# Lightweight Fog Testbed (LFT)
LFT is a framework designed to facilitate the creation of lightweight network topologies with ease. Using Docker containers, it is possible to add any container to the network to provide network services or even emulate network devices, such as switches, controllers (in Software Defined Networking). This project has integration with OpenvSwitch to emulate the network forwarding devices and srsRAN 4G to emulate wireless links for Fog and Edge application scenarios.

## Requirement
This framework was developed and tested on Ubuntu Desktop 24.04 LTS. We recommend this Linux version.

## Installation
To install the project you need to run:

'''
pip3 install profissa_lft
'''

In case of any missing dependency you can manually clone the repository and run the dependencies script:

```
git clone https://github.com/alexandrekaihara/lft
cd lft
chmod +X dependencies.sh
./dependencies.sh
```

## First run
On the source root of the project run:

'''
cd examples
python3 
'''
rlpp 0.5.6
A GUI tool for building Pygame applications and Reinforcement Learning
Requires Python: >=3.9

# Reinforcement Learning with Pygame and Python

This project was inspired by the development of technologies in AI and reinforcement learning applications.  
Python has seen the development of very powerful pipelines and libraries like Pytorch and Tensorflow that allow users to create complex projects with deep learning, and therefore gives Python an advantage over perhaps faster but harder to integrate compiled programming languages like C, C# or C++.  
However, while Python has the AI libraries, it doesn't have a formal GUI-based library for game-like development like Unity or UnrealEngine does, and while emulating the complexity of building an engine doesn't overcome the benefits of library integration at this point, Python does offer tools for the creation of windows and the coding of agents with the library Pygame.  
We hope to narrow the gap between user friendly environment design by providing a simple GUI that works on pyQt5, and offer additional tools to expedite and, to some extent, standardize the structure of Reinforcement Learning Agents that can be deployed in Pygame environments.  

This library supplements the online book "The RL Playground with Python", which we consider a good resource for information on the deployment of reinforcement learning agents at an introductory level.  
https://ugarcil.github.io/The_RL_Playground_with_python/