semvec/pypi-packages huggingface dataset:
filebrowser-client 0.1.0
An async CLI client and library for filebrowser API
License: MIT
Requires Python: >=3.7.2,<4.0
Keywords: filebrowser,cli,client,asyncio

# Overview

The `filebrowser-client` is an async client CLI and library for the [Filebrowser](https://github.com/filebrowser/filebrowser) API.

## Installation

The easiest way to install the `filebrowser-client` is to use `pip`:

```bash
    pip3 install filebrowser-client
```

## Features

-   [x] Download a remote file or a directory
-   [x] Upload a file or a directory to a remote location
-   [x] Delete a file or a directory from a remote location

## Usage

The `filebrowser-client` provides a cli client and a library to interact with the `Filebrowser` API.

### CLI

Run `filebrowser-client --help` to see the global options and the available commands.

```bash
    filebrowser-client --help
    Usage: filebrowser-client [OPTIONS] COMMAND [ARGS]...

    Options:
    --help  Show this message and exit.


    Commands:
    download  Download a file or a directory from a remote location
    upload    Upload a file or a directory to a remote location
    delete    Delete a file or a directory from a remote location
```

### Library

```python
    import asyncio
    from filebrowser_client import FilebrowserClient

    client = FilebrowserClient("http://localhost:8080", "admin", "admin")
    asyncio.run(client.connect())

    asyncio.run(client.download("/path/to/file", "/path/to/destination"))
```

## License

This project is licensed under the MIT License

## Development

The `filebrowser-client` is developed using `poetry` and `pre-commit`.
### Prerequisites

-   [Python 3.7+](https://www.python.org/downloads/)
-   [Poetry](https://python-poetry.org/docs/#installation)
-   [Pre-commit](https://pre-commit.com/#install)

### Setup

```bash
    poetry install
    pre-commit install
```
## Build

```bash
    poetry build
```
super-py 1.0.3
Features that Python should have in the standard library
License: MIT
Requires Python: >=3.8,<4.0

# SuperPy

[![Downloads](https://pepy.tech/badge/super-py)](https://pepy.tech/project/super-py)
[![Downloads](https://pepy.tech/badge/super-py/month)](https://pepy.tech/project/super-py)
[![Downloads](https://pepy.tech/badge/super-py/week)](https://pepy.tech/project/super-py)

There are 5 sub modules:
- sp.logging
- sp.testing
- sp.concurrency
- sp.dicts
- sp.disk
- sp.string


## sp.logging

SuperPy's logging system is a simple abstraction from the standard library logging module.
It also provides some nice extra functionalities.
Here are some examples:

### Logging messages

``` python
import super_py as sp

log = sp.logging.Logger("info",
    ts_color="bright_green",
    terminal=True,
    files=["info.log", "combined.log"],
)

log("This is a simple log!")
```

This will write the following log line to the terminal, and the files `info.log` and `comnined.log`:
```
[info        ] 2022-10-04 15:53:09            This is a simple log!
```
where the name and timestamp will be colored in `bright_green`.

### Logging function benchmarks

You can also use the provided decorator to log benchmarks of your functions:

``` python
import super_py as sp

log = sp.logging.Logger("benchmark",
    ts_color="bright_green",
    terminal=True,
)

@log.benchmark(with_args=[0])
def wait(seconds):
    time.sleep(seconds)

for i in range(10):
    wait(i / 10)
```

This will write the following log lines:
```
[benchmark   ] 2022-10-04 16:03:39     0.0ms  wait((0.0))
[benchmark   ] 2022-10-04 16:03:39   105.1ms  wait((0.1))
[benchmark   ] 2022-10-04 16:03:39   205.1ms  wait((0.2))
[benchmark   ] 2022-10-04 16:03:40   308.3ms  wait((0.3))
[benchmark   ] 2022-10-04 16:03:40   403.5ms  wait((0.4))
[benchmark   ] 2022-10-04 16:03:40   505.1ms  wait((0.5))
[benchmark   ] 2022-10-04 16:03:41   605.1ms  wait((0.6))
[benchmark   ] 2022-10-04 16:03:42   705.1ms  wait((0.7))
[benchmark   ] 2022-10-04 16:03:43   804.1ms  wait((0.8))
[benchmark   ] 2022-10-04 16:03:43   903.3ms  wait((0.9))
```

You can use benchmark without calling the decorator, it will still work:
``` python
@log.benchmark
def wait(seconds):
    time.sleep(seconds)
```

The benchmark decorator takes the following keyword arguments:
- `with_args: list[int]`: The list of indices of function arguments which should be logged.
- `with_kwargs: list[str]`: The list of keyword argument names of the function which should be logged.
statsd 4.0.1
A simple statsd client.
License: MIT

======================
A Python statsd client
======================

statsd_ is a friendly front-end to Graphite_. This is a Python client
for the statsd daemon.

.. image:: https://github.com/jsocol/pystatsd/actions/workflows/ci.yml/badge.svg
   :target: https://github.com/jsocol/pystatsd/actions/workflows/ci.yml
   :alt: Latest CI status

.. image:: https://img.shields.io/pypi/v/statsd.svg
   :target: https://pypi.python.org/pypi/statsd/
   :alt: Latest release

.. image:: https://img.shields.io/pypi/pyversions/statsd.svg
   :target: https://pypi.python.org/pypi/statsd/
   :alt: Supported Python versions

.. image:: https://img.shields.io/pypi/wheel/statsd.svg
   :target: https://pypi.python.org/pypi/statsd/
   :alt: Wheel Status

:Code:          https://github.com/jsocol/pystatsd
:License:       MIT; see LICENSE file
:Issues:        https://github.com/jsocol/pystatsd/issues
:Documentation: https://statsd.readthedocs.io/

Quickly, to use:

.. code-block:: python

    >>> import statsd
    >>> c = statsd.StatsClient('localhost', 8125)
    >>> c.incr('foo')  # Increment the 'foo' counter.
    >>> c.timing('stats.timed', 320)  # Record a 320ms 'stats.timed'.

You can also add a prefix to all your stats:

.. code-block:: python

    >>> import statsd
    >>> c = statsd.StatsClient('localhost', 8125, prefix='foo')
    >>> c.incr('bar')  # Will be 'foo.bar' in statsd/graphite.


Installing
==========

The easiest way to install statsd is with pip!

You can install from PyPI::

    $ pip install statsd

Or GitHub::

    $ pip install -e git+https://github.com/jsocol/pystatsd#egg=statsd

Or from source::

    $ git clone https://github.com/jsocol/pystatsd
    $ cd pystatsd
    $ python setup.py install


Docs
====

There are lots of docs in the ``docs/`` directory and on ReadTheDocs_.


.. _statsd: https://github.com/etsy/statsd
.. _Graphite: https://graphite.readthedocs.io/
.. _ReadTheDocs: https://statsd.readthedocs.io/en/latest/index.html
rohr 0.2.0
Build easy data processing pipelines in python.
License: MIT
Requires Python: >=3.4

# rohr

Build easy data processing pipelines in python.

Example:
```python
import rohr

class CapitalizeNode(rohr.Node):
    def run(self, data: str) -> str:
        return data.capitalize()

class SpaceNode(rohr.Node):
    def run(self, data: str) -> str:
        return f'  {data}  '

pipeline = rohr.Pipeline()
pipeline.add(CapitalizeNode()).add(SpaceNode())

name = 'paul'

result = pipeline.run(name)
# result is `  Paul  `
print(result)
```