semvec/pypi-packages huggingface dataset:
autonogame 1.2.0a0
Ogame bot
License: MIT
Keywords: ogame,bot,hack,script

# autonogame

Bot for the browser game OGame.

<https://en.ogame.gameforge.com/>

This software is under development. It is capable of building `resources`, `deposits` and `facilities`. New features will be implemented in the future.

It is built on top of the Python module `pyogame` which provides the API to communicate with the game. The GitHub repository is [here](https://github.com/alaingilbert/pyogame).

## Installing

You can install this software as a `pip` package and run it from a terminal.

```bash
pip install autonogame
autonogame
```

In alternative you can download and execute the pre-built app (Windows only) by visiting the [Releases](https://github.com/tassoneroberto/autonogame/releases) page.

## Contributing

If you are a developer and you want to contribute to this project you can clone, install and test this software on your Windows or Unix machine.

```bash
git clone --recursive git@github.com:tassoneroberto/autonogame.git
cd autonogame
```

You can install this Python module locally on Windows or Unix.

### Windows

```powershell
py -m venv venv
.\venv\Scripts\Activate.ps1
py -m pip install -e .
```

### Unix

```bash
python -m venv venv
source venv/bin/activate
python -m pip install -e .
```

### Run

You can run the GUI by simply executing the following command:

```bash
autonogame
```

## Build app

A Windows executable `.exe` (or MacOS application `.app`) can be built using the `pyinstaller` software (more info [here](https://pyinstaller.org/en/stable/usage.html#cmdoption-version-file)). The command can be execute using `Make`:

```bash
make build-app
```

If you are on a Windows OS and you don't have `Make` already installed you can get it from [CHOCOLATEY](https://chocolatey.org/install):

```powershell
choco install make
```

The `./app` folder will contain the portable executable.
config-py2 1.3.3
A Config Management CLI Tool similar to dynaconf for python 2 and above
License: MIT
Requires Python: >=2.7
Keywords: config,cli,toml,json,yaml,python2,python 2.x,dynaconf

# A Config Management CLI Tool similar to dynaconf for python 2 and above
=============================================================================

#### The library provides a basic cli tool `config_py2` to initialize a config mechanism in the current directory
Once installed you can run the `--help` to see the list of commands and options supported.

Please note that although the validation is missing currently, it will be supported in future releases.

```
$ config_py2 --help

Usage: config_py2 [OPTIONS] COMMAND [ARGS]

Options:
  --version         Show config_py2 version currently installed
  --help            Show this message and exit

Commands:
  init              Inits a config_py2 project. Default behavior of using `settings.toml` can be overriden with [ARGS]      
  list              Lists all defined config values

Args:   Optionally use EITHER one of these in conjunction with `init` command
  -f, --filename    Pass one or more of this followed by a filename (with extension) to give a list of file(s) to use for config
  -t, --filetype    Pass one or more of this followed by a filetype (extension) to use for settings file.
                    Possible values are: [toml | json | yaml]
                    Please note that this option will not be used if filenames are passed via the -f, --filename flag       
  -e, --env_prefix  Pass this option to override the ENV_PREFIX that will be used to override configs with the shell variables
                    Format of environment variables will be `ENV_PREFIX_{}`. By default it is set to 'CONFIG'
```

#### Examples to get you started with the `init` command
```
# Initializes a config_manager.py and settings.toml with placeholders for various environments
$ config_py2 init
Configuring your environment. Please Wait !


# Initializes a config_manager.py and settings.json with placeholders for various environments
$ config_py2 init -t json
Configuring your environment. Please Wait !


# Initializes a config_manager.py and settings.toml, settings-override.toml with placeholders for various environments
# Note that the configs will be read in the same order as provided during the `init` command

# Also note that the subsequent settings files don't need to have a `default` section of their own as long
# as the first file has one. This can be useful when you have seperate files for different environments

$ config_py2 init -f settings.toml -f settings-override.toml
Configuring your environment. Please Wait !


# This wil print the list of all configs as it'll be available for your application
$ config_py2 list
{
    "APP_ENV": "local",
    "CONFIG_ENVIRONMENT": "local"
}
```

#### Examples for usage in code once the config mechanism is initialized via the cli-tool
```
$ export CONFIG_ENVIROMENT=local

$ python
    >>> from config import settings
    >>> settings.APP_ENV
    'local'
    >>> settings.CONFIG_ENVIRONMENT
    'local'
```
north-robots 0.0.31
A high-level library for controlling and programming North robots
License: MIT
Requires Python: >=3.6.0


### North Robots

The `north_robots` library provides a high-level API for interacting with North Robotics robots and components.

## Installation

Install the `north_robots` library
```bash
pip install git+https://gitlab.com/north-robotics/north_robots
```

Import the `C9Controller` and `N9Robot` classes
```python
from north_c9.controller import C9Controller
from north_robots.n9 import N9Robot
```

Now create instances of the controller and robot
```python
controller = C9Controller()
robot = N9Robot(controller)
```

Now you can home and move the N9 robot arm around
```python
robot.home()
robot.move(0, 150)
robot.move(0, 150, 200)
robot.move(gripper=90)
robot.elbow.move_degrees(-90)
```
rlacalc 0.4.0
Statistical calculations for risk-limiting election tabulation audits (RLAs)
License: MIT
Requires Python: >=3.8,<4.0
Keywords: RLA,risk-limiting audit,election,audit

**rlacalc** crunches the numbers for risk-limiting post-election audits.
It can calculate sample sizes, as well as calculate risk levels based on observed ballots.
It can handle many of the commonly used RLA tests, including ballot-level comparison via Kaplan-Markov and
ballot polling via BRAVO.

# Goals
It is important to emphasize that the output of an audit should be
a report providing evidence related to election outcome, details about and explanations of any discrepancies found,
and conclusions based on that evidence.  See the paper
[Evidence-Based Elections Stark and Wagner](http://www.stat.berkeley.edu/~stark/Preprints/evidenceVote12.pdf)
and the report [Risk-Limiting Post-Election Audits: Why and How](http://www.stat.berkeley.edu/~stark/Preprints/RLAwhitepaper12.pdf).

rlacalc helps observers to explore the best way to do an audit beforehand, and to check the numbers in reports published after an audit, e.g. as described for a [Public RLA Oversight Protocol](http://bcn.boulder.co.us/~neal/elections/PublicRLAOversightProtocol.pdf).

rlacalc can be used to perform calculations from the command line or used as a library in Python. In addition, if the hug package
is available, it can be accessed over the web.

# Installation

rlacalc works with Python 2.7 and Python 3.x.
There are no other mandatory dependencies beyond the standard library.

If hug is installed, rlacalc can be deployed via a web server.

# Usage

```
$ rlacalc --help
...

$ rlacalc --test
...

$ rlacalc -m 1 -n
Sample size = 479 for margin 1%, risk 10%, gamma 1.03905, o1 0, o2 0, u1 0, u2 0

$ rlacalc -m 1 -n --o1 1
Sample size = 615 for margin 1%, risk 10%, gamma 1.03905, o1 1, o2 0, u1 0, u2 0

$ rlacalc -m 3 -r 5
KM_exp_rnd  = 226 for margin 3%, risk 5%, gamma 1.03905, or1 0.001, or2 0.0001, ur1 0.001, ur2 0.0001, roundUp1 1, roundUp2 0
```

# Background
For tools implemented in javascript, with plots, see

* [Tools for Comparison Risk\-Limiting Election Audits](https://www.stat.berkeley.edu/~stark/Vote/auditTools.htm)
* [Tools for Ballot\-Polling Risk\-Limiting Election Audits](https://www.stat.berkeley.edu/~stark/Vote/ballotPollTools.htm)

# History
rlacalc was included as part of [audit_cvrs](https://github.com/nealmcb/audit_cvrs) in 2015 to help run some early pilot audits in Colorado as part of the [The Colorado Risk-Limiting Audit Project (CORLA)](http://bcn.boulder.co.us/~neal/elections/corla/).
rigged-sb3 0.0.1
Experimental version of SB3
License: MIT
Requires Python: >=3.7
Keywords: reinforcement-learning-algorithms reinforcement-learning machine-learning gym openai stable baselines toolbox python data-science

# This isn't the official Stable Baselines3, it's an experimental version

The official SB3 is here: https://github.com/DLR-RM/stable-baselines3
pdf2pptx 1.0.5
Utility to convert a PDF slideshow to Powerpoint PPTX.
License: MIT

# pdf2pptx

**Utility to convert a PDF slideshow to Powerpoint PPTX.**

Renders each page as a PNG image and creates the resulting Powerpoint 
slideshow from these images. Useful when you want to use Powerpoint 
to present a set of PDF slides (e.g. slides from Beamer). You can then
use the presentation capabilities of Powerpoint (notes, ink on slides,
etc.) with slides created in LaTeX.

I use this to present PDF slides on a Surface Pro so that I can annotate
them with a stylus as I present.

Uses [PyMuPDF](https://github.com/pymupdf/PyMuPDF) and 
[python-pptx](https://github.com/scanny/python-pptx) to do the hard work.

## Installation

```bash
pip install pdf2pptx
```

## Usage

The following will create a `slides.pptx` file from a `slides.pdf` file.

```bash
pdf2pptx slides.pdf
```

Run `pdf2pptx --help` for more info on the command line interface.