semvec/pypi-packages huggingface dataset:
mom-scrape 0.0.8
Script to parse MOM's website for report and stats updates
Requires Python: >=3.6

# `mom_scrape`

example usage:

```
from mom_scrape.scrapers import ReportScraper, StatsScraper

# this retrieves the MOM reports
# take as input the selinium webdriver
reportscraper=ReportScraper(driver=driver, 
filter_by='Reports',
save_dir='stats/reports')

results=reportscraper.get_info()

# for the StatsScraper (this retrieves the stats)
statsscraper=StatsScraper(driver=driver, 
                        dataset_of_interest=INTEREST[url], 
                        website_link=url, 
                        save_as_zip=True, 
                        save_dir='stats')
# use save_as_zip if you want to save as zip, then send out the email later

results=statsscraper.get_info()

```
## ReportScraper
This first creates a `dates` folder then dump the dates of the various repoerts in the `mom_reports.json` file. Then, the new PDFs (these are PDFs that are not already recorded in `mom_reports.json` file) are downloaded under save_dir

## StatsScraper
Likewise, this also creates dumps the seens dates in the `dates` folder. Then, for new stats, we will download and save it under `self.save_dir` folder
ion-python 1.8.10
Python Binding for ion-kit
Requires Python: >=3.8.0

# ionpy - Python binding for ion-kit

```
pip3 install "git+https://github.com/fixstars/ion-kit.git#egg=ionpy&subdirectory=python"
```

## Test

```
LD_LIBRARY_PATH=<path-to-ion-libs> PYTHONPATH=. pytest ./tests/
```
featureform 1.15.8
Package for the Featureform Feature Store
Requires Python: >=3.9

# Featureform Python Client

## Overview

Featureform’s Python client is a SDK for defining, managing and serving resources (e.g. infrastructure providers, data sources, transformations, etc.). At a high level, the API is divided into two parts:

* Registration: register data stores (e.g. PostgreSQL), data sources (e.g. tables or CSV files) as resources or get and/or list previously registered resources
* Serving: retrieve training sets and features for offline training or online inference

## Requirements

* Python 3.9-3.12

## Setting Up Your Local Development Environment

### Step 1: Install gRPC and Protocol Buffer Tooling

