Package: wnpp
Severity: wishlist

* Package name    : pelias
  Version         : 
  Upstream Author : Peter Johnson pelias.t...@gmail.com
* URL             : https://github.com/pelias/pelias
* License         : MIT
  Programming Lang: JavaScript
  Description     : Pelias is a modular open-source geocoder using 
Elasticsearch.

metapackage for:
https://github.com/pelias/schema/
https://github.com/pelias/api/
https://github.com/pelias/placeholder
https://github.com/pelias/pip-service
https://github.com/pelias/libpostal-service
https://github.com/pelias/interpolation/
https://github.com/pelias/polylines
https://github.com/pelias/openstreetmap/
https://github.com/pelias/whosonfirst/
https://github.com/pelias/geonames/
https://github.com/pelias/csv-importer
https://github.com/pelias/openaddresses/


A modular, open-source geocoder built on top of Elasticsearch for fast and 
accurate global search.

What are the most interesting features of Pelias?

    Completely open-source and MIT licensed
    A powerful data import architecture: Pelias supports many open-data 
projects out of the box but also works great with private data
    Support for searching and displaying results in many languages
    Fast and accurate autocomplete for user-facing geocoding
    Support for many result types: addresses, venues, cities, countries, and 
more
    Modular design, so you don't need to be an expert in everything to make 
changes
    Easy installation with minimal external dependencies

What are the main goals of the Pelias project?

    Provide accurate search results
    Work equally well for a small city and the entire planet
    Be highly configurable, so different use cases can be handled easily and 
efficiently
    Provide a friendly, welcoming, helpful community that takes input from 
people all over the world

Where did Pelias come from?

Pelias was created in 2014 as an early project at Mapzen. After Mapzen's 
shutdown in 2017, Pelias is now part of the Linux Foundation.
How does it work?

Like any geocoder, Pelias combines full text search techniques with knowledge 
of geography to quickly search over many millions of records, each representing 
some sort of location on Earth.
The Pelias architecture has three main components and several smaller pieces.

Data importers

The importers filter, normalize, and ingest geographic datasets into the Pelias 
database. Currently there are six officially supported importers:

    OpenStreetMap: supports importing nodes and ways from OpenStreetMap
    OpenAddresses: supports importing the hundreds of millions of global 
addresses collected from various authoritative government sources by 
OpenAddresses
    Who's on First: supports importing admin areas and venues from Who's on 
First
    Geonames: supports importing admin records and venues from Geonames
    Polylines: supports any data in the Google Polyline format. It's mainly 
used to import roads from OpenStreetMap
    CSV: supports importing any data in CSV format, which is great for custom 
data or proprietary data

We are always discussing supporting additional datasets. Pelias users can also 
write their own importers, for example to import proprietary data into your own 
instance of Pelias.
Database

The underlying datastore that does most of the query heavy-lifting and powers 
our search results. We use Elasticsearch. Currently version 6 is supported, 
with plans to support Elasticsearch 7 soon.

We've built a tool called pelias-schema that sets up Elasticsearch indices 
properly for Pelias.
Frontend services

This is where the actual geocoding process happens, and includes the components 
that users interact with when performing geocoding queries. The services are:

    API: The API service defines the Pelias API, and talks to Elasticsearch or 
other services as needed to perform queries.
    Placeholder: A service built specifically to capture the relationship 
between administrative areas (a catch-all term meaning anything like a city, 
state, country, etc). Elasticsearch does not handle relational data very well, 
so we built Placeholder specifically to manage this piece.
    PIP: For reverse geocoding, it's important to be able to perform 
point-in-polygon(PIP) calculations quickly. The PIP service is is very good at 
quickly determining which admin area polygons a given point lies in.
    Libpostal: Pelias uses the libpostal project for parsing addresses using 
the power of machine learning. We use a Go service built by the Who's on First 
team to make this happen quickly and efficiently.
    Interpolation: This service knows all about addresses and streets. With 
that knowledge, it is able to supplement the known addresses that are stored 
directly in Elasticsearch and return fairly accurate estimated address results 
for many more queries than would otherwise be possible.

Dependencies

These are software projects that are not used directly but are used by other 
components of Pelias.

There are lots of these, but here are some important ones:

    model: provide a single library for creating documents that fit the Pelias 
Elasticsearch schema. This is a core component of our flexible importer 
architecture
    wof-admin-lookup: A library for performing administrative lookup using 
point-in-polygon math. Previously included in each of the importers but now 
only used by the PIP service.
    query: This is where most of our actual Elasticsearch query generation 
happens.
    config: Pelias is very configurable, and all of it is driven from a single 
JSON file which we call pelias.json. This package provides a library for 
reading, validating, and working with this configuration. It is used by almost 
every other Pelias component
    dbclient: A Node.js stream library for quickly and efficiently importing 
records into Elasticsearch

Reply via email to