semvec/pypi-packages huggingface dataset:
azurecloudhandler 0.3
Library to optimally handle some resources on Azure

# Azure Cloud Handler

Library to optimally handle some resources on Azure

## libs

### Azure Kubernetes Service (aks) - doesn't yet exist in the official Azure SDK

Functionalities

* status of cluster
* start cluster
* stop cluster
* commands - kubectl

### Azure Data Lake Storage Gen2 (adls2) - datalake_gen2

Functionalities

* upload file in chunks
    * avoid memory overhead for big files

* move file in chunks
    * move file between file systems
onlinezip 0.0.2
Reading zip file through network
Requires Python: >=3.6

# Onlinezip

Onlinezip is a Python library for reading zip file through network without downloading whole file locally.

You can read one entry or whole zip file entry by entry.

It may be useful when you want to read just few entries or file is really big and you don't want to download it at once. 

## Prerequisites

server with zip file must fulfill two conditions:
- respond to HTTP HEAD request
- allows to read bytes in ranges

Most modern servers supports this.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install onlinezip.

```bash
pip install onlinezip
```

## Usage

OnlineZip juz extending ZipFile. If you know how to use ZiFile class you also know how to use OnlineZip.

To start just pass url to constructor.
```python
from onlinezip.OnlineZip import OnlineZip

zip = OnlineZip('https://public-onlinezip.s3.eu-west-1.amazonaws.com/zip.zip')
```

```python
# returns names of all files in zip
zip.namelist()

# extract file a.txt to local directory
zip.extract('a.txt')

# extract all files
zip.extractall()

# open file
with zip.open('a.txt') as myfile:
    print(myfile.read())
```
Please remember that entries aren't stored neither cache so each time you calls method that read entry you are downloading it.

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
GNU GENERAL PUBLIC LICENSE
workforce-async 0.12.0
Asyncio Wrapper
Requires Python: >=3.6,<4.0
Keywords: asyncio,tasks,framework

# WorkForce Async
Asyncio Wrapper

# Install in your project
> $ pip install workforce-async

https://pypi.org/project/workforce-async/

# Select your python version
> $ poetry env use 3.7

# Install Dependencies
> $ poetry install

# Run example
> $ poetry run python examples/http_server.py

# Run tests
> $ poetry run pytest

# Interfaces
[Snippets taken from tests](https://github.com/Kick1911/WorkForce/blob/2bf0dd7dadcefd1240bfd87df8e2aa4a32b86572/tests/test_workforce.py#L54)

## Just run async functions
```python
workforce = WorkForce()

async def foo():
    await asyncio.sleep(0.8)
    bar.count += 1

f1 = workforce.schedule(foo)
```

## Just run normal functions in another thread
```python
def foo():
    bar.count += 1

f = workforce.schedule(foo)
```

## Function-based tasks
`.s()` supports both normal and async functions
```python
workforce = WorkForce()

def callback(wf, task):
    bar.result = task.result()

@workforce.task(callback=callback)
async def add(a, b):
    return a + b

task = add.s(4, 5)()

@workforce.task()
async def sleep(sec):
    await asyncio.sleep(sec)

workforce.queue('channel1')
queue = sleep.q(0.5)('channel1')
```

## Create queues of tasks
```python
workforce = WorkForce()
queue = workforce.queue('channel1')
queue.put(foo())
queue.put(foo())
queue.put(foo())
assert len(queue) == 3
```

## Class-based framework
Make your own workforce that distributes workitems to Workers
```python
class Company(WorkForce):
    def get_worker(self, workitem):
        try:
            worker_name = {
                'NewFeature': 'developer',
                'Hire': 'hr',
                'EmployeeCounseling': 'hr'
            }[type(workitem).__name__]

            return super().get_worker(worker_name)
        except KeyError:
            raise self.WorkerNotFound

company = Company()
```

Make your own workers that perform tasks based on the workitem they receive
```python
@company.worker
class Developer(Worker):
    def handle_workitem(self, workitem, *args, **kwargs):
        callback = getattr(workitem, 'callback', None)

        # All tasks here run concurrent
        coros = (getattr(self, task_name)(workitem)
                 for task_name in workitem.tasks)

        # Hack because asyncio.gather is not recognised as a coroutine
        async def gather(*aws, **kwargs):
            return await asyncio.gather(*aws, **kwargs)

        return gather(*coros), callback

    async def design(self, workitem):
        await asyncio.sleep(3)
        bar.arr.append('design')

    async def code(self, workitem):
        await asyncio.sleep(2)
        bar.arr.append('code')

    async def test(self, workitem):
        await asyncio.sleep(1)
        bar.arr.append('test')

    def make_pr(self, task, wf):
        time.sleep(0.2)
        bar.arr.append('make_pr')

company.schedule_workflow(NewFeature('New trendy ML'))
```
acni 0.0.1
A Jax/Optax implementation of Anticorrelated Noise Injection for Improved Generalization
Requires Python: >=3.8.0
Keywords: artificial intelligence,machine learning,jax,optax,generalization,noise injection

# Anticorrelated Noise Injection

A Jax/Optax implementation of [Anticorrelated Noise Injection for Improved Generalization](https://arxiv.org/abs/2202.02831)