semvec/pypi-packages huggingface dataset:
sdsort 0.3.1
Sorts functions and class methods according to the step-down rule
Requires Python: >=3.10

# sdsort

Sorts **top-level functions** and **class methods** in Python files according to the step-down rule, as described in [Robert C. Martin's](https://en.wikipedia.org/wiki/Robert_C._Martin) [Clean Code](https://www.oreilly.com/library/view/clean-code-a/9780136083238/).
More concretely, functions and methods are ordered in a depth-first-traversal order of the dependency tree, so higher-level code appears before lower-level code.

## Installation

`pip install sdsort`

Or run directly with [uv](https://docs.astral.sh/uv/):

`uvx sdsort <path>`

## Usage

To target individual files, run the `sdsort` command, followed by the paths to the files that should be sorted:

```bash
sdsort <file_1> <file_2>
```

To sort all `*.py` files in a directory, and all of its subdirectories, run the `sdsort` command followed by the directory path:

```bash
sdsort <directory_path>
```

To check if files are already sorted without modifying them, use the `--check` flag:

```bash
sdsort --check <file_or_directory>
```

This will exit with code 1 if any files would be re-arranged, making it suitable for CI pipelines and pre-commit hooks.

## Maturity

It's early days. Consider this an alpha for now.
olarmflowclient 1.0.6
The official asynchronous Python client for the Olarm Public API.
Requires Python: >=3.10
Keywords: olarm, api, security, alarm, asyncio

# OlarmFlowClient

## About Olarm

[Olarm](https://www.olarm.com) is a smart security company that transforms existing alarm systems into connected, app-controlled security solutions. Their products work with major alarm panels (Paradox, DSC, Texecom, IDS, Honeywell and more) to provide remote control, real-time alerts, and comprehensive security management from anywhere.

## Python Client

This is the official asynchronous Python client for interacting with the Olarm Public API.
For more information about our Olarm Public API, please see our official API documentation on our platform.

## Features

*   Fetch your devices information and state
*   Send commands to devices (arm, disarm, stay, sleep, bypass zones, control PGM etc..).
*   Subscribe to real-time state changes and events using MQTT

## Quick Start

1. Sign up at https://login.olarm.com
2. Go to API section, generate token
3. `pip install olarmflowclient`
4. Copy this code:
```
import asyncio
from olarmflowclient import OlarmFlowClient

async def main():
    async with OlarmFlowClient("your-token-here") as client:
        devices = await client.get_devices()
        print(f"You have {len(devices['data'])} devices")

# For non-async code:
import asyncio
result = asyncio.run(main())
```

Please check the examples for more uses!

## Examples

The repository includes example scripts that demonstrate how to use the library:

```bash
# Run the fetch devices example
python examples/fetch_devices.py --api-token YOUR_API_TOKEN

# Run the fetch devices example
python examples/fetch_device.py --api-token YOUR_API_TOKEN --device-id DEVICE_ID

# Run the MQTT events listener example
python examples/subscribe_device_mqtt.py --api-token YOUR_API_TOKEN --user-id YOUR_USER_ID
```
NOTE: you can find your User ID in the Olarm user portal

This library provides asynchronous access using `aiohttp` for API calls and `paho-mqtt` for real-time event handling via MQTT.

## Development

1.  Clone the repository.
2.  Setup venv if necessary
    ```bash
    python3 -m venv venv
    source venv/bin/activate # other shells might be different 
    ```
3.  Install dependencies:
    ```bash
    pip3 install -r requirements.txt
    ```
4.  Format code and check for linting errors using Ruff:
    ```bash
    # Check for issues
    python3 -m ruff check .

    # Fix issues and format code
    python3 -m ruff check . --fix
    python3 -m ruff format .
    ```

## Running Tests

The project uses pytest and pytest-asyncio for testing. To run the tests:

1. Make sure you have the testing dependencies installed:
   ```bash
   pip install -r requirements.txt
   ```

2. Run the tests with pytest:
   ```bash
   python -m pytest
   ```

## Issues / Feature Requests

Please log issues and feature requests in Github issues 👆

## Contributing

Contributions are welcome! Please open an issue or submit a pull request.
dbwarden 0.1.3.1
Database migration system for Python/SQLAlchemy projects
Requires Python: >=3.10
Keywords: database, fastapi, migrations, postgres, sqlalchemy

<div align="center">

# DBWarden

A database migration system for Python/SQLAlchemy projects.

<a href="https://emiliano-gandini-outeda.github.io/DBWarden/">
  <img src="https://img.shields.io/badge/docs-mkdocs-blue.svg" alt="Documentation">
</a>
<a href="https://deepwiki.com/emiliano-gandini-outeda/DBWarden">
  <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki">
</a>

</div>

## Installation

```bash
pip install dbwarden
```

## Configuration

Create `warden.toml` in your project:

```toml
sqlalchemy_url = "sqlite:///./development.db"
async = false
```

Or use environment variables:

```env
DBWARDEN_SQLALCHEMY_URL=postgresql://user:pass@localhost/db
DBWARDEN_ASYNC=false  # or true for async mode
```

## Basic Commands

| Command | Description |
|---------|-------------|
| `dbwarden init` | Initialize migrations directory |
| `dbwarden make-migrations "name"` | Generate SQL from SQLAlchemy models |
| `dbwarden migrate` | Apply pending migrations |
| `dbwarden migrate --verbose` | Apply with detailed logging |
| `dbwarden rollback` | Revert the last migration |
| `dbwarden history` | Show migration history |
| `dbwarden status` | Show current status |
| `dbwarden mode` | Show sync/async mode |
| `dbwarden check-db` | Inspect DB schema |
| `dbwarden diff` | Show models vs DB differences |

## SQLAlchemy Models

DBWarden automatically detects models in `models/`:

```python
# models/user.py
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    email = Column(String(255), unique=True)
```

## Complete Example

```bash
# 1. Initialize
dbwarden init

# 2. Create models in models/

# 3. Generate migration from models
dbwarden make-migrations "create users table"

# 4. Apply
dbwarden migrate --verbose

# 5. View history
dbwarden history
```

## Environment Variables

| Variable | Description |
|----------|-------------|
| `DBWARDEN_SQLALCHEMY_URL` | DB connection URL |
| `DBWARDEN_ASYNC` | Async mode (`true`/`false`) |
| `DBWARDEN_MODEL_PATHS` | Paths to SQLAlchemy models |

## Supported Databases

- PostgreSQL (sync + async)
- SQLite (sync + async)
- MySQL (sync)

## Docs

For more information, see [DBWarden Docs](http://emiliano-gandini-outeda.me/DBWarden/) or [DBWarden DeepWiki page](https://deepwiki.com/emiliano-gandini-outeda/DBWarden)

## License

This Project is Licensed under the MIT License. See [LICENSE](https://github.com/emiliano-gandini-outeda/DBWarden/blob/main/LICENSE)
sagemaker-studio-dataengineering-extensions 1.3.7
A python Package to enhance experience of SageMaker Unified Studio
Requires Python: >=3.11
Keywords: AWS, Amazon, Data Engineering, SageMaker, SageMaker Unified Studio

# SageMakerStudioDataEngineeringExtensions

SageMaker Unified Studio Data Engineering Extensions

This package contains several extensions that enhance the experiences for SageMakerStudioDataEngineeringSessions.

This pacakge is depend on SageMaker Unified Studio environment.

## List of extensions

- SageMaker Connection Magic JupyterLab Extension
- SageMaker Data Explorer
- SageMaker Jupyter Server Extension
- SageMaker Spark Monitor
- SageMaker Unified Studio Theme
- SageMaker UI Doc Manger JupyterLag Plugin

## How to install these extensions

### Conda
For Conda users, if you install this package via Conda, all of these extensions are installed by default.

### PyPi
For PyPi users, if you install this package via pip install,  all of these extensions are installed by default.

## Extension Details

### SageMaker Connection Magic JupyterLab Extension

This package contains a JupyterLab extension which provides a user-friendly experience for switching between different computes. For example, you can use this extension to easily switch from local python compute to different remote computes like EMR Cluster/Glue/EMR-Serverless.

### SageMaker Data Explorer

This package contains a JupyterLab extension which provides a side tab inside JupyterLab. That tab supports browsering data from different data source like Redshift/S3/LakeHouse.


### SageMaker Jupyter Server Extension

This package contains some Jupyter Server api to support other extensions in SageMaker Unified Studio.

### SageMaker Spark Monitor

This package contains a JupyterLab extension which provides a widget showing the progress of a running spark application in remote compute.

#### Setup

To load this extension, make sure you have iPython config file generated. If not, you could run `ipython profile create`, then a file with path `~/.ipython/profile_default/ipython_config.py` should be generated

Then you will need to add the following line in the end of that config file

```
c.InteractiveShellApp.extensions.extend(['sagemaker_sparkmonitor.kernelextension'])
```

once that config is added, restart the JupyterLab kernel to make the config change apply

### SageMaker Unified Studio Theme

This package contains a custom Theme for SageMaker Unified Studio

### SageMaker UI Doc Manger JupyterLag Plugin

This package is a JupyterLab extension which supports a shortcut from SageMaker Unified Studio portal to open a notebook in JupyterLab.
ned-client 0.0.3
A terminal interface for Spotify
Requires Python: >=3.9
Keywords: spotify, tui

# ned
[![Build Python Package](https://github.com/Jackkillian/ned/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Jackkillian/ned/actions/workflows/python-publish.yml) [![PyPI](https://img.shields.io/pypi/v/ned-client?label=pypi%20package)](https://pypi.org/project/ned-client/)

-----

![demo](https://raw.githubusercontent.com/Jackkillian/ned/master/demo.png)

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation
**NOTE: This project is under heavy development.**

### Simple
Install ned with pip:
```console
pip install ned-client
```

Run ned in your terminal:
```console
ned
```

### Advanced
To test the latest build for yourself, clone and run
```console
hatch run ned
```

## License
`ned` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
mixtrain 0.1.37
Mixtrain SDK and CLI
Requires Python: >=3.10

# Mixtrain

**Mixtrain** is a Python SDK and CLI for [mixtrain.ai](https://mixtrain.ai) platform.

## Installation

Using uv

```bash
uv add mixtrain
```
or if you use pip

```bash
pip install mixtrain
```

Refer to https://mixtrain.ai/docs for more details.
uvdat-flood-sim 1.0.3
An end-to-end dynamic flood simulation.
Requires Python: >=3.10

# Dynamic Flood Simulations

Created in collaboration with Northeastern University

## Overview

This end-to-end dynamic flood simulation is intended for use with the Analytics workflow in [UVDAT (Urban Visualization and Data Analysis Toolkit)](https://github.com/OpenGeoscience/uvdat). This module consists of three parts: downscaling prediction, hydrological prediction, and hydrodynamic prediction.

## Explanation

First, an AI downscaling model uses regional climate projections to determine future local precipitation conditions, such as the intensity of extreme rainstorms. These extreme precipitation levels are fed into a hydrological model, which uses precipitation and evapotranspiration to determine runoff and discharge. Finally, a hydrodynamic model uses discharge to map flood depth over time.

This is a proof of concept for the Charles River in Boston that could be translated to other rivers and cities. The user selects the inputs described below, and the output is a flood simulation, represented as a multiframe stacked GeoTIFF raster, a time-varying map of flood depth with one frame per hour for 24 hours.

## Inputs

1. Time Period: the 20 year time period in which to predict a flood. Options are "2031-2050" and "2041-2060" (the former is the default).

2. Annual Probability: the probability that a flood of this magnitude will occur in any given year. This value must be greater than 0 and less than 1. The default is 0.04, which represents a 1 in 25 year flood.

3. Hydrograph: a list of proportions that sum to 1; these represent fractions of the total rainfall volume per timestep. This may also be specified as Hydrograph Name, where options include "short_charles" and "long_charles", which represent premade hydrograph data. The former is the default.

4. Potential Evapotranspiration Percentile: Select the percentile value for potential evapotranspiration

5. Soil Moisture Percentile: Select the percentile value for soil moisture

6. Ground Water Percentile: Select the percentile value for ground water

7. Initial Condition Set: Initial conditions "001", "002", and "003" start real-world emissions from year 1850 with the climate state from the 1001st, 1021st, and 1041st year of a pre-industrial control simulation. Since Earth's climate undergoes multi-year and multi-decadal cycles, the different initializations reveal the range of possible climates in real-world years 2031 and beyond.

## Installation

```
pip install uvdat-flood-sim
```

## Example usage

To run a flood simulation with default inputs:

```
python -m uvdat_flood_sim
```

To see the help menu explaining how to use arguments to specify input values:

```
python -m uvdat_flood_sim --help
```

## Viewing Results

By default, results will be displayed with a `matplotlib` animation. This animation is saved in the outputs folder as `animation.gif`. Results are also saved in the outputs folder as a multiframe geospatial tiff called `flood_simulation.tif`, which can be added to UVDAT for visualization.