# M3S - Multi Spatial Subdivision System
A unified Python package for working with hierarchical spatial grid systems. M3S (Multi Spatial Subdivision System) provides a consistent interface for working with different spatial indexing systems including Geohash, MGRS, H3, Quadkey, S2, and Slippy Map tiles.
## Features
- **6 Grid Systems**: Support for Geohash, MGRS, H3, Quadkey, S2, and Slippy Map tiles
- **Area Calculations**: All grids support `area_km2` property for theoretical cell areas
- **GeoPandas Integration**: Native support for GeoDataFrames with automatic CRS transformation
- **UTM Zone Integration**: Automatic UTM zone detection and inclusion for optimal spatial analysis
- **Polygon Intersection**: Find grid cells that intersect with any Shapely polygon or GeoDataFrame
- **Hierarchical Operations**: Work with different precision levels and resolutions
- **Neighbor Finding**: Get neighboring grid cells across all supported systems
- **Parallel Processing**: Distributed computing with Dask, GPU acceleration, and streaming support
- **Unified Interface**: Consistent API across all grid systems
- **Modern Python**: Built with modern Python packaging and comprehensive type hints
- **Comprehensive Testing**: Full test coverage with pytest
## Installation
```bash
pip install m3s
```
For development:
```bash
git clone https://github.com/yourusername/m3s.git
cd m3s
pip install -e ".[dev]"
```
## Quick Start
### All Grid Systems
```python
from m3s import GeohashGrid, MGRSGrid, H3Grid, QuadkeyGrid, S2Grid, SlippyGrid
from shapely.geometry import Point, box
import geopandas as gpd
# Create grids with different systems
grids = {
'Geohash': GeohashGrid(precision=5), # ~4,892 km² cells
'MGRS': MGRSGrid(precision=1), # 100 km² cells
'H3': H3Grid(resolution=7), # ~5.16 km² cells
'Quadkey': QuadkeyGrid(level=12), # ~95.73 km² cells
'S2': S2Grid(level=10), # ~81.07 km² cells
'Slippy': SlippyGrid(zoom=12) # ~95.73 km² cells
}
# Get cell areas
for name, grid in grids.items():
print(f"{name}: {grid.area_km2:.2f} km² per cell")
# Get cells for NYC coordinates
lat, lon = 40.7128, -74.0060
for name, grid in grids.items():
cell = grid.get_cell_from_point(lat, lon)
print(f"{name}: {cell.identifier}")
# Example output:
# Geohash: 5,892.00 km² per cell
# MGRS: 100.00 km² per cell
# H3: 5.16 km² per cell
# Quadkey: 95.73 km² per cell
# S2: 81.07 km² per cell
# Slippy: 95.73 km² per cell
#
# Geohash: dr5ru
# MGRS: 18TWL8451
# H3: 871fb4662ffffff
# Quadkey: 120220012313
# S2: 89c2594
# Slippy: 12/1207/1539
```
### GeoDataFrame Integration with UTM Zones
```python
import geopandas as gpd
from m3s import H3Grid, QuadkeyGrid, SlippyGrid
from shapely.geometry import Point, box
# Create a GeoDataFrame
gdf = gpd.GeoDataFrame({
'city': ['NYC', 'LA', 'Chicago'],
'population': [8_336_817, 3_979_576, 2_693_976]
}, geometry=[
Point(-74.0060, 40.7128), # NYC
Point(-118.2437, 34.0522), # LA
Point(-87.6298, 41.8781) # Chicago
], crs="EPSG:4326")
# Intersect with any grid system - includes UTM zone information for applicable grids
grid = H3Grid(resolution=7)
result = grid.intersects(gdf)
print(f"Grid cells: {len(result)}")
print(result[['cell_id', 'utm', 'city', 'population']].head())
# Example output:
# cell_id utm city population
# 0 8828308281fffff 32618 NYC 8336817
# 1 88283096773ffff 32611 LA 3979576
# 2 8828872c0ffffff 32616 Chicago 2693976
# Web mapping grids (Quadkey, Slippy) don't include UTM zones
web_grid = SlippyGrid(zoom=12)
web_result = web_grid.intersects(gdf)
print(web_result[['cell_id', 'city']].head())
# Output:
# cell_id city
# 0 12/1207/1539 NYC
# 1 12/696/1582 LA
# 2 12/1030/1493 Chicago
```
### MGRS Grids with UTM Integration
```python
from m3s import MGRSGrid
# Create an MGRS grid with 1km precision
grid = MGRSGrid(precision=2)
# Get a grid cell from coordinates
cell = grid.get_cell_from_point(40.7128, -74.0060)
print(f"MGRS: {cell.identifier}")
# Intersect with GeoDataFrame - automatically includes UTM zone
result = grid.intersect_geodataframe(gdf)
print(result[['cell_id', 'utm']].head())
# Output shows MGRS cells with their corresponding UTM zones:
# cell_id utm
# 0 18TWL23 32618 # UTM Zone 18N for NYC area
```
### H3 Grids
```python
from m3s import H3Grid
# Create an H3 grid with resolution 7 (~4.5km edge length)
grid = H3Grid(resolution=7)
# Get a hexagonal cell from coordinates
cell = grid.get_cell_from_point(40.7128, -74.0060)
print(f"H3: {cell.identifier}")
# Get neighboring hexagons (6 neighbors)
neighbors = grid.get_neighbors(cell)
print(f"Neighbors: {len(neighbors)}")
# Get children at higher resolution
children = grid.get_children(cell)
print(f"Children: {len(children)}") # Always 7 for H3
# Find intersecting cells with UTM zone information
result = grid.intersect_geodataframe(gdf)
print(result[['cell_id', 'utm', 'city']].head())
```
## Grid Systems
### Geohash
Hierarchical spatial data structure using Base32 encoding. Each character represents 5 bits of spatial precision.
- **Precision Levels**: 1-12
- **Cell Shape**: Rectangular
- **Use Cases**: Databases, simple spatial indexing
### MGRS (Military Grid Reference System)
Coordinate system based on UTM with standardized square cells.
- **Precision Levels**: 0-5 (100km to 1m)
- **Cell Shape**: Square
- **Use Cases**: Military, surveying, precise location reference
### H3 (Uber's Hexagonal Hierarchical Spatial Index)
Hexagonal grid system with uniform neighbor relationships and excellent area representation.
- **Resolution Levels**: 0-15
- **Cell Shape**: Hexagonal
- **Use Cases**: Spatial analysis, ride-sharing, logistics
### Quadkey (Microsoft Bing Maps)
Quadtree-based square tiles used by Microsoft Bing Maps.
- **Levels**: 1-23
- **Cell Shape**: Square
- **Use Cases**: Web mapping, tile-based applications
### S2 (Google's Spherical Geometry)
Spherical geometry cells using Hilbert curve for optimal spatial locality.
- **Levels**: 0-30
- **Cell Shape**: Curved (spherical quadrilaterals)
- **Use Cases**: Large-scale applications, global spatial indexing
### Slippy Map Tiles
Standard web map tiles used by OpenStreetMap and most web mapping services.
- **Zoom Levels**: 0-22
- **Cell Shape**: Square (in Web Mercator projection)
- **Use Cases**: Web mapping, tile servers, caching
## API Reference
### BaseGrid
All grid classes inherit from `BaseGrid`:
```python
class BaseGrid:
@property
def area_km2(self) -> float
"""Theoretical area in km² for cells at this precision/resolution/level"""
def get_cell_from_point(self, lat: float, lon: float) -> GridCell
def get_cell_from_identifier(self, identifier: str) -> GridCell
def get_neighbors(self, cell: GridCell) -> List[GridCell]
def get_children(self, cell: GridCell) -> List[GridCell]
def get_parent(self, cell: GridCell) -> Optional[GridCell]
def get_cells_in_bbox(self, min_lat: float, min_lon: float,
max_lat: float, max_lon: float) -> List[GridCell]
def get_covering_cells(self, polygon: Polygon, max_cells: int = 100) -> List[GridCell]
# GeoDataFrame integration methods with UTM zone support
def intersects(self, gdf: gpd.GeoDataFrame,
target_crs: str = "EPSG:4326") -> gpd.GeoDataFrame
```
### Parallel Processing
```python
from m3s.parallel import ParallelGridEngine, ParallelConfig
# Configure parallel processing
config = ParallelConfig(
use_dask=True,
use_gpu=True,
n_workers=4,
chunk_size=10000
)
# Process large datasets in parallel
engine = ParallelGridEngine(config)
result = engine.intersect_parallel(grid, large_gdf)
```
### UTM Zone Integration
All grid systems now automatically include a `utm` column in their `intersect_geodataframe()` results:
- **MGRS**: UTM zone extracted directly from MGRS identifier
- **Geohash**: UTM zone calculated from cell centroid coordinates
- **H3**: UTM zone calculated from hexagon centroid coordinates
The UTM column contains EPSG codes (e.g., 32614 for UTM Zone 14N, 32723 for UTM Zone 23S).
## Development
### Setup
```bash
git clone https://github.com/yourusername/m3s.git
cd m3s
pip install -e ".[dev]"
```
### Running Tests
```bash
pytest
```
### Code Formatting
```bash
black m3s tests examples
```
### Type Checking
```bash
mypy m3s
```
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Dependencies
### Required
- [Shapely](https://shapely.readthedocs.io/) - Geometric operations
- [PyProj](https://pyproj4.github.io/pyproj/) - Coordinate transformations
- [GeoPandas](https://geopandas.org/) - Geospatial data manipulation
- [mgrs](https://pypi.org/project/mgrs/) - MGRS coordinate conversions
- [h3](https://pypi.org/project/h3/) - H3 hexagonal grid operations
- [s2sphere](https://pypi.org/project/s2sphere/) - S2 spherical geometry operations
### Optional (for parallel processing)
- [dask](https://dask.org/) - Distributed computing (`pip install m3s[parallel]`)
- [cupy](https://cupy.dev/) - GPU acceleration (`pip install m3s[gpu]`)
**Notes**:
- Geohash, Quadkey, and Slippy Map Tiles are implemented using pure Python (no external dependencies)
- S2 functionality requires the s2sphere library for proper spherical geometry calculations
## Acknowledgments
- Built for geospatial analysis and location intelligence applications
- Thanks to the maintainers of the underlying spatial libraries
Raw data
{
"_id": null,
"home_page": null,
"name": "m3s",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "gis, spatial, grid, geohash, mgrs, h3, quadkey, s2, hierarchical, subdivision, geometry",
"author": null,
"author_email": "Nicolas Karasiak <karasiak@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/2d/67/069db1f722ea96d683a3a0390cc7c874a638050da91602595dcb0d47a558/m3s-0.3.0.tar.gz",
"platform": null,
"description": "# M3S - Multi Spatial Subdivision System\n\nA unified Python package for working with hierarchical spatial grid systems. M3S (Multi Spatial Subdivision System) provides a consistent interface for working with different spatial indexing systems including Geohash, MGRS, H3, Quadkey, S2, and Slippy Map tiles.\n\n## Features\n\n- **6 Grid Systems**: Support for Geohash, MGRS, H3, Quadkey, S2, and Slippy Map tiles\n- **Area Calculations**: All grids support `area_km2` property for theoretical cell areas\n- **GeoPandas Integration**: Native support for GeoDataFrames with automatic CRS transformation\n- **UTM Zone Integration**: Automatic UTM zone detection and inclusion for optimal spatial analysis\n- **Polygon Intersection**: Find grid cells that intersect with any Shapely polygon or GeoDataFrame\n- **Hierarchical Operations**: Work with different precision levels and resolutions\n- **Neighbor Finding**: Get neighboring grid cells across all supported systems\n- **Parallel Processing**: Distributed computing with Dask, GPU acceleration, and streaming support\n- **Unified Interface**: Consistent API across all grid systems\n- **Modern Python**: Built with modern Python packaging and comprehensive type hints\n- **Comprehensive Testing**: Full test coverage with pytest\n\n## Installation\n\n```bash\npip install m3s\n```\n\nFor development:\n\n```bash\ngit clone https://github.com/yourusername/m3s.git\ncd m3s\npip install -e \".[dev]\"\n```\n\n## Quick Start\n\n### All Grid Systems\n\n```python\nfrom m3s import GeohashGrid, MGRSGrid, H3Grid, QuadkeyGrid, S2Grid, SlippyGrid\nfrom shapely.geometry import Point, box\nimport geopandas as gpd\n\n# Create grids with different systems\ngrids = {\n 'Geohash': GeohashGrid(precision=5), # ~4,892 km\u00b2 cells\n 'MGRS': MGRSGrid(precision=1), # 100 km\u00b2 cells \n 'H3': H3Grid(resolution=7), # ~5.16 km\u00b2 cells\n 'Quadkey': QuadkeyGrid(level=12), # ~95.73 km\u00b2 cells\n 'S2': S2Grid(level=10), # ~81.07 km\u00b2 cells\n 'Slippy': SlippyGrid(zoom=12) # ~95.73 km\u00b2 cells\n}\n\n# Get cell areas\nfor name, grid in grids.items():\n print(f\"{name}: {grid.area_km2:.2f} km\u00b2 per cell\")\n\n# Get cells for NYC coordinates\nlat, lon = 40.7128, -74.0060\nfor name, grid in grids.items():\n cell = grid.get_cell_from_point(lat, lon)\n print(f\"{name}: {cell.identifier}\")\n\n# Example output:\n# Geohash: 5,892.00 km\u00b2 per cell\n# MGRS: 100.00 km\u00b2 per cell \n# H3: 5.16 km\u00b2 per cell\n# Quadkey: 95.73 km\u00b2 per cell\n# S2: 81.07 km\u00b2 per cell\n# Slippy: 95.73 km\u00b2 per cell\n#\n# Geohash: dr5ru\n# MGRS: 18TWL8451\n# H3: 871fb4662ffffff\n# Quadkey: 120220012313\n# S2: 89c2594\n# Slippy: 12/1207/1539\n```\n\n### GeoDataFrame Integration with UTM Zones\n\n```python\nimport geopandas as gpd\nfrom m3s import H3Grid, QuadkeyGrid, SlippyGrid\nfrom shapely.geometry import Point, box\n\n# Create a GeoDataFrame\ngdf = gpd.GeoDataFrame({\n 'city': ['NYC', 'LA', 'Chicago'],\n 'population': [8_336_817, 3_979_576, 2_693_976]\n}, geometry=[\n Point(-74.0060, 40.7128), # NYC\n Point(-118.2437, 34.0522), # LA \n Point(-87.6298, 41.8781) # Chicago\n], crs=\"EPSG:4326\")\n\n# Intersect with any grid system - includes UTM zone information for applicable grids\ngrid = H3Grid(resolution=7)\nresult = grid.intersects(gdf)\nprint(f\"Grid cells: {len(result)}\")\nprint(result[['cell_id', 'utm', 'city', 'population']].head())\n\n# Example output:\n# cell_id utm city population\n# 0 8828308281fffff 32618 NYC 8336817\n# 1 88283096773ffff 32611 LA 3979576\n# 2 8828872c0ffffff 32616 Chicago 2693976\n\n# Web mapping grids (Quadkey, Slippy) don't include UTM zones\nweb_grid = SlippyGrid(zoom=12)\nweb_result = web_grid.intersects(gdf)\nprint(web_result[['cell_id', 'city']].head())\n# Output:\n# cell_id city\n# 0 12/1207/1539 NYC\n# 1 12/696/1582 LA\n# 2 12/1030/1493 Chicago\n```\n\n### MGRS Grids with UTM Integration\n\n```python\nfrom m3s import MGRSGrid\n\n# Create an MGRS grid with 1km precision\ngrid = MGRSGrid(precision=2)\n\n# Get a grid cell from coordinates\ncell = grid.get_cell_from_point(40.7128, -74.0060)\nprint(f\"MGRS: {cell.identifier}\")\n\n# Intersect with GeoDataFrame - automatically includes UTM zone\nresult = grid.intersect_geodataframe(gdf)\nprint(result[['cell_id', 'utm']].head())\n# Output shows MGRS cells with their corresponding UTM zones:\n# cell_id utm\n# 0 18TWL23 32618 # UTM Zone 18N for NYC area\n```\n\n### H3 Grids\n\n```python\nfrom m3s import H3Grid\n\n# Create an H3 grid with resolution 7 (~4.5km edge length)\ngrid = H3Grid(resolution=7)\n\n# Get a hexagonal cell from coordinates\ncell = grid.get_cell_from_point(40.7128, -74.0060)\nprint(f\"H3: {cell.identifier}\")\n\n# Get neighboring hexagons (6 neighbors)\nneighbors = grid.get_neighbors(cell)\nprint(f\"Neighbors: {len(neighbors)}\")\n\n# Get children at higher resolution\nchildren = grid.get_children(cell)\nprint(f\"Children: {len(children)}\") # Always 7 for H3\n\n# Find intersecting cells with UTM zone information\nresult = grid.intersect_geodataframe(gdf)\nprint(result[['cell_id', 'utm', 'city']].head())\n```\n\n## Grid Systems\n\n### Geohash\nHierarchical spatial data structure using Base32 encoding. Each character represents 5 bits of spatial precision.\n- **Precision Levels**: 1-12\n- **Cell Shape**: Rectangular\n- **Use Cases**: Databases, simple spatial indexing\n\n### MGRS (Military Grid Reference System)\nCoordinate system based on UTM with standardized square cells.\n- **Precision Levels**: 0-5 (100km to 1m)\n- **Cell Shape**: Square\n- **Use Cases**: Military, surveying, precise location reference\n\n### H3 (Uber's Hexagonal Hierarchical Spatial Index)\nHexagonal grid system with uniform neighbor relationships and excellent area representation.\n- **Resolution Levels**: 0-15\n- **Cell Shape**: Hexagonal\n- **Use Cases**: Spatial analysis, ride-sharing, logistics\n\n### Quadkey (Microsoft Bing Maps)\nQuadtree-based square tiles used by Microsoft Bing Maps.\n- **Levels**: 1-23\n- **Cell Shape**: Square\n- **Use Cases**: Web mapping, tile-based applications\n\n### S2 (Google's Spherical Geometry)\nSpherical geometry cells using Hilbert curve for optimal spatial locality.\n- **Levels**: 0-30\n- **Cell Shape**: Curved (spherical quadrilaterals)\n- **Use Cases**: Large-scale applications, global spatial indexing\n\n### Slippy Map Tiles\nStandard web map tiles used by OpenStreetMap and most web mapping services.\n- **Zoom Levels**: 0-22\n- **Cell Shape**: Square (in Web Mercator projection)\n- **Use Cases**: Web mapping, tile servers, caching\n\n## API Reference\n\n### BaseGrid\n\nAll grid classes inherit from `BaseGrid`:\n\n```python\nclass BaseGrid:\n @property\n def area_km2(self) -> float\n \"\"\"Theoretical area in km\u00b2 for cells at this precision/resolution/level\"\"\"\n \n def get_cell_from_point(self, lat: float, lon: float) -> GridCell\n def get_cell_from_identifier(self, identifier: str) -> GridCell\n def get_neighbors(self, cell: GridCell) -> List[GridCell]\n def get_children(self, cell: GridCell) -> List[GridCell]\n def get_parent(self, cell: GridCell) -> Optional[GridCell]\n def get_cells_in_bbox(self, min_lat: float, min_lon: float, \n max_lat: float, max_lon: float) -> List[GridCell]\n def get_covering_cells(self, polygon: Polygon, max_cells: int = 100) -> List[GridCell]\n \n # GeoDataFrame integration methods with UTM zone support\n def intersects(self, gdf: gpd.GeoDataFrame, \n target_crs: str = \"EPSG:4326\") -> gpd.GeoDataFrame\n```\n\n### Parallel Processing\n\n```python\nfrom m3s.parallel import ParallelGridEngine, ParallelConfig\n\n# Configure parallel processing\nconfig = ParallelConfig(\n use_dask=True,\n use_gpu=True,\n n_workers=4,\n chunk_size=10000\n)\n\n# Process large datasets in parallel\nengine = ParallelGridEngine(config)\nresult = engine.intersect_parallel(grid, large_gdf)\n```\n\n### UTM Zone Integration\n\nAll grid systems now automatically include a `utm` column in their `intersect_geodataframe()` results:\n\n- **MGRS**: UTM zone extracted directly from MGRS identifier\n- **Geohash**: UTM zone calculated from cell centroid coordinates \n- **H3**: UTM zone calculated from hexagon centroid coordinates\n\nThe UTM column contains EPSG codes (e.g., 32614 for UTM Zone 14N, 32723 for UTM Zone 23S).\n\n## Development\n\n### Setup\n\n```bash\ngit clone https://github.com/yourusername/m3s.git\ncd m3s\npip install -e \".[dev]\"\n```\n\n### Running Tests\n\n```bash\npytest\n```\n\n### Code Formatting\n\n```bash\nblack m3s tests examples\n```\n\n### Type Checking\n\n```bash\nmypy m3s\n```\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## Dependencies\n\n### Required\n- [Shapely](https://shapely.readthedocs.io/) - Geometric operations\n- [PyProj](https://pyproj4.github.io/pyproj/) - Coordinate transformations \n- [GeoPandas](https://geopandas.org/) - Geospatial data manipulation\n- [mgrs](https://pypi.org/project/mgrs/) - MGRS coordinate conversions\n- [h3](https://pypi.org/project/h3/) - H3 hexagonal grid operations\n- [s2sphere](https://pypi.org/project/s2sphere/) - S2 spherical geometry operations\n\n### Optional (for parallel processing)\n- [dask](https://dask.org/) - Distributed computing (`pip install m3s[parallel]`)\n- [cupy](https://cupy.dev/) - GPU acceleration (`pip install m3s[gpu]`)\n\n**Notes**: \n- Geohash, Quadkey, and Slippy Map Tiles are implemented using pure Python (no external dependencies)\n- S2 functionality requires the s2sphere library for proper spherical geometry calculations\n\n## Acknowledgments\n\n- Built for geospatial analysis and location intelligence applications\n- Thanks to the maintainers of the underlying spatial libraries\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Multi Spatial Subdivision System - A unified Python package for working with spatial grid systems",
"version": "0.3.0",
"project_urls": {
"Bug Tracker": "https://github.com/nkarasiak/m3s/issues",
"Documentation": "https://nkarasiak.github.io/m3s/",
"Homepage": "https://github.com/nkarasiak/m3s",
"Repository": "https://github.com/nkarasiak/m3s.git"
},
"split_keywords": [
"gis",
" spatial",
" grid",
" geohash",
" mgrs",
" h3",
" quadkey",
" s2",
" hierarchical",
" subdivision",
" geometry"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "3573d480c02d5da21c2602fa989408a04ae069549a79c2b9da6bc507b2c61b54",
"md5": "7a67d7c1f78ddab13bb60ebeffd427ee",
"sha256": "b7d2b0fcb4002b244880bd00ffe356679f1729b1b48a62ba6423f2b9d752ba0d"
},
"downloads": -1,
"filename": "m3s-0.3.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7a67d7c1f78ddab13bb60ebeffd427ee",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 38632,
"upload_time": "2025-08-21T01:15:37",
"upload_time_iso_8601": "2025-08-21T01:15:37.571086Z",
"url": "https://files.pythonhosted.org/packages/35/73/d480c02d5da21c2602fa989408a04ae069549a79c2b9da6bc507b2c61b54/m3s-0.3.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "2d67069db1f722ea96d683a3a0390cc7c874a638050da91602595dcb0d47a558",
"md5": "2fe0aa1b360dae8bf39461119f2f9058",
"sha256": "7b9f7feacc7e49ce5016c300a69e38922f0ddff1f97727cd35bd387faa6523d6"
},
"downloads": -1,
"filename": "m3s-0.3.0.tar.gz",
"has_sig": false,
"md5_digest": "2fe0aa1b360dae8bf39461119f2f9058",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 47149,
"upload_time": "2025-08-21T01:15:38",
"upload_time_iso_8601": "2025-08-21T01:15:38.830544Z",
"url": "https://files.pythonhosted.org/packages/2d/67/069db1f722ea96d683a3a0390cc7c874a638050da91602595dcb0d47a558/m3s-0.3.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-21 01:15:38",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "nkarasiak",
"github_project": "m3s",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "m3s"
}
JSON
