semvec/pypi-packages huggingface dataset:
ejcli 1.9.7
A testing system console client

# ejcli

A testing system console client.

# Installation

To install ejcli, simply type `pip3 install ejcli`. You may need to use `sudo`.

# Testing system compatibility

ejcli supports [ejudge](https://ejudge.ru), [PCMS2](https://neerc.ifmo.ru/trains/information/software.html), [informatics.msk.ru](https://informatics.msk.ru/), [codeforces.com](https://codeforces.com), [Google Code Jam](https://codingcompetitions.withgoogle.com/codejam) and [JJS](https://github.com/MikailBag/jjs), to a varying degree of compatibility.
suspycious 0.1.2a0
Python client library for the Sus protocol
Requires Python: >=3.6

# Suspycious

Suspycious is a Python implementation of the Sus protocol. It is a
secure, asynchronous, and easy to use protocol for sending messages
between two parties.

!!! warning "Pre-alpha software"
Suspycious is currently in an early stage of development and
should not be used in production.

## Installation

Suspycious is available on PyPI and can be installed with pip:

```bash
pip install suspycious
```

## Usage

The following example shows how to create a simple Sus network with
a client and a server. The client sends a message to the server and
the server responds with a message.

```python3
import asyncio

from sus import SusServer
from sus.common.util import Address

server = SusServer(('localhost', 5000), b"my secret key.".hex())


async def message_handler(addr: Address, p_id: int, message: bytes):
    print(f"Received message from {addr}: {message.decode()}")
    server.send(addr, b"Hello from the server!")


asyncio.run(server.start([message_handler]))
```

```python3
import asyncio

from sus import SusClient

client = SusClient(('localhost', 5000), b"server public key".hex(),
                   b"my protocol ID")
asyncio.run(client.start())
client.send(b"Hello from the client!")
```

## Documentation

The documentation is available [here](https://romirk.github.io/suspycious/).
scheptk 0.1.3
Python scheduling package

## `scheptk` - Scheduling Python ToolKit

`scheptk` is a collection of classes and functions to model and solve machine scheduling problems using Python. It is intended basically for teaching purposes, even if the algorithms can be integrated with MOIST, a more advanced scheduling tool.

# How to use it

In order to use `scheptk` you can install it as a Python package using `pip`:

`pip install scheptk`

At this point, the clasess and functions of `scheptk` should be available. You might want to have a look at the [wiki pages](https://github.com/framinan/scheptk/wiki) to get a handle on the documentation.
akamai-shared-cloudlets 0.1.1
Library that implements Akamai PI requests to control cloudlet API version 3
Requires Python: >3.10

# Akamai shared cloudlets library
## Purpose
This python program implements the API requests that deal with Akamai Shared Cloudlets 
(for more information about Akamai cloudlets, 
see https://techdocs.akamai.com/cloudlets/reference/api).

It could be used as a building block for any application using the 'shared cloudlets API'
(such as Akamai CLI https://github.com/akamai/cli or Terraform Akamai provider https://registry.terraform.io/providers/akamai/akamai/latest/docs/guides/get_started_cloudlets).

## Using it
### Prerequisites
* You need Akamai credentials. To get them, see the https://techdocs.akamai.com/developer/docs/set-up-authentication-credentials documentation. 
* You also need Python 3.8+ (it should work with older versions, but 3.8 is the oldest one that I tested with).

### Run
There are two basic ways how to work with the app - importing the app and making it part of your own code like that - or there is limited 'cli' capability (that doesn't provide all the requests, but it may help you find some basic information anyway.)
#### Getting it
It is recommended to use this app in virtual environment (especially for your development needs). Then install the app from PyPI.
Following command installs the app from the TEST PYPI:
##### TEST PYPI
```
python3 -m pip install --index-url https://test.pypi.org/simple/ akamai-shared-cloudlets
```

##### PROD PYPI
```
python3 -m pip install akamai-shared-cloudlets
```
##### Poetry
To add the library to your own project as dependency, and you happen to use Poetry to manage your dependencies:
```
poetry add akamai-shared-cloudlets
```
#### Using it
Next step would be to import (example):
```
from akamai_shared_cloudlets import akamai_api_requests_abstractions as akamai_api
```
And finally you're ready to use the app:
```
print(akamai_api.list_cloudlets("~/.edgerc"))
```
Example above does not do very much, but it shows how to start using the app. 

#### Usint it as CLI
Issuing the following command:
```commandline
cloudlets list-cloudlets
```
Would produce this output (for example, it may be different in your case)
```
Sending request to Akamai...
[{'cloudletType': 'ER', 'cloudletName': 'EDGE_REDIRECTOR'}]
```
Help is provided when issued the ```cloudlets``` command without any parameters or ```clouldets --help```
windmill_client 0.7.1
A client for the Windmill API

# windmill_client

## Overview

`windmill_client` is a Python package designed to interact with the Windmill API. It provides a convenient way to manage jobs, resources, and states within the Windmill environment, offering functionalities like job creation, execution, status tracking, and state management.

It's designed to remain api-compatible with the `wmill` package, but with some added features and a more direct usage
of Windmill's REST API.

## Installation

To install `windmill_client`, run the following command:

```bash
pip install windmill-client
```

## Usage

### Basic Usage

The `wmill` package has several methods at the top-level for the most frequent operations you will need.

The following are some common examples:

```python
import time
import windmill_client as wmill


def main():
    # Get the value of a variable
    wmill.get_variable("u/user/variable_path")
    
    # Run a script synchronously and get the result
    wmill.run_script("f/pathto/script", args={"arg1": "value1"})
    
    # Get the value of a resource
    wmill.get_resource("u/user/resource_path")
    
    # Set the script's state
    wmill.set_state({"ts": time.time()})
    
    # Get the script's state
    wmill.get_state()
```

### Advanced Usage

The `wmill` package also exposes the `Windmill` class, which is the core client for the Windmill platform.

```python
import time
from windmill_client import Windmill

def main():
    client = Windmill(
        # token=...  <- this is optional. otherwise the client will look for the WM_TOKEN env var
    )

    # Get the current version of the client
    client.version

    # Get the current user
    client.user
    
    # Convenience get and post methods exist for https://app.windmill.dev/openapi.html#/
    # these are thin wrappers around the httpx library's get and post methods
    # list worker groups
    client.get("/configs/list_worker_groups")
    # create a group
    client.post(
        f"/w/{client.workspace}/groups/create",
        json={
            "name": "my-group",
            "summary": "my group summary",
        }
    )
    
    # Get and set the state of the script
    now = time.time()
    client.state = {"ts": now}
    assert client.state == {"ts": now}
    
    # Run a job asynchronously
    job_id = client.run_script_async(path="path/to/script")
    # Get its status
    client.get_job_status(job_id)
    # Get its result
    client.get_result(job_id)
```