semvec/pypi-packages huggingface dataset:
gamercon-async 1.0.7
An async rcon protocol for video games.
Requires Python: >=3.11

# gamercon-async
 `gamercon-async` is an asynchronous Python rcon client tailored for managing and interacting with game servers such as Minecraft, Ark, and Palworld. This tool provides developers and server administrators with a powerful, non-blocking way to execute commands and handle server communications effectively.

## Version
> v1.0.7

## Protocols
 - GameRCON: This feature offers an asynchronous RCON protocol designed to connect to multiple servers simultaneously, enhancing the ability to manage and interact with game servers efficiently.
 - EvrimaRCON: Specifically tailored for The Isle: Evrima, EvrimaRCON is an asynchronous RCON protocol that provides specialized support for the unique needs of this game, facilitating better server management and player interaction.
 - GameRCONBase64: An advanced version of the GameRCON feature, GameRCONBase64 employs an asynchronous Base64-encoded RCON protocol. This allows for secure and efficient connections to any number of servers, ensuring a robust method for server management and communication.

## Supported Games
 - Minecraft
 - Source Engine Games
 - Palworld
 - Path of Titans
 - Ark: Survival Evolved
 - Ark: Survival Ascended
 - The Isle: Evrima
 - Source Engine Games

Mostly any game that supports source rcon will work with this protocol.

## Installation

 Install `gamercon-async` using pip:

 ```bash
 pip install gamercon-async
 ```

## Requirements
 - Python 3.11+

## Usage
 Quick example on how to use source games.

 ```python
import asyncio
from gamercon_async import GameRCON

async def main():
    client = GameRCON('host', 'port', 'password', timeout=10)
    async with client as pot_client:
        response = await pot_client.send('your_command')
        print(response)

asyncio.run(main())
```
Replace `host`, `port`, and `password` with your actual credentials and 'your_command' with the command you want to send.

Example with The Isle: Evrima
```python
import asyncio
from gamercon_async import EvrimaRCON

async def main():
   rcon = EvrimaRCON('host', port, 'password')
   await rcon.connect()
   
   save_response = await rcon.send_command(bytes('\x02', 'utf-8') + bytes('\x50', 'utf-8') + bytes('\x00', 'utf-8'))
   print(f"Save Server Response: {save_response}")
   
   announcement = "Hello, world!"
   announce_response = await rcon.send_command(bytes('\x02', 'utf-8') + bytes('\x10', 'utf-8') + announcement.encode() + bytes('\x00', 'utf-8'))
   print(f"Announcement Response: {announce_response}")

asyncio.run(main())
```
swpc-wamipe 0.0.3
Provides simple APIs to calculate neutral density values using the NOAA Whole Atmosphere Model-Ionosphere Plasmasphere Electrodynamics (WAM-IPE) model
Requires Python: >=3.8

# Project Overview

This software package is a collaboration between the [National Oceanic and Atmospheric Administration Space Weather Prediction Center (NOAA SWPC)](https://www.swpc.noaa.gov/)
and [App Dev Club LLC](https://appdevclub.com) at the University of Maryland. Using [outputs](https://noaa-nws-wam-ipe-pds.s3.amazonaws.com/index.html) from the Whole Atmosphere Model-Ionosphere Plasmasphere Electrodynamics (WAM-IPE) model, it allows users to input date, time, and satellite location (longitude + latitude) and output the neutral density value near the satellite at that date and time.

# Prerequisites

Installation of latest package versions of netCDF4, numpy, scipy, and requests.

# Usage

To install the package, open the terminal of a code editor and run the following command. <br>
**Update this command after each package version change to keep documentation up to date.**

```
pip install swpc-wamipe
```

To print a density value run the following code:

```py
from wam_api import WAMInterpolator
from datetime import datetime
foo = WAMInterpolator()
dt = datetime(2024, 5, 11, 18, 12, 22)
lat, lon, alt = -33.4, -153.24, 550.68  # degrees north, degrees east, km
my_density = foo.get_density(dt, lat, lon, alt)
print(my_density)
```

To get densities for an array of datetimes, run the following code:

```py
from wam_api import WAMInterpolator
from datetime import datetime, timedelta
foo = WAMInterpolator()
dt = datetime(2024, 5, 11, 18, 12, 22)
lat, lon, alt = -33.4, -153.24, 550.68  # degrees north, degrees east, km
dt_array = [dt + timedelta(minutes=10*i) for i in range(10)]
my_densities = foo.get_density_batch(dt_array, [lat] * 10, [lon] * 10, [alt] * 10)
print(my_densities)
```

# Updating the package version

To update the package version on PyPI from local with any changes you have made to the project,
first change the version number
in `pyproject.toml`.

Next,
run the following commands in order:

```
python -m build
```

```
python -m twine upload dist/*
```

To update the local version, run:

```
pip install swpc-wamipe --upgrade
```