semvec/pypi-packages huggingface dataset:
pyintercon-ridoineel 0.0.1
a simple python server and client to interconnect the hosts of your application
Requires Python: >=3.6

# Pyintercon is a simple python server and client to interconnect the hosts of your application.

> All package that use in this is built-in packages (refer in requirements.txt)

The server is activate on server host, and the client in all application clients (interconnected).

Client send request to Server and the Server answered.
The traitement function of server can be edit by developper.


## Example:

### Server:
```python
    >>> from pyintercon import Server

    >>> # initialize the server
    >>> sv = Server(nb_client = 1)

    >>> # run the server on $host address and $port
    >>> sv.actiavte("localhost", 8080)
    """Server is activated on localhost:8080...
    Tap CTRL + C to quit !!!!!"""
```

### Client
```python
    >>> from pyintercon import Client

    >>> # initialize the client
    >>> cl = Client()

    >>> """ server output:
        ('127.0.0.1', 44042) is connected ...
    """

    >>> # connect client to server on $host address and $port
    >>> cl.connect("localhost", 8080)

    >>> # Now send request to server and get response
    >>> response = cl.send({ message: "Hello World !" })

    >>> print(response)
    {'status': 1, 'message': 'default'}
    >>> # use disconnected method to disconnect server
    >>> cl.disconnect()

    >>> """ server output:
        ('127.0.0.1', 44042) is disconnected ...
    """
```
</br>

> #### The server manage the response loader by the treatment function.
> This function take the request data (dict object) and return by default _{"status": 1, "message": "default"}_. </br>
> He can edit it by set server.treatment = your_treatment_function

> ```python
>    >>> sv = Server() # One client by default
>    >>> sv.treatment = your_treatment_function
> ```

## Last's example:

### Server

```python
from pyintercon import Server

def response_loader(request):
    """ Just reverse the message content.
        He take dict object and return dict object

    """

    res = {"message": request["message"][::-1]}

    return res

def main():
    sv = Server()

    # set the treatment function
    sv.treatment = response_loader

    sv.activate("localhost", 8080)

if __name__ == "__main__":
    main()
```

### Client

```python
    >>> from pyintercon import Client
    >>> cl = Client()
    >>> cl.connect("localhost", 8080)
    >>> res = cl.send({"message": "Hello World !"})
    >>>
    >>> print(res)
    {"message": "! dlroW olleH"}
```

</br>

> ## Futures:
* Use threading for get client simultaneously with manage request response.
* Add more events, possibility to emit events.
pipelinewise-singer-python 2.0.1
Singer.io utility library - PipelineWise compatible

pipelinewise-singer-python
===================
[![PyPI version](https://badge.fury.io/py/pipelinewise-singer-python.svg)](https://badge.fury.io/py/pipelinewise-singer-python)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pipelinewise-singer-python.svg)](https://pypi.org/project/pipelinewise-singer-python/)
[![License: MIT](https://img.shields.io/badge/License-Apache2-yellow.svg)](https://opensource.org/licenses/Apache-2.0)

Writes the Singer format from Python.

This is a fork of [Singer's singer-python](https://github.com/singer-io/singer-python) made for [PipelineWise](https://transferwise.github.io/pipelinewise).

Usage
---

### Setup environment
This library depends on python3. We recommend using a `virtualenv` like this:

```bash
python3 -m venv ~/.virtualenvs/singer-python
```

### Installation
Next, install this library:

```bash
source ~/.virtualenvs/singer-python/bin/activate
git clone http://github.com/singer-io/singer-python
cd singer-python
make install
```

### Usage example
Now, from python code within the same `virtualenv`, you can use the library:

```python
import singer

singer.write_schema('my_table',
	            {'properties':{'id': {'type': 'string', 'key': True}}},
		    ['id'])
singer.write_records('my_table',
                     [{'id': 'b'}, {'id':'d'}])
singer.write_state({'my_table': 'd'})
```

### Logging configuration

**pipelinewise-singer-python** by default doesn't use any predefined logging configuration, it's up to the calling 
library to define it. However, if the environment variable `LOGGING_CONF_FILE` is found and set then the **pipelinewise-singer-python** 
would use the path provided in the env variable as the logging configuration for the logger. 


License
-------

Distributed under the Apache License Version 2.0
cappucino 0.1.4
Java GC Log Parser written in Python

# Java Garbage Collection parser written in Python
[![PyPI Latest Release](https://img.shields.io/pypi/v/cappucino.svg)](https://pypi.org/project/cappucino/)

## What is it?


**cappuccino** is a Python package that provides a way of parsing Java Garbage Collection Logs.

## Where to get it
The source code is currently hosted on GitHub at:
https://github.com/vidigalp/cappuccino


Binary installers for the latest released version are available at the [Python
Package Index (PyPI)](https://pypi.org/project/cappuccino).

```sh
# or PyPI
pip install cappuccino
```

## How to Run

```python
python cappuccino <input_directory>

gc_log1.log: 100%|██████████| 93842/93842 [00:00<00:00, 146317.63it/s]
gc_log2.log: 100%|██████████| 89468/89468 [00:00<00:00, 147814.29it/s]
gc_log3.log: 100%|██████████| 84950/84950 [00:00<00:00, 148095.09it/s]
gc_log4.log: 100%|██████████| 89549/89549 [00:00<00:00, 147173.26it/s]
gc_log5.log: 100%|██████████| 86187/86187 [00:00<00:00, 147973.24it/s]
                           count      mean       std   min   25%    50%  \
pause_type                                                                
G1 Evacuation Pause      16348.0  0.040432  0.141196  0.00  0.01  0.020   
G1 Humongous Allocation     34.0  0.228824  0.394222  0.03  0.07  0.105   
GCLocker Initiated GC        1.0  0.040000       NaN  0.04  0.04  0.040   
Metadata GC Threshold       15.0  0.024667  0.010601  0.01  0.02  0.020   

                           75%   max  
pause_type                            
G1 Evacuation Pause      0.030  4.58  
G1 Humongous Allocation  0.200  1.74  
GCLocker Initiated GC    0.040  0.04  
Metadata GC Threshold    0.035  0.04  

```

## Dependencies
- [Pandas - pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.](https://pandas.pydata.org)
- [NumPy - Adds support for large, multi-dimensional arrays, matrices and high-level mathematical functions to operate on these arrays](https://www.numpy.org)
- [python-dateutil - Provides powerful extensions to the standard datetime module](https://dateutil.readthedocs.io/en/stable/index.html)
- [pytz - Brings the Olson tz database into Python which allows accurate and cross platform timezone calculations](https://github.com/stub42/pytz)
- [Click - Click is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary.](https://click.palletsprojects.com/)
- [tqdm - Instantly make your loops show a smart progress meter - just wrap any iterable with tqdm(iterable), and you're done!](https://tqdm.github.io)