See grpc.io for instructions on installing the [protocol buffer compiler](https://grpc.io/docs/protoc-installation/) for your OS and language-specific plugins for [Golang](https://grpc.io/docs/languages/go/quickstart/#prerequisites) (**NOTE**: the Golang dependencies can also be installed via [Homebrew](https://brew.sh/).)

### Step 2: Create Python Virtual Environment

You may create a Python virtual environment however you prefer, but the directory name `.venv` is ignored by Git for convenience, so you may choose to create your virtual environment in the root of the project.

```shell
> python -m venv .venv && . .venv/bin/activate
(.venv) >
```

### Step 3: Upgrade pip and Install Build Dependencies

The following dependencies are required to build the client:

* [build](https://pypi.org/project/build/)
* [pytest](https://pypi.org/project/pytest/)
* [python-dotenv](https://pypi.org/project/python-dotenv/)
* [pytest-mock](https://pypi.org/project/pytest-mock/)

```shell
(.venv) > python -m pip install --upgrade pip
(.venv) > python -m pip install -r requirements.txt
```

### Step 4: Compile API Protocol Buffers and Python Stub

The shell script `gen_grpc.sh` has been provided for convenience. Change the file access permissions to make it executable and run it:

```shell
(.venv) > chmod +x gen_grpc.sh
(.venv) > ./gen_grpc.sh
```

### Step 5: Build Python Client and Dashboard

The shell script `pip_update.sh` has been provided for convenience. Change the file access permissions to make it executable and run it:

```shell
(.venv) > chmod +x pip_update.sh
(.venv) > ./pip_update.sh
```

### Step 6: Optionally Run Client Test Suite

To ensure your changes haven’t broken the client, run the test suite with the following make target:

```shell
(.venv) > make pytest
```

## Outcome

With steps 1-5 successfully completed, you should have the `featureform` CLI command accessible in your terminal session.

```shell
(.venv) > featureform -h
```

To further verify that your setup is complete and correct, you may optionally walk through the [Quickstart](https://docs.featureform.com/quickstart-local) tutorial. You may put the `definitions.py` file at the root of the project, which won’t be ignored by Git, or use a URL to a file (e.g. hosted on GitHub).
pyostrap 2025.4.11.0
A Python wrapper for the Biostrap REST API
Requires Python: >=3.8

# pyostrap
Python wrapper for Biostrap API

## Installing Pyostrap and Supported Versions

Pyostrap is available on PyPI:

```console
$ pip install pyostrap
```

Pyostrap officially supports Python 3.12+ and HTTP/2 protocol.

### Dependencies

Pyostrap project utilizes the httpx library - the HTTP client library for Python 3.

## Release Information
- `2025.04.11.0` added support for HTTP/2 protocol (#20)
- `2024.11.12.2` added granularity in user steps data retrieved (#16)
- `2024.11.4.7` implemented biometrics endpoint (#2)
- `2024.6.20.2` implemented lock/unlock device and user calories details endpoints (#3, #10)
r2-transformations 0.1.0
Library for rigid-body transformations, including velocities and forces.
Requires Python: >=3.10

# Transformations

Forked version of the
[DeepMind Robotics `transformations` library][dm_robotics-transformations]
which makes the JAX dependency optional, for lighterweight setups.

Transformations is a pure Python library for rigid-body transformations
including velocities and forces.

The objectives for this library are **simplicity** and **comprehensiveness**
across all canonical representations (euler, axis-angle, quaternion,
homogeneous matrices).

## Supported conversions

*   Quaternion to Rotation matrix, Axis-angle and Euler-angle
*   Axis-angle to Quaternion, Rotation matrix and Euler-angle
*   Rotation matrix to Quaternion, Axis-angle and Euler-angle
*   Euler-angle to Quaternion, Rotation matrix and Axis-angle

## Quaternions

Quaternions are represented with the scalar part (w) first, e.g.

```python
identity_quaternion = np.asarray([1, 0, 0, 0])  # w, i, j, k
```

Supported quaternion operations:

*   Difference
*   Distance
*   Multiplication
*   Inverse
*   Conjugate
*   Logarithm and Exponent
*   Slerp (spherical linear interpolation)
*   Rotation of a vector by a quaternion.

## Euler-angles

All 24 from-euler orderings are supported.
7 of 24 to-euler orderings are supported.

## Transforms

This library supports force and velocity transforms.

## Usage Example

```python
from dm_robotics.transformations import transformations as tr

# Convert a pose, euler angle into a homogeneous matrix (a 4x4 matrix):
hmat = tr.poseuler_to_hmat(
        np.array([x, y, z, rot_x, rot_y, rot_z]), 'XYZ')

# Convert the homogeneous matrix to a twist (a 6 vector):
twist = tr.hmat_to_twist(hmat)
```

[dm_robotics-transformations]: <https://github.com/google-deepmind/dm_robotics/tree/main/py/transformations>
minihtml 0.2.3
Simple HTML Generation
Requires Python: >=3.10

# minihtml - Simple HTML Generation

[![PyPI - Version](https://img.shields.io/pypi/v/minihtml)](https://pypi.org/project/minihtml/)

minihtml is a library to generate HTML documents from Python. It aims to
provide an API that allows you to define the structure of an HTML document in a
succinct and natural way.

By building up nested HTML elements using context managers, you can combine
HTML generation with control flow statements in a way that is easy to read and
does not obscure the structure of the resulting HTML document.

## Installation

Install the `minihtml` package from PyPI:

    pip install minihtml

or

    uv add minihtml

## Example

A basic "hello, world" example:

~~~python
>>> from minihtml.tags import html, head, title, body, div, p, a, img
>>> with html(lang="en") as elem:
...     with head:
...         title("hello, world!")
...     with body, div["#content main"]:
...         p("Welcome to ", a(href="https://example.com/")("my website"))
...         img(src="hello.png", alt="hello")
...
<...>

>>> print(elem)
<html lang="en">
  <head>
    <title>hello, world!</title>
  </head>
  <body>
    <div id="content" class="main">
      <p>Welcome to <a href="https://example.com/">my website</a></p>
      <img src="hello.png" alt="hello">
    </div>
  </body>
</html>

~~~

## Links

- [Documentation](https://minihtml.trendels.name/)
- [Changelog](https://github.com/trendels/minihtml/blob/main/Changelog.md)
- [PyPI project page](https://pypi.org/project/minihtml/)

## License

Minihtml is released under the MIT license. See [LICENSE](LICENSE) for more information.
emmett-pydal 17.3.2
a pure Python Database Abstraction Layer
Requires Python: >=3.8

# pyDAL

pyDAL is a pure Python Database Abstraction Layer.

It dynamically generates the SQL in real time using the specified dialect for the database back end, so that you do not have to write SQL code or learn different SQL dialects (the term SQL is used generically), and your code will be portable among different types of databases.

pyDAL comes from the original web2py's DAL, with the aim of being wide-compatible. pyDAL doesn't require web2py and can be used in any Python context.

[![pip version](https://img.shields.io/pypi/v/pydal.svg?style=flat-square)](https://pypi.python.org/pypi/pydal)
[![Build Status](https://img.shields.io/travis/web2py/pydal/master.svg?style=flat-square&label=Travis-CI)](https://travis-ci.org/web2py/pydal)
[![MS Build Status](https://img.shields.io/appveyor/ci/web2py/pydal/master.svg?style=flat-square&label=Appveyor-CI)](https://ci.appveyor.com/project/web2py/pydal)
[![Coverage Status](https://img.shields.io/codecov/c/github/web2py/pydal.svg?style=flat-square)](https://codecov.io/github/web2py/pydal)
[![API Docs Status](https://readthedocs.org/projects/pydal/badge/?version=latest&style=flat-square)](http://pydal.rtfd.org/)

## Installation

You can install pyDAL using pip:

    pip install pyDAL

## Usage and documentation

Here is a quick example:

    >>> from pydal import DAL, Field
    >>> db = DAL('sqlite://storage.db')
    >>> db.define_table('thing',Field('name'))
    >>> db.thing.insert(name='Chair')
    >>> query = db.thing.name.startswith('C')
    >>> rows = db(query).select()
    >>> print rows[0].name
    Chair
    >>> db.commit()

The complete documentation is available on http://www.web2py.com/books/default/chapter/29/06/the-database-abstraction-layer

## What's in the box?

A little *taste* of pyDAL features:

* Transactions
* Aggregates
* Inner Joins
* Outer Joins
* Nested Selects

## Which databases are supported?

pyDAL actually support these databases:

* sqlite
* postgresql
* mysql
* mssql
* db2
* firebird
* sybase
* oracle
* informix
* teradata
* sapdb
* ingres
* cubrid
* imap
* mongodb

## License

pyDAL is released under the BSD-3c License.
For further details, please check the `LICENSE` file.