semvec/pypi-packages huggingface dataset:
simbapy 0.4.1
System identification Methods leveraging Backpropagation
Requires Python: <4.0,>=3.10

# SIMBa
## System Identification Methods with Backpropagation

**SIMBa** (**S**ystem **I**dentification **M**ethods leveraging **B**ackpropagation) is an open-source toolbox leveraging Pytorch's Automatic Differentiation framework for stable state-space linear SysID. It allows the user to incorporate prior knowledge (like sparsity patterns of the state-space matrices) during the identification procedure.

## Intallation
SIMBa is available on pypi, it can be installed with `pip install simbapy`.  
Note that this will NOT install SIPPY or matlabengine to avoid compatibility issues (typically dependent on your MATLAB version). You can install them separately to allow Simba's initialization properties.

Alternatively, you can clone this github repository to use simba locally.

## Compatibility with matlab
If matlab is installed on your machine, you can install `matlabengine`. If you are on the latest version of MATLAB, `pip install matlabengine` works, otherwise you might need to install an older version of matlabengine. See [here](https://pypi.org/project/matlabengine) the supported version of MATLAB.  
SIMBa needs access the `System Identification Toolbox` and `Symbolic Math Toolbox` in MATLAB.  
You can disable the use of matlab by overwriting `IS_MATLAB` in `simba.parameters`

## Project status
SIMBa was first presented in [Stable Linear Subspace Identification: A Machine Learning Approach](https://arxiv.org/pdf/2311.03197.pdf) and subsequently extended in [SIMBa: System Identification Methods leveraging Backpropagation](https://arxiv.org/pdf/2311.13889.pdf).

## Known issue
### For SIPPY users
There seems to be a bug in the `control` library when the dimension of the control input is one, which raises an unwanted exception.  
This does not affect SIMBa in general but can fail is `SIPPY` is required (e.g., for SIMBa's initialization).

To correct it, you'll need to go to `timeresp.py` in the library, typically located in your virtual environment at `.venv/lib/python3.x/site-packages/control/` and add the following transpose at line 1002, before `_check_convert_array`:

    if len(U.shape) > 1:
        U = U.T

## Contact

This project is jointly led by Loris Di Natale and Muhammad Zakwan, with the participation of Bratislav Svetozarevic, Philipp Heer, Giancarlo Ferrari Trecate, and Colin N. Jones.  
Urban Energy Systems Lab, Empa, Switzerland  
Laboratoire d'Automatique, EPFL, Switzerland  

For more information, please contact loris.dinatale@alumni.epfl.ch
megaparse-sdk 0.1.12
Megaparse SDK
Requires Python: >=3.11

## MegaParse SDK

Welcome to the MegaParse SDK! This SDK allows you to easily interact with the MegaParse API to upload URLs and files for processing.

### Installation

To install the MegaParse SDK, use pip:

```sh
pip install megaparse-sdk
```

### Usage

Here is an example of how to use the MegaParse SDK:

#### Uploading URLs

```python
import asyncio
import os

from megaparse.sdk import MegaParseSDK

async def upload_url():
    api_key = str(os.getenv("MEGAPARSE_API_KEY"))
    megaparse = MegaParseSDK(api_key)

    url = "https://www.quivr.com"

    # Upload a URL
    url_response = await megaparse.url.upload(url)
    print(f"\n----- URL Response : {url} -----\n")
    print(url_response)

    await megaparse.close()

if __name__ == "__main__":
    asyncio.run(upload_url())
```

#### Uploading Files

```python
import asyncio
import os

from megaparse.sdk import MegaParseSDK

async def upload_file():
    api_key = str(os.getenv("MEGAPARSE_API_KEY"))
    megaparse = MegaParseSDK(api_key)

    file_path = "your/file/path.pdf"
    # Upload a file
    response = await megaparse.file.upload(
        file_path=file_path,
        method="unstructured",  # unstructured, llama_parser, megaparse_vision
        strategy="auto",
    )
    print(f"\n----- File Response : {file_path} -----\n")
    print(response)

    await megaparse.close()

if __name__ == "__main__":
    asyncio.run(upload_file())
```

### Features

- **Upload URLs**: Easily upload URLs for processing.
- **Upload Files**: Upload files with different processing methods and strategies.

### Getting Started

1. **Set up your API key**: Make sure to set the `MEGAPARSE_API_KEY` environment variable with your MegaParse API key.
2. **Run the example**: Use the provided example to see how to upload URLs and files.

For more details, refer to the [usage example](#file:usage_example.py-context).

We hope you find the MegaParse SDK useful for your projects!

Enjoy, _Quivr Team_ !
ecommerce-toolkit 0.1.1
A unified interface for e-commerce platform APIs
Requires Python: >=3.8

# E-commerce Toolkit

A unified interface for interacting with various e-commerce platform APIs. Currently supports Shopify and WooCommerce.

## Features

- Automatic platform detection
- Simple, unified interface for all supported platforms
- Environment-based configuration
- Product listing, search, and detailed view capabilities

## Installation

```bash
pip install ecommerce-toolkit
```

## Quick Start

1. Set up your environment variables in a `.env` file:

```env
STORE_URL=your-store.com
STORE_TYPE=shopify  # or woocommerce

# For Shopify
SHOPIFY_ACCESS_TOKEN=your_access_token

# For WooCommerce
WOO_CONSUMER_KEY=your_consumer_key
WOO_CONSUMER_SECRET=your_consumer_secret
```

2. Use the toolkit:

```python
from ecommerce_toolkit import toolkit

# List all products
products = toolkit.list_all_products()

# Search for products
results = toolkit.search_store("t-shirt")

# Get specific product
product = toolkit.get_product_details("123")
```

## Development

1. Clone the repository
2. Create a virtual environment:

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

3. Install development dependencies:

```bash
pip install -e ".[dev]"
```

4. Run tests:

```bash
pytest tests/
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Structure

ecommerce_toolkit/
│
├── src/
│ └── ecommerce_toolkit/
│ ├── **init**.py
│ ├── providers/
│ │ ├── **init**.py
│ │ ├── base.py # Contains EcommerceProvider ABC
│ │ ├── shopify.py # ShopifyProvider implementation
│ │ └── woocommerce.py # WooCommerceProvider implementation
│ ├── models/
│ │ ├── **init**.py
│ │ └── product.py # Product dataclass
│ ├── config.py # StoreConfig class
│ └── toolkit.py # Main EcommerceToolkit class
│
├── tests/
│ ├── **init**.py
│ ├── test_shopify.py
│ ├── test_woocommerce.py
│ └── test_toolkit.py
│
├── examples/
│ ├── basic_usage.py
│ └── advanced_usage.py
│
├── .env.example
├── .gitignore
├── LICENSE
├── MANIFEST.in
├── pyproject.toml
├── README.md
└── requirements.txt
url-matcher 0.6.0
URL matching rules library to connect URLs with resources
Requires Python: >=3.9

===========
url-matcher
===========

.. image:: https://img.shields.io/pypi/v/url-matcher.svg
   :target: https://pypi.python.org/pypi/url-matcher
   :alt: PyPI Version

.. image:: https://img.shields.io/pypi/pyversions/url-matcher.svg
   :target: https://pypi.python.org/pypi/url-matcher
   :alt: Supported Python Versions

.. image:: https://github.com/zytedata/url-matcher/workflows/tox/badge.svg
   :target: https://github.com/zytedata/url-matcher/actions
   :alt: Build Status

.. image:: https://codecov.io/github/zytedata/url-matcher/coverage.svg?branch=main
   :target: https://codecov.io/gh/zytedata/url-matcher
   :alt: Coverage report


URL matching library that relates URLs with resources. Rules are defined using
simple pattern definitions. It is simpler and faster than using regular expressions
if the rules involves many domains.

To illustrate it with an example, imagine that you have several proxy servers and
you want to route requests to the right one. You could define the following rules:

* ``site1.com`` →︎ ``us_proxy``
* ``site2.com/uk`` →︎ ``uk_proxy``
* ``site2.com/ie`` →︎ ``ie_proxy``

All URLs from ``site1.com`` should use the US proxy. The situation for ``site2.com`` URLs are
different: if the path starts with ``/uk``, then use the UK proxy, otherwise use the IE proxy.
This library allows to create a matcher that can be used to match URLs with the right proxy
using these rules.

Have a look to https://github.com/zytedata/url-matcher/blob/main/url_matcher/example.py
for an example of usage.

The following files are useful to understand the pattern, the set of patterns and
how they behave:

* https://github.com/zytedata/url-matcher/blob/main/tests/fixtures/single_patterns.json
* https://github.com/zytedata/url-matcher/blob/main/tests/fixtures/patterns.json

The full documentation can be found at https://url-matcher.readthedocs.io/

License is BSD 3-clause.

* Documentation: https://url-matcher.readthedocs.io/
* Source code: https://github.com/zytedata/url-matcher
* Issue tracker: https://github.com/zytedata/url-matcher/issues


Developing
**********

Setup your local Python environment via:

1. ``pip install -r requirements-dev.txt``
2. ``pre-commit install``

Now everytime you perform a ``git commit``, these tools will run against the staged files:

* ``black``
* ``isort``
* ``flake8``
* ``mypy``

You can also directly invoke ``pre-commit run --all-files`` to run them without performing a commit.


Using sphinx-autobuild
~~~~~~~~~~~~~~~~~~~~~~

When working on documentation, it is convenient to use sphinx-autobuild.
First, run ``pip install -r docs/requirements.txt sphinx-autobuild``. Then run

::

    sphinx-autobuild docs docs/_build/html

and then open http://127.0.0.1:8000/ in a browser, to see the current version
of docs. A process would be running in a background, watching for docs changes;
when docs are changed, a build is started, and the web page
is refreshed automatically when the build is finished.
autonomize-sdk-python-beta 0.0.47
Autonomize Python SDK
Requires Python: <4.0,>=3.12

# Autonomize SDK for Python

The Autonomize SDK for Python provides a comprehensive set of tools and utilities for integrating with Autonomize services. This SDK includes modules for telemetry, monitoring, and other essential services.

## Modules

The Autonomize SDK provides specialized modules for different aspects of application development and monitoring. Below is a detailed overview of each module:

### [Telemetry](./autonomize_sdk/telemetry/README.md)

The Telemetry module provides comprehensive observability for your applications through OpenTelemetry integration.

- **Distributed Tracing**: Track requests across service boundaries
- **Metrics Collection**: Monitor application performance and business metrics
- **Structured Logging**: Centralized logging with context and correlation
- **Automatic Instrumentation**: Built-in support for popular frameworks
- **Custom Measurements**: Create and track your own metrics and traces

## Installation

Install using pip:

```bash
pip install autonomize-sdk-python-beta
```

Or using Poetry:

```bash
poetry add autonomize-sdk-python-beta
```

## Development Setup

1. Clone the repository:
```bash
git clone https://github.com/autonomize-ai/autonomize-sdk-python.git
```

2. Install dependencies using Poetry:
```bash
poetry install
```

3. Set up pre-commit hooks:
```bash
poetry run pre-commit install
```

## Contributing

We love your input! We want to make contributing as easy and transparent as possible.

Please read our [**Contributing Guide**](CONTRIBUTING.md) before making any changes.

Together, we can make Autonomize SDK better! 🌟
pyemmesteel 0.0.1
Python Emmesteel Integration
Requires Python: >=3.8

# Emmesteel

Library for connecting to Emmesteel Digital Heat Controller.
This is the Digital Controller used in the italian-made towel warmers sold by [Amba](https://ambaproducts.com/) like the modello i, etc

## Background

### No Wifi Config Possible
The uses a dedicated Wifi AP for user-device control but it does not allow you to provide a wifi setting for the device to use.
To make any changes to the device settings or remotely control it, you must always temporarily connec to the device AP.

### No Scheduling
Furthermore, the software does not allowing scheduling start/end, only a shut-off timer.

### Solution
To get around these limitation, I developed a library that can communicate and control the device and a Home Assistant Integration to manage it.
For the Wifi AP problem, I decided to use a RaspberryPi as a proxy. The Pi connects to both wifi networks simutaneously, and then proxies home network requests to the device via the device's custome wifi network.

The Pi proxy also helps solve a very low wifi signal that is caused by the controller being inside a metal junction box.

## Network Setup - Summary
1. Setup a RaspberryPi with default OS and connect it to your home wifi
2. Use NetworkManager and a second wifi dongle to connect the pi to the towel warmer SSID (e.g. `EMMESTEEL_24TS00112`)
3. Use iptables to proxy home network requests to the device on `EMMESTEEL_24TS00112`

### Step-by-step

#### Network Manager
```
sudo nmcli connection add type wifi ifname wlan1 con-name EMMESTEEL_<SERIAL> ssid EMMESTEEL_<SERIAL>
sudo nmcli connection modify EMMESTEEL_<SERIAL> wifi-sec.key-mgmt wpa-psk
sudo nmcli connection modify EMMESTEEL_<SERIAL> wifi-sec.psk "<PWD>"
sudo nmcli connection up EMMESTEEL_<SERIAL>
```

#### Iptables

Setup Ip Forwarding
```
sudo sysctl net.ipv4.ip_forward
```

If not 1 use `sudo sysctl -w net.ipv4.ip_forward=1` and uncomment line in `/etc/sysctl.conf` to make it permanent`

```
sudo iptables -t nat -A PREROUTING -i wlan0 -p tcp --dport 80 -j DNAT --to-destination 192.168.X.X:80
sudo iptables -t nat -A POSTROUTING -o wlan1 -j MASQUERADE

sudo apt install iptables-persistent
sudo mkdir -p /etc/iptables
sudo iptables-save | sudo tee /etc/iptables/rules.v4
sudo nano /etc/rc.local
sudo iptables-restore < /etc/iptables/rules.v4
sudo chmod +x /etc/rc.local
sudo iptables-save > /etc/iptables/rules.v4
sudo reboot
```

## Verify
1. Laptop can ping pi proxy
2. Pi is connected to `EMMESTEEL_` (iwconfig)
3. Pi can curl `192.168.1.1` which is `EMMESTEEL_` router ip.
4. Assuming the above is working and iptables routing is correct,
5. curl `<pi-ip>/` should return the emmesteel UI.

## Take Control

Finally, you can use the `home-assistant` custom integration to see the status, power on/off, adjust heating level, etc.
tei-chunker 0.1.0
Hierarchical document chunking for TEI XML documents
Requires Python: >=3.8
Keywords: chunking, documents, nlp, tei, xml

# tei-chunker
Document chunker specialized for TEI XML (i.e. GROBID outputs from academic PDF parsing)

https://www.tei-c.org/  
https://github.com/kermitt2/grobid

```
tei-chunker/
├── .github/
│   └── workflows/
│       ├── docker.yml
│       └── publish.yml
├── examples/
│   └── github-workflow.yml
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_chunking.py
│   ├── test_document.py
│   └── test_github_utils.py
├── tei_chunker/
│   ├── __init__.py
│   ├── __about__.py
│   ├── chunking.py
│   ├── document.py
│   ├── github_utils.py
│   └── service.py
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
└── pyproject.toml
```