semvec/pypi-packages huggingface dataset:
tileputty 0.1.1
Tool to upload a tile cache to AWS S3
License: MIT

# Tile Putty

This tool helps to upload Vector and Raster tile caches(PBF/ MVT, PNG and JPG format) to AWS S3.
Directory structure on S3 follows this schema:

`layer_name/version/format/option/z/x/y`

## Installation

`pip install tileputty`

## Dependencies and Requirements

This tool uses boto3 to upload files to S3.
You will need to have write permission to the S3 bucket and you AWS credential in an accessible location,
either as [environment varibales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#environment-variables)
or in a [shared credential file](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#shared-credentials-file).

## Usage

Command Line Interface
```bash
Usage: tileputty [OPTIONS] TILE_CACHE

  TILE_CACHE: path to local tile cache

Options:
  --bucket TEXT    AWS Bucket
  --layer TEXT     Dataset Name
  --version TEXT   Dataset Version ID
  --option TEXT    Dataset Version ID
  --ext TEXT       Tile Cache format
  --update_latest  Update latest file in root folder with latest version
                   number
  --help           Show this message and exit.
```

Python
```python
from tileputty.upload_tiles import upload_tiles

tile_cache = "/path/to/tilecache/root"
layer = "mylayer"
version = "v1.0"
bucket = "mybucket"
option = "default"
ext = "png"
update_latest = False

upload_tiles(
    tile_cache,
    layer,
    version,
    bucket=bucket,
    option=option,
    ext=ext,
    update_latest=update_latest,
)
```
rdsdataapi 0.1.1
DBAPI 2.0 adapter & SqlAlchemy Dialect for the RDS Data API
License: MIT
Requires Python: >=3.6.0


## DB-API 2.0 driver & SqlAlchemy dialect for the AWS RDS Data API

**NOTE: This is currently ALPHA quality software and has not been thoroughly tested yet**

The RDS Data API allows use of MySQL and PostgreSQL RDS databases via an HTTP API, making it ideal
for use in AWS Lambda because it allow syou to use RDS without running your lambda in a VPC. This
library wraps that API in both a [DB-API 2.0](https://www.python.org/dev/peps/pep-0249/) driver and
[SqlAlchemy](https://www.sqlalchemy.org/) dialect allowing you to tap into the vast python
ecosystem for working with relational databases.


### Installation
```
pip install rdsdataapi
```


### Usage

To use the DB-API 2.0 interface:
```python
from rdsdataapi import connect
con = connect(
    resource_arn="arn:aws:rds:us-east-1:490103061721:cluster:database-2",
    secret_arn="arn:aws:secretsmanager:us-east-1:490103061721:secret:pgdb-gIucWr",
    database="postgres",
)
cur = con.cursor()
cur.execute("select :foo as bar", {"foo": "foobar"})
result = cur.fetchall()
```

Or via SqlAlchemy:
```python
engine = create_engine(
    'rdsdataapi://',
    connect_args=dict(
        resource_arn="arn:aws:rds:us-east-1:490103061721:cluster:database-2",
        secret_arn="arn:aws:secretsmanager:us-east-1:490103061721:secret:pgdb-gIucWr",
        database="postgres",
    )
)
with engine.connect() as con:
    result = con.execute("select :foo as bar", foo="foobar")
```