semvec/pypi-packages huggingface dataset:
BuildingsDownloader 0.1.0
A package to download and process building footprints from bounding box data
Requires Python: >=3.6

# Building Footprints Downloader

This script downloads building footprints within a specified area of interest (AOI), which can be defined either by a shapefile or by a bounding box (min/max latitude and longitude coordinates). It uses the `mercantile` library to handle tile-based requests and fetches building footprint data from a global dataset. The results are saved as a GeoJSON file.

## Features
- Fetch building footprints within a specified AOI.
- Support for AOI input as a shapefile or bounding box (minx, miny, maxx, maxy).
- Supports querying building footprint data from a global dataset by tile using quadkeys.
- Outputs results as a GeoJSON file.

## Requirements
- Python 3.6+
- Required Python libraries:
  - pandas
  - geopandas
  - shapely
  - mercantile
  - tqdm
  - argparse

You can install the required libraries using `pip`:

```bash
pip install pandas geopandas shapely mercantile tqdm
```

## Usage

### Command Line Arguments

- `--shp` (optional): Path to the input shapefile defining the AOI. If not provided, you must provide bounding box coordinates (`--minx`, `--miny`, `--maxx`, `--maxy`).
- `--minx` (optional): Minimum X coordinate (longitude) of the bounding box.
- `--miny` (optional): Minimum Y coordinate (latitude) of the bounding box.
- `--maxx` (optional): Maximum X coordinate (longitude) of the bounding box.
- `--maxy` (optional): Maximum Y coordinate (latitude) of the bounding box.
- `--output`: Required. Output file path (GeoJSON format) for the result.

### Example Usage

1. **Using a shapefile to define the AOI:**

```bash
python download_buildings.py --shp path_to_shapefile.shp --output output.geojson
```

2. **Using a bounding box to define the AOI:**

```bash
python download_buildings.py --minx -122.5 --miny 37.5 --maxx -122.0 --maxy 38.0 --output output.geojson
```

In this case, the bounding box is defined by:
- `minx`: Minimum longitude
- `miny`: Minimum latitude
- `maxx`: Maximum longitude
- `maxy`: Maximum latitude

### Notes

- If both a shapefile (`--shp`) and bounding box coordinates are provided, the shapefile will be used.
- The `mercantile` library is used to divide the requested area into tiles. Each tile is fetched by its quadkey from the global dataset.
- The output is saved as a `.geojson` file, which can be opened in GIS software such as QGIS.
aij-team 1.0.0
A library that does some math-based equations
Requires Python: >=3.6

# Python script to generate a README.md file for your utility functions library

readme_content = """# Python Utility Functions Library

This library provides a collection of commonly used utility functions for mathematical operations, string manipulations, and list processing. These functions are lightweight and designed to simplify everyday programming tasks.

---

## Installation

Clone the repository to your local machine:

```bash
pip install aij
```
basilico 0.1.0
Add your description here
Requires Python: >=3.11

# Basilico

Build HTML components in Python.

*Basilico* lets you create HTML components using pure Python code. Generate HTML5 markup effortlessly while building reusable components that enhance your development workflow.

## Key Features
- Write HTML components using familiar Python syntax
- Generate standards-compliant HTML5 output
- Create and maintain reusable components
- Keep your templates type-safe with Python's typing
- No external dependencies

# Usage
```shell
pip install basilico
```

```python
from basilico.attributes import Class, Href
from basilico.components import If
from basilico.elements import A, Li, Nav, Ol, Text
from basilico.node import Node


def navbar(logged_in: bool) -> Node:
    return Nav(
        Class("navbar"),
        Ol(
            navbar_item("Home", "/"),
            navbar_item("Contact", "/contact"),
            navbar_item("About", "/about"),
            If(
                logged_in is False,
                navbar_item("Login", "/login"),
            ),
        ),
    )


def navbar_item(name: str, path: str) -> Node:
    return Li(A(Href(path), Text(name)))
```

We can use generators to create components inline:
```python
from basilico.elements import Li, Text, Ul

items = ["Coffee", "Tea", "Milk"]
Ul(
    *(Li(Text(i)) for i in items),
)

# <ul>
#     <li>Coffee</li>
#     <li>Tea</li>
#     <li>Milk</li>
# </ul>
```

### HTMX support:
```python
from basilico import htmx as hx
from basilico.elements import Button

Button(hx.Get("/example"))

# <button hx-get="/example"></button>
```

### Alpine JS support:
```python
from basilico import alpine as x
from basilico.elements import Button, Div, Text

Div(
    x.Data("{ open: false }"),
    Button(x.On("click", "open = !open"), Text("Toggle")),
    Div(x.Show("open"), Text("Hello, Basilico!")),
)

# <div x-data="{ open: false }">
#     <button x-on:click="open = !open">Toggle</button>
#     <div x-show="open">Hello, Basilico!</div>
# </div>
```

## FastAPI example:
```python
from fastapi import FastAPI
from fastapi.responses import HTMLResponse

from basilico.attributes import Class, Src
from basilico.components import HTML5, HTML5Props
from basilico.elements import H1, Div, Script, Text
from basilico.node import Node

app = FastAPI()


def page(title: str, description: str, body: Node) -> Node:
    props = HTML5Props(
        title=title,
        description=description,
        language="en",
        head=[Script(Src("https://cdn.tailwindcss.com"))],
        body=[body],
    )
    return HTML5(props)


def body() -> Node:
    return Div(
        Class("min-h-screen flex items-center justify-center"),
        H1(
            Class("text-2xl font-bold text-teal-600 text-7xl"),
            Text("Hello, Basilico!"),
        ),
    )


@app.get("/")
def home():
    content = page(
        title="Home",
        description="This is a simple example of Basilico with FastAPI.",
        body=body(),
    )

    return HTMLResponse(content.string())
```
getmyip46 24.12.28
print the external ip address (v4 or v6)
Requires Python: >=3.6
Keywords: 'ip network'


## getmyip46 - Get My External IP Address

Retrieve the external ipv4 and/or ipv6 IP address 

## getmyip Command Usage and Options

Install with pip:

```bash
% pip install gitmyip46
```

```bash
% getmyip -h

usage: app.py [-h] [-v] [-4] [-6]

Report external IP address

options:
  -h, --help     show this help message and exit
  -v, --version  show program's version number and exit
  -4, --ipv4     Find public IPv4 address (default)
  -6, --ipv6     Find public IPv6 address

getmyip gunville 2024 v1
```

#### Method of IP address detection:

By default `getmyip` automatically detects the public IP address by sending an HTTP request to [ipv4.icanhazip.com](http://ipv4.icanhazip.com) for IPv4. and [ipv4.icanhazip.com](http://ipv6.icanhazip.com) for IPv6.

You can optionally use a different site to autodetect the public ip by setting the environment variable `IPAPIURL` to that URL:
```bash
% IPAPIURL='http://api.ipify.org'
% getmyip
````
You can do the same for IPv6 using the `IPV6APIURL` environment variable.