semvec/pypi-packages huggingface dataset:
pycorpus 2.3
Easy concurrent launch of series of file based experiments.
License: MIT
Requires Python: >=3.8,<4.0
Keywords: corpus

This module provide a easy, non intrusive way to process a big list of files in a parallel way. Also provides the
option to process theses files with a different packs of options, evaluate and generate reports.

# Requirements:

You need the PPSS script in same dir of this file.

# Instructions:

1. Import this module from your main file

    ```python
    import pyCorpus
    ```
    
2. Create the function that process the file

    ```python
    def my_process(file_name, config):
        # Some science stuff with the file
    ```

3. (Optional) Create a function that return a argument parser that capture all the configs that you need.

    ```python
    def my_parser():
        # Set up your argparse parser
        # Return the parser
        return my_parser_instance
    ```
    
4. Add at the end of the file something like this:

    ```python
    if __name__ == "__main__":
        corpus_processor = pyCorpus.CorpusProcessor(parse_cmd_arguments, process_file)
        corpus_processor.run_corpus()
   ```
   
# NOTES:

 * Dot not ADD the () to my_parser and my_process arguments.

 * If you don't need options you can ignore step 3 and the config file come as None. But never use the --config parameter.

 * The files are processed in a concurrent way so if you might store any results don't use the sys.out use a file.
baguette 0.3.1
Asynchronous web framework.
License: MIT
Requires Python: >=3.6

baguette - asynchronous web framework
=====================================

.. image:: https://img.shields.io/pypi/v/baguette?color=blue
    :target: https://pypi.python.org/pypi/baguette
    :alt: PyPI version info
.. image:: https://img.shields.io/pypi/pyversions/baguette?color=orange
    :target: https://pypi.python.org/pypi/baguette
    :alt: Supported Python versions
.. image:: https://img.shields.io/github/checks-status/takos22/baguette/master?label=tests
    :target: https://github.com/takos22/baguette/actions/workflows/lint-test.yml
    :alt: Lint and test workflow status
.. image:: https://readthedocs.org/projects/baguette/badge/?version=latest
    :target: https://baguette.readthedocs.io/en/latest/
    :alt: Documentation build status
.. image:: https://codecov.io/gh/takos22/baguette/branch/master/graph/badge.svg?token=0P3BV8D3AJ
    :target: https://codecov.io/gh/takos22/baguette
    :alt: Code coverage
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black
    :alt: Code style: Black
.. image:: https://img.shields.io/discord/831992562986123376.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2
    :target: https://discord.gg/PGC3eAznJ6
    :alt: Discord support server

``baguette`` is an asynchronous web framework for ASGI servers.

Installation
------------

**Python 3.6 or higher is required.**

Install ``baguette`` with pip:

.. code:: sh

    pip install baguette

You also need an ASGI server to run your app like `uvicorn <https://www.uvicorn.org/>`_ or `hypercorn <https://gitlab.com/pgjones/hypercorn/>`_.
To install `uvicorn <https://www.uvicorn.org/>`_ directly with baguette, you can add the ``uvicorn`` argument:

.. code:: sh

    pip install baguette[uvicorn]

Quickstart
----------

Create an application, in ``example.py``:

.. code:: python

    from baguette import Baguette

    app = Baguette()

    @app.route("/")
    async def index(request):
        return "<h1>Hello world</h1>"

Run the server with `uvicorn <https://www.uvicorn.org/>`_:

.. code:: sh

    uvicorn example:app

See `uvicorn's deployment guide <https://www.uvicorn.org/deployment/>`_ for more deployment options.

Contribute
----------

- `Source Code <https://github.com/takos22/baguette>`_
- `Issue Tracker <https://github.com/takos22/baguette/issues>`_


Support
-------

If you are having issues, please let me know by joining the discord support server at https://discord.gg/8HgtN6E

License
-------

The project is licensed under the MIT license.

Links
------

- `PyPi <https://pypi.org/project/baguette/>`_
- `Documentation <https://baguette.readthedocs.io/en/latest/index.html>`_
- `Discord support server <https://discord.gg/PGC3eAznJ6>`_
mancala 0.3.0
Mancala written in Python, playable in CLI (GUI coming soon)!
License: MIT
Requires Python: >=3.8,<4.0
Keywords: mancala,game,gym,reinforcement learning

# Mancala

