# Whitebox Workflows for Python
## What is Whitebox Workflows?
Whitebox Workflows (WbW) is a Python library for advanced geoprocessing, including [more than 400 functions](https://www.whiteboxgeo.com/manual/wbw-user-manual/book/tool_help.html) for GIS and remote sensing analysis operations and for for manipulating common types of raster, vector and LiDAR geospatial data.
> For more details about the project, see [the User Manual](https://www.whiteboxgeo.com/manual/wbw-user-manual/book/introduction.html).
## Why Whitebox Workflows when there already is WhiteboxTools Open Core?
**Whitebox Workflows** (WbW) is based on the **WhiteboxTools Open Core** (WbOC) open-source codebase. While the two products share many characteristics and functionality, there are important differences.
The WhiteboxTools Open Core is a command line back-end program that interfaces with various front-end applications, such as QGIS, ArcGIS and the R and Python scripting languages. Front-end/back-end communication is very limited. Front-ends can only communicate with WbOC by passing text-based commands and receive text-based outputs. Data files are provided as file names and are read into memory during tool operation and output data are written to disc. This design allows WbOC to be readily integrated into other projects. However, it doesn't allow front-ends to directly interact with Whitebox data, and it isn't well suited to longer geoprocessing workflows. Tools in a WbOC based geoprocessing script are essentially run independently of other tools in the same workflow.
By comparison, **Whitebox Workflows is a native Python extension library**; it has been designed to work with Python, providing a geoprocessing scripting environment. Like the open-core, WbW is developed using the fast programming language Rust, but is compiled to a shared library that can be directly imported into Python scripts, much like NumPy and other common Python scientific libraries.
**Each of the more than 400 geoprocessing tools that users love about the WbOC are also found in WbW.** The library design of WbW affords a much more intimate level of communication between it and your Python geoprocessing script. For instance, with WbW **you can directly manipulate raster, vector, and lidar data objects**, to perform low-level geoprocessing in a way that is impossible with the open-core. For example, below we manipulate raster data directly in Python using WbW:
```python
import whitebox_workflows as wbw
wbe = wbw.WbEnvironment()
dem = wbe.read_raster('/path/to/data/dem.tif')
high_areas = wbe.new_raster(dem.configs)
print("Finding high elevations")
for row in range(dem.configs.rows):
for col in range(dem.configs.columns):
elev = dem[row, col]
if elev != dem.configs.nodata and elev > 1000.0:
high_areas[row, col] = 1.0
else:
high_areas[row, col] = 0.0
wbe.write_raster(high_areas, 'high_areas.tif', compress=True)
```
Where tools in the open-core take file name strings as inputs, the WbW equivalent functions take in-memory geospatial objects as input parameters. WbW functions also return output objects. This means that for a typical geoprocessing workflow there is significantly less reading/writing of data to the disc. **There is no performance cost incurred by read/write operations during the intermediate processing.** WbW has been designed to meet enterprise-scale geoprocessing workflow needs.
The following example Python script interpolates a lidar file to a digital elevation model (DEM), performs some common pre-processing steps on the DEM, and then runs a flow accumulation operation, before outputting the flow accumulation grid to file:
```python
import whitebox_workflows as wbw
wbe = wbw.WbEnvironment()
lidar = wbe.read_lidar('/path/to/data/myfile.laz')
dem = wbe.lidar_tin_gridding(input_lidar=lidar, returns_included='last', cell_size=1.0)
dem_nodata_filled = wbe.fill_missing_data(dem, filter_size=21)
dem_breached = wbe.breach_depressions_least_cost(dem_nodata_filled, fill_deps=True)
dem_smoothed = wbe.feature_preserving_smoothing(dem_breached, filter_size=15)
flow_accum = wbe.dinf_flow_accum(dem_smoothed, log_transform=True)
wbe.write_raster(flow_accum, "flow_accumulation_grid.tif", compress=True)
```
Notice how each of the five tool functions return data objects that then serve as the inputs for later operations. While there's only one read operation and one write operation in the script, an equivalent WbOC workflow would result in 10 individual read/write operations. This characteristic **can result in significant gains in overall workflow performance**. It is often the case that read/write operations can be the bottle-neck in geoprocessing performance. Fewer read/write operations also means significantly **less wear on your hardware**.
The design of WbW also allows for **more natural geoprocessing of data objects**. For example, rather than using individual raster math tools (e.g. ``Add``, ``Divide``, ``Sin`` etc.), with WbW, you can often treat raster objects like any other numerical variables in scripts--with WbW, Python becomes your raster calculator!
```python
new_raster = 1.0 - (raster1 - raster2) / (raster1 + raster2)
new_raster = dem > 1000.0 # Note: This single line is equivalent to one of the example Python scripts above
new_raster = raster.sin().to_degrees()
new_raster = raster1.max(raster2) # You can use a number instead of a raster as the parameter, e.g. raster.max(100.0)
```
**Overall, if you're using the Whitebox platform to develop Python scripts for geoprocessing tasks, Whitebox Workflows is the clear winner.** It provides easier-to-write and faster-running scripting with less strain on your expensive hardware. Simply put, **it's a more productive geoprocessing environment**.
There is, however, one small downside to using WbW over WbOC. Developing WbW was not a matter of simply compiling the existing WbOC codebase as a library; it took a substantial development effort to create this great product. Whitebox Workflows is not free. **You need to [purchase a valid license activation code](https://www.whiteboxgeo.com/whitebox-workflows-for-python/) to use WbW**. The good news is, annual licenses for WbW are very reasonably priced--only about $10. We want as many people using this wonderful product as possible!
## Installation
If you have Python installed on your machine, simply type ``pip install whitebox-workflows`` at the command prompt. Windows (64-bit), Mac (Intel and ARM), and Linux (x86_64) operating systems are supported.
If you have installed whitebox-workflows Python package before and want to upgrade to the latest version, you can use the following command:
```pip install whitebox-workflows -U```
It is recommended that you use a Python virtual environment to test the whitebox-workflows package.
## Usage
```python
from whitebox_workflows import WbEnvironment
##########################
# Set up the environment #
##########################
wbe = WbEnvironment() # A WbEnvironment object is needed to read/write data and run tools.
wbe.verbose = True # Determines if tools output to std::out
wbe.max_procs = -1
wbe.working_directory = '/path/to/my/data'
############################
# Read some data from disc #
############################
dem = wbe.read_raster('DEM_5m.tif')
points = wbe.read_vector('points.shp')
lidar = wbe.read_lidar('my_lidar_tile.laz')
######################
# Run some functions #
#######################
hillshade_raster = wbe.hillshade(dem, azimuth=270.0)
pointer = wbe.d8_pointer(dem)
watersheds = wbe.watershed(pointer, points)
###########################
# Write some data to disc #
###########################
wbe.write_raster(hillshade_raster, 'hillshade.tif', compress=True)
wbe.write_raster(watersheds, 'watersheds.tif', compress=True)
######################
# Raster map algebra #
######################
elev_in_ft = dem * 3.28084
high_in_watershed = (dem > 500.0) * (watersheds == 1.0)
tan_elev = dem.tan()
dem += 10.0
raster3 = raster1 / raster2
###############################
# Manipulate lidar point data #
###############################
lidar = wbe.read_lidar('/path/to/data/lidar_tile.laz')
lidar_out = wbe.new_lidar(lidar.header) # Create a new file
print('Filtering point data...')
for a in range(lidar.header.number_of_points):
(point_data, time, colour, waveform) = lidar.get_point_record(a)
if point_data.is_first_return() or point_data.is_intermediate_return():
lidar_out.add_point(point_data, time)
wbe.write_lidar(lidar_out, "new_lidar.laz")
```
## Release history
## Version 1.2.8 (May 1, 2024)
- Minor release fixing bug in lidar_join function.
- Updated a number of libraries to newer versions.
## Version 1.2.7 (April 15, 2024)
- Added the filter_lidar_by_percentile function, which extracts a subset of points from an
input LiDAR point cloud that correspond to a user-specified percentile of the points within
the local neighbourhood.
- Added the filter_lidar_by_reference_surface function, which extract a subset of points from an
input LiDAR point cloud that satisfy a query relation with a user-specified raster reference surface.
- Added the improved_ground_point_filter function, which identifies and extracts ground points from
an input LiDAR point cloud.
## Version 1.2.6 (April 4, 2024)
- Added the sieve and nibble functions for class map generalization.
- Added the ridge_and_valley_vectors function for extracting ridge and valley
lines from digital elevation models.
- Added the skyline_analysis tool for performing local landscape visibility
analysis.
- Fixed a bug with the RandomForestRegressionPredict tool, where output
rasters had an integer data type.
## Version 1.2.4 (March 17, 2024)
- Fixed an issue with the stub file (pyi) being saved in the wrong location for
a mixed Rust/Python PyO3 project. This issue resulted in WbW not having correct
type hinting in Python coding environments since we migrated to a mixed project
format.
## Version 1.2.3 (March 17, 2024)
- Added the average_horizon_distance, horizon_area, and sky_view_factor functions.
- Added the standard_deviation_overlay tool.
- Split the random_forest_regression and random_forest_classification tools into
model fitting and prediction stages, e.g. random_forest_regression_fit and
random_forest_regression_prediction.
### Version 1.2.1 (February 25, 2024)
- Added the horton_ratios function for calculating the laws of drainage network composition.
- Fixed a bug with the depth_to_water function, where it threw an error that the input
stream network was not of the correct shape type, even when it was.
### Version 1.1.2 (October 2, 2023)
- Added the ability to use the string 'value' as the TRUE and FALSE parameters of a raster
con statement (conditional evaluation). Previously these statements had to be either a
raster object, a numerical constant, or the strings 'null' or 'nodata'.
- Fixed an issue with the aspect function that had previously been fixed in WbTools, but no
ported to Workflows.
### Version 1.1.1 (September 10, 2023)
- Made several minor bug fixes, including one important one that affected the mosaic function.
### Version 1.1 (June 17, 2023)
- Added ability to read COPC lidar files.
- Added the extract_by_attribute tool to filter out vector features by attribute characteristics.
- Added the deviation_from_regional_direction tool.
- Added the otsu_thresholding tool, which uses Ostu's method for optimal binary thresholding,
transforming the input image into background and foreground pixels.
- Added the topographic_hachures tool.
- Fixed a bug with polygon holes in the raster_to_vector_polygons tool.
- Fixed a bug with the individual_tree_detection tool that prevented use of the min_height parameter
when applied in batch mode.
- Fixed a bug with the breakline_mapping tool in WbW-Pro.
Raw data
{
"_id": null,
"home_page": null,
"name": "whitebox-workflows",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "spatial analysis, GIS, remote sensing",
"author": "Whitebox Geospatial Inc.",
"author_email": "support@whiteboxgeo.com",
"download_url": null,
"platform": null,
"description": "# Whitebox Workflows for Python\n\n\n## What is Whitebox Workflows?\n\nWhitebox Workflows (WbW) is a Python library for advanced geoprocessing, including [more than 400 functions](https://www.whiteboxgeo.com/manual/wbw-user-manual/book/tool_help.html) for GIS and remote sensing analysis operations and for for manipulating common types of raster, vector and LiDAR geospatial data.\n\n> For more details about the project, see [the User Manual](https://www.whiteboxgeo.com/manual/wbw-user-manual/book/introduction.html).\n\n\n## Why Whitebox Workflows when there already is WhiteboxTools Open Core?\n\n**Whitebox Workflows** (WbW) is based on the **WhiteboxTools Open Core** (WbOC) open-source codebase. While the two products share many characteristics and functionality, there are important differences.\n\nThe WhiteboxTools Open Core is a command line back-end program that interfaces with various front-end applications, such as QGIS, ArcGIS and the R and Python scripting languages. Front-end/back-end communication is very limited. Front-ends can only communicate with WbOC by passing text-based commands and receive text-based outputs. Data files are provided as file names and are read into memory during tool operation and output data are written to disc. This design allows WbOC to be readily integrated into other projects. However, it doesn't allow front-ends to directly interact with Whitebox data, and it isn't well suited to longer geoprocessing workflows. Tools in a WbOC based geoprocessing script are essentially run independently of other tools in the same workflow.\n\nBy comparison, **Whitebox Workflows is a native Python extension library**; it has been designed to work with Python, providing a geoprocessing scripting environment. Like the open-core, WbW is developed using the fast programming language Rust, but is compiled to a shared library that can be directly imported into Python scripts, much like NumPy and other common Python scientific libraries. \n\n**Each of the more than 400 geoprocessing tools that users love about the WbOC are also found in WbW.** The library design of WbW affords a much more intimate level of communication between it and your Python geoprocessing script. For instance, with WbW **you can directly manipulate raster, vector, and lidar data objects**, to perform low-level geoprocessing in a way that is impossible with the open-core. For example, below we manipulate raster data directly in Python using WbW:\n\n```python\nimport whitebox_workflows as wbw\n\nwbe = wbw.WbEnvironment()\ndem = wbe.read_raster('/path/to/data/dem.tif')\nhigh_areas = wbe.new_raster(dem.configs)\n\nprint(\"Finding high elevations\")\n\nfor row in range(dem.configs.rows):\n for col in range(dem.configs.columns):\n elev = dem[row, col]\n if elev != dem.configs.nodata and elev > 1000.0:\n high_areas[row, col] = 1.0\n else:\n high_areas[row, col] = 0.0\n\nwbe.write_raster(high_areas, 'high_areas.tif', compress=True)\n```\n\nWhere tools in the open-core take file name strings as inputs, the WbW equivalent functions take in-memory geospatial objects as input parameters. WbW functions also return output objects. This means that for a typical geoprocessing workflow there is significantly less reading/writing of data to the disc. **There is no performance cost incurred by read/write operations during the intermediate processing.** WbW has been designed to meet enterprise-scale geoprocessing workflow needs. \n\nThe following example Python script interpolates a lidar file to a digital elevation model (DEM), performs some common pre-processing steps on the DEM, and then runs a flow accumulation operation, before outputting the flow accumulation grid to file:\n\n```python\nimport whitebox_workflows as wbw\n\nwbe = wbw.WbEnvironment()\n\nlidar = wbe.read_lidar('/path/to/data/myfile.laz')\ndem = wbe.lidar_tin_gridding(input_lidar=lidar, returns_included='last', cell_size=1.0)\ndem_nodata_filled = wbe.fill_missing_data(dem, filter_size=21)\ndem_breached = wbe.breach_depressions_least_cost(dem_nodata_filled, fill_deps=True)\ndem_smoothed = wbe.feature_preserving_smoothing(dem_breached, filter_size=15)\nflow_accum = wbe.dinf_flow_accum(dem_smoothed, log_transform=True)\nwbe.write_raster(flow_accum, \"flow_accumulation_grid.tif\", compress=True)\n```\n\nNotice how each of the five tool functions return data objects that then serve as the inputs for later operations. While there's only one read operation and one write operation in the script, an equivalent WbOC workflow would result in 10 individual read/write operations. This characteristic **can result in significant gains in overall workflow performance**. It is often the case that read/write operations can be the bottle-neck in geoprocessing performance. Fewer read/write operations also means significantly **less wear on your hardware**.\n\nThe design of WbW also allows for **more natural geoprocessing of data objects**. For example, rather than using individual raster math tools (e.g. ``Add``, ``Divide``, ``Sin`` etc.), with WbW, you can often treat raster objects like any other numerical variables in scripts--with WbW, Python becomes your raster calculator!\n\n```python\nnew_raster = 1.0 - (raster1 - raster2) / (raster1 + raster2)\nnew_raster = dem > 1000.0 # Note: This single line is equivalent to one of the example Python scripts above\nnew_raster = raster.sin().to_degrees()\nnew_raster = raster1.max(raster2) # You can use a number instead of a raster as the parameter, e.g. raster.max(100.0)\n```\n\n**Overall, if you're using the Whitebox platform to develop Python scripts for geoprocessing tasks, Whitebox Workflows is the clear winner.** It provides easier-to-write and faster-running scripting with less strain on your expensive hardware. Simply put, **it's a more productive geoprocessing environment**. \n\nThere is, however, one small downside to using WbW over WbOC. Developing WbW was not a matter of simply compiling the existing WbOC codebase as a library; it took a substantial development effort to create this great product. Whitebox Workflows is not free. **You need to [purchase a valid license activation code](https://www.whiteboxgeo.com/whitebox-workflows-for-python/) to use WbW**. The good news is, annual licenses for WbW are very reasonably priced--only about $10. We want as many people using this wonderful product as possible!\n\n\n## Installation\n\nIf you have Python installed on your machine, simply type ``pip install whitebox-workflows`` at the command prompt. Windows (64-bit), Mac (Intel and ARM), and Linux (x86_64) operating systems are supported.\n\nIf you have installed whitebox-workflows Python package before and want to upgrade to the latest version, you can use the following command:\n\n```pip install whitebox-workflows -U```\n\nIt is recommended that you use a Python virtual environment to test the whitebox-workflows package.\n\n\n## Usage\n\n```python\nfrom whitebox_workflows import WbEnvironment\n\n##########################\n# Set up the environment #\n##########################\nwbe = WbEnvironment() # A WbEnvironment object is needed to read/write data and run tools.\nwbe.verbose = True # Determines if tools output to std::out\nwbe.max_procs = -1\nwbe.working_directory = '/path/to/my/data'\n\n############################\n# Read some data from disc #\n############################\ndem = wbe.read_raster('DEM_5m.tif')\npoints = wbe.read_vector('points.shp')\nlidar = wbe.read_lidar('my_lidar_tile.laz')\n\n######################\n# Run some functions #\n#######################\nhillshade_raster = wbe.hillshade(dem, azimuth=270.0)\npointer = wbe.d8_pointer(dem)\nwatersheds = wbe.watershed(pointer, points)\n\n###########################\n# Write some data to disc #\n###########################\nwbe.write_raster(hillshade_raster, 'hillshade.tif', compress=True)\nwbe.write_raster(watersheds, 'watersheds.tif', compress=True)\n\n######################\n# Raster map algebra #\n######################\nelev_in_ft = dem * 3.28084\nhigh_in_watershed = (dem > 500.0) * (watersheds == 1.0)\ntan_elev = dem.tan()\ndem += 10.0 \nraster3 = raster1 / raster2\n\n###############################\n# Manipulate lidar point data #\n###############################\nlidar = wbe.read_lidar('/path/to/data/lidar_tile.laz')\nlidar_out = wbe.new_lidar(lidar.header) # Create a new file\n\nprint('Filtering point data...')\nfor a in range(lidar.header.number_of_points):\n (point_data, time, colour, waveform) = lidar.get_point_record(a)\n if point_data.is_first_return() or point_data.is_intermediate_return():\n lidar_out.add_point(point_data, time)\n\nwbe.write_lidar(lidar_out, \"new_lidar.laz\")\n```\n\n## Release history\n\n## Version 1.2.8 (May 1, 2024)\n- Minor release fixing bug in lidar_join function.\n- Updated a number of libraries to newer versions.\n\n## Version 1.2.7 (April 15, 2024)\n- Added the filter_lidar_by_percentile function, which extracts a subset of points from an \n input LiDAR point cloud that correspond to a user-specified percentile of the points within \n the local neighbourhood.\n- Added the filter_lidar_by_reference_surface function, which extract a subset of points from an \n input LiDAR point cloud that satisfy a query relation with a user-specified raster reference surface.\n- Added the improved_ground_point_filter function, which identifies and extracts ground points from\n an input LiDAR point cloud.\n\n## Version 1.2.6 (April 4, 2024)\n- Added the sieve and nibble functions for class map generalization.\n- Added the ridge_and_valley_vectors function for extracting ridge and valley\n lines from digital elevation models.\n- Added the skyline_analysis tool for performing local landscape visibility\n analysis.\n- Fixed a bug with the RandomForestRegressionPredict tool, where output\n rasters had an integer data type.\n\n## Version 1.2.4 (March 17, 2024)\n- Fixed an issue with the stub file (pyi) being saved in the wrong location for\n a mixed Rust/Python PyO3 project. This issue resulted in WbW not having correct\n type hinting in Python coding environments since we migrated to a mixed project\n format. \n\n## Version 1.2.3 (March 17, 2024)\n- Added the average_horizon_distance, horizon_area, and sky_view_factor functions.\n- Added the standard_deviation_overlay tool.\n- Split the random_forest_regression and random_forest_classification tools into\n model fitting and prediction stages, e.g. random_forest_regression_fit and\n random_forest_regression_prediction.\n\n### Version 1.2.1 (February 25, 2024)\n- Added the horton_ratios function for calculating the laws of drainage network composition.\n- Fixed a bug with the depth_to_water function, where it threw an error that the input\n stream network was not of the correct shape type, even when it was.\n\n### Version 1.1.2 (October 2, 2023)\n- Added the ability to use the string 'value' as the TRUE and FALSE parameters of a raster \n con statement (conditional evaluation). Previously these statements had to be either a\n raster object, a numerical constant, or the strings 'null' or 'nodata'.\n- Fixed an issue with the aspect function that had previously been fixed in WbTools, but no\n ported to Workflows.\n\n### Version 1.1.1 (September 10, 2023)\n- Made several minor bug fixes, including one important one that affected the mosaic function.\n\n### Version 1.1 (June 17, 2023)\n- Added ability to read COPC lidar files.\n- Added the extract_by_attribute tool to filter out vector features by attribute characteristics.\n- Added the deviation_from_regional_direction tool.\n- Added the otsu_thresholding tool, which uses Ostu's method for optimal binary thresholding,\n transforming the input image into background and foreground pixels.\n- Added the topographic_hachures tool.\n- Fixed a bug with polygon holes in the raster_to_vector_polygons tool.\n- Fixed a bug with the individual_tree_detection tool that prevented use of the min_height parameter\n when applied in batch mode.\n- Fixed a bug with the breakline_mapping tool in WbW-Pro.\n\n",
"bugtrack_url": null,
"license": null,
"summary": "whitebox_workflows is a Python library for advanced spatial analysis.",
"version": "1.2.8",
"project_urls": null,
"split_keywords": [
"spatial analysis",
" gis",
" remote sensing"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "80b3923d20f41293ae32f6fa755ef8f7d5f4279404f2e881eff5aebbb61aa12e",
"md5": "218cf29fc2960ab3a5bba9ab953bfda2",
"sha256": "b232e0135fbd7ad1c89eb717553a3639c228248a3894daff69efc55e4b451cff"
},
"downloads": -1,
"filename": "whitebox_workflows-1.2.8-cp38-abi3-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "218cf29fc2960ab3a5bba9ab953bfda2",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 8337139,
"upload_time": "2024-05-01T12:19:21",
"upload_time_iso_8601": "2024-05-01T12:19:21.041868Z",
"url": "https://files.pythonhosted.org/packages/80/b3/923d20f41293ae32f6fa755ef8f7d5f4279404f2e881eff5aebbb61aa12e/whitebox_workflows-1.2.8-cp38-abi3-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e0107f32bb783abd0a957ebf425c05eb0e9586f87e1df0fe8f26251e68822316",
"md5": "67db2aa7c910e6933b2b28fb1b31bc55",
"sha256": "d81cb0a6d990ce7f3fdd7ea2a24a602960dc738131dae03dbfa1324a76628886"
},
"downloads": -1,
"filename": "whitebox_workflows-1.2.8-cp38-abi3-manylinux_2_31_x86_64.whl",
"has_sig": false,
"md5_digest": "67db2aa7c910e6933b2b28fb1b31bc55",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 10833796,
"upload_time": "2024-05-01T12:19:23",
"upload_time_iso_8601": "2024-05-01T12:19:23.079729Z",
"url": "https://files.pythonhosted.org/packages/e0/10/7f32bb783abd0a957ebf425c05eb0e9586f87e1df0fe8f26251e68822316/whitebox_workflows-1.2.8-cp38-abi3-manylinux_2_31_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "64edbc4d5b66c1df26cb26233eb336a9827e1a47e3860edb49a3e412248f4663",
"md5": "088b0819e86da65fee34a8d2a962145e",
"sha256": "80c9d462484218fdb16eb0c0e4b8b0913b3c36ef1c12bd6e217a969121107ea8"
},
"downloads": -1,
"filename": "whitebox_workflows-1.2.8-cp38-abi3-win_amd64.whl",
"has_sig": false,
"md5_digest": "088b0819e86da65fee34a8d2a962145e",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 9036959,
"upload_time": "2024-05-01T12:19:25",
"upload_time_iso_8601": "2024-05-01T12:19:25.802703Z",
"url": "https://files.pythonhosted.org/packages/64/ed/bc4d5b66c1df26cb26233eb336a9827e1a47e3860edb49a3e412248f4663/whitebox_workflows-1.2.8-cp38-abi3-win_amd64.whl",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-05-01 12:19:21",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "whitebox-workflows"
}
JSON