### Erlang Quick Start Examples

Source: https://github.com/uxeon/erlgeo

Demonstrates basic usage of the erlgeo library in an Erlang shell, including cloning the repository, starting the application, and performing reverse and forward geocoding operations.

```Erlang
$ git clone git://github.com/uxeon/erlgeo.git
$ cd erlgeo

# Configure
# Put your API key into config/sys.config
# (or check above file to add proper config to your app`s sys.config)

# Testing in Erlang shell
$ make start
1> application:ensure_all_started(erlgeo).
2> erlgeo:reverse(20.0,50.0).
3> erlgeo:forward("Aleje Jerozolimskie 214, Warszawa").
4> erlgeo:forward(<<"Aleje Jerozolimskie 214, Warszawa">>).

```

--------------------------------

### Project Setup and Testing Commands (Shell)

Source: https://github.com/tsamaya/opencage-api-client

Provides essential shell commands for setting up and testing the OpenCageData project. This includes cloning the repository, installing dependencies, configuring API keys, running tests, building the project, and executing example scripts.

```shell
cd repository
pnpm install
echo "OPENCAGE_API_KEY=YOUR-OPENCAGE_DATA_API_KEY" > .env
pnpm run test:coverage
pnpm run build
./scripts/run-examples.sh
```

--------------------------------

### Erlang Geocoding Quick Start

Source: https://github.com/uxeon/erlgeo

This snippet demonstrates how to get started with the erlgeo library. It covers cloning the repository, configuring the API key, and testing basic geocoding functions like reverse and forward geocoding within the Erlang shell.

```bash
# clone
$ git clone git://github.com/uxeon/erlgeo.git
$ cd erlgeo

# Configure
# Put your API key into config/sys.config
# (or check above file to add proper config to your app`s sys.config)

# Testing in Erlang shell
$ make start
1> application:ensure_all_started(erlgeo).
2> erlgeo:reverse(20.0,50.0).
3> erlgeo:forward("Aleje Jerozolimskie 214, Warszawa").
4> erlgeo:forward(<<"Aleje Jerozolimskie 214, Warszawa">>).
```

--------------------------------

### Project Setup and Running Commands

Source: https://github.com/tsamaya/opencage-react-native

Commands to clone the repository, start the development server, and run the application on iOS and Android devices using Yarn.

```shell
clone the repo
yarn start
yarn ios
yarn android
```

--------------------------------

### Development Setup and Testing

Source: https://datasette.io/plugins/datasette-enrichments-opencage

Instructions for setting up the plugin locally for development, including creating a virtual environment, installing dependencies, and running tests.

```shell
cd datasette-enrichments-opencage
python3 -m venv venv
source venv/bin/activate
```

```shell
pip install -e '.["test"]'
```

```shell
pytest
```

--------------------------------

### Build and Test OpenCage API Client

Source: https://github.com/tsamaya/opencage-api-client

Provides commands for setting up, building, and testing the OpenCage API client. This includes installing dependencies, configuring the API key, running tests, and executing example scripts.

```shell
cd repository
pnpm install
echo "OPENCAGE_API_KEY=YOUR-OPENCAGE_DATA_API_KEY" >.env
pnpm run test:coverage
pnpm run build
./scripts/run-examples.sh
```

--------------------------------

### cpp-opencage-geocoder Installation and Usage Overview

Source: https://github.com/karnival/cpp-opencage-geocoder

Provides an overview of how to install and use the cpp-opencage-geocoder library. Details on setup and basic functionality are typically found in this section.

```cpp
/*
  cpp-opencage-geocoder is open-source software distributed under the MIT license – see LICENSE.txt for details.
*/

