semvec/pypi-packages huggingface dataset:
mktable 0.1.0
A simple Python CLI table library with no extra dependencies.
Requires Python: >=3.8

1.You need to make an instance by doing it like this:
    ```python
    your_table_name = mktable.Table()
    ```
    and you can have arguements like :
    ```python
    your_table_name = mktable.Table(["first", "row"], ["Other", "Rows(Optional)"])
    ```

2.How to add rows? 
    ```python
    your_table.add_row(["ABC","DEF"], ["Your", "Content"]) 
    ```
    just include any row you want how many you want.
3.How to render and Use? 
    use the render function
    like 
    ```python
    table_list = your_table.render()
    ```
    or you can add arguements such as custom separators like this
    ```python
    render(self, h_sep_char = '-',v_sep_char ='|', connection_point = '+')
    ```
    and btw it returns a list you can `str(your_table)` 
    to get the printable str
    or if you want to print it just do `print(your_table)` 
    it automaticaly casts it to str.
    
        Argurments:
        connection point : the point where separators connect.
            default: table.connection_point = "+"
        v_sep_char : vertical separator character
            default: table.v_sep_char = "|"
        h_sep_char : vertical separator character
            default: table.h_sep_char = "-"

    
           
4.How to remove rows?
    call the function 
    ```python
    table.remove_row(*index)
    ```
    like
    ```python
    table.remove_row(1, 5, 10)
    ```
    make sure you have that amount of rows or you will get index out of range error
    
    
5.How to use dictionaries?
    for importing from dict:
        ```python
        my_table.import_dict(my_dict, 'insert', index)  
        #replace my_table with your table and my dict with your dictionary and replace index with an index(int)
        #index in default is 0 and only matters in 'index' method
        ```
        method can be either 'insert', 'append' or 'overwrite'.method must be string.
        and the method string is not case-sensetive
            methods:
                overwrite: overwrites all the rows in the table
                insert: inserts the dict from given index (0 if non given)
                append: appends the dict to the end of the table

for exporting to a dict:
        use this method:
        ```python
        my_table.export_dict() #returns a dict
        ```
        for assigning it to a new dict (if the variable already exists it will be overwritten):
        ```python
        my_dict = my_table.export_dict()
        ```
        and for adding it to a dict:
            ```python
            my_dict += my_table.export_dict()
            ```
missedSampleLib 1.1.3
missedSampleLib
Keywords: python, missedSampleLib, misidentified samples

This repository contains the Python-based machine learning model developed as part of the study titled:
"Development and Validation of a CDS-Based Machine Learning Model for Accurate Detection of Misidentified Samples in Hospitalized Patients".
The model, built using the XGBoost algorithm, was trained on real-world clinical data from hospitalized patients to detect sample misidentification errors (MIS), including:
•	MIS cases: confirmed errors (25%) and randomly simulated sample reordering (25%)
•	Properly identified control samples (50%)
This package was specifically designed for integration into a Clinical Decision Support System (CDS) to automate the detection of analytical inconsistencies and enhance patient safety in routine clinical workflows.
Repository contents:
•	Trained model script (.py)
•	Brief documentation for implementation
This file is part of the technical supplementary material associated with the manuscript, and is provided to support transparency, reproducibility, and practical deployment.
pymosquitto 0.4.1
A lightweight Python MQTT client implemented as a thin wrapper around libmosquitto
Requires Python: >=3.8

# PyMosquitto

A lightweight Python MQTT client implemented as a thin wrapper around libmosquitto.

It provides an efficient synchronous client (`client.Mosquitto`) and two variants of asynchronous clients:

- `aio.AsyncMosquitto` - async interface to libmosquitto loop running in its own thread. It's faster, but consumes a little bit more memory.
- `aio.TrueAsyncMosquitto` - manages all events in asyncio loop by utilizing `mosquitto_loop_{read,write,misc}` functions.


## Dependencies

- python3.8+
- libmosquitto1


## Installation

- pip install pymosquitto


## Usage

