semvec/pypi-packages huggingface dataset:
Rtool-JianhongGao 0.0.3
A small example package

# Example Package

nestList.py是一个可以打印缩进列表的示例函数,示例代码如下：

    from example_pkg_zx1 import nestList
    alist = ["grace", "angle", "roy", 
                ["anna", "jhon", "richard", ["nio", "lily"]], 
                "bluce"]        
    nestList.print_list(alist)
Rtool-GJH01 0.0.2
A small example package

# Example Package

nestList.py是一个可以打印缩进列表的示例函数,示例代码如下：

    from example_pkg_zx1 import nestList
    alist = ["grace", "angle", "roy", 
                ["anna", "jhon", "richard", ["nio", "lily"]], 
                "bluce"]        
    nestList.print_list(alist)
Rtool-GJH 0.0.1
A small example package

# Example Package

nestList.py是一个可以打印缩进列表的示例函数,示例代码如下：

    from example_pkg_zx1 import nestList
    alist = ["grace", "angle", "roy", 
                ["anna", "jhon", "richard", ["nio", "lily"]], 
                "bluce"]        
    nestList.print_list(alist)
test1212121gg 0.0.1
A small example package

# Example Package

nestList.py是一个可以打印缩进列表的示例函数,示例代码如下：

    from example_pkg_zx1 import nestList
    alist = ["grace", "angle", "roy", 
                ["anna", "jhon", "richard", ["nio", "lily"]], 
                "bluce"]        
    nestList.print_list(alist)
d-magent 0.2.3
Multi-Agent Reinforcement Learning environments with very large numbers of agents
Requires Python: >=3.7
Keywords: Reinforcement Learning,game,RL,AI

# MAgent

MAgent is a library for creating 2D environments with very large numbers of agents for conducting research in Multi-Agent Reinforcement Learning. These can look like this:

<img src="magent-graph-1.gif" width="200"><img src="magent-graph-2.gif" width="200">

This is a maintained fork from the original repo- https://github.com/geek-ai/MAgent. The code is signifigantly cleaned up in many aspects and some unfortunate names have been fixed, but there are no major differences.