// Installation and Usage sections are typically detailed here.
// Example structure:
// 
// # Installation
// git clone <repository_url>
// cd cpp-opencage-geocoder
// mkdir build && cd build
// cmake ..
// make
// 
// # Usage
// #include <opencage/geocoder.h>
// 
// int main() {
//   // Initialize geocoder with API key
//   opencage::geocoder geocoder("YOUR_API_KEY");
// 
//   // Perform a geocoding request
//   opencage::geocoder_result results = geocoder.geocode("Berlin, Germany");
// 
//   // Process results
//   if (!results.empty()) {
//     auto lat = results[0].lat;
//     auto lng = results[0].lng;
//     // ...
//   }
//   return 0;
// }
```

--------------------------------

### Development Setup and Testing Commands

Source: https://github.com/eyeseast/geocode-sqlite

Provides essential commands for setting up the development environment. This includes creating and activating a Python virtual environment, installing project dependencies with testing extras, and running the test suite using pytest.

```bash
cd geocode-sqlite
python -m venv .venv
source .venv/bin/activate

# Or if you are using `pipenv`:
pipenv shell

# Now install the dependencies and tests:
pip install -e '.["test"]'

# To run the tests:
pytest
```

--------------------------------

### Install opencage-api-client

Source: https://github.com/tsamaya/opencage-api-client

Install the opencage-api-client library using npm, yarn, or pnpm. Note that starting from v2, dotenv is no longer bundled and must be installed separately if needed for environment variable management.

```bash
npm i --save opencage-api-client
```

```bash
yarn add opencage-api-client
```

```bash
pnpm add opencage-api-client
```

--------------------------------

### Erlang Geocoding Examples

Source: https://github.com/uxeon/erlgeo

Demonstrates basic usage of the `erlgeo` module for geocoding operations, including starting applications and performing reverse and forward geocoding.

```erlang
application:ensure_all_started(erlgeo).
erlgeo:reverse(20.0,50.0).
erlgeo:forward("Aleje Jerozolimskie 214, Warszawa").
erlgeo:forward(<<"Aleje Jerozolimskie 214, Warszawa">>).
```

--------------------------------

### Install OpenCage Go Client

Source: https://github.com/alexliesenfeld/opencage

This snippet shows the command to install the OpenCage Geocoder API client library for Go using the go get command. This is the first step to integrate the client into your Go project.

```bash
go get github.com/alexliesenfeld/opencage
```

--------------------------------

### Project Setup and Management Commands

Source: https://github.com/tsamaya/react-leaflet-opencage

This section details the common commands used for managing the react-leaflet-opencage project, covering installation, testing, local development, and production builds. These commands are typically executed using either Yarn or npm package managers.

```bash
Install dependencies:
$ yarn
# or
$ npm i
```

```bash
Run tests:
$ yarn test
# or
$ npm test
```

```bash
Start development server:
$ yarn start
# or
$ npm start
```

```bash
Build production application:
$ yarn build
# or
$ npm run build
```

--------------------------------

### Install opencage-api-client with npm

Source: https://github.com/tsamaya/opencage-api-client

Installs the opencage-api-client library using npm. Ensure you have Node.js and npm installed on your system.

```shell
npm i --save opencage-api-client
```

--------------------------------

### Install OpenCageData Go Package

Source: https://github.com/alexliesenfeld/opencage

Installs the opencage Go package using the standard Go command-line tool. This command fetches and installs the package and its dependencies.

```shell
go get github.com/alexliesenfeld/opencage
```

--------------------------------

### Install opencage-api-client with yarn

Source: https://github.com/tsamaya/opencage-api-client

Installs the opencage-api-client library using yarn. Ensure you have Node.js and yarn installed on your system.

```shell
yarn add opencage-api-client
```

--------------------------------

### Install opencage-api-client with pnpm

Source: https://github.com/tsamaya/opencage-api-client

Installs the opencage-api-client library using pnpm. Ensure you have Node.js and pnpm installed on your system.

```shell
pnpm add opencage-api-client
```

--------------------------------

### Install opencage-geocoder Ruby Gem

Source: https://opencagedata.com/tutorials/geocode-in-ruby

Instructions for installing the 'opencage-geocoder' Ruby gem, either directly via the 'gem install' command or by adding it to a Gemfile.

```Ruby
gem install opencage-geocoder
```

```Ruby
source 'https://rubygems.org'
gem 'opencage-geocoder'
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/tsamaya/react-leaflet-opencage

Steps to clone the repository and install necessary project dependencies using either Yarn or npm package managers.

```Shell
cd path/to/cloned/repo
```

