semvec/pypi-packages huggingface dataset:
openstreetmap-downloader 1.1.3
Downloads OpenStreetMap data by configurations
Requires Python: >=3.11

# openstreetmap-downloader

Downloads OpenStreetMap data by configurations

## Setup

```bash
# Install dependencies
uv sync
```

## Usage

```bash
# Run importer
uv run -m osm_downloader.main
```

Usage from python

```python
from osm_downloader import osm_download

osm_download()
```

## Configuration

Check [osm_config.yaml](./osm_config.yaml) for a configuration example.

This examples creates a file `./data/borgo_vals/parking.geojson` with all records matching the properties in `groups.parking` (parking areas and EV charging stations).

```yaml
areas:
  - name: borgo_vals
    place: "Borgo Valsugana, Trentino"
    groups:
      parking:
        - key: "amenity"
          value: "parking"
        - key: "amenity"
          value: "parking_space"
        - key: "amenity"
          value: "charging_station"
```

A `.env` file can be used to control those variables

```ini
# base path where to save downloaded data
DATA_DIR=./data

# path to config file
CONFIG_PATH=./osm_config.yaml
```

## License

Licensed under `Apache-2.0` see [LICENSE](./LICENSE)
membank 0.5.6
A library to handle persistent memory
Requires Python: >=3.10

# membank
Python library for storing data in persistent memory (sqlite, postgresql, berkeley db)
## goals
Provide interface to database storage that automates heavy lifting of database setup, migration, table definition, query construction.
## quick intro
### add items to persistent storage
```python
import dataclasses as data # Python standard library

from membank import LoadMemory

@data.dataclass
class Dog():
    breed: str
    color: str = "black"
    weight: float = 0
    data: dict = data.field(default_factory=dict)
    picture: bytes = b''
    aliases: list = data.field(default_factory=list)

@data.dataclass
class DogWithID():
    id: str = data.field(default=None, metadata={"key": True})
    breed: str
    color: str = "black"
    weight: float = 0
    data: dict = data.field(default_factory=dict)
    picture: bytes = b''
    alive: bool = True

memory = LoadMemory() # defaults to sqlite memory
memory.put(Dog('Puli')) # stores object into database
dog = memory.get.dog() # retrieves first object found
assert dog.breed == 'Puli'
dog.color = "white"
memory.put(dog) # be carefull you store another dog
dog = memory.put(DogWithID("AB1234", "Puli"))
dog = memory.get.dogwithid(id="AB1234")
dog.color = "white"
memory.put(dog) # now you update existing dog

```
### retrieve those after
```python
memory = LoadMemory() # to make this work in new process, don't use sqlite memory
dog = memory.get.dog() # get first found or None
assert dog.color == 'black'
dogs = memory.get("dog") # always returns list (empty or with items)
assert len(dogs) >= 0
```
### editing returned objects
```python
dog = memory.get.dog()
dog.breed = 'Labdrador'
memory.put(dog) # stores edited object back
```
### filter objects
```python
dog = memory.get.dog(breed='Labdrador')
assert dog.breed == 'Labrador'
```
v-installer 0.0.34
Install my app, not for all people
Requires Python: >=3.6

# Build package

```bash
python3 setup.py sdist bdist_wheel
```

# Publish package to Pypi

```bash
twine upload dist/*
```

# Docker environment

```bash
docker run -it --rm -v $(pwd):/workspace/v-installer python:3.10.10-alpine /bin/sh

apk update
cd /workspace/v-installer
python3 -m pip install setuptools
python3 setup.py sdist bdist_wheel
apk add twine
apk add gcc python3-dev musl-dev linux-headers
TWINE_USERNAME="__token__" TWINE_PASSWORD="pypi-....................................................." twine upload --non-interactive dist/*
```
duct 1.0.1
a library for running child processes
Requires Python: >=3.9

# duct.py [![Actions Status](https://github.com/oconnor663/duct.py/workflows/tests/badge.svg)](https://github.com/oconnor663/duct.py/actions) [![PyPI version](https://badge.fury.io/py/duct.svg)](https://pypi.python.org/pypi/duct) [![Documentation Status](https://readthedocs.org/projects/ductpy/badge/?version=latest)](https://ductpy.readthedocs.io/en/latest/?badge=latest)

Duct is a library for running child processes. Duct makes it easy to
build pipelines and redirect IO like a shell. At the same time, Duct
helps you write correct, portable code: whitespace is never significant,
errors from child processes get reported by default, and a variety of
[gotchas, bugs, and platform
inconsistencies](https://github.com/oconnor663/duct.py/blob/master/gotchas.md)
are handled for you the Right Way™.

- [Documentation](https://ductpy.readthedocs.io)
- [PyPI package](https://pypi.python.org/pypi/duct)
- [the same library, in Rust](https://github.com/oconnor663/duct.rs)

Examples
--------

Run a command without capturing any output. Here "hi" is printed directly to
the terminal:

```python
>>> from duct import cmd
>>> cmd("echo", "hi").run()
hi
Output(status=0, stdout=None, stderr=None)
```

Capture the standard output of a command. Here "hi" is returned as a string:

```python
>>> cmd("echo", "hi").read()
'hi'
```

Capture the standard output of a pipeline:

```python
>>> cmd("echo", "hi").pipe(cmd("sed", "s/i/o/")).read()
'ho'
```

Merge standard error into standard output and read both incrementally:

```python
>>> big_cmd = cmd("bash", "-c", "echo out && echo err 1>&2")
>>> reader = big_cmd.stderr_to_stdout().reader()
>>> with reader:
...     reader.readlines()
[b'out\n', b'err\n']
```

Children that exit with a non-zero status raise an exception by default:

```python
>>> cmd("false").run()
Traceback (most recent call last):
...
duct.StatusError: Expression cmd('false') returned non-zero exit status: Output(status=1, stdout=None, stderr=None)
>>> cmd("false").unchecked().run()
Output(status=1, stdout=None, stderr=None)
```
amde 0.1.6
Easy way to embed your data
Requires Python: >=3.8

# Amde

> A lightweight and fast package for generating embeddings across multiple data modalities.

[![Website](https://img.shields.io/badge/Visit-Website-brightgreen)](https://amde.dev)

---

##  Overview

**Amde** is a lightweight and fast Python package that enables developers to generate embeddings for various data types — including text, images, and audio — through a simple, unified interface.

##  Installation

```bash
pip install amde