```python
from pymosquitto import Mosquitto


def on_message(client, userdata, msg):
    print(msg)


client = Mosquitto()
client.on_connect = lambda *_: client.subscribe("#", 1)
client.on_message = on_message
client.connect_async("localhost", 1883)
client.loop_forever()
```

Async client example:

```python
import asyncio

from pymosquitto.aio import AsyncMosquitto


async def main():
    async with AsyncMosquitto() as client:
        await client.connect("localhost", 1883)
        await client.subscribe("#", 1)
        async for msg in client.read_messages():
            print(msg)


asyncio.run(main())
```

Check out more examples in `tests` directory.


## Benchmarks

Receiving one million messages with QoS 0.

*The memory plots exclude the Python interpreter overhead (~10.3 MB).

![benchmark-results](./results.png)

Losers excluded:

![benchmark-results-fast](./results_fast.png)

**benchmark.csv**

```text
Module;Time;RSS
pymosq;0:04.84;18940
pymosq_async;0:08.06;25560
pymosq_true_async;0:10.78;25092
paho;0:09.07;23620
gmqtt;0:04.63;24740
mqttools;0:06.57;28068
aiomqtt;0:56.60;578380
amqtt;1:02.72;757084
```


## License

MIT
connectlife 0.5.5
A Python library for communicating with the ConnectLife API
Requires Python: >=3.11

# Python library for ConnectLife API 

Used by devices from Hisense, Gorenje, ASKO & ATAG and ETNA Connect.

The goal of this library is to support a native [Home Assistant](https://www.home-assistant.io/) integration for devices
that uses the ConnectLife API.

The code is based on [Connectlife API proxy / MQTT Home Assistant integration](https://github.com/bilan/connectlife-api-connector)
([MIT license](https://github.com/bilan/connectlife-api-connector/blob/51c6b8e4562205e1c343d0cba19354f411bd5e77/composer.json#L2-L6)).

Software is provided as is - use at your own risk. There is probably no way to harm your physical devices, but
there is no guarantee that you don't experience other problems, for instance locking your ConnectLife account. 

Licensed under [GPLv3](LICENSE).

To test out the library:
```bash
pip install connectlife
python -m connectlife.dump --username <username> --password <password>
```

This will log in to the ConnectLife API using the provided username and password, and print the list of all fields
for all appliances that is registered with the account.

The Home Assistant integration is currently in discovery phase. Please contribute your device dumps to help
the development.

## Test server

To use the test server to support developing the Home Assistant integration, clone this repo and see
[DEVELOPMENT.md](DEVELOPMENT.md#test-server):
remarkable-multidownload 1.0.3
Download multiple files from your remarkable tablet at once.
Requires Python: >=3.10

# remarkable-multidownload

Download multiple files from your reMarkable tablet and save them into a single ZIP archive. The CLI can be installed via pip and then run as `remarkable_multidownload` with options to choose the output file and an optional starting folder on the tablet.

## Installation

- From source (local checkout):
  - pip install -e .
- From PyPI:
  - pip install remarkable-multidownload

Once installed, the console command `remarkable_multidownload` is available.

## Usage

Basic usage (download everything into `example.zip`):

- remarkable_multidownload

Choose a custom output filename:

- remarkable_multidownload --output my_docs.zip

Start from a specific folder on the reMarkable (e.g., a collection called `Notes/Project`):

- remarkable_multidownload --path Notes/Project

Combine both:

- remarkable_multidownload -p Notes/Project -o project_notes.zip

The command shows a progress bar with the current filename while downloading. In non-interactive environments, the progress bar is automatically disabled.

## How it works

- Connects to the reMarkable web interface at 10.11.99.1.
- Recursively lists collections and documents
- Downloads each document as PDF and writes it to the ZIP, preserving folder paths

## Troubleshooting

- Ensure your computer can reach the tablet at 10.11.99.1. Make sure the USB connection is active under Settings > General settings > Storage settings and the tablet is awake.
- If you see network timeouts, try reconnecting the device and ensure it’s awake.
- If you need to narrow the scope, use `--path` to start from a specific collection.