```Shell
yarn
or
npm i
```

--------------------------------

### Install with Composer

Source: https://github.com/opencagedata/php-opencage-geocode

This command installs the opencage/geocode library into your project using Composer. It's the recommended and easiest way to get started.

```php
$ composer require opencage/geocode
```

--------------------------------

### Running OpenCagex Locally

Source: https://github.com/dsantosmerino/open-cagex

Instructions for cloning the repository, installing dependencies, and running tests or linting the project.

```Shell
git clone git@github.com:dsantosmerino/open-cagex.git
cd open_cagex
mix deps.get
mix test
mix credo
```

--------------------------------

### Get APOC Version

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

Retrieve the currently installed version of the APOC (Awesome Procedures On Cypher) library. This function is useful for verifying the APOC installation and compatibility.

```cypher
RETURN apoc.version();
```

--------------------------------

### Build and Install APOC from Source

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

Instructions to clone the APOC repository, build the project using Gradle (specifically the 'shadow' task for a fat JAR), and then copy the resulting JAR file into the Neo4j plugins directory, followed by a Neo4j restart.

```shell
git clone https://github.com/neo4j-contrib/neo4j-apoc-procedures
cd neo4j-apoc-procedures
./gradlew shadow
cp build/full/libs/apoc-<version>-all.jar $NEO4J_HOME/plugins/
$NEO4J_HOME/bin/neo4j restart
```

--------------------------------

### Installation Commands

Source: https://github.com/karnival/cpp-opencage-geocoder

Commands to clone the repository, configure the build using CMake, and compile the project. This process assumes libcurl is already installed on the system.

```bash
git clone https://github.com/karnival/cpp-opencage-geocoder.git

cd /path/to/build/
cmake /path/to/cpp-opencage-geocoder/
make
```

--------------------------------

### Install via Git

Source: https://github.com/opencagedata/leaflet-opencage-geocoding

Clone the repository directly from GitHub to get the latest version of the OpenCage Geocoding Control for Leaflet.

```shell
git clone git@github.com:opencagedata/leaflet-opencage-geocoding.git
```

--------------------------------

### Get APOC Version

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

A simple function to retrieve the currently installed APOC library version.

```cypher
RETURN apoc.version();
```

--------------------------------

### Build and Install APOC from Source

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

This sequence of commands outlines how to build the APOC library from its GitHub repository. It involves cloning the repository, navigating into the directory, running a Gradle build to create a shadow JAR, and then copying the resulting JAR file to the Neo4j plugins directory, followed by a Neo4j restart.

```bash
git clone https://github.com/neo4j-contrib/neo4j-apoc-procedures
cd neo4j-apoc-procedures
./gradlew shadow
cp build/full/libs/apoc-<version>-all.jar $NEO4J_HOME/plugins/
$NEO4J_HOME/bin/neo4j restart
```

--------------------------------

### Install opencage CLI

Source: https://github.com/GaryStanton/OpenCageCFC

Installs the opencage command-line interface tool. This is typically the first step before using the library.

```bash
box install opencage
```

--------------------------------

### Zig Project Execution Example

Source: https://github.com/geonot/zig-opencage

An example command for building and running a project, likely related to Zig development, which might integrate with services like OpenCageData.

```zig
zig build run
```

--------------------------------

### Install Leaflet OpenCage Geocoding via Git

Source: https://github.com/opencagedata/leaflet-opencage-geocoding

Clone the project repository directly from GitHub to get the latest version of the Leaflet OpenCage Geocoding control.

```shell
git clone git@github.com:opencagedata/leaflet-opencage-geocoding.git
```

--------------------------------

### Install Dependencies and Run Tests/Lint

Source: https://github.com/dsantosmerino/open-cagex

Provides commands to manage the OpenCagex project. It includes changing into the project directory, fetching dependencies using Mix, running tests, and performing code linting with Credo.

```shell
cd open_cagex
mix deps.get
```

```shell
mix test
```

```elixir
mix credo
```

--------------------------------

### OpenCage CLI Tool: Installation and Usage

Source: https://opencagedata.com/tutorials/geocode-in-shell-scripts

