semvec/pypi-packages huggingface dataset:
screenmonkey 0.1.0
Packing for recording and executing on-screen actions
Requires Python: >=3.6

# Screen Monkey

This package allows users to record and execute sequences of on-screen actions by interacting with Sequence objects.

Currently, only mouse actions are supported -- development of keyboard support is underway.

Currently, only saving/loading through excel files is supported -- csv and other filetypes is under developemnt.

Thanks to Pravin Nath for developing the pynput library, which this packed is based off. Details here: https://github.com/pravinnath/pynput

# Installation

# Examples

To record and save a Sequence of actions:

```python
from screenmonkey import Sequence

mySeq = Sequence()  # initializes your Sequence object
mySeq.record()  # prompts user to do actions that they wish to record
mySeq.save_excel('testSeq.xlsx')  # saves Sequence as Excel file for repeated use
```
To run a saved Sequence:

```python
from screenmonkey import Sequence

mySeq = Sequence()  # initializes your Sequence object
mySeq.load_excel('testSeq.xlsx')  # loads a saved Sequence of actions
mySeq.run()  # prompts user to prepare screen, then executes actions
```


# Contact

Screen Monkey is developed by Bryce Merrill, please contact at: brycelmerrill@gmail.com
peach-collector 1.1.6
Peach Collector client library for Python
Requires Python: >=3.8

# peach-collector

Peach Collector client implementation in Python 3.8


# PeachCollector

Simplest way to send events.

    collector = PeachCollector("a-site-key", "an-app-id")
    collector.add_event({"type":"an-event-type", foo": 666})
    collector.add_event({"type":"an-event-type", "bar": 777})
    await collector.send_events()


# PeachCollectorQueue

Pushes events on to a Redis queue which is drained at regular intervals.

    # Client
    q = PeachCollectorQueue("redis://localhost")
    q.push_event({"type":"an-event-type", "foo": 66})
    q.push_event({"type":"an-event-type", "bar": 777})

    # Scheduled Worker
    collector = PeachCollector("a-site-key", "an-app-id")
    q = PeachCollectorQueue("redis://localhost", collector)
    q.drain()
oscontainer 1.0.2
The small Python library to read resources available for Linux OS container.
Requires Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7

[![Python package](https://github.com/yaricom/oscontainer/actions/workflows/python-package.yml/badge.svg)](https://github.com/yaricom/oscontainer/actions/workflows/python-package.yml)
[![pypi](https://img.shields.io/pypi/v/oscontainer.svg)](https://pypi.org/project/oscontainer/)
![versions](https://img.shields.io/pypi/pyversions/oscontainer.svg)
[![license](https://img.shields.io/github/license/yaricom/oscontainer.svg)](https://github.com/yaricom/oscontainer/blob/master/LICENSE)

# Overview

The simple library to gather CPU and memory resource limits from within OS Container bases on Linux.

## Install

```bash
pip install oscontainer
```

## Usage in code

The library can be used to acquire current limits exposed to the container or process as following:

```python
from oscontainer import OSContainer

# Get the container instance
container = OSContainer()

# Check if current process runs inside container
if container.is_containerized():
    # Get active processors
    cpus_count = container.active_processor_count()
    
    # Get the limit of available memory for this process.
    mem_limit = container.memory_limit_in_bytes()
else:
    print("No Container support detected")
```

For extra metrics available see [OSContainer](./oscontainer/os_container.py).

## Run in Docker from source code

To run library in the test container you need to build the docker image and run it as container.

Checkout the repository.

```bash
git clone git@github.com:yaricom/oscontainer.git
```

Build local image with `oscontainer` name.

```bash
cd oscontainer

docker build -f Dockerfile -t oscontainer . 
```

Run the image we built within container with specific CPU limits set. 
For details about setting container resources limits with Docker, see: [Runtime options with Memory, CPUs, and GPUs](https://docs.docker.com/config/containers/resource_constraints).

The following command will start container and open interactive shell:

```bash
docker run -it --cpus=".5" oscontainer /bin/bash
```

Now, execute `main.py` script within shell to see resource constraints that was detected:

```bash
python main.py 
```

This will produce the output like following:

```text
OSContainer:
==========================
   active processors: 1
      container type: cgroup2
--------------------------
 > MEMORY:
--------------------------
memory limit (bytes): -1
memory usage (bytes): 8413184
--------------------------
 > CPU:
--------------------------
               quota: 50000
              period: 100000
              shares: -1
         cpuset cpus: 0-2
==========================
System information:
==========================
multiprocessing.cpu_count: 3
     process cpu affinity: {0, 1, 2}
==========================
```