Fast Geospatial Feature Storage API

Related tags

Geospatial Hecate
Overview

Hecate

OpenStreetMap Inspired Data Storage Backend Focused on Performance and GeoJSON Interchange

Hecate Feature Comparison

Feature Hecate ESRI MapServer OSM Backend
Vector Tile Creation ✔️ ✔️
Streaming Query API ✔️
Multi User Support ✔️ ✔️ ✔️
Feature History ✔️ ✔️
Atomic API Operations ✔️ ✔️
GeoJSON-LD Based API ✔️ ✔️
Mapbox GL JS Styling ✔️ ✔️
Integrated Data Stats ✔️ ✔️

Table Of Contents

  1. Brief
  2. Why Use Hecate
  3. Table of Contents
  4. Related Libraries
  5. Build Environment
  6. Docker File
  7. Feature Format
  8. Server
  9. API

Related Libraries

  • HecateJS Javascript Library & CLI Tool for interacting with the Hecate API
  • Hecate-Example Script for importing some fake data for testing

Built something cool that uses the Hecate API? Let us know!

Build Environment

  • Start by installing Rust from rust-lang.org, this will install the current stable version
curl https://sh.rustup.rs -sSf | sh
  • Hecate is designed to run on the latest stable version of Rust, but has been thoroughly tested with 1.38.0. This will install 1.38.0
curl https://sh.rustup.rs -sSf | sh -s --  --default-toolchain 1.38.0
  • Source your bashrc/bash_profile to update your PATH variable
source ~/.bashrc        # Most Linux Distros, some OSX
source ~/.bash_profile  # Most OSX, some Linux Distros
  • Download and compile the project and all of it's libraries
cargo build
  • Ensure you have database dependencies postgres and postgis installed.

  • Create the hecate database using the provided schema file. These instructions assume you have set up a role postgres with sufficient privileges.

echo "CREATE DATABASE hecate;" | psql -U postgres

psql -U postgres -f src/schema.sql hecate
  • This step will also create a database role called hecate and hecate_read. If the connection fails due to authentication, your pg_hba file may not be set up to trust local connections.

Your pb_hba file location can be found using echo "show hba_file;" | psql -U postgres

Replace the file with the following:

local all postgres trust
local all all trust
host all all 127.0.0.1/32 trust
host all all ::1/128 trust
host replication postgres samenet trust
cd web/
yarn install
  • Build frontend UI
yarn build

Note: if actively working on developing the UI, a live reloading server can be started via:

yarn dev
  • Start the server
cargo run
  • Test it is working - should respond with HTTP200
curl localhost:8000

You will now have an empty database which can be populated with your own data/user accounts.

If you want to populate the database with sample data for testing, ingalls/hecate-example has a selection of scripts to populate the database with test data.

Docker File (Coverage Tests)

The Docker file is designed to give the user a testing environment to easily run rust tests.

Install docker and then run

docker build .

docker run {{HASH FROM ABOVE}}

Feature Format

Hecate is designed as a GeoJSON first interchange and uses standard GeoJSON with a couple additions and exceptions as outlined below.

Supported Geometry Types

  • Point
  • MultiPoint
  • LineString
  • MultiLineString
  • Polygon
  • MultiPolygon

Unsupported Geometry Types

  • GeometryCollection

Additional Members

The following table outlines top-level members used by hecate to handle feature creation/modification/deletion.

Key/Value pairs in the .properties of a given feature are never directly used by the server and are simply passed through to the storage backend. This prevents potential conflicts between user properties and required server members.

Member Notes
id The unique integer id of a given feature. Note that all features get a unique id accross GeoJSON Geometry Type
version The version of a given feature, starts at 1 for a newly created feature
action Only used for uploads, the desired action to be performed. One of create, modify, delete, or restore
key Optional A String containing a value that hecate will ensure remains unique across all features. Can be a natural id (wikidata id, PID, etc), computed property hash, geometry hash etc. The specifics are left up to the client. Should an attempt at importing a Feature with a differing id but identical key be made, the feature with will be rejected, ensuring the uniqueness of the key values. By default this value will be NULL. Duplicate NULL values are allowed.
force Optional Boolean allowing a user to override version locking and force UPSERT a feature. Disabled by default

Examples

Downloaded Features

{
    "id": 123,
    "key": "Q1234",
    "version": 2,
    "type": "Feature",
    "properties": {
        "shop": true,
        "name": "If Pigs Could Fly"
    },
    "geometry": {
        "type": "Point",
        "coordinates": [0,0]
    }
}

Downloaded Features will return the integer id of the feature, the current version and the user supplied properties and geojson. action is not applicable for downloaded features, it is only used on upload.

Create Features

{
    "action": "create",
    "key": "11-22-33-44-1234",
    "type": "Feature",
    "properties": {
        "shop": true,
        "name": "If Pigs Could Fly"
    },
    "geometry": {
        "type": "Point",
        "coordinates": [0,0]
    }
}

A features being uploaded for creation must have the action: create property. Since an id and version have not yet been assigned they must be omitted. Should an id be included it will be ignored. Adding a version property will throw an error.

Optionally create actions can use the force: true option to perform an UPSERT like option. In this mode the uploader must specify the key value. Hecate will then INSERT the feature if the key value is new, if the key is already existing, the existing feature will be overwritten with the forced feature. Note that this mode ignores version checks and is therefore unsafe.

Force Prerequisites

  • Disabled by default, must be explicitly enabled via Custom Authentication
  • Can only be performed on a feature with action: create
  • Must specify a valid key

Modify Features

{
    "id": 123,
    "key": "Fn4aAsJ30",
    "version": 1,
    "action": "modify",
    "type": "Feature",
    "properties": {
        "shop": true,
        "name": "If Pigs Could Fly"
    },
    "geometry": {
        "type": "Point",
        "coordinates": [0,0]
    }
}

A feature being uploaded for modification must have the action: modify as well as the id and version property. The id is the integer id of the feature to modify and the version property is the current version of the feature as stored by the server. If the version uploaded does not match the version that the server has stored, the modify will fail. This prevents consecutive edits from conflicting.

