semvec/pypi-packages huggingface dataset:
heroku-manager 0.1.2
A package for managing Heroku dynos with autoscaling capabilities
Requires Python: >=3.6

# Heroku Manager

A Python package for managing Heroku dynos with autoscaling capabilities.

## Features

- Automatic scaling of Heroku dynos based on memory usage and load
- Monitoring of dyno health and performance
- Automatic restart of unresponsive dynos
- Integration with Django for caching and configuration

## Installation

```bash
pip install heroku-manager
```

## Usage

```python
from heroku_manager import HerokuManager

# Get the autoscaler instance
autoscaler = HerokuManager.get_autoscaler()

# Start continuous autoscaling
autoscaler.start_continuous_autoscale()

# Manual scaling operations
if autoscaler.requires_upscale:
    autoscaler.upscale_formation_to_next_level()
elif autoscaler.allow_downscale:
    autoscaler.downscale_formation_to_original_size()

# Stop autoscaling
autoscaler.stop_continuous_autoscale()
```

## Configuration

The package requires the following environment variables:

- `HEROKU_API_KEY`: Your Heroku API key
- `HEROKU_APP_NAME`: The name of your Heroku app
- `DYNO`: The name of the current dyno (automatically set by Heroku)

## Django Settings

When used with Django, the following settings are available:

- `DYNO_CONTINUOS_AUTOSCALE_ENABLED`: Enable continuous autoscaling
- `DYNO_AUTOSCALE_INTERVAL`: Interval between autoscale checks (in seconds)
- `DYNO_TIME_BETWEEN_SCALES`: Minimum time between scaling operations (in seconds)
- `DYNO_MIN_UPSCALE_DURATION`: Minimum duration to keep a dyno upscaled (in seconds)
- `DYNO_DOWNSCALE_CHECK_INTERVAL`: Interval for checking if a dyno can be downscaled (in seconds)
- `DYNO_ZOMBIE_THRESHOLD`: Time threshold for considering a dyno as unresponsive (in seconds)
- `DYNO_LOG_THREADS_USED`: Whether to log the number of threads used
- `DYNO_LOGS_CACHE_DURATION`: Duration to cache dyno logs (in seconds)
- `DYNO_ERRORS_TIMEOUT_DURATION`: Duration to cache error information (in seconds)
- `DYNO_GENERAL_CACHE_DURATION`: General cache duration (in seconds)
- `DYNO_TIME_BETWEEN_RESTARTS`: Minimum time between dyno restarts (in seconds)
- `DYNO_AUTOSCALE_ENABLED_FOR_BEATWORKER`: Whether to enable autoscaling for beat workers
- `UPSCALE_PERCENTAGE_HIGH_MEM_USE`: Memory usage percentage threshold for upscaling
- `DOWNSCALE_PERCENTAGE_HIGH_MEM_USE`: Memory usage percentage threshold for downscaling
- `HIGH_MEM_USE_MB`: High memory usage threshold in MB
pykaahma-linz 0.1.10
A Pythonic client for accessing and querying datasets from the LINZ Data Service.
Requires Python: >=3.10
Keywords: kaahma, koordinates, LINZ, geospatial, open data, API, GIS

# pykaahma-linz
A Pythonic client for accessing and querying datasets from the LINZ Data Service.

## Overview  
pykaahma-linz is a Python package that provides a clean, Pythonic interface to the Koordinates geospatial content management system. It allows users to connect to the Koordinates API, retrieve metadata, and query datasets such as vector layers, tables, rasters, and point clouds. As the name indicates, this was written with LINZ (Land Information New Zealand) in mind and simplifies programmatic access to their open geospatial data. 

Documentation available at [Github Pages documentation website](https://phaakma.github.io/pykaahma-linz/)  

## Disclaimer  
This is a hobby project and the modules are provided as-is on a best-effort basis and you assume all risk for using it.  
The author has no affiliation with either Koordinates nor LINZ. As such, the underlying API's and services may change at any time without warning and break these modules. The author is not privvy to any inside knowledge or documentation beyond what is available online or by inspecting the payloads returned by the services.  

This project does not cover the full spectrum of the Koordinates API and probably never will. It focuses currently on basic workflows such as connecting using an api key, getting references to datasets and downloading them. The package has not been tested against any other Koordinates deployment and there may be LINZ specific logic buried in the code. 

The author is happy to take feedback and consider suggestions and code contributions as time allows. Preferred method for feedback is via the Github repository issues page.    

## Installation  

```bash
pip install pykaahma-linz
```

## Usage  

* Import KServer.  
* Create a KServer object, passing in an api key.  
* Get a reference to an item using {kserver}.content.get({layer_id})
* Perform actions on the item.  

Basic example:  
```python
from pykaahma_linz.KServer import KServer
linz = KServer(api_key)
rail_station_layer_id = "50318"
itm = linz.content.get(rail_station_layer_id)
data = itm.query()
data.head()
```

## Tests  
Tests are written using pytest. To run tests using UV:  

```bash
uv run -m pytest --log-cli-level=INFO
```

There is currently very limited test coverage. Any live tests require a "LINZ_API_KEY" entry to exist in a .env file in the root project folder.
xray-cfo 0.1.0
This is a library for xray-core created using autogeneration with the betterproto2 plugin
Requires Python: >=3.13

# xray-cfo

A simple Python package for Xray-core functionality.

## Installation

You can install `xray-cfo` using pip:

```bash
pip install xray-cfo
```

Or with uv for faster installation:
```bash
uv pip install xray-cfo

```