Details the installation of the OpenCage command-line interface tool using pip and provides an example of its usage for batch reverse geocoding. The tool requires Python 3.8+ and facilitates processing CSV data.

```bash
pip install opencage
opencage -h
```

```csv
49.403370,2.325642
48.048349,-1.601447
44.504731,1.188501
43.606452,-1.381768
```

```bash
opencage reverse --api-key YOUR-API-KEY --input coordinates.csv --output results.csv --add-columns country,formatted
```

```csv
49.403370,2.325642,France,"1 Rue du Général Leclerc, 60510 La Neuville-en-Hez, France"
48.048349,-1.601447,France,"9 Allée du Close Suzan, 35770 Vern-sur-Seiche, France"
44.504731,1.188501,France,"1 Rue du Quercy, 46220 Prayssac, France"
43.606452,-1.381768,France,"1635 Route du Tuc, 40230 Orx, France"
```

--------------------------------

### Initialize and Use OpenCage Geocoder API (Go)

Source: https://github.com/alexliesenfeld/opencage

Demonstrates how to import the package, initialize the client with an API key, and perform a basic forward geocoding request using a location string. It also shows how to manage the request context for timeouts and cancellations.

```go
import (
	"context"
	"github.com/alexliesenfeld/opencage"
)

// Initialize the client with your API key
client := opencage.New("my-api-key")

// Use context for managing timeouts, cancellation, etc.
ctx := context.Background()

// Perform forward geocoding for a location
response, err := client.Geocode(ctx, "Berlin, Germany", nil)

// Handle potential errors
if err != nil {
	// Handle error
}

// Process the response
// fmt.Printf("%+v\n", response)
```

--------------------------------

### Run Datasette with Configuration

Source: https://datasette.io/plugins/datasette-enrichments-opencage

Starts the Datasette server with a specified database file and metadata configuration, enabling features like user authentication and plugin settings.

```shell
datasette mydatabase.db -m metadata.yml --root
```

--------------------------------

### Building the c-ocgeo Library

Source: https://github.com/sgsfak/c-ocgeo

Instructions for building the c-ocgeo library, assuming a POSIX compliant environment. It requires libcurl and includes cJSON and Simple Dynamic Strings (sds) as source files. A GNU Makefile is provided for static library creation.

```APIDOC
Building:
  - POSIX compliant environment (MacOSX, OpenBSD, Linux tested).
  - Prerequisites:
    - libcurl (for HTTP requests).
    - cJSON (ultralightweight JSON parser).
    - Simple Dynamic Strings (sds) (version 1.0.0).
  - Build process:
    - Uses a GNU Makefile to build a static library (libocgeo.a).
    - Users can copy source files and use their own build process.
    - Adjust Makefile for non-standard libcurl header/library paths (e.g., /usr/local/include, /usr/local/lib).
```

--------------------------------

### OpenCage Geocoding API Documentation Overview

Source: https://opencagedata.com/guides/how-to-compare-and-test-geocoding-services

Provides an overview of the OpenCage Geocoding API, its features, and how to get started. It links to comprehensive documentation and resources for various programming languages.

```APIDOC
OpenCage Geocoding API:
  - Comprehensive documentation available at https://opencagedata.com/api
  - Guide to reverse geocoding: https://opencagedata.com/reverse-geocoding
  - Tutorials and code examples for various languages: https://opencagedata.com/tutorials
  - SDKs for 30+ programming languages: https://opencagedata.com/sdks
  - Contact for clarification: https://opencagedata.com/contact#geocoding
```

--------------------------------

### Development Setup with venv

Source: https://github.com/eyeseast/geocode-sqlite

Instructions for setting up a Python development environment using a virtual environment (venv). This includes navigating to the project directory, creating the environment, and activating it.

```shell
cd geocode-sqlite
python -m venv .venv
source .venv/bin/activate
```

--------------------------------

### Manual APOC Installation for Neo4j Docker (Production)

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

This method demonstrates a production-ready approach for integrating APOC with Neo4j Docker. It involves creating a plugins directory, downloading a specific APOC JAR file, and then mounting this directory as a volume to the Neo4j container. This ensures the correct APOC version is used.

