semvec/pypi-packages huggingface dataset:
manufacture 0.6.1
A simple command-line tool to create and manage files.
Requires Python: >=3.6

# Manufacture

Manufacture is a command-line tool designed to help developers manage and create files with specified names and types efficiently. It streamlines file handling tasks, making it easier to organize project files.

## Features

- Create files with specific names and types
- Rename files with optional backup
- Change file permissions and ownership
- Create directories
- Display file information
- Compress directories
- Easy installation via pip
- Simplified file management from the terminal
- Short-form commands for quicker usage
- Ability to handle multiple filenames or directories in a single command

## Installation

You can install Manufacture using pip:

```bash
pip install manufacture
```

## Usage

```bash
# Create a new file with a specified name
manufacture create <filename>
manufacture -c <filename>

# Create a new directory
manufacture directory <dirname>
manufacture -d <dirname>

# Rename a file with an optional backup
manufacture change <oldname> <newname> [--backup]
manufacture -ch <oldname> <newname> [--backup]

# Change file permissions
manufacture permissions <filename> <permissions>
manufacture -p <filename> <permissions>

# Change file ownership
manufacture ownership <filename> <owner> <group>
manufacture -o <filename> <owner> <group>

# Display information about a file
manufacture info <filename>
manufacture -i <filename>

# Compress a directory
manufacture compress <directory> --output=<output>
manufacture -z <directory> --output=<output>

# Create directories and add content to them
manufacture create_with_content create_with_content <dirname> -c <file>... -d <dirname>... [-cc <dirname> -c <file>... -d <dirname>...] 
manufacture -cc -cc <dirname> -c <file>... -d <dirname>... [-cc <dirname> -c <file>... -d <dirname>...]
```




## Examples

Create one or multiple files:
```bash
manufacture create script1.py script2.rs
manufacture -c main.go test.rs
```

Create a new directory:
```bash
manufacture directory dir1 dir2
manufacture -d dir1 dir2
```

Rename a file with backup:
``` bash
manufacture change oldname.txt newname.txt --backup
manufacture -ch oldname.txt newname.txt --backup
```

Change file permissions to read, write, and execute for the owner:
```bash
manufacture permissions my_script.py 755
manufacture -p my_script.py 755
```

Change file ownership to user jack and group developers:
```bash
manufacture ownership my_script.py jack developers
manufacture -o my_script.py jack developers
```

Display information about a file:
```bash
manufacture info my_script.py
manufacture -i my_script.py
```

Compress a directory:
```bash
manufacture compress my_project --output=my_project.zip
manufacture -z my_project --output=my_project.zip
```

Create dir1 with files main.py, test.go and a subdirectory frontend, and create dir2 with a subdirectory backend and files start.rs, docs.txt
```bash
manufacture -cc dir1 -c main.py test.go -d frontend -cc dir2 -d backend -c start.rs docs.txt
```
spin-dataset-api 1.0.0
A description of your package
Requires Python: >=3.6

# SPIN API
![A line of photos representing samples from our dataset with subpart decompositions.](static/spin_teaser.jpg)
A Python package for interacting with the [SPIN dataset](https://arxiv.org/abs/2407.09686v1), visualizing annotations, and rasterizing segmentations.

This repository supplements the paper "SPIN: Hierarchical Segmentation with Subpart Granularity in Natural Images".

## Installation

To install the package, you can use pip:

```bash
pip install spin-api
```

We provide an example of how to use the SPIN API in `demo.ipynb`. Of note, we offer functions for downloading the annotations and provide them in a nice COCO format, or allow for rasterization if desired.

## Documentation
API documentation can be found at [this webpage](https://joshmyersdean.github.io/spin-api/).

## Images
Obtain the images from the Segmentation split of [PartImageNet](https://github.com/TACJu/PartImageNet).

## Data Documentation
To view the annotator instructions and other dataset-specific information including a data sheet, please refer to the [data_spec](data_spec/) directory.

## Issues
If you find an issue with the API or dataset, please feel free to make a pull request or an issue. Also feel free to reach out directly at josh.myers-dean@colorado.edu

## Citation
If you find our work useful, please consider citing!

```pre
@InProceedings{Myers-Dean_2024_ECCV,
	author    = {Myers-Dean, Josh and Reynolds, Jarek and Price, Brian and Fan, Yifei and Gurari, Danna},
	title     = {SPIN: Hierarchical Segmentation with Subpart Granularity in Natural Images},
	booktitle = {European Conference on Computer Vision},
	year      = {2024},
} 
```
parcel-building-mapper 0.1.0
A package for mapping parcels and buildings using various data sources
Requires Python: >=3.6

# building2parcel-training

building2parcel-training is a Python package for mapping parcels and buildings, designed to assist in training models to associate buildings with their corresponding parcels. It provides functionality for loading, processing, and visualizing geospatial data for parcels and buildings.

## Features

- Load and process parcel and building data from shapefiles
- Join parcel and building data based on spatial relationships
- Generate maps using different base layers:
  - Mapbox satellite imagery
  - NASA GIBS REST API
  - NASA GIBS Web Map Service (WMS)
  - Simple maps without satellite imagery
- Customize map output with various options
- Support for creating training datasets for building-to-parcel association models

## Installation

You can install building2parcel-training using pip:

```

pip install building2parcel-training

```

For development, clone the repository and install in editable mode:

```

git clone https://github.com/yourusername/building2parcel-training.git
cd building2parcel-training
pip install -e .

```

## Usage

Here's a basic example of how to use building2parcel-training:

```python
from building2parcel_training import ParcelBuildingMapper

# Initialize the mapper with paths to your data
parcels_path = "path/to/your/parcels.shp"
buildings_path = "path/to/your/buildings.shp"
mapper = ParcelBuildingMapper(parcels_path, buildings_path)

# Set output paths
parcels_output_path = "output/parcels/"
buildings_output_path = "output/buildings/"

# Generate maps using Mapbox satellite imagery
mapper.generate_maps(parcels_output_path, buildings_output_path,
                     start_index=0, end_index=5, distance=200,
                     map_type='mapbox_satellite')

# Generate simple maps without satellite imagery
mapper.generate_maps(parcels_output_path, buildings_output_path,
                     start_index=5, end_index=10, distance=200,
                     map_type='simple')

# Generate maps using NASA GIBS REST API
mapper.generate_maps(parcels_output_path, buildings_output_path,
                     start_index=10, end_index=15, distance=200,
                     map_type='nasa_gibs_rest')

# Generate maps using NASA GIBS WMS
mapper.generate_maps(parcels_output_path, buildings_output_path,
                     start_index=15, end_index=20, distance=200,
                     map_type='nasa_gibs_wms')

## Requirements

- matplotlib
- cartopy
- geopandas
- python-dotenv
- Pillow
- numpy
- owslib

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments

- Thanks to Mapbox and NASA GIBS for providing satellite imagery services.
- This project was developed to support machine learning efforts in associating buildings with their corresponding parcels.
```