![PyPI - Downloads](https://img.shields.io/pypi/dm/mancala?label=pip%20install%20mancala)

Mancala board game written in python.

![img](https://github.com/qqhann/Mancala/blob/main/assets/preview_cli.png)

## Features & Road maps

- [x] Mancala playable on CLI
- [x] Cmpatible with the gym API
- [ ] Can train RL agents
- [ ] Mancala playable on GUI

## Installation

```shell
$ pip install mancala
```

## Usage

### Play a game with agents

```shell
$ mancala play --player0 human --player1 random
```

### Compare each agents and plot their win rates

The values are player1's (second move) win rates in percentage

```shell
$ mancala arena
              p0_random  p0_exact  p0_max  p0_minimax  p0_negascout
p1_random          50.0      53.0     3.0         0.0           0.0
p1_exact           42.0      48.0     4.0         1.0           1.0
p1_max             95.0      91.0    41.0         0.0           3.0
p1_minimax        100.0      96.0    87.0        30.0          39.0
p1_negascout      100.0      97.0    84.0        19.0          32.0
```

## Algorithms

Mancala is a game with perfect information.
マンカラは完全情報ゲームです。

### Mini-Max

Mini-max is an algorithm for n-player zero-sum games.
The concept is to assume the opponent will take their best move and try to minimize them.

- MiniMax <https://en.wikipedia.org/wiki/Minimax>
- Alpha-beta pruning <https://en.wikipedia.org/wiki/Alpha–beta_pruning>
- Negamax <https://en.wikipedia.org/wiki/Negamax>

### Value Iteration

Using Dynamic Programming (DP), calculate value for states and memorize them.
Use the value to plan future actions.

Other implementations

- OpenSpiel value_iteration
  algorithm <https://github.com/deepmind/open_spiel/blob/master/open_spiel/python/algorithms/value_iteration.py>
  example <https://github.com/deepmind/open_spiel/blob/master/open_spiel/python/examples/value_iteration.py>

### Policy Iteration

Using Dynamic Programming (DP), calculate value for states and memorize them.
Use the value and policy for planning.

## References

- <https://github.com/mdavolio/mancala>

### Multi agent RL

- <https://github.com/deepmind/open_spiel>
- <https://github.com/PettingZoo-Team/PettingZoo>
grefornoobs 1.1.2
Your python GRE preparation tool
License: MIT

# GRE for Noobs
GRE for Noobs is a python library that helps you with your GRE preparation. It has features such as adding new words in your vocabulary database, trying random vocabulary quizzes, etc.

## Installation
```pip install grefornoobs```

## How to use it?
- Import the library `import gre`
- Start building necessary database `gre.start()`
- Start recording your progress `gre.hello()`
- GRE basic informations `gre.about()`
- Add new words in your vocabulary file `gre.new()`
- Find meaning of a word `gre.meaning()`
- View all words in a set `gre.set()`
- Flashcard of a set `gre.flash()`
- Try a random vocabulary quiz `gre.exam()`
- See your progress `gre.progress()`
- Updates database from the internet `gre.update()`
- Ask for help `gre.help()`

## Contribute
If you have discovered a bug or something else you want to change, feel free to contact the author at `abdussamiakanda@gmail.com`.

## License
&copy; 2021 Md. Abdus Sami Akanda

This repository is licensed under the MIT license. See LICENSE for details.
randnames 0.1.1
Draw random first and last USA names
License: MIT

# randnames
Python module to draw random names.

# Summary

to be done

# Installation

Randnames is availabe in python repository, and can be downloaded with pip.

```
pip3 install randnames
```

# Simple Usage

For more visit project [website](https://github.com/ajwalkiewicz/randnames) or 
[documentation](https://ajwalkiewicz.github.io/randnames/_build/html/index.html#)

```
>>> import randnames

# Get first name
>>> randnames.first_name()
'John'

# Get last name
>>> randnames.last_name()
'Doe'

# Get full name
>>>randnames.full_name()
'John Doe'
```

# Documentation

Detailed documentation of module can by found here:
[randnames documentation](https://ajwalkiewicz.github.io/randnames/_build/html/index.html#)

# Database

So far project uses databases from www.census.gov and www.ssa.gov.

### Last names

Databases for USA last names: 

https://www.census.gov/topics/population/genealogy/data/1990_census.html
https://www.census.gov/topics/population/genealogy/data/2000_surnames.html
https://www.census.gov/topics/population/genealogy/data/2010_surnames.html

### first names

Database for USA first names:

https://www.ssa.gov/oact/babynames/limits.html

### license
https://www.census.gov/data/software/x13as/disclaimer.html

# License

Randnames is licensed under the terms of the [MIT license](LICENSE)