```bash
mkdir plugins
pushd plugins
wget https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.4.0.38/apoc-4.4.0.38-all.jar
popd
docker run --rm -e NEO4J_AUTH=none -p 7474:7474 -v $PWD/plugins:/plugins -p 7687:7687 neo4j:4.4
```

--------------------------------

### Geocode Address with geokit Gem

Source: https://opencagedata.com/tutorials/geocode-in-ruby

Example of geocoding an address using the 'geokit' gem with the OpenCageData provider. It shows how to set the API key, configure the provider, and perform a forward geocode lookup to get latitude and longitude.

```ruby
require 'geokit'

Geokit::Geocoders::OpencageGeocoder.key = 'YOUR-API-KEY'

Geokit::Geocoders::provider_order = [:opencage]

result = Geokit::Geocoders::MultiGeocoder.geocode("900 Sycamore Drive")

puts "#{result.provider}: #{result.latitude}, #{result.longitude}"
```

--------------------------------

### OpenCageData Geocoding API Request Example

Source: https://github.com/sgsfak/ocgeo_fdw

Demonstrates a typical GET request to the OpenCageData Geocoding API. It shows how to query for an address, specify the API key, and set parameters like result limits and annotation preferences.

```APIDOC
API Endpoint: https://api.opencagedata.com/geocode/v1/json

Method: GET

Description: Retrieves geocoding results for a given query.

Parameters:
  - q (string, required): The address or query string to geocode.
  - key (string, required): Your OpenCageData API key.
  - limit (integer, optional): Maximum number of results to return (default 50).
  - no_annotations (integer, optional): Set to 1 to disable annotations (default 0).

Example Usage:
https://api.opencagedata.com/geocode/v1/json?q=Trierer%20Stra%C3%9Fe%2015%2C%2099423%2C%20Weimar%2C%20Deutschland&limit=50&no_annotations=0&key=YOUR_API_KEY

Response Status:
  - returned status: 200 (OK)
  - results: Number of results found
  - time: Time taken for the API call in milliseconds
```

--------------------------------

### Clone MCP Server Repository

Source: https://opencagedata.com/tutorials/geocode-inside-an-llm-via-mcp

Clones the OpenCage Geocoding MCP server code from GitHub. This is the first step to setting up the server locally.

```shell
git clone git@github.com:OpenCageData/opencage-geocoding-mcp.git
```

```shell
git clone https://github.com/OpenCageData/opencage-geocoding-mcp.git
```

--------------------------------

### Reverse Geocoding with OpenCageClient in Scala

Source: https://github.com/opencagedata/scala-opencage-geocoder

Illustrates how to perform reverse geocoding by converting geographic coordinates (latitude and longitude) into a human-readable address. The example shows client setup, calling the `reverseGeocode` method with latitude and longitude, and handling the asynchronous response. The client is closed in a finally block.

```scala
val client = new OpenCageClient(authKey)
try {
 val latitude = 52.51627f
 val longitue = 3.37769f
 val responseFuture = client.reverseGeocode(latitude, longitude)
 val response = Await.result(responseFuture, 5 seconds)
}
finally {
 client.close()
}
```

--------------------------------

### Docker Build and Run

Source: https://github.com/sgsfak/c-ocgeo

Instructions for building a lightweight Docker image for the OpenCageData Geocoder library and running it with an API key and query.

```shell
docker build -t ocgeo .

```

```shell
docker run ocgeo <api-key> <query>

```

--------------------------------

### OpenCageData Geocoding API Request and Response

Source: https://opencagedata.com/api

This entry covers the OpenCageData Geocoding API. It includes an example of a GET request for reverse geocoding with specific coordinates and the corresponding JSON response format. The API allows querying geographic coordinates to obtain address information.