Note that the modify operation is not a delta operation and the full feature with the complete Geometry & All Properties must be included with each modify.

Also note that since the id pool is shared accross geometry types, an id is allowed to change it's geometry type. eg. If id: 1 is a Point and then a subsequent action: modify with a Polygon geometry is performed, id: 1 is allowed to switch to the new Polygon type.

Delete Features

{
    "id": 123,
    "version": 1,
    "action": "delete",
    "type": "Feature",
    "properties": null,
    "geometry": null
}

A feature being uploaded for deletion must have the action: delete as well as the id and version property. See Modify Features above for an explanation of those properties.

Note the properties and geometry attributes must still be included. They can be set to null or be their previous value. They will be ignored.

Restore Features

{
    "id": 123,
    "version": 2,
    "key": "new-optional-key",
    "action": "restore",
    "type": "Feature",
    "properties": {
        "test": true,
        "random_array": [1, 2, 3]
    },
    "geometry": {
        "type": "Point",
        "coordinates": [ 12.34, 56.78 ]
    }
}

A feature being uploaded for restoration must have the action: restore as well as the id and version properties. A restore action is just a modify on a deleted feature.

Restore places the new given geometry/properties at the id specified. It does not automatically roll back the feature to it's state before deletion, if this is desired, one must use the Feature History API to get the state before deletion and then perform the restore action.

Note: Restore will throw an error if an feature still exists.

Server

This section of the guide goes over various options for launching the server

Hecate can be launched with default options with

cargo run

Database

Main Connection

By default hecate will attempt to connect to hecate@localhost:5432/hecate for read/write operations and simultaneously connect to hecate_read@localhost:5432/hecate for sandboxed read only operations.

Note that only postgres w/ postgis enabled is supported.

This database should be created prior to launching hecate. For instructions on setting up the database see the Build Environment section of this doc.

A custom database name, postgres user or port can be specified using the database flag.

Example

cargo run -- --database "<USER>:<PASSWORD>@<HOST>/<DATABASE>"

cargo run -- --database "<USER>@<HOST>/<DATABASE>"

Sandbox Connection

A second read-only account should also be created with permissions to SELECT from the geo & deltas table. This endpoint will only be used for the query endpoint, which allows arbitrary user query execution. A sample implementation can be found in the schema.sql document

Note: It is up to the DB Admin to ensure the permissions are limited in scope for this user. Hecate will expose access to this user via the query endpoint.

If multiple instances of database_sandbox are present, hecate will load balance accross the multiple read instances.

cargo run -- --database_sandbox "<USER>:<PASSWORD>@<HOST>/<DATABASE>"

cargo run -- --database_sandbox "<USER>@<HOST>/<DATABASE>"

cargo run -- --database_sandbox "<USER>@<HOST>/<DATABASE>" --database_sandbox "<USER>@<HOST>/<DATABASE>"

Replica Connection [optional]

Finally, optionally multiple --database_replica conncetions can be specified which hecate will use to load balance read traffic accross, alleviating capacity on the master db for write operations.

cargo run -- --database_replica "<USER>:<PASSWORD>@<HOST>/<DATABASE>"

cargo run -- --database_replica "<USER>@<HOST>/<DATABASE>"

cargo run -- --database_replica"<USER>@<HOST>/<DATABASE>" --database_replica "<USER>@<HOST>/<DATABASE>"

JSON Validation

By default Hecate will allow any property on a given GeoJSON feature, including nestled arrays, maps, etc.

A custom property validation file can be specified using the schema flag.

Example

cargo run -- --schema <PATH-TO-SCHEMA>.json

Note hecate currently supports the JSON Schema draft-04. Once draft-06/07 support lands in valico we can support newer versions of the spec.

Custom Authentication

By default the Hecate API is most favourable to a crowd-sourced data server. Any users can access the data/vector tiles, users can create & manage data, and admins can manage user accounts.

This provides a middle ground for most users but all endpoints are entirely configurable and can run from a fully open server to fully locked down.

If the default values aren't suitable for what you intend, passing in an authentication configuration JSON document will override the defaults.

Example

cargo run -- --auth path/to/auth.json

Contents of auth.json

{
    "endpoints": {
        "server": "public",
        "schema": null,
        "mvt": {
            "get": "user",
            "regen": "admin",
            "meta": null
        },
        "users": {
            "info": "admin",
            "create": "admin",
            "create_session": null
        },

        ....

    }
}

It is important to note that if custom authentication is used, every category must be either disabled or have an option for every sub category within it set. One cannot conditionally override only a subset of of the default options. This is for the security of private servers, since adding a new API endpoint is a non-breaking change, the server checks that you have specified a policy for every endpoint or are happy with just the defaults before it will start.

IE:

The below schema is invalid. Each category (schema, user, style) etc. must be specified as disabled or have a map containing the auth for each subkey.

{
    "endpoint": {
        "schema": null
    }
}

Behavior Types

Type Description
"public" Allow any authenticated or unauthenticated user access
"admin" Allow only users with the access: 'admin' property on their user accounts access
"user" Allow any user access to the endpoint
"self" Only the specific user or an admin can edit their own metadata
"disabled" Disable all access to the endpoint

Endpoint Lookup