This maintainenace was primarily done in the service of the [PettingZoo library](https://github.com/Farama-Foundation/PettingZoo). PettingZoo is the easiest way to use environments in this library, and has comprehensive documentation of them.

## Requirements
MAgent supports Linux and macOS and Python 3.6+


## Install instructions
You can simply use `pip install magent`


If you use this in your research, please cite the original paper:

```
@inproceedings{zheng2018magent,
  title={MAgent: A many-agent reinforcement learning platform for artificial collective intelligence},
  author={Zheng, Lianmin and Yang, Jiacheng and Cai, Han and Zhou, Ming and Zhang, Weinan and Wang, Jun and Yu, Yong},
  booktitle={Thirty-Second AAAI Conference on Artificial Intelligence},
  year={2018}
}
```

If you wish to cite this repo with it's modifications specifically, please cite:

```
@misc{magent2020,
  author = {Terry, Jordan K and Black, Benjamin and Jayakumar, Mario},
  title = {MAgent},
  year = {2020},
  publisher = {GitHub},
  note = {GitHub repository},
  howpublished = {\url{https://github.com/Farama-Foundation/MAgent}}
}
```
chicken-nugget-falafel 0.0.1
A stupid programming language
Requires Python: >=3.10

  This package is a new programming language built in Python.
  <br />It's really hard to write code in, but very easy to read.
  <br /><br />For example, to assign a variable in chicken nugget falafel, <br />
  you would do it like this: `ASSIGN var TO 'hello'`.
  <br />As you can see that's very easy to read, but not so easy to
  <br /> write.<br /><br />
  To print to the console do it like this: `PRINT var`. To print<br />
  a blank line just use the `PRINT` statement by itself.
  <br /><br />To define a function, do it like this: `DEFINE FUNCTION func`<br />
  `WITH ARGUMENTS (x, y, z)`. To call the function and assign
  <br />it a value, do it like this: `CALL func WITH ARGUMENTS`<br />
  `(1, 2, 3) AND ASSIGN TO var`.
  
Import the module like this: `import chicken_nugget_falafel`<br />
and type in the file name. It's a good idea to end the targeted file<br />
with cnf, for example `my_file.cnf`.

THE END
fastchange 1.0.2
Fast change point detection in Python

# fastchange: Fast change point detection in Python

Fastchange is a change point detection library that is intended to be extendable, interpretable, and above all else, fast! We acheive this by adhering to the Scikit-learn API and using Numba, a just-in-time compiler that allows developers to write pure Python with NumPy that is then compiled to fast C code. 


# Documentation

All documentation can be found at https://gursky1.github.io/fastchange/
py-GameOfLife-simplified 0.0.0.2
A simple implementation of Conway's Game of Life
Requires Python: >=3.5
Keywords: GameOfLife,gameoflife,conwaysgame

[![Build and Publish to PyPI](https://github.com/avinashkarhana/GameOfLife/actions/workflows/publish-to-pypi-and-testpypi.yml/badge.svg?branch=master)](https://github.com/avinashkarhana/GameOfLife/actions/workflows/publish-to-pypi-and-testpypi.yml)

# GameDriver

A simple implementation of Conway's Game of Life.

Pythonic interface for easy imports to other projects.

    Check `GameDriver.py` for reference

## INSTALLATION:
    > pip install py-GameOfLife-simplified

## USAGE:
    python3 GameOfLife [options]
    Options:
        -h, --help                      :   Show this help message and exit.
        -v, --version                   :   Show version and exit.
        board_size=<int>                :   Set board size.
        show_generation_changes=<bool>  :   Show changes that are going to take 
                                            place in upcoming generation.
        clear_terminal=<bool>           :   Clear terminal before each generation.
        show_board_with_icons=<bool>    :   Show board with icons.
        stepper_mode=<bool>             :   Step through generations.
        next_gen_interval=<float>       :   Display new generation with given 
                                            seconds of interval.
        # In stepper mode, use `Enter` key to move to next generation. 
        # Use `CTRL+C` key-combination to exit in non stepper mode to exit.
        # Use 'Q' key in stepper mode to exit.
    Example:
        python3 -m GameOfLife board_size=50 show_generation_changes=False clear_terminal=True show_board_with_icons=true stepper_mode=False next_gen_interval=0.5
rigid-transform-py 0.1.1
Library for Rigid body Transformation.
Requires Python: >=3.6

# Rigid Transform Py

This library provides classes to manipulate rigid transformation.

![rigid transform illustration](images/transform.svg "transform illustration")

## Install

```Shell
pip install rigid-transform-py
```

## Usage

### Transform 3D Rigid Body

```python
from rigid_transform import Rigid3, Translation, Rotation
import math

T12 = Rigid3(
    Translation(x=1., y=0., z=0.), 
    Rotation(roll=0., pitch=0., yaw=math.pi / 2)
)
T23 = Rigid3(
    Translation(x=1., y=0., z=0.), 
    Rotation(roll=0., pitch=0., yaw=0.)
)
T13 = T12 * T23
print(T13) # Rigid3(T xyz: (1.0000, 1.0000, 0.0000), R wxyz: (0.7071, 0.0000, 0.0000, 0.7071))

assert(T23 == T12.inverse() * T13)
assert(T12 == T13 * T23.inverse())

# access the elements of the Rigid3 object.
print("x: {}, y: {}, z: {}".format(
	T13.translation.x, T13.translation.y, T13.translation.z)
) # x: 1.0, y: 1.0000000000000002, z: 0.0

print("w: {}, x: {}, y: {}, z: {}".format(
	T13.rotation.w, T13.rotation.x, T13.rotation.y, T13.rotation.z)
) # w: 0.7071067811865477, x: 0.0, y: 0.0, z: 0.7071067811865476

roll, pitch, yaw = T13.rotation.ToEuler()
print("roll: {}, pitch: {}, yaw: {}".format(roll, pitch, yaw)) # roll: 0.0, pitch: 0.0, yaw: 1.5707963267948968
```

### Transform 3D Vector

```python
from rigid_transform import Rigid3, Translation, Rotation, Vector3
import math

T = Rigid3(
    Translation(x=1., y=0., z=0.), 
    Rotation(roll=0., pitch=0., yaw=math.pi / 2)
)
v1 = Vector3(x=1., y=0., z=0.)
v2 = T * v1
print(v2) # Vector3(xyz: (1.0000, 1.0000, 0.0000))

# access the elements of the Vector3 object
print("x: {}, y: {}, z: {}".format(v2.x, v2.y, v2.z)) # x: 1.0, y: 1.0000000000000002, z: 0.0
```

### Transform 2D Rigid Body

```python
from rigid_transform import Rigid2, Translation, Rotation
import math

T12 = Rigid2(x=1., y=0., theta=math.pi / 2)
T23 = Rigid2(x=1., y=0., theta=0.)
T13 = T12 * T23
print(T13) # Rigid2(x,y,theta: 1.0000, 1.0000, 1.5708)

assert(T23 == T12.inverse() * T13)
assert(T12 == T13 * T23.inverse())

# access the elements of the Rigid2 object
print("x: {}, y: {}, theta: {}".format(T13.x, T13.y, T13.theta)) # x: 1.0, y: 1.0000000000000002, theta: 1.570796326794897
```
pyleaps 0.0.2
Simple porting of the LEAPS package on python. Not optimized yet.
Requires Python: >=3.6

## PYLEAPS

This package wants to be a simple porting of the regsubset function from R.
Unlike `leaps` in `R`, the package is not optimized yet, and requires extra work to improve code readability.
For now, I have implemented forward/backward/best subset selection for linear regression, building on top
of the excellent `statsmodels` package.

In addition, for now, the user needs to manually code the categorical variable contrasts. This will be fixed in the future.

The package can be easily installed through pip. Check out https://pypi.org/project/pyleaps/ for details

## TO INSTALL

`pip install pyleaps`

The relevant dependencies should automatically get installed, in case they are not present in the environment

## COLLABORATION

Any help/collaboration is very welcome. Just let me know what kind of edits you propose and I will be very happy to discuss them.

## TO DOs
This section contains a list of future edits:

1. Improve general code readability  
1. Figure out a way to speed up best subset section. So far, it is way slower than the R counterpart.