```APIDOC
OpenCageData Geocoding API:

Endpoint: https://api.opencagedata.com/geocode/v1/json

Method: GET

Parameters:
  q: The query string. For reverse geocoding, this is the latitude and longitude, e.g., "-22.6792,14.5272".
  key: Your API key. Required for authentication.
  pretty: (Optional) If set to 1, the JSON response will be pretty-printed.

Example Request:
https://api.opencagedata.com/geocode/v1/json?q=-22.6792%2C+14.5272&key=YOUR-API-KEY&pretty=1

Response Format:
JSON (default) or GeoJSON, XML.

JSON Response Structure:
{
  "documentation": "string",
  "licenses": [
    {
      "name": "string",
      "url": "string"
    }
  ],
  "rate": {
    "limit": integer,
    "remaining": integer,
    "reset": integer
  },
  "results": [
    {
      "annotations": {
        "DMS": {
          "lat": "string",
          "lng": "string"
        },
        "MGRS": "string",
        "Maidenhead": "string",
        "Mercator": {
          "x": float,
          "y": float
        },
        "OSM": {
          "edit_url": "string",
          "note_url": "string",
          "url": "string"
        },
        "UN_M49": {
          "regions": {
            "AFRICA": "string",
            "NA": "string",
            "SOUTHERN_AFRICA": "string",
            "SUB-SAHARAN_AFRICA": "string",
            "WORLD": "string"
          },
          "statistical_groupings": ["string"]
        },
        "callingcode": integer,
        "currency": {
          "alternate_symbols": ["string"],
          "decimal_mark": "string",
          "disambiguate_symbol": "string",
          "format": "string",
          "html_entity": "string",
          "iso_code": "string",
          "iso_numeric": "string",
          "name": "string",
          "smallest_denomination": integer,
          "subunit": "string",
          "subunit_to_unit": integer,
          "symbol": "string",
          "symbol_first": integer,
          "thousands_separator": "string"
        },
        "flag": "string",
        "geohash": "string",
        "qibla": float,
        "roadinfo": {
          "drive_on": "string",
          "road": "string",
          "road_type": "string",
          "speed_in": "string"
        },
        "sun": {
          "rise": {
            "apparent": integer,
            "astronomical": integer,
            "civil": integer,
            "nautical": integer
          },
          "set": {
            "apparent": integer,
            "astronomical": integer,
            "civil": integer,
            "nautical": integer
          }
        },
        "timezone": {
          "name": "string",
          "now_in_dst": integer,
          "offset_sec": integer,
          "offset_string": "string",
          "short_name": "string"
        },
        "what3words": {
          "words": "string"
        }
      },
      "bounds": {
        "northeast": {
          "lat": float,
          "lng": float
        },
        "southwest": {
          "lat": float,
          "lng": float
        }
      },
      "components": {
        "ISO_3166-1_alpha-2": "string",
        "ISO_3166-1_alpha-3": "string",
        "ISO_3166-2": ["string"],
        "_category": "string",
        "_normalized_city": "string",
        "_type": "string",
        "city": "string",
        "continent": "string",
        "country": "string",
        "country_code": "string",
        "postcode": "string",
        "road": "string",
        "road_type": "string",
        "state": "string",
        "suburb": "string"
      },
      "confidence": integer,
      "distance_from_q": {
        "meters": integer
      },
      "formatted": "string"
    }
  ]
}
```