Example Endpoint Config Name Default Supported Behaviors Notes
GET /api server public All
Server Meta meta null 2
GET /api/meta/<key> meta::get public All
POST /api/meta/<key> meta::set admin user, admin, disabled
JSON Schema schema null 2
GET /api/schema schema::get public All
Custom Auth JSON auth null 2
GET /api/auth auth::get public All
Mapbox Vector Tiles mvt null 2
DELETE /api/tiles mvt::delete admin All
GET /api/tiles/<z>/<x>/<y> mvt::get public All
GET /api/tiles/<z>/<x>/<y>/regen mvt::regen user All
GET /api/tiles/<z>/<x>/<y>/meta mvt::meta public All
Users user null 2
GET /api/users user::list user All
GET /api/user/info user::info self self, admin, disabled
GET /api/create user::create public All
GET /api/create/session user::create_session self self, admin, disabled
Mapbox GL Styles style null 2
POST /api/style style::create self self, admin, disabled
PATCH /api/style style::patch self self, admin, disabled
POST /api/style/<id>/public style::set_public self All
POST /api/style/<id>/private style::set_private self self, admin, disabled
DELETE /api/style/<id> style::delete self self, admin, disabled
GET /api/style/<id> style::get public All 1
GET /api/styles style::list public All 1
Deltas delta null 2
GET /api/delta/<id> delta::get public All
GET /api/deltas delta::list public All
Webhooks webhooks null 2
GET /api/webhooks/<id> webhooks::get admin All
POST /api/webhooks/<id> webhooks::set admin All
Data Stats stats public All
GET /api/data/stats stats::get public All
Features feature null 2
POST /api/data/feature(s) feature::create user user, admin, disabled
GET /api/data/feature/<id> feature::get public All
GET /api/data/feature/<id>/history feature::history public All
POST /api/data/feature(s) w/ force` feature::force admin user, admin, disabled
Clone clone null 2
GET /api/data/clone clone::get user All
GET /api/data/query clone::query user All
Bounds bounds null 2
GET /api/bounds bounds::list public All
GET /api/bounds/<id> bounds::get public All
POST /api/bounds/<id> bounds::create admin All
DELETE /api/bounds/<id> bounds:delete admin All
OpenStreetMap Shim osm null 2
GET /api/0.6/map osm::get public All 3
PUT /api/0.6/changeset/<id>/upload osm::create user user, admin, disabled 3

Notes

  1. This only affectes public styles. The private attribute on a style overrides this. A private style can never be seen publicly regardless of this setting.
  2. This is a category, the only valid option is null this will disable access to the endpoint entirely
  3. OSM software expects the authentication on these endpoints to mirror OSM. Setting these to a non-default option is supported but will likely have unpredicable support when using OSM software. If you are running a private server you should disable OSM support entirely.

API

Index

GET /

HTTP Healthcheck URL, currently returns Hello World!

Example

curl -X GET 'http://localhost:8000/'

Admin Interface

View the Admin Interface in your browser by pointing to 127.0.0.1:8000/admin/index.html


Meta

GET /api

Return a JSON object containing metadata about the server

Example

curl -X GET 'http://localhost:8000/api'

Data Stats

Note: Analyze stats depend on the database having ANALYZE run. For performance reasons these stats are calculated from ANALYZEd stats where possible to ensure speedy results. For more up to date stats, ensure your database is running ANALYZE more often. This can be done manually in the database or by using the /api/data/stats/regen API.

GET /api/data/stats

Return a JSON object containing statistics and metadata about the geometries stored in the server

Example

curl -X GET 'http://localhost:8000/api/data/stats'

GET /api/data/stats/regen

Perform an ANAYLZE call on the geo table to update the global stats.

Example

curl -X GET 'http://localhost:8000/api/data/stats/regen'

Styles

GET /api/styles

Return an array containing a reference to every public style

Example

curl -X GET 'http://localhost:8000/api/styles'

GET /api/styles/<user id>

Return an array containing styles owned by a particular user.

By default any request will only return the public styles for a given user.

If an authenticated user requests their own styles, it will return their public and private styles.

Options

Option Notes
<user id> REQUIRED Numeric ID of the user to get styles from

Example

Return only public styles of user 1

curl -X GET 'http://localhost:8000/api/styles/1'

User requesting their own styles will get public & private styles

curl -X GET \
    -u 'username:password' \
    'http://localhost:8000/api/styles/1'

POST /api/style

Create a new private style attached to the authenticated user

Example

curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{"name": "Name of this particular style", "style": "Mapbox Style Object Here"}' \
    -u 'username:password' \
    'http://localhost:8000/api/style'

DELETE /api/style/<id>

Delete a particular style by id. Users must be authorized and can only delete styles created by them.

Options

Option Notes
<id> REQUIRED Numeric ID of a given style to delete

Example

curl -X DELETE 'http://localhost:8000/api/style/1'

GET /api/style/<id>

Get a particular style by id, public styles can be requested unauthenticated, private styles can only be obtained by the corresponding user making the request.

Options

Option Notes
<id> REQUIRED Numeric ID of a given style to download

Example

curl -X GET 'http://localhost:8000/api/style/1'

PATCH /api/style/<id>

Update a style - auth required - users can only update their own styles

Options

Option Notes
<id> REQUIRED Numeric ID of a given style to download

Example

curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{"name": "New Name", "style": "New Mapbox Style Object Here"}' \
    -u 'username:password' \
    'http://localhost:8000/api/style/1'

POST /api/style/<id>/private

Update a public style and mark it as private.

Note: Once a style is public other users may have cloned it. This will not affect cloned styles that were made when it was public.

Options

Option Notes
<id> REQUIRED Numeric ID of a given style to download

Example

curl -X POST \
    -u 'username:password' \
    'http://localhost:8000/api/style/1/private'

POST /api/style/<id>/public

Update a style to make it public.

It will then appear to all users in the global styles list and other users will be able to download, clone, and use it

Options

Option Notes
<id> REQUIRED Numeric ID of a given style to download

Example

curl -X POST \
    -u 'username:password' \
    'http://localhost:8000/api/style/1/public'

Schema

GET /api/schema

Return a JSON object containing the schema used by the server or return a 404 if no schema file is in use.

Example

curl -X GET 'http://localhost:8000/api/schema'

Authentication

GET /api/auth

Returns a JSON object containing the servers auth permissions as defined by the default auth rules or the custom JSON auth as defined in the Custom Authentication section of this guide

Example

curl -X GET 'http://localhost:8000/api/auth'

Vector Tiles

Admin Only

DELETE /api/tiles

Remove all tiles from the integrated tile cache

Example

curl -X DELETE 'http://localhost:8000/api/tiles

GET /api/tiles/<z>/<x>/<y>

Request a vector tile for a given set of coordinates. A Mapbox Vector Tile is returned.

Options

Option Notes
<z> REQUIRED Desired zoom level for tile
<x> REQUIRED Desired x coordinate for tile
<y> REQUIRED Desired y coordinate for tle

Example

curl -X GET 'http://localhost:8000/api/tiles/1/1/1'

GET /api/tiles/<z>/<x>/<y>/meta

Return any stored metadata about a given tile.

Options

Option Notes
<z> REQUIRED Desired zoom level for tile
<x> REQUIRED Desired x coordinate for tile
<y> REQUIRED Desired y coordinate for tle

Example

curl -X GET 'http://localhost:8000/api/tiles/1/1/1/meta'

GET /api/tiles/<z>/<x>/<y>/regen

Allows an authenticated user to request a new tile for the given tile coordinates, ensuring the tile isn't returned from the tile cache.

Options

Option Notes
<z> REQUIRED Desired zoom level for tile
<x> REQUIRED Desired x coordinate for tile
<y> REQUIRED Desired y coordinate for tle

Example

curl -X GET \
    -u 'username:password' \
    'http://localhost:8000/api/tiles/1/1/1/regen

Webhooks

GET /api/webhooks

Return a JSON object containing a list of all webhooks maintained by the server

Example

curl -X GET 'http://localhost:8000/api/webhooks'

GET /api/webhooks/<id>

Return a JSON object containing information about a specific webhook

Options

Option Notes
<id> REQUIRED ID of the webhook to retrieve

Example

curl -X GET 'http://localhost:8000/api/webhooks/1'

POST /api/webhooks/<id>

Update a webhook ID with the given webhook data

Options

Option Notes
<id> REQUIRED ID of the webhook to update

Example

curl
    -X POST
    -H "Content-Type: application/json" \
    -d '{ "name": "webhook name", "url": "https://example.com", "actions": ["meta", "user", "delta", "style"] }' \
    -u 'username:password' \
    'http://localhost:8000/api/webhooks'

DELETE /api/webhooks/<id>

Delete a given webhook

Options

Option Notes
<id> REQUIRED ID of the webhook to delete

Example

curl -X DELETE 'http://localhost:8000/api/webhooks/1'


User Options

GET /api/users

Get a list of users (up to 100) or filter by a given user prefix.

Options

Option Notes
filter Optional Desired search prefix for username
limit Optional Optionally limit the number of returned results

Example

curl -X GET 'http://localhost:8000/api/users'

GET /api/user/create

Create a new user, provied the username & email are not already taken

Options

Option Notes
username REQUIRED Desired username, must be unique
password REQUIRED Desired password
email REQUIRED Desired email, must be unique

Example

curl -X GET 'http://localhost:8000/api/user/create?username=ingalls&password=yeaheh&[email protected]

GET /api/user/session

Return a new session cookie and the uid given an Basic Authenticated request.

Example

curl -X GET \
    -u 'username:password' \
    'http://localhost:8000/api/user/session

GET /api/user/info

Allows an authenticated user to obtain information about their own account

Example

curl -X GET \
    -u 'username:password' \
    'http://localhost:8000/api/user/info'

Admin Only

GET /api/user/<id>

Obtain information about any user in the system by their numeric User ID.

Note the information returned is the same information that a user is able to lookup about themself with the GET /api/user/info endpoint.

Options

Option Notes
<id> REQUIRED User ID to obtain user information of

Example

curl -X GET 'http://localhost:8000/api/user/create?username=ingalls&password=yeaheh&[email protected]

Admin Only

PUT /api/user/<id>/admin

Allows an admin to add another user to the admin pool.

Options

Option Notes
<id> REQUIRED User ID to obtain user information of

Example

curl -X PUT \
    -u 'username:password' \
    'http://localhost:8000/api/user/1/admin'

Admin Only

DELETE /api/user/<id>/admin

Allows an existing admin to remove another user from the admin pool.

Options

Option Notes
<id> REQUIRED User ID to obtain user information of

Example

curl -X DELETE \
    -u 'username:password' \
    'http://localhost:8000/api/user/1/admin'

Downloading via Clone

GET /api/data/clone

Return a Line-Delimited GeoJSON stream of all features currently stored on the server.

Note: All streaming GeoJSON endpoints will send the Unitcode End Of Transmission, EOT (0x04) on stream completion. This can be used to ensure that a stream did not exit early.

Example

curl -X GET 'http://localhost:8000/api/data/clone'

Downloading via Query

GET /api/data/query

Return a Line-Delimited GeoJSON stream of all features that match the given query.

The query must be a valid SQL query against the geo table. Note that the geo is the only table that this endpoint can access. Only read operations are permitted.

Note: All streaming GeoJSON endpoints will send the Unitcode End Of Transmission, EOT (0x04) on stream completion. This can be used to ensure that a stream did not exit early.

IE:

SELECT count(*) FROM geo
SELECT props FROM geo WHERE id = 1

Options

Option Notes
query=<query> SQL Query to run against Geometries
limit=<limit> Optional Optionally limit the number of returned results

Examples

curl -X GET 'http://localhost:8000/api/data/query?query=SELECT%20count(*)%20FROM%20geo'
curl -X GET 'http://localhost:8000/api/data/query?query=SELECT%20props%20FROM%20geo%20WHERE%20id%20%3D%201'

Boundaries

Boundaries allow downloading data via a set of pre-determined boundary files.

GET /api/data/bounds

Return an array of possible boundary files with which data can be extracted from the server with

Options

Option Notes
filter Optional Desired search prefix for username
limit Optional Optionally limit the number of returned results

Example

curl -X GET 'http://localhost:8000/api/data/bounds'

GET /api/data/bounds/<bounds>

Return line delimited GeoJSON Feature of all the geometries within the specified boundary file.

Note: All streaming GeoJSON endpoints will send the Unitcode End Of Transmission, EOT (0x04) on stream completion. This can be used to ensure that a stream did not exit early.

Options

Option Notes
<bounds> REQUIRED One of the boundary files as specified via the /ap/data/bounds

Example

curl -X GET 'http://localhost:8000/api/data/bounds/us_dc'

POST /api/data/bounds/<bounds>

Create or replace a boundary with the given name.

Note: Boundaries must be a Polygon or MultiPolygon Feature GeoJSON.

Options

Option Notes
<bounds> REQUIRED the name of the bounds to create or replace

Example

curl -X POST \
    -H "Content-Type: application/json" \
    -d '{"type": "Feature", "properties": {}, "geometry": { "type": "Point", "coordinates": [ 1.1, 1.1 ] } }' \
    -u 'username:password' \
    'http://localhost:8000/api/data/bounds/us_dc'

DELETE /api/data/bounds/<bounds>

Delete a bounds file with the given name.

Options

Option Notes
<bounds> REQUIRED the name of the bounds to create or replace

Example

curl -X DELETE \
    -u 'username:password' \
    'http://localhost:8000/api/data/bounds/us_dc'

GET /api/data/bounds/<bounds>/stats

Return statistics about geometries that intersect a given bounds

Options

Option Notes
<bounds> REQUIRED One of the boundary files as specified via the /ap/data/bounds

Example

curl -X GET 'http://localhost:8000/api/data/bounds/us_dc/stats'

GET /api/data/bounds/<bounds>/meta

Return GeoJSON feature representing the bound

Options

Option Notes
<bounds> REQUIRED One of the boundary files as specified via the /ap/data/bounds

Example

curl -X GET 'http://localhost:8000/api/data/bounds/us_dc/meta'

Downloading Individual Features

GET /api/data/feature

Return a single GeoJSON Feature given a query parameter

Options

Option Notes
key=<key> Optional Key value to retrieve a given feature by
point=<lng,lat> Optional Query for a single feature at the given point

Example

curl -X GET 'http://localhost:8000/api/data/feature?key=123'
curl -X GET 'http://localhost:8000/api/data/feature?point=1.1324%2C-45.322'

GET /api/data/feature/<id>

Return a single GeoJSON Feature given its' ID.

Options

Option Notes
<id> REQUIRED Numeric ID of a given feature to download

Example

curl -X GET 'http://localhost:8000/api/data/feature/1542'

GET /api/data/feature/<id>/history

Return an array containing the full feature history for the provided feature id.

Options

Option Notes
<id> REQUIRED Numeric ID of a given feature to download

Example

curl -X GET 'http://localhost:8000/api/data/feature/1542/history'

Downloading Multiple Features

GET /api/data/features

Return streaming Line-Delimited GeoJSON within the provided BBOX or Point

Note: All streaming GeoJSON endpoints will send the Unicode End Of Transmission, EOT (0x04) on stream completion. This can be used to ensure that a stream did not exit early.

Options

Option Notes
bbox=<minX,minY,maxX,maxY> Optional Bounding Box in format left,bottom,right,top
point=<Lng,Lat> Optional Point to query for intersections

Example

curl -X GET 'http://localhost:8000/api/data/features/?bbox=-122.51791%2C37.60447%2C-122.35499%2C37.83244'
curl -X GET 'http://localhost:8000/api/data/features/?point=-95.2734375%2C36.03133177633187'

GET /api/data/features/history

Return streaming Line-Delimited GeoJSON of all versions of features that fall within the provided BBOX or Point. This includes the current version of the feature. Features in delete state will not be included as their geometries are not recorded.

Note: All streaming GeoJSON endpoints will send the Unicode End Of Transmission, EOT (0x04) on stream completion. This can be used to ensure that a stream did not exit early.

Options

Option Notes
bbox=<minX,minY,maxX,maxY> Optional Bounding Box in format left,bottom,right,top
point=<Lng,Lat> Optional Point to query for intersections

Example

curl -X GET 'http://localhost:8000/api/data/features/history?bbox=-122.51791%2C37.60447%2C-122.35499%2C37.83244'
curl -X GET 'http://localhost:8000/api/data/features/history?point=-95.2734375%2C36.03133177633187'

Feature Creation

POST /api/data/feature Auth Required

Create, Modify, or Delete an individual GeoJSON Feature

The Feature must follow format defined in Feature Format.

The feature also must contain a top-level String message attribute describing the changes being made (The delta message)

Example

curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{"action": "create", "message": "Random Changes", "type":"Feature","properties":{"shop": true},"geometry":{"type":"Point","coordinates":[0,0]}}' \
    -u 'username:password' \
    'http://localhost:8000/api/data/feature'

POST /api/data/features Auth Required

Create, Modify, and/or Delete many features via a GeoJSON FeatureCollection

The Features in the FeatureCollection must follow format defined in Feature Format.

The FeatureCollection also must contain a top-level String message attribute describing the changes being made (The delta message)

Note that a mix of create, modify, and delete operations are allowed within each FeatureCollection

Example

curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{"type":"FeatureCollection","message":"A bunch of changes","features": [{"action": "create", "type":"Feature","properties":{"shop": true},"geometry":{"type":"Point","coordinates":[0,0]}}]}' \
    -u 'username:password' \
    'http://localhost:8000/api/data/features'

Deltas

GET /api/deltas

Returns an array of the last limit defined number of deltas (default: 20). with their corresponding metadata. Does not include geometric data on the delta. Request a specific delta to get geometric data.

The deltas endpoint has 2 modes. The first is a fixed list of the last n deltas. The second is listing deltas by time stamp. the query parameters for these two modes are mutually exclusive.

Limit Options

Return the last n deltas starting at the specified offset.

Where n defaults to 20 and can be up to 100 by utilizing the limit parameter

Option Notes
offset=<offset> OPTIONAL Returns deltas before the given offset
limit=<limit> OPTIONAL Increase or decrease the max number of returned deltas (Max 100)

Date Options

Return deltas between a given start and end parameter.

The start parameter should be the most recent TIMESTAMP, while the end parameter should be the furthest back in time.

IE: start > end.

   |---------|------|
Current    start   end
 Time
  • If both start and end are specified, return all deltas by default
  • If start or end is specified, return last 20 deltas or the number specified by limit
Option Notes
start=<start> OPTIONAL Return deltas after n time - ISO 8601 compatible timestamp
end=<end> OPTIONAL Return deltas before n time - ISO 8601 compatible timestamp
limit=<limit> OPTIONAL Increase or decrease the max number of returned deltas (Max 100)

Example

curl -X GET 'http://localhost:8000/api/deltas'
curl -X GET 'http://localhost:8000/api/deltas?offset=3'
curl -X GET 'http://localhost:8000/api/deltas?offset=3&limit=100'

GET /api/deltas/<id>

Returns all data for a given delta as a JSON Object, including geometric data.

Options

Option Notes
<id> REQUIRED Get all data on a given delta

Example

curl -X GET 'http://localhost:8000/api/delta/4'

OpenStreetMap API

The primary goal of the hecate project is a very fast GeoJSON based Interchange. That said, the tooling the OSM community has built around editing is unparalleled. As such, Hecate provides a Work-In-Progress OpenStreetMap Shim to support a subset of API operations as defined by the OSM API v0.6 document.

Important Notes

  • All GeoJSON types can be downloaded via the API and viewed in JOSM
  • MultiPoints
    • Are represented using an OSM Relation
    • The type will be multipoint
    • The member type will be point
  • MultiLineStrings
    • Are represented using an OSM Relation
    • The type will be multilinestring
    • The member will be line
  • Uploading Way & Relation types are not currently supported, attempting to upload them may produce undesirable results.

The following incomplete list of endpoints are implemented with some degree of coverage with the OSM API Spec but are likely incomplete/or written with the minimum flexibility required to support editing from JOSM. See the code for a full list.

GET /api/capabilities

GET /api/0.6/capabilities

Return a static XML document describing the capabilities of the API.

Example

curl -X GET 'http://localhost:8000/api/capabilities'

GET /api/0.6/user/details Auth Required

Returns a static XML document describing the number of unread messages that a user has. Every n minutes JOSM checks this and displays in the interface if there is a new message, to cut down on errors it simply returns a 0 message response.

Example

curl -X GET 'http://localhost:8000/api/0.6/user/details'

PUT /api/0.6/changeset/create Auth Required

Create a new changeset and set the meta information, returning the opened id.

Example

curl \
    -X PUT \
    -d '<osm><changeset><tag k="comment" v="Just adding some streetnames"/></changeset></osm>' \
    'http://localhost:8000/api/0.6/changeset/create

GET /api/0.6/changeset/<changeset_id>/upload Auth Required

Upload osm xml data to a given changeset

Example

curl \
    -X POST \
    -d '<diffResult version="0.6">NODE/WAY/RELATIONS here</diffResult>' \
    'http://localhost:8000/api/0.6/changeset/1/upload'

PUT /api/0.6/changeset/<changeset_id>/close Auth Required

Close a given changeset, preventing further modification to it

Example

curl -X PUT 'http://localhost:8000/api/0.6/changeset/1/close'

Comments
  • Compilation error (with rust & cargo nightly)

    Compilation error (with rust & cargo nightly)

    error[E0432]: unresolved import `std::boxed::FnBox`
     --> /build/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.1/src/fairing/ad_hoc.rs:2:5
      |
    2 | use std::boxed::FnBox;
      |     ^^^^^^^^^^^^^^^^^ no `FnBox` in `boxed`
    
    error: aborting due to previous error
    

    Seems similar to https://github.com/SergioBenitez/Rocket/issues/1042 May you please update to Rocket 0.4.2?

    cc/ @ingalls

    opened by uswoods 11
  • DB connection params documentation

    DB connection params documentation

    Following the installation guide, the database connection cannot be established:

    ERROR 2018-11-19T23:24:23Z: r2d2: database error: FATAL: password authentication failed for user "hecate"

    It does work however with user postgres for the db writer role. For example, this will work:

    cargo run -- --database_read "hecate_read:123456@localhost:5432/hecate" --database "postgres:123456@localhost:5432/hecate"

    This doesn't work:

    cargo run -- --database_read "hecate_read:123456@localhost:5432/hecate" --database "hecate:123456@localhost:5432/hecate"

    (I changed passwords prior to running the example above in order to rule out empty password config issues).

    question 
    opened by benstadin 6
  • JOSM Auth Token

    JOSM Auth Token

    Context

    An unexpected side affect of allowing full server auth in #184 was that JOSM doesn't send authentication except when creating objects. This effectively broke JOSM integration for servers that ran full authentication.

    This PR sidesteps the issue by allowing users to create a URL with the access token in the URL, which can then be used in JOSM, circumventing the need for Basic auth for normally unauthenticated read operations.

    Screenshot from 2019-09-12 14-47-31 Screenshot from 2019-09-12 14-47-36

    cc/ @ingalls

    bug enhancement 
    opened by ingalls 5
  • UUIDs?

    UUIDs?

    We've had discussions in the past about running multiple internal instances of the OSM stack for different data projects, and I imagine we might want to do the same with this tool. It would be nice if you could then later combine the contents of two such servers and not have their IDs collide. Could we consider UUIDs instead of autoincrementing integers? (Not sure this would play nice with JOSM 🤔 )

    opened by apendleton 5
  • Web Feature Service Support (WFS)

    Web Feature Service Support (WFS)

    Context

    Add basic preliminary support for portions of the WFS 2.0.0 spec as defined here: http://www.opengeospatial.org/standards/wfs

    • Initial goal is to allow QGIS to download and interact with features stored in hecate.
    • Future goal is to support all or part of the WFS-T (Transactional) model to allow QGIS to natively support editing Hecate Datastores.

    Progress

    • [ ] Add support for GetCapabilities
      • [x] Define Data & Extent
      • [ ] Remove all unsupported operations, ensuring all capabilities claimed are supported
      • [ ] Read and expose metadata about data provider
      • [ ] Edit metadata via admin web ui
    • [x] Add support for DescribeFeatureType
      • [x] HecatePointData
      • [x] HecateMultiPointData
      • [x] HecateLineStringData
      • [x] HecateMultiLineStringData
      • [x] HecatePolygonData
      • [x] HecateMultiPolygonData
    • [x] Add support for GetFeature
      • [x] Version output
      • [x] Key output
      • [x] Arbitrary Properties
      • [x] Point Geometry
      • [x] MultiPoint Geometry
      • [x] LineString Geometry
      • [x] MultiLineString Geometry
      • [x] Polygon Geometry
      • [x] MultiPolygon Geometry
    • [ ] Compile and Test with OGC WFS Compliance Library: http://cite.opengeospatial.org/teamengine/about/wfs/2.0.0/site/

    cc/ @ingalls

    WIP 
    opened by ingalls 4
  • Arbitrary SQL

    Arbitrary SQL

    • [x] Introduces a hecate_read role to the schema which has restricted Read Only permissions on the geo table
    • [x] Adds /api/data/query endpoint which allows arbitrary SQL queries to be run inside the scope of the hecate_read role.
    • [x] By default requires the user to be authenticated
    • [x] Authentication settings are controlled by the new clone::query scope.
    • [x] Returns the same line delimited GeoJSON other download endpoints offer

    cc/ @mapbox/geocoding-gang @lukasmartinelli

    opened by ingalls 4
  • User Administration

    User Administration

    Context

    Add a UI modal to allow an administrator to modify user accounts

    • Change username
    • Change email
    • Change access level
    • disable account

    Only mergable after https://github.com/mapbox/Hecate/pull/210 lands

    cc/ @ingalls

    enhancement 
    opened by ingalls 3
  • Fantastic Features

    Fantastic Features

    Context

    • Completely rework UI based error handling into a single error handling component
    • Move more UI API calls into the standard hecate library
    • Add support for loading the server schema at load time
    • Add support for displaying schema descriptions in the features panel

    Screenshot from 2019-07-16 23-54-16

    cc/ @ingalls

    enhancement 
    opened by ingalls 3
  • Custom Styles UI

    Custom Styles UI

    Implemented

    • generate improvements to UI architecture
    • Add styles listing & ability to apply style
    • Closes: https://github.com/ingalls/Hecate/issues/46 (GET styles list should return user name)

    TODO

    • Create new style
    • Update an existing style
    • Delete a style
    • Set as public/private
    WIP 
    opened by ingalls 3
  • Rocket/nightly?

    Rocket/nightly?

    Current Hecate relies on the Rocket web framework, which requires the use of the unstable/nightly Rust compiler. Nightly contains language features that are subject to change, and also breaks occasionally, and at least per the current instructions (which recommend installing the latest nightly), each developer contributing to the project might end up with a different compiler with different features, behavior, and bugs depending on when they happen to set up their dev environment.

    Rocket itself doesn't seem particularly close to running on stable (it seems like a project mostly interesting in pushing the language envelope rather than running on stable), and independent of stable vs unstable, the lead dev anticipates a major API overhaul to move towards async as the Rust async story matures.

    The ergonomics do seem nice, but in the interests of building on a solid foundation and making it easy for everyone to work on it, I wonder if we shouldn't consider moving to a framework with a stable API that runs on the stable compiler? Nickel seems like a possibility, or if we wanted to get a head-start on async, maybe Gotham ?

    opened by apendleton 3
  • State of this Project?

    State of this Project?

    Hello,

    What is the state of this project? I can see that the last commit was 8 months ago, but there's no note of abandonment. Is this still being developed?

    cc/ @ingalls

    opened by anlumo 2
  • Create .htmlnanorc

    Create .htmlnanorc

    yarn build failed for me; I saw tree.render is not a function.

    This ~~fixes it~~ works around it for me.

    https://stackoverflow.com/a/67133536

    Context

    cc/ @ingalls

    yarn build
    yarn run v1.19.0
    $ NODE_ENV=prodution parcel build index.html login/index.html --public-url='/admin/' --no-source-maps
    🚨  /home/ia/dev/mapbox/Hecate/web/src/modals/User.vue: tree.render is not a function
        at /home/ia/dev/mapbox/Hecate/web/node_modules/htmlnano/lib/modules/minifySvg.js:19:23
        at /home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:91:45
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:26)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:105:17)
        at traverse (/home/ia/dev/mapbox/Hecate/web/node_modules/posthtml/lib/api.js:111:5)
    error Command failed with exit code 1.
    info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
    qfi 10-09 07:22:19 ~/dev/mapbox/Hecate/web dev %
    mv htmlnanorc .htmlnanorc 
    czu 10-09 07:22:32 ~/dev/mapbox/Hecate/web dev %
    yarn build
    yarn run v1.19.0
    $ NODE_ENV=prodution parcel build index.html login/index.html --public-url='/admin/' --no-source-maps
    ✨  Built in 8.80s.
    
    dist/main.0500f194.js                   844.72 KB    8.45s
    dist/assembly.deb7806c.css              174.47 KB     14ms
    dist/assembly.13c84db5.js                49.02 KB     12ms
    dist/favicon.692d1453.ico                15.04 KB     14ms
    dist/mapbox-gl-geocoder.7f2c12df.css      3.58 KB      8ms
    dist/login/index.html                     1.67 KB     13ms
    dist/index.html                             776 B    276ms
    Done in 9.23s.
    
    opened by whilei 0
  • Hecate Project Clarification

    Hecate Project Clarification

    This is not a real issue but rather a question.

    I'm having a hard time truly understanding the goal of Hecate. It it to provide a framework to take OSM data and produce Vector tiles? Is it to automatically process OSM data which can be updated by users? Will the project aim at automatically import OSM data ? Will it submit changes automatically to OSM? Is its purpose to replace Mapbox's current tile server (I don't know which it is) ?

    Sorry but I'm truly struggling with understanding the tool. In my case, I'm trying to avoid early project costs by hosting/generating my own tiles until I'm able to support Mapbox's cost. Trying to understand if this would be a good alternative to my current cumbersome/manual/error-prone pipeline.

    opened by lhorus 1
  • Version Check

    Version Check

    Context

    Add an endpoint that would perform feature id => version checks to see if a feature has been modified since the feature was originally downloaded.

    This API would be immediately useful for the HecateJS import API, mostly closing the door on one of the remaining reasons as to why an import could fail halfway.

    Endpoint

    POST: URL TBD
    

    Payload Body

    {
        "feature id": "feature version",
       ...
    }
    

    Expected response

    Sucess

    status: HTTP 200 SUCCESS body: empty

    Failure

    status: HTTP 409 CONFLICT body:

    [
        "feature id with version mismatch",
        ...
    ]
    

    cc/ @ingalls

    opened by ingalls 0
  • [UI] Deleted Feature with null properties error

    [UI] Deleted Feature with null properties error

    Context

    Delete features are allowed to have null properties & geometry but the UI will throw an error if a feature with action: delete is attempted to be visualized without the geometry

    Screenshot from 2019-12-11 17-35-37

    Next Actions

    • Drop properties & geometry for all features with action: delete at ingestion.
    • Use history API to populate geometry & properties with last properties/geometry for visualization in the UI

    cc/ @ingalls

    bug good first issue 
    opened by ingalls 0
  • Delta API Start/End

    Delta API Start/End

    Context

    The Delta List API currently supports start/end dates to surface a given list of deltas

    Ref: https://github.com/mapbox/Hecate#get-apideltas

    We should expand these parameters to support more deterministic methods of accessing delta information by alternatively supporting a start/end delta ID.

    Next Actions

    • [ ] Add support for start/end Delta ID
    • [ ] Add support for offsets from a given start ID
    • [ ] Add assoc. tests

    cc/ @ingalls

    enhancement 
    opened by ingalls 0
Releases(v0.82.2-stream-logging.5)
Owner
Mapbox
Mapbox is the location data platform for mobile and web applications. We're changing the way people move around cities and explore our world.
Mapbox
An advanced geospatial data analysis platform

Bringing the power of Whitebox GAT to the world at large This page is related to the stand-alone command-line program and Python scripting API for geo

John Lindsay 683 Jan 5, 2023
Geospatial primitives and algorithms for Rust

geo Geospatial Primitives, Algorithms, and Utilities The geo crate provides geospatial primitive types such as Point, LineString, and Polygon, and pro

GeoRust 990 Jan 1, 2023
Zero-Copy reading and writing of geospatial data.

GeoZero Zero-Copy reading and writing of geospatial data. GeoZero defines an API for reading geospatial data formats without an intermediate represent

GeoRust 155 Dec 29, 2022
Geo-rasterize - a pure-rust 2D rasterizer for geospatial applications

geo-rasterize: a pure-rust 2D rasterizer for geospatial applications This crate is intended for folks who have some vector data (like a geo::Polygon)

null 23 Dec 26, 2022
A single-binary, GPU-accelerated LLM server (HTTP and WebSocket API) written in Rust

Poly Poly is a versatile LLM serving back-end. What it offers: High-performance, efficient and reliable serving of multiple local LLM models Optional

Tommy van der Vorst 13 Nov 5, 2023
Kubernetes leader election using the coordination.k8s.io API.

Kube Coordinate Kubernetes leader election using the coordination.k8s.io API. Kube Coordinate builds upon the kube-rs ecosystem, and implements a stre

Anthony Dodd 4 Dec 14, 2023
An fast, offline reverse geocoder (>1,000 HTTP requests per second) in Rust.

Rust Reverse Geocoder A fast reverse geocoder in Rust. Inspired by Python reverse-geocoder. Links Crate 2.0.0 Docs 1.0.1 Docs Description rrgeo takes

Grant Miner 91 Dec 29, 2022
Blazing fast and lightweight PostGIS vector tiles server

Martin Martin is a PostGIS vector tiles server suitable for large databases. Martin is written in Rust using Actix web framework. Requirements Install

Urbica 921 Jan 7, 2023
Fast 2D Delaunay triangulation in Rust. A port of Delaunator.

delaunator-rs A very fast static 2D Delaunay triangulation library for Rust. A port of Delaunator. Documentation Example use delaunator::{Point, trian

Vladimir Agafonkin 123 Dec 20, 2022
Fast shortest path calculations for Rust

Fast Paths The most famous algorithms used to calculate shortest paths are probably Dijkstra's algorithm and A*. However, shortest path calculation ca

Andi 226 Jan 2, 2023
A fast R-tree for Rust. Ported from an implementation that's designed for Tile38.

rtree.rs A fast R-tree for Rust. Ported from an implementation that's designed for Tile38. Features Optimized for fast inserts and updates. Ideal for

Josh Baker 102 Dec 30, 2022
A fast, offline, reverse geocoder

Rust Reverse Geocoder A fast reverse geocoder in Rust. Inspired by Python reverse-geocoder. Links Crate Changelog Latest Docs v2.0 Docs v1.0 Docs Desc

Grant Miner 82 Dec 3, 2022
Trees for fast location-to-value lookup.

HexTree hextree provides tree structures that represent geographic regions with H3 cells. The primary structures are: HexTreeMap: an H3 cell-to-value

Jay Kickliter 38 Dec 15, 2022
Plugin for macro-, mini-quad (quads) to save data in simple local storage using Web Storage API in WASM and local file on a native platforms.

quad-storage This is the crate to save data in persistent local storage in miniquad/macroquad environment. In WASM the data persists even if tab or br

ilya sheprut 9 Jan 4, 2023
K-dimensional tree in Rust for fast geospatial indexing and lookup

kdtree K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup Crate Documentation Usage Benchmark License Usage Add kdtr

Rui Hu 152 Jan 2, 2023
K-dimensional tree in Rust for fast geospatial indexing and lookup

kdtree K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup Crate Documentation Usage Benchmark License Usage Add kdtr

Rui Hu 154 Jan 4, 2023
Network Block Storage server, written in Rust. Supports pluggable and chainable underlying storage

nbd-rs Disclaimer DO NEVER USE THIS FOR PRODUCTION Do not use this for any data that you cannot afford to lose any moment. Expect data loss, corruptio

Rainlab Inc 10 Sep 30, 2022
UnlimCloud provides unlimited cloud storage for your files, utilizing Telegram as the storage solution

UnlimCloud provides unlimited cloud storage for your files, utilizing Telegram as the storage solution. Simply log in using your Telegram ID, and you are good to go.

inulute 5 Nov 27, 2023
Geospatial primitives and algorithms for Rust

geo Geospatial Primitives, Algorithms, and Utilities The geo crate provides geospatial primitive types such as Point, LineString, and Polygon, and pro

GeoRust 989 Dec 29, 2022
An advanced geospatial data analysis platform

Bringing the power of Whitebox GAT to the world at large This page is related to the stand-alone command-line program and Python scripting API for geo

John Lindsay 683 Jan 5, 2023