```JSON
{
   "documentation" : "https://opencagedata.com/api",
   "licenses" : [
      {
         "name" : "see attribution guide",
         "url" : "https://opencagedata.com/credits"
      }
   ],
   "rate" : {
      "limit" : 10000,
      "remaining" : 8976,
      "reset" : 1718841600
   },
   "results" : [
      {
         "annotations" : {
            "DMS" : {
               "lat" : "22\u00b0 40' 45.26256'' S",
               "lng" : "14\u00b0 31' 37.93728'' E"
            },
            "MGRS" : "33KVQ5143391910",
            "Maidenhead" : "JG77gh36gx",
            "Mercator" : {
               "x" : 1617161.042,
               "y" : -2576805.433
            },
            "OSM" : {
               "edit_url" : "https://www.openstreetmap.org/edit?way=184393212#map=16/-22.67924/14.52720",
               "note_url" : "https://www.openstreetmap.org/note/new#map=16/-22.67924/14.52720&layers=N",
               "url" : "https://www.openstreetmap.org/?mlat=-22.67924&mlon=14.52720#map=16/-22.67924/14.52720"
            },
            "UN_M49" : {
               "regions" : {
                  "AFRICA" : "002",
                  "NA" : "516",
                  "SOUTHERN_AFRICA" : "018",
                  "SUB-SAHARAN_AFRICA" : "202",
                  "WORLD" : "001"
               },
               "statistical_groupings" : [
                  "LEDC"
               ]
            },
            "callingcode" : 264,
            "currency" : {
               "alternate_symbols" : [
                  "N$"
               ],
               "decimal_mark" : ".",
               "disambiguate_symbol" : "N$",
               "format" : "%n %u",
               "html_entity" : "$",
               "iso_code" : "NAD",
               "iso_numeric" : "516",
               "name" : "Namibian Dollar",
               "smallest_denomination" : 5,
               "subunit" : "Cent",
               "subunit_to_unit" : 100,
               "symbol" : "$",
               "symbol_first" : 0,
               "thousands_separator" : ","
            },
            "flag" : "\ud83c\uddf3\ud83c\udde6",
            "geohash" : "k7fqfx67u7m1bew3kzh3",
            "qibla" : 31.02,
            "roadinfo" : {
               "drive_on" : "left",
               "road" : "Woermann Street",
               "road_type" : "residential",
               "speed_in" : "km/h"
            },
            "sun" : {
               "rise" : {
                  "apparent" : 1718775720,
                  "astronomical" : 1718770920,
                  "civil" : 1718774220,
                  "nautical" : 1718772600
               },
               "set" : {
                  "apparent" : 1718814300,
                  "astronomical" : 1718819100,
                  "civil" : 1718815740,
                  "nautical" : 1718817420
               }
            },
            "timezone" : {
               "name" : "Africa/Windhoek",
               "now_in_dst" : 0,
               "offset_sec" : 7200,
               "offset_string" : "+0200",
               "short_name" : "CAT"
            },
            "what3words" : {
               "words" : "outsmarted.cheering.chemical"
            }
         },
         "bounds" : {
            "northeast" : {
               "lat" : -22.6791681,
               "lng" : 14.5277944
            },
            "southwest" : {
               "lat" : -22.6793015,
               "lng" : 14.5266951
            }
         },
         "components" : {
            "ISO_3166-1_alpha-2" : "NA",
            "ISO_3166-1_alpha-3" : "NAM",
            "ISO_3166-2" : [
               "NA-ER"
            ],
            "_category" : "road",
            "_normalized_city" : "Swakopmund",
            "_type" : "road",
            "city" : "Swakopmund",
            "continent" : "Africa",
            "country" : "Namibia",
            "country_code" : "na",
            "postcode" : "13001",
            "road" : "Woermann Street",
            "road_type" : "residential",
            "state" : "Erongo Region",
            "suburb" : "Central"
         },
         "confidence" : 9,
         "distance_from_q" : {
            "meters" : 4
         },
         "formatted" : "Woermann Street, Swakopmund 13001, Namibia"
      }
   ]
}
```

--------------------------------

### Install geocode-sqlite

Source: https://github.com/eyeseast/geocode-sqlite

Installs the geocode-sqlite package using pip. It is recommended to install within a virtual environment.

```bash
# install inside a virtualenv
pip install geocode-sqlite
```

--------------------------------

### Run Neo4j Docker with APOC via Environment Variable

Source: https://github.com/neo4j-contrib/neo4j-apoc-procedures

This command starts a Neo4j Docker container, mapping ports and volumes. It uses the NEO4JLABS_PLUGINS environment variable to automatically download and install the latest APOC library at runtime. It also enables APOC's import/export file features.

```shell
docker run \
 -p 7474:7474 -p 7687:7687 \
 -v $PWD/data:/data -v $PWD/plugins:/plugins \
 --name neo4j-apoc \
 -e NEO4J_apoc_export_file_enabled=true \
 -e NEO4J_apoc_import_file_enabled=true \
 -e NEO4J_apoc_import_file_use__neo4j__config=true \
 -e NEO4JLABS_PLUGINS=\"[\"apoc\"]\" \
 neo4j:4.0
```