Datasets:

markhneedham

/

blog

like 0

2021-01-28 00:44:37

Materialize: Creating multiple views on one source

This is another post describing https://markhneedham.com/blog/tag/materialize/[my exploration^] of https://materialize.com/[Materialize^], a SQL streaming database. In this post we're going to learn how to create multiple views on top of the same underlying source. image::{{<siteurl>}}/uploads/2021/01/materialize-multi-views-banner.png[] We're still going to be using data extracted from Strava, an app that I use to record my runs, but this time we have more detailed information about each run. As in the previous blog posts, each run is represented as JSON document and store in the https://github.com/mneedham/materialize-sandbox/blob/main/strava/data/activities-detailed-all.json[`activities-detailed-all.json`^] file in JSON lines format. Below is an example of one line in this file: [source,bash] ---- head -n1 data/activities-detailed-all.json | jq -c '{id, distance, moving_time, elapsed_time, total_elevation_gain, elv_high, elev_low, average_speed, max_speed, average_heartrate, max_heartrate, start_date, best_efforts, splits_metric, splits_standard, segments_efforts}' ---- .Results [source,json] ---- {"id":259558400,"distance":3116.1,"moving_time":"0:17:48","elapsed_time":"0:17:55","total_elevation_gain":0,"elv_high":null,"elev_low":6,"average_speed":2.918,"max_speed":7.2,"average_heartrate":null,"max_heartrate":null,"start_date":"2015-02-25T06:18:39+00:00","best_efforts":[{"effort_name":"400m","moving_time":131,"elapsed_time":130,"effort_distance":400,"average_heartrate":null,"max_heartrate":null},{"effort_name":"1/2 mile","moving_time":266,"elapsed_time":265,"effort_distance":805,"average_heartrate":null,"max_heartrate":null},{"effort_name":"1k","moving_time":336,"elapsed_time":336,"effort_distance":1000,"average_heartrate":null,"max_heartrate":null},{"effort_name":"1 mile","moving_time":548,"elapsed_time":547,"effort_distance":1609,"average_heartrate":null,"max_heartrate":null}],"splits_metric":[{"distance":1002.9,"elapsed_time":"0:05:48","elevation_difference":3.2,"moving_time":"0:05:41","average_heartrate":null,"split":1,"pace_zone":0,"average_speed":2.94},{"distance":999.4,"elapsed_time":"0:05:48","elevation_difference":-1.9,"moving_time":"0:05:48","average_heartrate":null,"split":2,"pace_zone":0,"average_speed":2.87},{"distance":1001.7,"elapsed_time":"0:05:39","elevation_difference":-2.1,"moving_time":"0:05:39","average_heartrate":null,"split":3,"pace_zone":0,"average_speed":2.95},{"distance":112.1,"elapsed_time":"0:00:40","elevation_difference":0.7,"moving_time":"0:00:40","average_heartrate":null,"split":4,"pace_zone":0,"average_speed":2.8}],"splits_standard":[{"distance":1612.2,"elapsed_time":"0:09:21","elevation_difference":4.7,"moving_time":"0:09:14","average_heartrate":null,"split":1,"pace_zone":0,"average_speed":2.91},{"distance":1503.9,"elapsed_time":"0:08:34","elevation_difference":-4.8,"moving_time":"0:08:34","average_heartrate":null,"split":2,"pace_zone":0,"average_speed":2.93}],"segments_efforts":null} ---- == Connecting to Materialize We're going to query that data using Materialize, which we'll set up using the following Docker Compose configuration: .docker-compose.yml [source,yaml] ---- version: '3' services: materialize: image: materialize/materialized:v0.5.3 container_name: "materialize-sandbox-docker-compose" volumes: - ./data:/data ports: - "6875:6875" ---- The `data` directory containing the https://github.com/mneedham/materialize-sandbox/blob/main/strava/data/activities-detailed-all.json[`activities-detailed-all.json`^] file is in the https://github.com/mneedham/materialize-sandbox/tree/main/strava[mneedham/materialize-sandbox/strava^] GitHub repository. The repository also contains setup instructions. Once we've cloned that repository, we can launch Materialize by running the following command: [source, bash] ---- docker-compose up ---- We're now ready to connect to Materialize, which we can do using the https://www.postgresql.org/docs/9.3/app-psql.html[`psql` CLI tool^]: [source, bash] ---- psql -h localhost -p 6875 materialize ---- .Results [source,text] ---- psql (12.5 (Ubuntu 12.5-0ubuntu0.20.04.1), server 9.5.0) Type "help" for help. materialize=> ---- == Creating a materialized view We're going to start by creating a source around the file: .CREATE SOURCE [source,sql] ---- CREATE SOURCE activities_detailed_source FROM FILE '/data/activities-detailed-all.json' WITH(tail=true) FORMAT TEXT; ---- Not it's time to create some views on top of the source. We'll start with the `activites_detailed` view, which returns the raw values from the JSON file: .CREATE VIEW [source,sql] ---- CREATE VIEW activities_detailed AS SELECT (val->>'id')::float::bigint AS id, (val->>'start_date')::timestamp AS start_date, (val->'best_efforts') AS best_efforts, (val->'splits_metric') AS splits_metric, (val->'splits_standard') AS splits_standard, (val->'segment_efforts') AS segment_efforts FROM (SELECT text::json AS val FROM activities_detailed_source); ---- We're not going to do any direct querying against this view, so we create a `VIEW` rather than a `MATERIALIZED VIEW`. If we want to query that view, we'll need to make sure we append the `AS OF` clause to the end of our query, as shown in the following example: [source,sql] ---- SELECT * FROM activities_detailed LIMIT 1 AS OF 1; ---- .Results [opts="header"] |=== | id | start_date | best_efforts | splits_metric | splits_standard | segment_efforts | 3217642015 | 2020-03-25 18:27:10 | [] a| [source,json] ---- [{"average_heartrate":136.11428571428573,"average_speed":3.09,"distance":108.1,"elapsed_time":"0:00:41","elevation_difference":-0.3,"moving_time":"0:00:35","pace_zone":2.0,"split":1.0}] ---- a| [source,json] ---- [{"average_heartrate":136.11428571428573,"average_speed":3.09,"distance":108.1,"elapsed_time":"0:00:41","elevation_difference":-0.3,"moving_time":"0:00:35","pace_zone":2.0,"split":1.0}] ---- | [] |=== This view returns JSON arrays for `splits_metric`, `splits_standard`, `best_efforts`, and `segment_efforts`. It'd be good if we could explode those array elements into individual rows so that we could query them, which we can do with the `jsonb_array_elements` function that I wrote about in https://markhneedham.com/blog/2020/12/29/materialize-json-arrays/[Materialize: Querying JSON arrays^]. We'd generally be querying each of these things separately, so we'll create one materialized view for each one, as shown in the following diagram: image::{{<siteurl>}}/uploads/2021/01/materialize-views.png[] Let's see how to create a couple of those materialized views. We can do this by running the following queries: .CREATE MATERIALZIED VIEW best_efforts [source,sql] ---- CREATE MATERIALIZED VIEW best_efforts AS SELECT id, start_date, (effort->>'effort_name') AS effort_name, (effort->>'effort_distance')::float AS distance, (effort->>'elapsed_time')::float AS elapsed_time, (effort->>'moving_time')::float AS moving_time, (effort->>'average_heartrate')::float AS average_heartrate, (effort->>'max_heartrate')::float AS max_heartrate FROM ( SELECT id, start_date, best_efforts FROM activities_detailed ), jsonb_array_elements(best_efforts) AS effort; ---- .CREATE MATERIALIZED VIEW segment_efforts [source,sql] ---- CREATE MATERIALIZED VIEW segment_efforts AS SELECT id, start_date, (effort->>'segment_id') AS segment_id, (effort->>'segment_name') AS segment_name, (effort->>'distance')::float AS distance, (effort->>'elapsed_time')::float AS elapsed_time, (effort->>'moving_time')::float AS moving_time FROM ( SELECT id, start_date, segment_efforts FROM activities_detailed ), jsonb_array_elements(segment_efforts) AS effort; ---- == Querying the materialized views Now that we've created those views, it's time to query them. We'll start by finding the fastest 10km runs that I've done [source,sql] ---- select start_date, to_char(to_timestamp(moving_time), 'HH24:MI:SS') AS time from best_efforts WHERE effort_name = '10k' ORDER BY moving_time LIMIT 10; ---- .Results [opts="header"] |=== | start_date | time |2018-08-18 09:50:40 | 00:44:03 |2018-07-11 04:24:10 | 00:44:17 |2019-06-14 10:14:39 | 00:44:32 |2018-10-20 06:14:46 | 00:44:38 |2018-05-19 08:55:00 | 00:44:43 |2018-10-27 09:48:01 | 00:44:54 |2018-07-20 11:05:28 | 00:44:57 |2018-06-01 04:17:44 | 00:45:00 |2019-05-25 06:45:53 | 00:45:03 |2018-08-08 04:28:36 | 00:45:06 |=== All my fastest times were in 2018 or 2019! I haven't been anywhere near that sort of pace for a long while. If we have the id for a specific run we can write a query to find all the best efforts for that run, as shown below: [source,sql] ---- select start_date, effort_name, to_char(to_timestamp(moving_time), 'MI:SS') AS time from best_efforts WHERE id=2448908609 ORDER BY moving_time LIMIT 10; ---- .Results [opts="header"] |=== |start_date | effort_name | time |2019-06-14 10:14:39 | 400m | 01:39 |2019-06-14 10:14:39 | 1/2 mile | 03:23 |2019-06-14 10:14:39 | 1k | 04:15 |2019-06-14 10:14:39 | 1 mile | 06:52 |2019-06-14 10:14:39 | 2 mile | 13:57 |2019-06-14 10:14:39 | 5k | 21:53 |2019-06-14 10:14:39 | 10k | 44:32 |=== Now let's move onto segment efforts. We can find the most popular segments by running the following query: [source,sql] ---- select segment_id, segment_name, count(*) AS count from segment_efforts GROUP BY segment_id, segment_name ORDER BY count DESC LIMIT 5; ---- .Results [opts="header"] |=== |segment_id | segment_name | count |17236468 | Lap of the track | 260 |17875147 | York to Vet | 226 |17875143 | Stanley to Bridge | 186 |23952234 | The misdiseaveing incline | 96 |23952158 | 5 gym dash | 93 |=== Lap of the track is a running track that I've clearly done a lot of laps on. Let's explore those laps in more detail: [source,sql] ---- SELECT start_date, to_char(to_timestamp(min(moving_time)), 'MI:SS') AS fastestTime, to_char(to_timestamp(max(moving_time)), 'MI:SS') AS slowestTime, to_char(to_timestamp(avg(moving_time)), 'MI:SS') AS averageTime, count(*) AS lapsDone FROM segment_efforts WHERE segment_id = '17236468' GROUP BY start_date ORDER BY min(moving_time) LIMIT 5; ---- .Results [opts="header", cols="2,1,1,1,1"] |=== |start_date | fastesttime | slowesttime | averagetime | lapsdone |2018-04-02 16:05:31 | 01:42 | 02:08 | 01:55 | 18 |2018-03-26 02:23:47 | 01:46 | 02:10 | 02:07 | 15 |2016-07-22 05:18:37 | 01:48 | 02:10 | 02:01 | 9 |2016-08-03 12:16:23 | 01:49 | 02:06 | 02:01 | 13 |2020-03-11 02:35:09 | 01:50 | 02:24 | 02:11 | 25 |=== Again my fastest laps were in 2018! I clearly need to work on my speed. == In summary One of the things that I really like about Materialize is that you can defer data transformation. I'm used to having to decide up front how I want to shape the data and then having the queries I can write be limited by that initial transformation. With Materialize you can instead create a single source and then later on create as many views as you want to analyse the data in all different ways.

In this post we'll learn how to create multiple views on top of one source using the Materialize SQL streaming database.

uploads/2021/01/materialize-multi-views-banner.png

materialize-multiple-views-one-source

https://markhneedham.com/blog/2021/01/28/materialize-multiple-views-one-source

2021-06-21 00:44:37

Apache Pinot: {'errorCode': 410, 'message': 'BrokerResourceMissingError'}

I've recently been playing around with https://pinot.apache.org/[Apache Pinot^], a realtime analytical data store that's used for user facing analytics use cases. In this blog post I want to walk through some challenges I had connecting to Pinot using the Python driver and how I got things working. I'm running Pinot locally using the Docker image, which I setup in a Docker compose file: .docker-compose.yml [source,yaml] ---- version: '3.7' services: pinot: image: apachepinot/pinot:0.7.1 command: "QuickStart -type batch" container_name: "pinot-quickstart" volumes: - ./config:/config - ./data:/opt/pinot/data ports: - "9000:9000" - "8000:8000" - "8099:8099" ---- I launched that using the following command: [source, bash] ---- docker-compose up ---- And waited for this line in the output: [source, bash] ---- pinot-quickstart | You can always go to http://localhost:9000 to play around in the query console ---- If we navigate to that URL we can run queries against Pinot from the web app, but I want to run some queries from Python, so we'll now install the https://docs.pinot.apache.org/users/clients/python[Python driver^]: [source, bash] ---- pip install pinotdb ---- We'll import the module into our Python script: [source, python] ---- from pinotdb import connect ---- Now let's see if we can connect to the database using https://github.com/python-pinot-dbapi/pinot-dbapi[a sample query from the GitHub repository^]: [source, python] ---- conn = connect(host='localhost', port=8099, path='/query/sql', scheme='http') curs = conn.cursor() curs.execute(""" SELECT * FROM airlineStats LIMIT 5 """) for row in curs: print(row) ---- If we run this query, we'll see the following output: .Output [source, text] ---- Traceback (most recent call last): File "blog.py", line 5, in <module> curs.execute(""" File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/pinotdb/db.py", line 44, in g return f(self, *args, **kwargs) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/pinotdb/db.py", line 270, in execute r = requests.post(self.url, headers=headers, json=payload) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/requests/api.py", line 119, in post return request('post', url, data=data, json=json, **kwargs) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/requests/api.py", line 61, in request return session.request(method=method, url=url, **kwargs) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/requests/sessions.py", line 542, in request resp = self.send(prep, **send_kwargs) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/requests/sessions.py", line 655, in send r = adapter.send(request, **kwargs) File "/home/markhneedham/.local/share/virtualenvs/pinot-playground-V0PLiJ36/lib/python3.8/site-packages/requests/adapters.py", line 516, in send raise ConnectionError(e, request=request) requests.exceptions.ConnectionError: HTTPConnectionPool(host='localhost', port=8099): Max retries exceeded with url: /query/sql (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f5e585f84f0>: Failed to establish a new connection: [Errno 111] Connection refused')) ---- Hmmm, we can't even connect to port 8099, so that must be the wrong one. I noticed port 8000 mentioned in some documentation, so perhaps we'll fare better querying on that port: [source, python] ---- conn = connect(host='localhost', port=8000, path='/query/sql', scheme='http') curs = conn.cursor() curs.execute(""" SELECT * FROM airlineStats LIMIT 5 """) for row in curs: print(row) ---- If we run this query we'll see the following output: .Output [source, text] ---- --------------------------------------------------------------------------- DatabaseError Traceback (most recent call last) <ipython-input-182-7ce88c8878a1> in <module> 1 curs = conn.cursor() ----> 2 curs.execute(""" 3 SELECT * FROM airlineStats LIMIT 5 4 """) 5 for row in curs: /opt/conda/lib/python3.8/site-packages/pinotdb/db.py in g(self, *args, **kwargs) 42 if self.closed: 43 raise exceptions.Error(f"{self.__class__.__name__} already closed") ---> 44 return f(self, *args, **kwargs) 45 46 return g /opt/conda/lib/python3.8/site-packages/pinotdb/db.py in execute(self, operation, parameters) 301 if query_exceptions: 302 msg = "\n".join(pformat(exception) for exception in query_exceptions) --> 303 raise exceptions.DatabaseError(msg) 304 305 rows = [] # array of array, where inner array is array of column values DatabaseError: {'errorCode': 410, 'message': 'BrokerResourceMissingError'} ---- We're able to connect this time, but still can't execute the query. The error message indicates that it https://docs.pinot.apache.org/basics/getting-started/frequent-questions/query-faq#i-get-the-following-error-when-running-a-query-what-does-it-mean[can't find a broker to process the query]. This is true - we don't actually have a table called `airlineStats`, so there wouldn't be a broker that could process a query against that table. We do have a table called `baseballStats`, so let's query that instead: [source, python] ---- conn = connect(host='localhost', port=8000, path='/query/sql', scheme='http') curs = conn.cursor() curs.execute(""" SELECT * FROM baseballStats LIMIT 5 """) for row in curs: print(row) ---- .Output [source, text] ---- [0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 'NL', 11, 11, 'aardsda01', 'David Allan', 1, 0, 0, 0, 0, 0, 0, 'SFN', 0, 2004] [2, 45, 0, 0, 0, 0, 0, 0, 0, 0, 'NL', 45, 43, 'aardsda01', 'David Allan', 1, 0, 0, 0, 1, 0, 0, 'CHN', 0, 2006] [0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 'AL', 25, 2, 'aardsda01', 'David Allan', 1, 0, 0, 0, 0, 0, 0, 'CHA', 0, 2007] [1, 5, 0, 0, 0, 0, 0, 0, 0, 0, 'AL', 47, 5, 'aardsda01', 'David Allan', 1, 0, 0, 0, 0, 0, 1, 'BOS', 0, 2008] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'AL', 73, 3, 'aardsda01', 'David Allan', 1, 0, 0, 0, 0, 0, 0, 'SEA', 0, 2009] ---- Success!

In this post we'll learn about the Apache Pinot BrokerResourceMissingError error message.

pinot-broker-resource-missing

https://markhneedham.com/blog/2021/06/21/pinot-broker-resource-missing

2021-06-22 00:44:37

Apache Pinot: Analysing England's Covid case data

As I mentioned https://www.markhneedham.com/blog/2021/06/21/pinot-broker-resource-missing/[in my last blog post^], I've been playing around with Apache Pinot, a data store that's optimised for user facing analytical workloads. image::{{<siteurl>}}/uploads/2021/06/pinot-covid-banner.png[] My understanding is that Pinot is a really good fit for datasets where: . The query patterns are of an analytical nature e.g. slicing and dicing on any columns. . We're ingesting the data in real time from a stream of events. Kenny Bastani has some cool blog posts showing how to do this with https://medium.com/apache-pinot-developer-blog/analyzing-wikipedia-in-real-time-with-apache-kafka-and-pinot-4b4e5e36936b[Wikipedia^] and https://medium.com/apache-pinot-developer-blog/using-apache-pinot-and-kafka-to-analyze-github-events-93cdcb57d5f7[GitHub^], and Jackie Jiang showed how to https://www.youtube.com/watch?v=TQoXSoKHLp8[analyse Meetup's RSVP stream^] in last week's Pinot meeetup. In this blog post I'm going to show how we can use Pinot to analyse Coronavirus case data in England that I https://coronavirus.data.gov.uk/details/download[downloaded from the UK's Covid dashboard^]. This dataset is static, so it would fit in the first category of datasets. The code used in this post is all included in the https://github.com/mneedham/pinot-covid-cases[github.com/mneedham/pinot-covid-cases] GitHub repository. == Setup We're going to analyse the dataset using Pinot and its Python driver via a Jupyter notebook. The following Docker Compose config will spin up local instances of Pinot and Jupyter: .docker-compose.yml [source,yaml] ---- version: '3.7' services: pinot: image: apachepinot/pinot:0.7.1 command: "QuickStart -type batch" container_name: "pinot-covid-cases" volumes: - ./config:/config ports: - "9000:9000" - "8000:8000" jupyter: container_name: "jupyter-covid-cases" image: jupyter/scipy-notebook:${JUPYTER_VERSION:-latest} volumes: - ./notebooks:/home/jovyan ports: - "8888:8888" ---- We've mounted a directory at `/covid` on the Pinot container. This directory contains the CSV file that we want to import into Pinot as well as some spec files that we'll describe later on in this blog post. The contents of the directory are shown below: .Contents of /covid [source, bash] ---- tree config/covid/cases/ config/covid/cases/ ├── job-spec.yml ├── ltla_2021-06-21.csv ├── schema.json └── table.json 0 directories, 4 files ---- We can launch the containers by running the following command: [source, bash] ---- docker-compose up ---- And then we're looking for the following lines of output: .Output [source, output] ---- ... jupyter-covid-cases | To access the notebook, open this file in a browser: jupyter-covid-cases | file:///home/jovyan/.local/share/jupyter/runtime/nbserver-7-open.html jupyter-covid-cases | Or copy and paste one of these URLs: jupyter-covid-cases | http://b3f5460bd961:8888/?token=753baf80a0ac8236a35d12fd0426c85cf476765959513805 jupyter-covid-cases | or http://127.0.0.1:8888/?token=753baf80a0ac8236a35d12fd0426c85cf476765959513805 .... pinot-covid-cases | You can always go to http://localhost:9000 to play around in the query console ---- == Dataset Now that we're got the infrastructure up and running let's have a look at the dataset. Below is a sample of the first rows of the CSV file: .Covid cases [source, csv] ---- areaCode,areaName,areaType,date,age,cases,rollingSum,rollingRate E06000003,Redcar and Cleveland,ltla,2021-06-16,00_04,0,1,14.1 E06000003,Redcar and Cleveland,ltla,2021-06-16,00_59,15,64,65.9 E06000003,Redcar and Cleveland,ltla,2021-06-16,05_09,0,0,0.0 E06000003,Redcar and Cleveland,ltla,2021-06-16,10_14,1,3,38.1 E06000003,Redcar and Cleveland,ltla,2021-06-16,15_19,1,6,85.6 E06000003,Redcar and Cleveland,ltla,2021-06-16,20_24,2,12,167.6 E06000003,Redcar and Cleveland,ltla,2021-06-16,25_29,2,12,145.4 E06000003,Redcar and Cleveland,ltla,2021-06-16,30_34,2,3,36.6 E06000003,Redcar and Cleveland,ltla,2021-06-16,35_39,2,7,92.1 ---- For each area we have the number of cases per day for each age group. Before we import this CSV file into Pinot we need to decide which fields we're going to import and the type of each field. Pinot has https://docs.pinot.apache.org/configuration-reference/schema[three field types^]: * Dimension - Attributes about the data. We will split the data on these columns and they'll be used in the selection, filter, and group-by parts of the query. * Date Time - Time stamp for the data. We will filter or group by these columns. * Metric - Measurements. We will aggregate by these columns. We'll map our fields as shown below: [options="header"] |=== | Dimension | Date Time | Metric | `areaName`, `areaCode`, `age` | `date` | `cases` |=== == Create Table Now we're going to create a Pinot table to store the data from our CSV file. First, we need to create a https://docs.pinot.apache.org/configuration-reference/schema[schema config^], as shown below: .schema.json [source,json] ---- { "schemaName": "cases", "dimensionFieldSpecs": [ { "name": "areaCode", "dataType": "STRING" }, { "name": "areaName", "dataType": "STRING" }, { "name": "age", "dataType": "STRING" } ], "metricFieldSpecs": [ { "name": "cases", "dataType": "INT" } ], "dateTimeFieldSpecs": [{ "name": "date", "dataType": "STRING", "format" : "1:DAYS:SIMPLE_DATE_FORMAT:yyyy-MM-dd", "granularity": "1:DAYS" }] } ---- You can find a list of https://docs.pinot.apache.org/basics/components/schema#data-types[supported data types^] in the Pinot documentation. Since Pinot doesn't have a `DATETIME` type, we need to provide a string or number and indicate its format so that Pinot can convert it into an appropriate format when applying operations against that field. Once we've created the schema config, next up we need to create a https://docs.pinot.apache.org/configuration-reference/table[table config^]. .table.json [source,json] ---- { "tableName": "cases", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1, "timeColumnName": "date", "timeType": "DAYS", "retentionTimeUnit": "DAYS", "retentionTimeValue": 365 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP" }, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" } }, "metadata": {} } ---- The table type can be either `OFFLINE` (for batch ingestion of data) or `REALTIME` (for streamed ingestion of data). [source, bash] ---- docker exec -it pinot-covid-cases bin/pinot-admin.sh AddTable \ -tableConfigFile /config/covid/cases/table.json \ -schemaFile /config/covid/cases/schema.json -exec ---- .Output [source,text] ---- Executing command: AddTable -tableConfigFile /config/covid/cases/table.json -schemaFile /config/covid/cases/schema.json -controllerProtocol http -controllerHost 192.168.96.2 -controllerPort 9000 -exec Sending request: http://192.168.96.2:9000/schemas to controller: a03d8fd1626e, version: Unknown {"status":"Table cases_OFFLINE succesfully added"} ---- The message indicates that a table with the name `cases_OFFLINE` has been created, but we will be able to query it using the `cases` name. == Import CSV file Now that we've created our table it's time to import our CSV file. To do that we'll need to create an ingestion job spec. An ingestion job spec for our Covid cases CSV file is shown below: .job-spec.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentGenerationJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' segmentUriPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentUriPushJobRunner' jobType: SegmentCreationAndTarPush inputDirURI: '/config/covid/cases' includeFileNamePattern: 'glob:**/*.csv' outputDirURI: '/opt/pinot/data/cases/segments/' overwriteOutput: true pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS recordReaderSpec: dataFormat: 'csv' className: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReader' configClassName: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReaderConfig' tableSpec: tableName: 'cases' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- `tableSpec.tableName` should match the table name that we used in the table spec and `inputDirURI` refers to the directory that we mounted when launching the Pinot Docker container. We can run the ingestion job by running the following command: [source,bash] ---- docker exec -it pinot-covid-cases bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/covid/cases/job-spec.yml ---- .Output [source,text] ---- Start pushing segments: [/opt/pinot/data/cases/segments/cases_OFFLINE_2020-01-30_2021-06-16_0.tar.gz]... to locations: [org.apache.pinot.spi.ingestion.batch.spec.PinotClusterSpec@7c214cc0] for table cases Pushing segment: cases_OFFLINE_2020-01-30_2021-06-16_0 to location: http://localhost:9000 for table cases Sending request: http://localhost:9000/v2/segments?tableName=cases to controller: a03d8fd1626e, version: Unknown Response for pushing table cases segment cases_OFFLINE_2020-01-30_2021-06-16_0 to location http://localhost:9000 - 200: {"status":"Successfully uploaded segment: cases_OFFLINE_2020-01-30_2021-06-16_0 of table: cases"} ---- == Querying Pinot We're going to query Pinot via a Jupyter notebook, which is available at http://localhost:8888/notebooks/Explore.ipynb if you're playing along. You can also find the notebook at https://github.com/mneedham/pinot-covid-cases/blob/main/notebooks/Explore.ipynb[github.com/mneedham/pinot-covid-cases/blob/main/notebooks/Explore.ipynb^]. First we need to install the Pinot Python driver: [source, bash] ---- pip install pinotdb ---- We're going to visualise the results of our queries using matplotlib, so let's import that library and pinotdb: [source, python] ---- from pinotdb import connect import pandas as pd pd.options.plotting.backend = "matplotlib" import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') ---- Next we'll create a connection to the database and run a query that counts the number of rows to make sure that everything's working: [source, python] ---- conn = connect(host='pinot-covid-cases', port=8000, path='/query/sql', scheme='http') curs = conn.cursor() curs.execute(""" SELECT count(*) FROM cases """) for row in curs: print(row) ---- .Output [source, text] ---- [3234594] ---- So far so good! Now let's write some more Pinoty (I'm sure that's not a word!) queries. First up, which areas have had the most cases: [source, python] ---- curs.execute(""" SELECT areaName, sum(cases) AS totalCases FROM cases GROUP BY areaName ORDER BY totalCases DESC LIMIT 10 """) df_by_area = pd.DataFrame(curs, columns=["areaName", "numberOfCases"]) df_by_area ---- .Areas with the most Covid cases [format="csv", options="header"] |=== include::content/2021/06/22/data/top_areas.csv[] |=== We can then create a matplotlib visualisation of that data using the code below: [source, python] ---- ax = df_by_area.plot( kind="bar", x="areaName", y="numberOfCases", legend=None, figsize=(10, 5) ) ax.set(xlabel="Area Name", ylabel="Number of cases") ax ---- .Top areas for Coronavirus cases image::{{<siteurl>}}/uploads/2021/06/top_areas.png[] It's a bit tricky to interpret the results of this query because it's not really telling us that the most cases have been in the midlands and north of England. Rather the break down of the local areas in that part of the country doesn't seem to be as granular as in London, for example. Talking of London, for our next query we'll filter the data to only return rows for the `areaName` of `Sutton`, and return the total number of cases by age group: [source, python] ---- area_name="Sutton" curs.execute(f""" SELECT age, sum(cases) as totalCases from cases WHERE areaName = '{area_name}' GROUP BY age ORDER BY totalCases DESC limit 50 """) df_by_area = pd.DataFrame(curs, columns=["age", "numberOfCases"]) df_by_area ax = df_by_area.plot( kind="bar", x="age", y="numberOfCases", legend=None, figsize=(10, 5) ) ax.set(xlabel="Age Group", ylabel="Number of cases") ax ---- .Coronavirus cases by age group in Sutton image::{{<siteurl>}}/uploads/2021/06/cases_by_age_group_sutton.png[] From these results we can see that the number of cases are being double booked - once as a fine grained age range (e.g. 35-39 or 80-84) and once as a coarse grained age range (0-59 or 60+). Let's now have a look at the number of cases in Sutton going back to March 2020 excluding the coarse grained age groups: [source, python] ---- area_name="Sutton" curs.execute(f""" SELECT "date", sum(cases) AS totalCases FROM cases WHERE areaName = '{area_name}' AND age not in ('00_59', '60+') GROUP BY "date" ORDER BY "date" LIMIT 1000 """) df_by_area = pd.DataFrame(curs, columns=["date", "numberOfCases"]) ax = df_by_area.plot( kind="line", x="date", y="numberOfCases", legend=None, figsize=(10, 5), linewidth=1 ) ax.set(xlabel="Area Name", ylabel="Number of cases") ax ---- .Coronavirus cases per day in Sutton image::{{<siteurl>}}/uploads/2021/06/cases_in_sutton.png[] The most cases happened at the end of December 2020/beginning of January 2020, with the peak on 29th December. == In Summary I appreciate that we've only brushed the surface of what Pinot can do in this blog post, but I had to start somewhere and it's been a fun tool to play with. I think my next dataset needs to have more columns per row and preferably have more than one metrics column. I also need to learn more about indexing and in particular the https://docs.pinot.apache.org/basics/indexing/star-tree-index[Star-Tree Index^] that https://www.startree.ai/[the company behind Pinot^] is named after. I should also say that I found the https://communityinviter.com/apps/apache-pinot/apache-pinot[Pinot Community Slack^] really helpful for getting up to speed. Special thanks to https://twitter.com/nehapawar18[Neha Pawar^] and https://www.linkedin.com/in/mayankshriv/[Mayank Shrivastava^] for answering my questions!

In this post we'll learn how to analyse data on the number of Coronavirus cases in England by date, area, and age group.

uploads/2021/06/pinot-covid-banner.png

pinot-analysing-england-covid-cases

https://markhneedham.com/blog/2021/06/22/pinot-analysing-england-covid-cases

2021-12-03 00:44:37

Apache Pinot: Convert DateTime string to Timestamp - IllegalArgumentException: Invalid timestamp

In this post we'll learn how to deal with a field that contains DateTime strings when importing a CSV file into Apache Pinot. We'll also cover some of the error messages that you'll see if you do it the wrong way. .Apache Pinot - Convert DateTime string to Timestamp image::{{<siteurl>}}/uploads/2021/12/datetime-timestamp.png[] == Setup We're going to spin up a local instance of Pinot using the following Docker compose config: .docker-compose.yml [source, yaml] ---- version: '3.7' services: zookeeper: image: zookeeper:3.5.6 hostname: zookeeper container_name: manual-zookeeper ports: - "2181:2181" environment: ZOOKEEPER_CLIENT_PORT: 2181 ZOOKEEPER_TICK_TIME: 2000 pinot-controller: image: apachepinot/pinot:0.9.0 command: "StartController -zkAddress manual-zookeeper:2181" container_name: "manual-pinot-controller" volumes: - ./config:/config - ./data:/data restart: unless-stopped ports: - "9000:9000" depends_on: - zookeeper pinot-broker: image: apachepinot/pinot:0.9.0 command: "StartBroker -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-broker" volumes: - ./config:/config - ./data:/data ports: - "8099:8099" depends_on: - pinot-controller pinot-server: image: apachepinot/pinot:0.9.0 command: "StartServer -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-server" volumes: - ./config:/config - ./data:/data depends_on: - pinot-broker ---- == Data We'll be working with the following CSV file that has `ID` and `Date` columns: .dates.csv [format="csv", options="header"] |=== include::content/2021/12/03/data/dates.csv[] |=== == Create Table Now we're going to create a Pinot schema and table based on this CSV file. The schema is defined below: ./config/schema.json [source.json] ---- { "schemaName": "dates", "dimensionFieldSpecs": [ { "name": "ID", "dataType": "INT" } ], "dateTimeFieldSpecs": [ { "name": "Date", "dataType": "TIMESTAMP", "format" : "1:SECONDS:SIMPLE_DATE_FORMAT:MM/dd/yyyy HH:mm:ss a", "granularity": "1:HOURS" } ] } ---- We're going to use the `TIMESTAMP` data type so that we can write queries that require date operations against the values in this column. Our table config is defined below:s ./config/table.json [source.json] ---- { "tableName": "dates", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP" }, "nullHandlingEnabled": true, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" } }, "metadata": {} } ---- Now let's create the table and schema: [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table.json \ -schemaFile /config/schema.json -exec ---- == Import CSV file After we've done that, it's time to import the CSV file. We'll do this using the ingestion job spec defined below: ./config/job-spec.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentGenerationJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' segmentUriPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentUriPushJobRunner' jobType: SegmentCreationAndTarPush inputDirURI: '/data' includeFileNamePattern: 'glob:**/dates.csv' outputDirURI: '/opt/pinot/data/dates' overwriteOutput: true pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS recordReaderSpec: dataFormat: 'csv' className: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReader' configClassName: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReaderConfig' tableSpec: tableName: 'dates' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- Notice that `includeFileNamePattern` refers to the `dates.csv` file that we saw earlier in this post. We can run the ingestion job like so: [source,bash] ---- docker exec \ -it manual-pinot-controller bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/job-spec.yml ---- [source, text] ---- 2021/12/03 12:16:56.848 ERROR [RecordReaderSegmentCreationDataSource] [pool-2-thread-1] Caught exception while gathering stats java.lang.RuntimeException: Caught exception while transforming data type for column: Date at org.apache.pinot.segment.local.recordtransformer.DataTypeTransformer.transform(DataTypeTransformer.java:95) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.recordtransformer.CompositeTransformer.transform(CompositeTransformer.java:83) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.RecordReaderSegmentCreationDataSource.gatherStats(RecordReaderSegmentCreationDataSource.java:80) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.RecordReaderSegmentCreationDataSource.gatherStats(RecordReaderSegmentCreationDataSource.java:42) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:173) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:155) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:104) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.plugin.ingestion.batch.common.SegmentGenerationTaskRunner.run(SegmentGenerationTaskRunner.java:118) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner.lambda$submitSegmentGenTask$1(SegmentGenerationJobRunner.java:263) ~[pinot-batch-ingestion-standalone-0.9.0-shaded.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515) [?:?] at java.util.concurrent.FutureTask.run(FutureTask.java:264) [?:?] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) [?:?] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) [?:?] at java.lang.Thread.run(Thread.java:829) [?:?] Caused by: java.lang.IllegalArgumentException: Invalid timestamp: '09/05/2015 01:30:00 PM' at org.apache.pinot.spi.utils.TimestampUtils.toTimestamp(TimestampUtils.java:43) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$10.toTimestamp(PinotDataType.java:524) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$9.convert(PinotDataType.java:485) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$9.convert(PinotDataType.java:442) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.recordtransformer.DataTypeTransformer.transform(DataTypeTransformer.java:90) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] ... 13 more 2021/12/03 12:16:56.856 ERROR [SegmentGenerationJobRunner] [pool-2-thread-1] Failed to generate Pinot segment for file - file:/data/dates.csv java.lang.RuntimeException: Caught exception while transforming data type for column: Date at org.apache.pinot.segment.local.recordtransformer.DataTypeTransformer.transform(DataTypeTransformer.java:95) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.recordtransformer.CompositeTransformer.transform(CompositeTransformer.java:83) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.RecordReaderSegmentCreationDataSource.gatherStats(RecordReaderSegmentCreationDataSource.java:80) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.RecordReaderSegmentCreationDataSource.gatherStats(RecordReaderSegmentCreationDataSource.java:42) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:173) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:155) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.segment.creator.impl.SegmentIndexCreationDriverImpl.init(SegmentIndexCreationDriverImpl.java:104) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.plugin.ingestion.batch.common.SegmentGenerationTaskRunner.run(SegmentGenerationTaskRunner.java:118) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner.lambda$submitSegmentGenTask$1(SegmentGenerationJobRunner.java:263) ~[pinot-batch-ingestion-standalone-0.9.0-shaded.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515) [?:?] at java.util.concurrent.FutureTask.run(FutureTask.java:264) [?:?] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) [?:?] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) [?:?] at java.lang.Thread.run(Thread.java:829) [?:?] Caused by: java.lang.IllegalArgumentException: Invalid timestamp: '09/05/2015 01:30:00 PM' at org.apache.pinot.spi.utils.TimestampUtils.toTimestamp(TimestampUtils.java:43) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$10.toTimestamp(PinotDataType.java:524) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$9.convert(PinotDataType.java:485) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.common.utils.PinotDataType$9.convert(PinotDataType.java:442) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] at org.apache.pinot.segment.local.recordtransformer.DataTypeTransformer.transform(DataTypeTransformer.java:90) ~[pinot-all-0.9.0-jar-with-dependencies.jar:0.9.0-cf8b84e8b0d6ab62374048de586ce7da21132906] ... 13 more ---- Hmmm, that didn't quite work as expected. There was a failure when trying to convert the string to a timestamp, and if we take a look at https://github.com/apache/pinot/blob/master/pinot-spi/src/main/java/org/apache/pinot/spi/utils/TimestampUtils.java#L29[`Timestamputils#toTimestamp`^], we can see that this function actually only supports the following input formats: * 'yyyy-mm-dd hh:mm:ss[.fffffffff]' * Millis since epoch Our DateTime strings have the `MM/dd/yyyy HH:mm:ss a` format, which isn't supported. One way to fix this problem would be to massage `dates.csv` so that the values in the `Date` column are in the expected format. The CSV file would then look like this: .dates.csv [format="csv", options="header"] |=== include::content/2021/12/03/data/dates_clean.csv[] |=== We can then re-run the ingestion job and the date will be imported into the `Date` column. Alternatively, we could write a transformation function in our table config to take care of it. Our table config would then instead look this: ./config/table-transform.json [source.json] ---- { "tableName": "dates", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP" }, "nullHandlingEnabled": true, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" }, "transformConfigs": [ {"columnName": "Date", "transformFunction": "FromDateTime(\"Date\", 'MM/dd/yyyy HH:mm:ss a')" } ] }, "metadata": {} } ---- This transform function uses the https://docs.pinot.apache.org/users/user-guide-query/supported-transformations#datetime-functions[`FromDateTime`^] function, which converts a DateTime string to epoch millis. Before we update the table config, let's drop the segment that we created earlier (by running the ingest job): .Drop dates table segments [source, bash] ---- curl -X DELETE "http://localhost:9000/segments/dates?type=OFFLINE" -H "accept: application/json" ---- Now we can update the table config: .Update table config [source, bash] ---- curl 'http://localhost:9000/tables/dates_OFFLINE' \ -X 'PUT' \ -H 'Content-Type: application/json' \ --data-binary "@config/table-transform.json" ---- .Output [source, text] ---- {"_code":400,"_error":"Invalid table config: dates_OFFLINE with error: Arguments of a transform function '[Date]' cannot contain the destination column 'Date'"} ---- Hmmm, we can't use the same name for the transformed and source columns. We'll have to instead update our schema and table config to store the transformed value in a `Timestamp` column instead. The updated schema and table config are shown below: ./config/schema-transform.json [source.json] ---- { "schemaName": "dates", "dimensionFieldSpecs": [ { "name": "ID", "dataType": "INT" } ], "dateTimeFieldSpecs": [ { "name": "Timestamp", "dataType": "TIMESTAMP", "format" : "1:MILLISECONDS:EPOCH", "granularity": "1:HOURS" } ] } ---- ./config/table-transform.json [source.json] ---- { "tableName": "dates", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP" }, "nullHandlingEnabled": true, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" }, "transformConfigs": [ {"columnName": "Timestamp", "transformFunction": "FromDateTime(\"Date\", 'MM/dd/yyyy HH:mm:ss a')" } ] }, "metadata": {} } ---- We can't remove columns from a schema, so let's drop the schema and table and re-create them both: [source,bash] ---- curl -X DELETE "http://localhost:9000/schemas/dates" -H "accept: application/json" && curl -X DELETE "http://localhost:9000/tables/dates?type=offline" -H "accept: application/json" ---- [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table-transform.json \ -schemaFile /config/schema-transform.json -exec ---- We can then run the ingestion job again and the datetime values will be loaded into the `Timestamp` column, as shown in the screenshot below: .The dates table with timestamps loaded image::{{<siteurl>}}/uploads/2021/12/query.png[] Success!

In this post we'll learn how to convert a DateTime string to timestamp in Apache Pinot.

uploads/2021/12/datetime-timestamp.png

apache-pinot-convert-datetime-string-timestamp-invalid-timestamp

https://markhneedham.com/blog/2021/12/03/apache-pinot-convert-datetime-string-timestamp-invalid-timestamp

2021-12-07 00:44:37

Apache Pinot: Exploring range queries

:icons: font In https://www.markhneedham.com/blog/2021/11/30/apache-pinot-exploring-index-chicago-crimes/[our last post about the Chicago Crimes dataset and Apache Pinot^], we learnt how to use various indexes to filter columns by exact values. In this post we're going to learn how to write range queries against the dataset. .Apache Pinot - Range Queries image::{{<siteurl>}}/uploads/2021/12/range-queries.png[] == Recap To recap, the Chicago Crimes dataset contains more than 7 million crimes committed in Chicago from 2001 until today. For each crime we have various identifiers, a timestamp, location, and codes reprsenting the type of crime that's been committed. A subset of the data is shown below: .Chicago Crimes Dataset image::{{<siteurl>}}/uploads/2021/11/chicago-crimes.png[Chicago Crimes Dataset, role='medium-zoom-image'] We loaded this data into Apache and Pinot and then analysed the `numEntriesScannedInFilter` and `timeUsedMs` values returned in the query metadata to see how well we'd optimised our queries. == Setup We're going to use the same Docker Compose script as before, which spins up the various components for Apache Pinot 0.9.0: .docker-compose.yml [source, yaml] ---- version: '3.7' services: zookeeper: image: zookeeper:3.5.6 hostname: zookeeper container_name: manual-zookeeper ports: - "2181:2181" environment: ZOOKEEPER_CLIENT_PORT: 2181 ZOOKEEPER_TICK_TIME: 2000 pinot-controller: image: apachepinot/pinot:0.9.0 command: "StartController -zkAddress manual-zookeeper:2181" container_name: "manual-pinot-controller" volumes: - ./config:/config - ./data:/data restart: unless-stopped ports: - "9000:9000" depends_on: - zookeeper pinot-broker: image: apachepinot/pinot:0.9.0 command: "StartBroker -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-broker" volumes: - ./config:/config - ./data:/data ports: - "8099:8099" depends_on: - pinot-controller pinot-server: image: apachepinot/pinot:0.9.0 command: "StartServer -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-server" volumes: - ./config:/config - ./data:/data depends_on: - pinot-broker ---- == Schema We've made a small change to our schema since the last blog post. Instead of storing the timestamp as a `STRING`, we're going to store it as a `TIMESTAMP` so that we can perform date time operations. We'll also change the column name from `Timestamp` to `DateEpoch`. The updated schema is shown below: ./config/schema.json [source,json] ---- { "schemaName": "crimes", "dimensionFieldSpecs": [ { "name": "ID", "dataType": "INT" }, { "name": "CaseNumber", "dataType": "STRING" }, { "name": "Block", "dataType": "STRING" }, { "name": "IUCR", "dataType": "STRING" }, { "name": "PrimaryType", "dataType": "STRING" }, { "name": "Arrest", "dataType": "BOOLEAN" }, { "name": "Domestic", "dataType": "BOOLEAN" }, { "name": "Beat", "dataType": "STRING" }, { "name": "District", "dataType": "STRING" }, { "name": "Ward", "dataType": "STRING" }, { "name": "CommunityArea", "dataType": "STRING" }, { "name": "FBICode", "dataType": "STRING" }, { "name": "Latitude", "dataType": "DOUBLE" }, { "name": "Longitude", "dataType": "DOUBLE" } ], "dateTimeFieldSpecs": [ { "name": "DateEpoch", "dataType": "TIMESTAMP", "format" : "1:MILLISECONDS:EPOCH", "granularity": "1:MILLISECONDS" } ] } ---- If you read the first post about this dataset you'll remember that the timestamp was a DateTime string in the `MM/dd/yyyy HH:mm:ss a` format, rather than the number of milliseconds since the epoch. We're going to take care of that with a https://docs.pinot.apache.org/users/user-guide-query/supported-transformations[transformation function^] in our table config. == Table The table config is described below: ./config/table.json [source, json] ---- { "tableName": "crimes", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP", "sortedColumn": ["Beat"] }, "nullHandlingEnabled": true, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" }, "transformConfigs": [ {"columnName": "CaseNumber", "transformFunction": "\"Case Number\"" }, {"columnName": "PrimaryType", "transformFunction": "\"Primary Type\"" }, {"columnName": "CommunityArea", "transformFunction": "\"Community Area\"" }, {"columnName": "FBICode", "transformFunction": "\"FBI Code\"" }, {"columnName": "DateEpoch", "transformFunction": "FromDateTime(\"Date\", 'MM/dd/yyyy HH:mm:ss a')" } ] }, "metadata": {} } ---- As mentioned in the previous section, we're using the `FromDateTime` transformation function to convert the DateTime strings in the `Date` column into timestamps. [NOTE] ==== For more details on the data transformation works see my blog post https://www.markhneedham.com/blog/2021/12/03/apache-pinot-convert-datetime-string-timestamp-invalid-timestamp/[Converting a DateTime String to Timestamp in Apache Pinot^]. ==== Now let's create the table and schema: [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table.json \ -schemaFile /config/schema.json -exec ---- == Import CSV Now we're going to import the crimes into Pinot, using the following ingestion spec: ./config/job-spec-sorted.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentGenerationJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' jobType: SegmentCreationAndTarPush inputDirURI: '/data' includeFileNamePattern: 'glob:**/Crimes_beat_sorted.csv' outputDirURI: ' ' pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS recordReaderSpec: dataFormat: 'csv' className: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReader' configClassName: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReaderConfig' tableSpec: tableName: 'crimes' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- [source,bash] ---- docker exec \ -it manual-pinot-controller bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/job-spec-sorted.yml ---- == Range Querying Now it's time to do some range querying. Let's start by counting the crimes committed on 1st January 2019, which we can do by running the following query: [source,sql] ---- SELECT count(*) FROM crimes WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') ---- As in the last post, we'll be looking at the output in JSON format to see what's going on under the covers: .Output [source,json] ---- { "numDocsScanned": 1065, "numEntriesScannedInFilter": 7434990, "numEntriesScannedPostFilter": 0, "timeUsedMs": 80 } ---- As we might expect, the SQL engine has scanned all 7,434,990 rows to check which ones match the date range. 1,065 crimes were committed on this day and the query took 80 ms. Now we're going to create another table called `crimes_index` that has a https://docs.pinot.apache.org/basics/indexing/range-index[range index^] applied to the `DateEpoch` column: ./config/table-range-index.json [source, json] ---- { "tableName": "crimes_range_index", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1, "schemaName": "crimes", <1> }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP", "sortedColumn": ["Beat"], "rangeIndexVersion": 2, "rangeIndexColumns": ["DateEpoch"] <2> }, "nullHandlingEnabled": true, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" }, "transformConfigs": [ {"columnName": "CaseNumber", "transformFunction": "\"Case Number\"" }, {"columnName": "PrimaryType", "transformFunction": "\"Primary Type\"" }, {"columnName": "CommunityArea", "transformFunction": "\"Community Area\"" }, {"columnName": "FBICode", "transformFunction": "\"FBI Code\"" }, {"columnName": "DateEpoch", "transformFunction": "FromDateTime(\"Date\", 'MM/dd/yyyy HH:mm:ss a')" } ] }, "metadata": {} } ---- <1> We need to explicitly specify the schema name since it doesn't match the table name. <2> Add a range index on the `DateEpoch` column. Run the following command to create the table: [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table-range-index.json \ -schemaFile /config/schema.json -exec ---- Now let's copy the segment from the `crimes` table to the `crimes_range_index` table. We can do this with the following ingestion spec: ./config/job-spec-download-only.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' jobType: SegmentTarPush outputDirURI: '/opt/pinot/data/crimes' pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS tableSpec: tableName: 'crimes_range_index' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- Run the ingestion spec: [source,bash] ---- docker exec \ -it manual-pinot-controller bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/job-spec-download-only.yml ---- [NOTE] ==== For more details on how this ingestion spec works, see my blog post https://www.markhneedham.com/blog/2021/12/06/apache-pinot-copy-segment-new-table/[Apache Pinot: Copying a segment to a new table^]. ==== Now let's re-run the query against the new table: [source,sql] ---- SELECT count(*) FROM crimes_range_index WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') ---- .Output [source, json] ---- { "numDocsScanned": 1065, "numEntriesScannedInFilter": 0, "numEntriesScannedPostFilter": 0, "timeUsedMs": 14 } ---- `numEntriesScannedInFilter` is now down to 0 and the query is more than 5 times faster than it was before. Now let's see what happens if we filter on multiple columns. We have a sorted index on the `Beat` column, so let's find the crimes committed on a specific beat on 1st January 2019: [source, sql] ---- SELECT count(*) FROM crimes WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') AND Beat = '0421' ---- .Output [source, json] ---- { "numDocsScanned": 13, "numEntriesScannedInFilter": 57573, "numEntriesScannedPostFilter": 0, "timeUsedMs": 3 } ---- [source, sql] ---- SELECT count(*) FROM crimes_range_index WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') AND Beat = '0421' ---- .Output [source, json] ---- { "numDocsScanned": 13, "numEntriesScannedInFilter": 0, "numEntriesScannedPostFilter": 0, "timeUsedMs": 12 } ---- In this case, the combination of sorted index on `Beat` and a scan of the forward index on `DateEpoch` is quicker than querying indexes on both fields. Admittedly this is far from the normal usage of Pinot. I'm only running one query at a time, whereas there would normally be thousands (if not more) concurrent queries, which would tip things in favour of using the indexes on both fields. Having said that, there is https://github.com/apache/pinot/issues/7600[a GitHub issue^] to have the query engine be smarter when deciding whether to scan or use an index. If we include more beats, the query that uses both indexes is slightly quicker: [source, sql] ---- SELECT count(*) FROM crimes WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') AND Beat IN ('0421', '0423', '0624', '1834', '0511', '1112', '1533', '0823', '0414', '1522') ---- .Output [source, json] ---- { "numDocsScanned": 90, "numEntriesScannedInFilter": 513052, "numEntriesScannedPostFilter": 0, "timeUsedMs": 12 } ---- [source, sql] ---- SELECT count(*) FROM crimes_range_index WHERE DateEpoch BETWEEN FromDateTime('2019-01-01', 'yyyy-MM-dd') AND FromDateTime('2019-01-02', 'yyyy-MM-dd') AND Beat IN ('0421', '0423', '0624', '1834', '0511', '1112', '1533', '0823', '0414', '1522') ---- .Output [source, json] ---- { "numDocsScanned": 90, "numEntriesScannedInFilter": 0, "numEntriesScannedPostFilter": 0, "timeUsedMs": 11 } ---- == Conclusion In this post we learnt how to use Apache Pinot's range index so that we could find crimes that happened on a given day. We then combined filter predicates and saw that sometimes it can be faster to do a column scan rather than merging together the results of querying two indexes. We haven't yet explored how to query the spatial data that this dataset contains, so perhaps that's what we'll look at in our next post!

In this post we'll learn how to write range queries against Apache Pinot using a Chicago Crimes dataset.

uploads/2021/12/range-queries.png

apache-pinot-exploring-range-queries

https://markhneedham.com/blog/2021/12/07/apache-pinot-exploring-range-queries

2021-12-06 00:44:37

Apache Pinot: Copying a segment to a new table

In this post we'll learn how to use the same Pinot segment in multiple tables. .Apache Pinot - Copy segment to another table image::{{<siteurl>}}/uploads/2021/12/segment-new-table.png[] == Setup First, we're going to spin up a local instance of Pinot using the following Docker compose config: .docker-compose.yml [source, yaml] ---- version: '3.7' services: zookeeper: image: zookeeper:3.5.6 hostname: zookeeper container_name: manual-zookeeper ports: - "2181:2181" environment: ZOOKEEPER_CLIENT_PORT: 2181 ZOOKEEPER_TICK_TIME: 2000 pinot-controller: image: apachepinot/pinot:0.9.0 command: "StartController -zkAddress manual-zookeeper:2181" container_name: "manual-pinot-controller" volumes: - ./config:/config - ./data:/data restart: unless-stopped ports: - "9000:9000" depends_on: - zookeeper pinot-broker: image: apachepinot/pinot:0.9.0 command: "StartBroker -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-broker" volumes: - ./config:/config - ./data:/data ports: - "8099:8099" depends_on: - pinot-controller pinot-server: image: apachepinot/pinot:0.9.0 command: "StartServer -zkAddress manual-zookeeper:2181" restart: unless-stopped container_name: "manual-pinot-server" volumes: - ./config:/config - ./data:/data depends_on: - pinot-broker ---- == Data We'll be working with a CSV file taken https://docs.pinot.apache.org/basics/getting-started/pushing-your-data-to-pinot[from Pinot's documentation^]: .transcript.csv [format="csv", options="header"] |=== include::content/2021/12/06/data/transcript.csv[] |=== == Create Table Let's create a Pinot schema and table based on this CSV file. The schema is defined below: ./config/schema.json [source.json] ---- { "schemaName": "transcript", "dimensionFieldSpecs": [ { "name": "studentID", "dataType": "INT" }, { "name": "firstName", "dataType": "STRING" }, { "name": "lastName", "dataType": "STRING" }, { "name": "gender", "dataType": "STRING" }, { "name": "subject", "dataType": "STRING" } ], "metricFieldSpecs": [ { "name": "score", "dataType": "FLOAT" } ], "dateTimeFieldSpecs": [{ "name": "timestampInEpoch", "dataType": "LONG", "format" : "1:MILLISECONDS:EPOCH", "granularity": "1:MILLISECONDS" }] } ---- Our table config is defined below: ./config/table.json [source.json] ---- { "tableName": "transcript", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1 }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP" }, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" } }, "metadata": {} } ---- Now let's create the table and schema: [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table.json \ -schemaFile /config/schema.json -exec ---- == Import CSV file After we've done that, it's time to import the CSV file. We'll do this using the ingestion job spec defined below: ./config/job-spec.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentGenerationJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentGenerationJobRunner' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' jobType: SegmentCreationAndTarPush inputDirURI: '/data' includeFileNamePattern: 'glob:**/transcript.csv' outputDirURI: '/opt/pinot/data/transcript' overwriteOutput: true pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS recordReaderSpec: dataFormat: 'csv' className: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReader' configClassName: 'org.apache.pinot.plugin.inputformat.csv.CSVRecordReaderConfig' tableSpec: tableName: 'transcript' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- `includeFileNamePattern` refers to the `transcript.csv` file that we saw earlier in this post. We can run the ingestion job like so: [source,bash] ---- docker exec \ -it manual-pinot-controller bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/job-spec.yml ---- This ingestion job does two things. _segmentGenerationJobRunnerClassName_ writes the segment file to the https://docs.pinot.apache.org/basics/components/deep-store[deep store^], which is stored under `/opt/pinot/data/transcript` on our Pinot Controller container. We can run the following command to check that it's there: [source,bash] ---- docker exec -it manual-pinot-controller ls -lh /opt/pinot/data/transcript ---- .Output [source,text] ---- total 4.0K -rw-r--r-- 1 root root 1.7K Dec 6 17:08 transcript_OFFLINE_0.tar.gz ---- And then once the segment has been written to the deep store, _segmentTarPushJobRunnerClassName_ copies the segment file down to the Pinot Server. == Copy segment to new table Now let's say we create a new table `transcript2` that uses the same schema, but has an inverted index on one of the columns. The table config is described below: ./config/table-indexes.json [source.json] ---- { "tableName": "transcript2", "tableType": "OFFLINE", "segmentsConfig": { "replication": 1, "schemaName": "transcript" }, "tenants": { "broker":"DefaultTenant", "server":"DefaultTenant" }, "tableIndexConfig": { "loadMode": "MMAP", "invertedIndexColumns": ["subject"] }, "ingestionConfig": { "batchIngestionConfig": { "segmentIngestionType": "APPEND", "segmentIngestionFrequency": "DAILY" } }, "metadata": {} } ---- Create the table: [source, bash] ---- docker exec -it manual-pinot-controller bin/pinot-admin.sh AddTable \ -tableConfigFile /config/table-indexes.json \ -exec ---- Once the table's created, we're going to download the segment (`transcript_OFFLINE_0.tar.gz`) to this table, which we can do using the following ingestion job spec: ./config/job-spec-download-only.yml [source,yaml] ---- executionFrameworkSpec: name: 'standalone' segmentTarPushJobRunnerClassName: 'org.apache.pinot.plugin.ingestion.batch.standalone.SegmentTarPushJobRunner' jobType: SegmentTarPush outputDirURI: '/opt/pinot/data/transcript' pinotFSSpecs: - scheme: file className: org.apache.pinot.spi.filesystem.LocalPinotFS tableSpec: tableName: 'transcript2' pinotClusterSpecs: - controllerURI: 'http://localhost:9000' ---- This time our job type is _SegmentTarPush_, which means it will only run the _segmentTarPushJobRunnerClassName_ job. This job will (indirectly) copy the segment from _outputDirURI_ down to the Pinot Server. [source,bash] ---- docker exec \ -it manual-pinot-controller bin/pinot-admin.sh LaunchDataIngestionJob \ -jobSpecFile /config/job-spec-download-only.yml ---- We can then navigate to the `transcripts2` table (via http://localhost:9000/#/tables) in the Pinot Data Explorer, and see that the segment has been loaded: .transcripts2 table with segment downloaded from transcripts table image::{{<siteurl>}}/uploads/2021/12/segment-downloaded.png[] We can now run queries against this segment from the `transcripts2` table.

In this post we'll learn how to use a copy of a Pinot segment in another table.

uploads/2021/12/segment-new-table.png

apache-pinot-copy-segment-new-table

https://markhneedham.com/blog/2021/12/06/apache-pinot-copy-segment-new-table

2020-03-31 00:21:00

Streamlit: multiselect - AttributeError: 'numpy.ndarray' object has no attribute 'index'

In this post we'll learn how to overcome a problem I encountered while building a small https://www.streamlit.io/[Streamlit^] application to analyse https://github.com/CSSEGISandData/COVID-19[John Hopkin's data on the COVID-19 disease^]. The examples in this post use https://github.com/CSSEGISandData/COVID-19/blob/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv[a CSV file that contains time series data of deaths in each country^]. I started with the following code to create https://docs.streamlit.io/api.html#streamlit.multiselect[a multiselect widget^] that lists all countries and selected the `United Kingdom` by default: [source,python] ---- import streamlit as st import pandas as pd default_countries = ["United Kingdom"] url="https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv" df=pd.read_csv(url) countries = st.sidebar.multiselect( 'Select countries', options=df["Country/Region"].unique(), default=default_countries ) ---- We can run our application by executing the following command: [source,bash] ---- $ streamlit run app.py You can now view your Streamlit app in your browser. Local URL: http://localhost:8501 Network URL: http://192.168.1.192:8501 ---- And if we view that page in our web browser we'll see the following: [source, text] ---- AttributeError: 'numpy.ndarray' object has no attribute 'index' Traceback: File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/ScriptRunner.py", line 322, in _run_script exec(code, module.__dict__) File "/home/markhneedham/projects/covid-19/app.py", line 55, in <module> default=default_countries File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 121, in wrapped_method return dg._enqueue_new_element_delta(marshall_element, delta_type, last_index) File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 342, in _enqueue_new_element_delta rv = marshall_element(msg.delta.new_element) File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 119, in marshall_element return method(dg, element, *args, **kwargs) File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 1693, in multiselect indices = _check_and_convert_to_indices(options, default) File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 1691, in _check_and_convert_to_indices return [options.index(value) for value in default_values] File "/home/markhneedham/.local/share/virtualenvs/covid-19-r91ZMWVf/lib/python3.7/site-packages/streamlit/DeltaGenerator.py", line 1691, in <listcomp> return [options.index(value) for value in default_values] ---- I tried changing the type of the collection passed to `default`, but kept getting the same error, until I eventually converted `options` to a Python list. This resulted in the following code: [source,python] ---- import streamlit as st import pandas as pd default_countries = ["United Kingdom"] url="https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv" df=pd.read_csv(url) countries = st.sidebar.multiselect( 'Select countries', options=list(df["Country/Region"].unique()), default=default_countries ) ---- And now if we run the application we'll see the following output: image::{{<siteurl>}}/uploads/2020/03/streamlit-multiselect.png[title="Streamlit multiselect widget"] Job done!

Learn how to overcome a problem specifying default values with Streamlit's multiselect widget.

streamlit-multiselect-numpy-no-attribute-index

https://markhneedham.com/blog/2020/03/31/streamlit-multiselect-numpy-no-attribute-index

2020-04-18 00:21:00

Python: Find the starting Sunday for all the weeks in a month

In this post we're going to learn how to find the dates of all the Sundays in a given month, as well as the Sunday immediately preceding the 1st day in the month, assuming that day isn't a Sunday. Let's start by importing some libraries that we're going to use in this blog post: [source, python] ---- from dateutil import parser import datetime import calendar ---- Next we need to find the first day of the current month, which we can do with the following code: [source,python] ---- today = datetime.date.today() start = today.replace(day=1) >>> start datetime.date(2020, 4, 1) ---- Now we need to find the last day of the month. I found a cool https://stackoverflow.com/questions/42950/how-to-get-the-last-day-of-the-month[StackOverflow thread^] that suggested lots of different approaches. I liked the following one best: [source,python] ---- weekday, last_day = calendar.monthrange(now.year, now.month) >>> last_day 30 ---- We can now create a new date by updating the day to be `last_day`: [source,python] ---- end = today.replace(day=last_day) ---- And now let's output the `start` and `end` variables: [source,python] ---- >>> start datetime.date(2020, 4, 1) >>> end datetime.date(2020, 4, 30) ---- So far so good! Our next task is to create a collection containing all the days between these dates. One way to do this is to iterate over a range of the number of days between these dates, and then add the https://docs.python.org/3/library/datetime.html#datetime.timedelta[timedelta^] of the increasing number of days to the start date. We can compute the number of days between these two dates by using a subtraction operation, which will return a `timedelta` object. We'll then call the `days` property on that: [source,python] ---- >>> end - start datetime.timedelta(days=29) >>> (end - start).days 29 ---- Now let's create a range from 0 to that number of days and create a list containing the dates between these two dates: [source,python] ---- >>> [start + datetime.timedelta(day) for day in range(0, (end - start).days + 1)] [datetime.date(2020, 4, 1), datetime.date(2020, 4, 2), datetime.date(2020, 4, 3), datetime.date(2020, 4, 4), datetime.date(2020, 4, 5), datetime.date(2020, 4, 6), datetime.date(2020, 4, 7), datetime.date(2020, 4, 8), datetime.date(2020, 4, 9), datetime.date(2020, 4, 10), datetime.date(2020, 4, 11), datetime.date(2020, 4, 12), datetime.date(2020, 4, 13), datetime.date(2020, 4, 14), datetime.date(2020, 4, 15), datetime.date(2020, 4, 16), datetime.date(2020, 4, 17), datetime.date(2020, 4, 18), datetime.date(2020, 4, 19), datetime.date(2020, 4, 20), datetime.date(2020, 4, 21), datetime.date(2020, 4, 22), datetime.date(2020, 4, 23), datetime.date(2020, 4, 24), datetime.date(2020, 4, 25), datetime.date(2020, 4, 26), datetime.date(2020, 4, 27), datetime.date(2020, 4, 28), datetime.date(2020, 4, 29), datetime.date(2020, 4, 30)] ---- NOTE: The `range` function doesn't include the upper bound, so we had to add 1 so that the end date is included. So far so good. Now we want to filter the list to only return Sundays. We can use the `isoweekday` function to do this. Sundays are represented by a value of 7, which gives us the following code: [source,python] ---- >>> [date for date in [start + datetime.timedelta(day) for day in range(0, (end - start).days + 1)] if date.isoweekday() == 7] [datetime.date(2020, 4, 5), datetime.date(2020, 4, 12), datetime.date(2020, 4, 19), datetime.date(2020, 4, 26)] ---- We've now got all the Sundays in April. And our final step is get the Sunday preceding April 1st. We can work this out by https://stackoverflow.com/questions/19216334/python-give-start-and-end-of-week-data-from-a-given-date[subtracting the `isoweekday`^] of our `start` variable: [source,python] ---- >>> start.isoweekday() 3 >>> start - datetime.timedelta(days = start.isoweekday()) datetime.date(2020, 3, 29) ---- We can now update our `start` date. This leads to the following code to compute start and end dates: [source,python] ---- today = datetime.date.today() weekday, last_day = calendar.monthrange(now.year, now.month) start = today.replace(day=1) start = start - datetime.timedelta(days = start.isoweekday()) end = today.replace(day=last_day) ---- Let's quickly check those dates: [source,python] ---- >>> start datetime.date(2020, 3, 29) >>> end datetime.date(2020, 4, 30) ---- And now we can find all the Sundays between these dates: [source,python] ---- >>> [date for date in [start + datetime.timedelta(day) for day in range(0, (end - start).days + 1)] if date.isoweekday() == 7] [datetime.date(2020, 3, 29), datetime.date(2020, 4, 5), datetime.date(2020, 4, 12), datetime.date(2020, 4, 19), datetime.date(2020, 4, 26)] ---- And we're done!

Learn how to find the Sundays in a given month.

python-starting-sundays-in-a-month

https://markhneedham.com/blog/2020/04/18/python-starting-sundays-in-a-month

2020-04-27 00:21:00

Python: Select keys from map/dictionary

In this post we're going to learn how to filter a Python map/dictionary to return a subset of keys or values. I needed to do this recently while logging some maps that had a lot of keys that I wasn't interested in. We'll start with the following map: [source, python] ---- x = {"a": 1, "b": 2, "c": 3, "d": 4} {'a': 1, 'b': 2, 'c': 3, 'd': 4} ---- We want to filter this map so that we only have the keys `a` and `c`. If we just want the values, we can create a list comprehension to do this: [source,python] ---- >>> [x[key] for key in ["a", "b"]] [1, 2] ---- But what if we want to return the values as well? This is where https://markhneedham.com/blog/2013/08/13/python-forlist-comprehensions-and-dictionaries/[dictionary comprehensions^] come in handy. We can tweak our code as follows: [source,python] ---- >>> {key: x[key] for key in ["a", "b"]} {'a': 1, 'b': 2} ---- Or we can iterate over all the entries in the map and filter it that way: [source,python] ---- >>> {key:value for key,value in x.items() if key in ["a", "b"]} {'a': 1, 'b': 2} ---- This approach is longer but more flexible. For example, we could find the keys and values for all entries with a value great than 2 with the following code: [source,python] ---- >>> {key:value for key,value in x.items() if value > 2} {'c': 3, 'd': 4} ----

Learn how to filter a map to select specific keys

python-select-keys-from-map-dictionary

https://markhneedham.com/blog/2020/04/27/python-select-keys-from-map-dictionary

2020-04-21 00:21:00

QuickGraph #6: COVID-19 Taxonomy Graph

It's been several months since https://markhneedham.com/blog/2020/01/23/quick-graph-australian-open/[our last QuickGraph^] and the world feels very different than it was back then. I've been reading a couple of books about viruses - https://www.amazon.co.uk/Spillover-Animal-Infections-Human-Pandemic-ebook/dp/B009EQG794/[Spillover^] and https://www.amazon.co.uk/Pale-Rider-Spanish-Changed-World-ebook/dp/B01GH07CG6[Pale Rider^] - and am now very curious to learn more about the medical terms reference in the books. With the https://github.com/neo4j-labs/neosemantics/releases/tag/4.0.0-beta[Pre Release of neosemantics (n10s) for Neo4j 4.0^], I thought it would be interesting to create a graph of the taxonomy of the virus that caused COVID-19, using data extracted from https://markhneedham.com/blog/2020/01/29/newbie-guide-querying-wikidata/[Wikidata's SPARQL API^]. image::{{<siteurl>}}/uploads/2020/04/quick-graph-covid-taxonomy.png[title="The COVID-19 Taxonomy Graph"] Let's get started! == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .docker-compose.yml [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0-enterprise container_name: "covid-graph" volumes: - ./plugins:/plugins - ./data-4.0:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4J_apoc_import_file_enabled=true - NEO4J_apoc_export_file_enabled=true - NEO4J_dbms_directories_import=import - NEO4JLABS_PLUGINS=["apoc"] ---- We'll manually copy the n10s jar into the `plugins` directory, and then run the following command: [source,bash] ---- docker-compose up ---- If everything's working properly, we'll see the following: [source,text] ---- Starting covid-graph ... done Attaching to covid-graph covid-graph | Changed password for user 'neo4j'. covid-graph | Fetching versions.json for Plugin 'apoc' from https://neo4j-contrib.github.io/neo4j-apoc-procedures/versions.json covid-graph | Installing Plugin 'apoc' from https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.0.0.7/apoc-4.0.0.7-all.jar to /plugins/apoc.jar covid-graph | Applying default values for plugin apoc to neo4j.conf covid-graph | Directories in use: covid-graph | home: /var/lib/neo4j covid-graph | config: /var/lib/neo4j/conf covid-graph | logs: /logs covid-graph | plugins: /plugins covid-graph | import: /var/lib/neo4j/import covid-graph | data: /var/lib/neo4j/data covid-graph | certificates: /var/lib/neo4j/certificates covid-graph | run: /var/lib/neo4j/run covid-graph | Starting Neo4j. covid-graph | 2020-04-20 19:56:48.326+0000 INFO ======== Neo4j 4.0.3 ======== covid-graph | 2020-04-20 19:56:48.333+0000 INFO Starting... covid-graph | 2020-04-20 19:56:55.257+0000 INFO Called db.clearQueryCaches(): Query cache already empty. covid-graph | 2020-04-20 19:57:04.198+0000 INFO Sending metrics to CSV file at /var/lib/neo4j/metrics covid-graph | 2020-04-20 19:57:04.220+0000 INFO Bolt enabled on 0.0.0.0:7687. covid-graph | 2020-04-20 19:57:04.220+0000 INFO Started. covid-graph | 2020-04-20 19:57:04.370+0000 INFO Server thread metrics have been registered successfully covid-graph | 2020-04-20 19:57:05.324+0000 INFO Remote interface available at http://0.0.0.0:7474/ ---- == Configuring n10s Let's now configure n10s so that it's ready to import some data. We need to create a unique constraint on `:Resource(uri)` and then call the `n10s.graphconfig.init` procedure to configure the library: [source, cypher] ---- CREATE CONSTRAINT n10s_unique_uri ON (r:Resource) ASSERT r.uri IS UNIQUE; CALL n10s.graphconfig.init({handleVocabUris: "MAP"}); ---- == Virus Taxonomy We're now ready to start exploring Wikidata. The virus behind COVID-19 is called https://www.wikidata.org/wiki/Q82069695[SARS-CoV-2], so we'll start there and then manually follow the `parent taxon` statement as far as we can. This eventually leads us to https://www.wikidata.org/wiki/Q62002503[Riboviria^], which is described as follows: [quote, https://en.wikipedia.org/wiki/Riboviria] ____ Riboviria is a realm of viruses that encompasses all RNA viruses and viroids that replicate by means of RNA-dependent RNA polymerases. ____ Our manual traversal can also be expressed by the following SPARQL query: .https://query.wikidata.org/#CONSTRUCT%20%7B%0A%20%20%3Fcat%20rdfs%3Alabel%20%3FcatName%20.%0A%20%20%3FsubCat%20rdfs%3Alabel%20%3FsubCatName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP171%20%3FparentCat%20.%0A%20%20%7D%20%0AWHERE%20%7B%0A%20%20%3Fcat%20rdfs%3Alabel%20%22Riboviria%22%40en%20.%0A%20%20%3Fcat%20rdfs%3Alabel%20%3FcatName%20.%0A%20%20filter%28lang%28%3FcatName%29%20%3D%20%22en%22%29%20.%0A%20%20%3FsubCat%20wdt%3AP171%2B%20%3Fcat%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP171%20%3FparentCat%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FsubCatName%0A%20%20%20%20%20%20%20%20%20%20filter%28lang%28%3FsubCatName%29%20%3D%20%22en%22%29%20.%0A%7D[Run query on Wikidata^] [source, sparql] ---- CONSTRUCT { ?cat rdfs:label ?catName . ?subCat rdfs:label ?subCatName ; wdt:P171 ?parentCat . } WHERE { ?cat rdfs:label "Riboviria"@en . ?cat rdfs:label ?catName . filter(lang(?catName) = "en") . ?subCat wdt:P171+ ?cat ; wdt:P171 ?parentCat; rdfs:label ?subCatName filter(lang(?subCatName) = "en") . } ---- If we execute this query, we'll see the following (truncated) output: .Results [opts="header", separator=","] |=== ,subject,predicate,object 3+, ,http://www.wikidata.org/entity/Q5331908,http://www.w3.org/2000/01/rdf-schema#label,Ebolavirus ,http://www.wikidata.org/entity/Q5331908,http://www.wikidata.org/prop/direct/P171,http://www.wikidata.org/entity/Q46305 3+, ,http://www.wikidata.org/entity/Q82069695,http://www.w3.org/2000/01/rdf-schema#label,SARS-CoV-2 ,http://www.wikidata.org/entity/Q82069695,http://www.wikidata.org/prop/direct/P171,http://www.wikidata.org/entity/Q278567 3+, ,http://www.wikidata.org/entity/Q4902157,http://www.w3.org/2000/01/rdf-schema#label,Middle East respiratory syndrome coronavirus ,http://www.wikidata.org/entity/Q4902157,http://www.wikidata.org/prop/direct/P171,http://www.wikidata.org/entity/Q57754679 |=== Now let's import this data into Neo4j so we can explore it further. == Constructing the Virus Taxonomy Graph We're going to import the data into the following Neo4j graph model: image::{{<siteurl>}}/uploads/2020/04/taxonomy-graph.png[title="Virus Taxonomy Graph"] Our SPARQL query returns triples with the predicates `http://www.wikidata.org/prop/direct/P171` and `http://www.w3.org/2000/01/rdf-schema#label`. We'll need to convert those to `CHILD_OF` and `name` respectively, which we can do by executing the following procedures: [source,cypher] ---- CALL n10s.mapping.addSchema("http://www.wikidata.org/prop/direct/", "wdt"); CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","CHILD_OF","P171"); CALL n10s.mapping.addSchema("http://www.w3.org/2000/01/rdf-schema#", "rdfs"); CALL n10s.mapping.addMappingToSchema("http://www.w3.org/2000/01/rdf-schema#","name","label"); ---- We can now import the results of our SPARQL query into Neo4j using the `n10s.rdf.import.fetch` procedure: [source,cypher] ---- WITH ' CONSTRUCT { ?cat rdfs:label ?catName . ?subCat rdfs:label ?subCatName ; wdt:P171 ?parentCat . } WHERE { ?cat rdfs:label "Riboviria"@en . ?cat rdfs:label ?catName . filter(lang(?catName) = "en") . ?subCat wdt:P171+ ?cat ; wdt:P171 ?parentCat; rdfs:label ?subCatName filter(lang(?subCatName) = "en") . } ' AS query CALL n10s.rdf.import.fetch( "https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(query), "JSON-LD", { headerParams: { Accept: "application/ld+json"}}) YIELD triplesLoaded RETURN triplesLoaded; ---- .Results [opts="header"] |=== |triplesLoaded |3259 |=== Let's now add the `Virus` label to each of our nodes: [source,cypher] ---- MATCH (n:Resource) SET n:Virus; ---- Before we continue, let's do a bit of cleanup. Wikidata's taxonomy has some unnecessary shortcuts that make the graph harder to understand. For example in the following visualisation we can remove a couple of extraneous `CHILD_OF` relationships: image::{{<siteurl>}}/uploads/2020/04/shortcuts.png[title="Taxonomy Shortcuts"] We can remove these shortcut relationships by running the following query: [source,cypher] ---- MATCH (v:Virus)<-[co:CHILD_OF*2..]-(child)-[shortcut:CHILD_OF]->(v) DELETE shortcut; ---- We're now ready to query the graph. == Querying the Virus Taxonomy Graph Let's start with a query to find out the shortest path from the SARS virus to the SARS-CoV-2 virus: [source,cypher] ---- MATCH (r1:Virus {name: "SARS-CoV-2"}) MATCH (r2:Virus {name: "severe acute respiratory syndrome coronavirus"}) MATCH path = shortestpath((r1)-[*]-(r2)) RETURN path; ---- If we run this query, we'll see the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/04/sars-sars-cov-2.svg[title="Path between SARS and SARS-CoV-2"] Both of these viruses have a common parent, https://www.wikidata.org/wiki/Q278567[severe acute respiratory syndrome-related coronavirus^]. Where does the parent category fit in the whole taxonomy? We can find out by writing the following query: [source,cypher] ---- MATCH (r1:Virus {name: "SARS-CoV-2"}) MATCH (r2:Virus {name: "severe acute respiratory syndrome coronavirus"}) MATCH path1 = (r1)-[:CHILD_OF*]->(r1root) WHERE not((r1root)-[:CHILD_OF]->()) MATCH path2 = (r2)-[:CHILD_OF*]->(r2root) WHERE not((r2root)-[:CHILD_OF]->()) RETURN path1, path2 ---- And if we run this query, we'll see the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/04/sars-sars-cov2-root.svg[title="SARS and SARS-CoV-2 in the virus taxonomy"] Both of these coronaviruses are part of the https://en.wikipedia.org/wiki/Betacoronavirus[Betacoronaviruses^] family, and from its Wikipedia page we learn that the virus that caused Middle East Respiratory Syndrome: [quote, https://en.wikipedia.org/wiki/Betacoronavirus] ____ The Beta-CoVs of the greatest clinical importance concerning humans are OC43 and HKU1 of the A lineage, SARS-CoV and SARS-CoV-2 (which causes the disease COVID-19) of the B lineage, and MERS-CoV of the C lineage. MERS-CoV is the first betacoronavirus belonging to lineage C that is known to infect humans. ____ [source,cypher] ---- WITH ["SARS-CoV-2", "Middle East respiratory syndrome coronavirus", "severe acute respiratory syndrome coronavirus"] AS virus UNWIND apoc.coll.combinations(virus, 2, 2) AS pair MATCH (r1:Virus {name: pair[0]}) MATCH (r2:Virus {name: pair[1]}) MATCH path = shortestpath((r1)-[*]-(r2)) RETURN path ---- If we run this query, we'll see the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/04/coronaviruses.svg[title="Paths between SARS, SARS-CoV-2, and MERS"] MERS comes under https://en.wikipedia.org/wiki/Merbecovirus[Merbecovirus^], which is described below: [quote, https://en.wikipedia.org/wiki/Merbecovirus] ____ Merbecovirus is a subgenus of viruses in the genus Betacoronavirus. The viruses in this subgenus were previously known as group 2c coronaviruses. The viruses of this subgenus, like other coronaviruses, have a lipid bilayer envelope in which the membrane (M), envelope (E) and spike (S) structural proteins are anchored. ____ Now I'm curious about the other sub children of Betacoronavirus, which we can explore by writing the following query: [source, cypher] ---- MATCH path = (virus:Virus {name: "Betacoronavirus"})<-[:CHILD_OF*]-(child) RETURN path ---- The Neo4j Browser visualisation below shows the full taxonomy: image::{{<siteurl>}}/uploads/2020/04/beta-coronavirus.svg[title="Betacoronavirus Taxonomy"] == Enriching the graph Now we're going to add some more data to our graph. It'd be good to know which hosts each virus can infect, the diseases caused by these viruses, events associated with each disease, and the locations affected. We're eventually going to have the following graph model: image::{{<siteurl>}}/uploads/2020/04/taxonomy-graph-enriched.png[title="Virus Graph"] Let's start by adding the hosts. In Wikidata, the host statement is https://www.wikidata.org/wiki/Property:P2975[P2975^], so we'll need to create an n10s mapping to translate this to the `HOST` relationship type: [source,cypher] ---- CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","HOST","P2975"); ---- We can then write the following query to import the hosts for each virus: [source,cypher] ---- MATCH (r:Virus) WITH n10s.rdf.getIRILocalName(r.uri) AS virus, r WITH 'prefix schema: <http://schema.org/> CONSTRUCT { wd:' + virus + ' wdt:P2975 ?host. ?host rdfs:label ?hostName ; rdf:type schema:Host } WHERE { OPTIONAL { wd:' + virus + ' wdt:P2975 ?host. ?host rdfs:label ?hostName. filter(lang(?hostName) = "en") } }' AS query, r CALL n10s.rdf.import.fetch("https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(query), "JSON-LD", { headerParams: { Accept: "application/ld+json"}}) YIELD triplesLoaded RETURN r.name, triplesLoaded; ---- Now we're going to add the diseases, events, and locations. We have a few more Wikidata to n10s mappings to do: * https://www.wikidata.org/wiki/Property:P828[has cause (P828)^] -> `HAS_CAUSE` * https://www.wikidata.org/wiki/Property:P31[instance of (P31)^] -> `INSTANCE_OF` * https://www.wikidata.org/wiki/Property:P276[location (P276)^] -> `LOCATION` * https://www.wikidata.org/wiki/Property:P793[significant event (P793)^] -> `SIGNIFICANT_EVENT` We can create these mappings by making the following procedure calls: [source,cypher] ---- CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","HAS_CAUSE","P828"); CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","INSTANCE_OF","P31"); CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","LOCATION","P276"); CALL n10s.mapping.addMappingToSchema("http://www.wikidata.org/prop/direct/","SIGNIFICANT_EVENT","P793"); ---- Now we're ready to import the data, which we can do by running the following query: [source,cypher] ---- MATCH (r:Virus) WITH n10s.rdf.getIRILocalName(r.uri) AS virus, r WITH 'prefix schema: <http://schema.org/> CONSTRUCT { ?event wdt:P828 wd:' + virus + '; wdt:P31 ?eventType; rdfs:label ?diseaseName; wdt:P276 ?origin ; wdt:P793 ?significantEvent. ?origin rdfs:label ?originName; rdf:type schema:Place . ?eventType rdfs:label ?eventTypeName. ?significantEvent rdfs:label ?significantEventName ; rdf:type schema:Event. } WHERE { { ?event wdt:P828 wd:'+ virus + '; } UNION { ?event wdt:P1478 wd:' + virus + '; } . ?event rdfs:label ?diseaseName . filter(lang(?diseaseName) = "en") OPTIONAL { ?event wdt:P31 ?eventType. ?eventType rdfs:label ?eventTypeName filter(lang(?eventTypeName) = "en")} OPTIONAL { ?event wdt:P276 ?origin . ?origin rdfs:label ?originName . filter(lang(?originName) = "en") } OPTIONAL { ?event wdt:P793 ?significantEvent . ?significantEvent rdfs:label ?significantEventName . filter(lang(?significantEventName) = "en") } }' AS query, r CALL n10s.rdf.import.fetch("https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(query), "JSON-LD", { headerParams: { Accept: "application/ld+json"}}) YIELD triplesLoaded RETURN r.name, triplesLoaded ORDER BY triplesLoaded DESC; ---- Once this has finished, we'll run the following query to add the `Disease` label to any nodes that have an `INSTANCE` of relationship to a node that represents an infectious disease: [source,cypher] ---- MATCH (r:Resource)-[:INSTANCE_OF]->(item:Resource) WHERE item.name CONTAINS "infectious disease" WITH r, collect(item.name) AS items SET r:Disease; ---- == Querying the Enriched Graph Now that we've got that data loaded, let's start by finding the viruses that affect humans: [source, cypher] ---- MATCH hostPath = (h:Host {name: "Homo sapiens"})<-[:HOST]-(virus)-[:HOST]->(otherHost) RETURN hostPath ---- image::{{<siteurl>}}/uploads/2020/04/corona-hosts.svg[title="Viruses that affect humans"] We get back the three viruses that we've explored so far: SARS, SARS-CoV-2, and MERS. SARS and SARS-CoV-2 also affect bats, and MERS affects camels. Let's extend our query to return viruses and diseases as well: [source,cypher] ---- MATCH hostPath = (h:Host {name: "Homo sapiens"})<-[:HOST]-(virus)-[:HOST]->(otherHost) OPTIONAL MATCH diseasePath = (virus)<-[:CHILD_OF*0..]-(v)<-[:HAS_CAUSE]-(thing) OPTIONAL MATCH eventPath = (thing)-[:LOCATION|:SIGNIFICANT_EVENT]->(event) RETURN hostPath, diseasePath, eventPath ---- If we run this query, we'll see the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/04/corona-graph.svg[title="Coronavirus Graph - viruses, diseases, events, locations"] We can now see nodes representing the pandemics in different countries for COVID-19. There's also one node representing the SARS outbreak in 2002, and 3 nodes for the MERS outbreaks in 2012, 2015, and 2018. == What’s interesting about this QuickGraph? This QuickGraph has gone on for much longer than I expected, so it's time to wrap up. What makes this QuickGraph interesting to me is that the dataset is perfect for writing https://neo4j.com/docs/cypher-manual/current/syntax/patterns/#cypher-pattern-varlength[variable path queries^]. It also gave me an opportunity to use n10s for the first time, which was a good experience. I have to say thanks to https://twitter.com/barrasadv?lang=en[Jesus^] for all his help with the queries in this post. And finally, if you want to build this graph yourself, the code is available in the https://github.com/mneedham/covid-graph[mneedham/covid-graph^] GitHub repository.

Learn how to build a graph of the taxonomy around COVID-19.

uploads/2020/04/quick-graph-covid-taxonomy.png

quick-graph-covid-19-taxonomy

https://markhneedham.com/blog/2020/04/21/quick-graph-covid-19-taxonomy

2020-04-13 00:21:00

React Semantic-UI: Adding a custom icon to open link in a new window

I've been building a little React app that uses the https://react.semantic-ui.com/[Semantic UI^] library and found myself wanting to render a custom icon. Semantic UI describes an https://react.semantic-ui.com/elements/icon/[icon^] as "a glyph used to represent something else", and there are a big list of in built icons. For example, the following code renders a thumbs up icon: [source,javascript] ---- import {Icon} from "semantic-ui-react"; <Icon name="thumbs up outline icon green large" style={{margin: 0}}/> ---- image::{{<siteurl>}}/uploads/2020/04/thumbs-up.png[title="Thumbs Up Icon"] I wanted to add an icon to indicate that a link would open in a new window, and came across this https://github.com/Semantic-Org/Semantic-UI-React/issues/931[GitHub issue^] that explains how to add a custom icon. Instead of using the `name` property, we can use the `className` property to have a icon render based on our own CSS. Ruard van Elburg explained how to render an open in new window icon in https://stackoverflow.com/a/61104675/1093511[this StackOverflow answer^]. We'll first add the following CSS: [source,css] ---- i.icon.open-new-window:after { content: "\f35d"; } ---- And then can use the `open-new-window` class to render our icon: [source,javascript] ---- <a href="https://www.neo4j.com" target="_blank"> <Icon className="open-new-window black"/> </a> ---- image::{{<siteurl>}}/uploads/2020/04/open-window.png[title="Open Window Icon"] And we're done!

Learn how to render a custom icon when using React Semantic-UI.

react-semantic-ui-custom-add-icon-open-new-window

https://markhneedham.com/blog/2020/04/13/react-semantic-ui-custom-add-icon-open-new-window

2020-05-05 00:21:00

QuickGraph #7: An entity graph of TWIN4j using APOC NLP

One of the most popular use cases for Neo4j is knowledge graphs, and part of that process involves using NLP to create a graph structure from raw text. If we were doing a serious NLP project we'd want to use something like https://graphaware.com/products/hume/[GraphAware Hume^], but in this blog post we're going to learn how to add basic NLP functionality to our graph applications. image::{{<siteurl>}}/uploads/2020/05/apoc-nlp.png[title="Building an entity graph of TWIN4j using APOC NLP"] == APOC NLP The big cloud providers (AWS, GCP, and Azure) all have Natural Language Processing APIs and, although their APIs aren't identical, they all let us extract entities, key phrases, and sentiment from text documents. image::{{<siteurl>}}/uploads/2020/05/1_go7sTFOGN2fJGgYrI3E-FA.png[title="AWS, GCP, Azure"] While these APIs are easy to enough to use via client drivers, we thought it'd be fun to make them even more accessible by https://neo4j.com/docs/labs/apoc/current/nlp/[adding procedures that call these APIs to the popular APOC Library^] Each procedure has two modes: * Stream - returns a map constructed from the JSON returned from the API * Graph - creates a graph or virtual graph based on the values returned by the API At the moment we've got procedures covering some of the https://neo4j.com/docs/labs/apoc/current/nlp/aws/[AWS^] and https://neo4j.com/docs/labs/apoc/current/nlp/gcp/[GCP^] endpoints, but we'll be adding more over time. In this blog post we're going to learn how to use the AWS procedures. == The Problem We're going to use the procedures to build a mini recommendation engine for https://neo4j.com/tag/twin4j[This Week in Neo4j (TWIN4j)^], Neo4j's weekly newsletter. The newsletter covers wide ranging topics, which means that if you like one version of the newsletter, it doesn't necessarily mean that you'll like the next one! The NLP procedures let us build a graph of entities in each newsletter, which we can use to recommend other newsletters that a user might like to read. == Importing TWIN4j blog posts Before we do any NLP work, we need to load the TWIN4j blog posts into Neo4j. We can get a list of all those posts from the Wordpress JSON API. We'll process the resulting documents using APOC's Load JSON procedure. We can see the available keys/properties on each document by running the following query: [source,cypher] ---- CALL apoc.load.json("https://neo4j.com/wp-json/wp/v2/posts?tags=3201") YIELD value RETURN keys(value) LIMIT 1 ---- .Results [opts="header"] |=== | keys(value) | ["date", "template", "_links", "link", "type", "title", "content", "featured_media", "modified", "id", "categories", "date_gmt", "slug", "modified_gmt", "author", "yst_prominent_words", "format", "comment_status", "yoast_head", "tags", "ping_status", "meta", "sticky", "guid", "excerpt", "status"] |=== We're interested in the `title`, `date`, and `link` properties. Let's create nodes with the `Article` label by running the following query: [source, cypher] ---- CALL apoc.load.json("https://neo4j.com/wp-json/wp/v2/posts?tags=3201") YIELD value MERGE (a:Article {id: value.id}) SET a.title = value.title.rendered, a.date = datetime(value.date), a.link = value.link; ---- By default the WordPress API returns 10 items per page, which means that this query will create nodes for 10 TWIN4j entries. We'll use APOC's Periodic Iterate procedure to loop over the pages in the API: [source,cypher] ---- CALL apoc.periodic.iterate( "UNWIND range(1,16) AS page RETURN page", "CALL apoc.load.json('https://neo4j.com/wp-json/wp/v2/posts?tags=3201&page=' + page) YIELD value MERGE (a:Article {id: value.id}) SET a.title = value.title.rendered, a.date = datetime(value.date) a.link = value.link; ", {} ); ---- We are cheating a bit here by hard coding the highest page to 16. Ideally we'd have a more flexible approach, but we'll leave that for another day/blog post. Once that query has finished, we can check how many articles have been created by running the following query: [source, cypher] ---- MATCH (:Article) RETURN count(*); ---- .Results [opts="header"] |=== | count(*) | 159 |=== All good so far. And finally we're going to use APOC's https://neo4j.com/docs/labs/apoc/current/import/html/[Load HTML^] to scrape those pages and store the content in the `body` property of each node: [source,cypher] ---- CALL apoc.periodic.iterate( "MATCH (a:Article) WHERE not(exists(a.body)) RETURN a", "CALL apoc.load.html(a.link, {body: 'div.entry-content'}) YIELD value SET a.body = value.body[0].text", {batchSize: 10 }); ---- == Enabling APOC NLP procedures By default the NLP procedures aren't enabled once we've installed APOC. We'll need to add the NLP dependencies jar that is published https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/[with each release]. At the time of writing, the latest release is 4.0.0.10 and the dependencies jar can be downloaded from https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.0.0.10/apoc-nlp-dependencies-4.0.0.10.jar[apoc-nlp-dependencies-4.0.0.10.jar^]. Add that file to your `plugins` directory, restart the database, and then check that the procedures are available by running the following query: [source,cypher] ---- CALL apoc.help("nlp.aws"); ---- If everything's working as it should, we'll see the following output: .Results [opts="header"] |=== | type | name | text | signature | roles | writes | "procedure" | "apoc.nlp.aws.entities.graph" | "Creates a (virtual) entity graph for provided text" | "apoc.nlp.aws.entities.graph(source :: ANY?, config = {} :: MAP?) :: (graph :: MAP?)" | NULL | NULL | "procedure" | "apoc.nlp.aws.entities.stream" | "Returns a stream of entities for provided text" | "apoc.nlp.aws.entities.stream(source :: ANY?, config = {} :: MAP?) :: (node :: NODE?, value :: MAP?, error :: MAP?)" | NULL | NULL | "procedure" | "apoc.nlp.aws.keyPhrases.graph" | "Creates a (virtual) key phrases graph for provided text" | "apoc.nlp.aws.keyPhrases.graph(source :: ANY?, config = {} :: MAP?) :: (graph :: MAP?)" | NULL | NULL | "procedure" | "apoc.nlp.aws.keyPhrases.stream" | "Returns a stream of key phrases for provided text" | "apoc.nlp.aws.keyPhrases.stream(source :: ANY?, config = {} :: MAP?) :: (node :: NODE?, value :: MAP?, error :: MAP?)" | NULL | NULL | "procedure" | "apoc.nlp.aws.sentiment.graph" | "Creates a (virtual) sentiment graph for provided text" | "apoc.nlp.aws.sentiment.graph(source :: ANY?, config = {} :: MAP?) :: (graph :: MAP?)" | NULL | NULL | "procedure" | "apoc.nlp.aws.sentiment.stream" | "Returns stream of sentiment for items in provided text" | "apoc.nlp.aws.sentiment.stream(source :: ANY?, config = {} :: MAP?) :: (node :: NODE?, value :: MAP?, error :: MAP?)" | NULL | NULL |=== It's NLP time! == Entity Extraction using APOC NLP procedures To run the AWS procedures we'll need to have our AWS access key ID and secret access key available. We'll set them as parameters by running the following commands:s [source,cypher] ---- :param apiKey => ("<api-key-here>"); :param apiSecret => ("<api-secret-here>"); ---- Now let's extract the entities for one of our articles. By default AWS's NLP API has a https://docs.aws.amazon.com/comprehend/latest/dg/guidelines-and-limits.html#limits-all[maximum size of 5,000 bytes^] per document, so we'll need to find an article that's shorter than that in length. We can which articles are applicable using the `size` function on the `body` property of our articles: [source,cypher] ---- MATCH (n:Article) WHERE size(n.body) <= 5000 RETURN n.link, size(n.body) AS sizeInBytes, n.date ORDER BY n.date DESC LIMIT 5; ---- .Results [opts="header"] |=== | n.link | sizeInBytes | n.date | "https://neo4j.com/blog/this-week-in-neo4j-covid-19-contact-tracing-de-duplicating-the-bbc-goodfood-graph-stored-procedures-in-neo4j-4-0-sars-cov-2-taxonomy/" | 4326 | 2020-04-25T00:00:05Z | "https://neo4j.com/blog/this-week-in-neo4j-spring-data-neo4j%e2%9a%a1rx-released-graphs4good-graphhack-covid-19-special-multi-level-marketing-with-graphs/" | 4331 | 2020-04-18T00:00:28Z | "https://neo4j.com/blog/this-week-in-neo4j-graph-data-science-library-announced-neo4j-reactive-drivers-scm-analytics-sao-paulos-subway-system/" | 4711 | 2020-04-11T00:00:20Z | "https://neo4j.com/blog/this-week-in-neo4j-covid-19-contact-tracing-supply-chain-management-whats-new-in-neo4j-desktop/" | 4746 | 2020-04-04T00:00:26Z | "https://neo4j.com/blog/this-week-in-neo4j-neo4j-bi-connector-covid-19-supply-chain-management/" | 4929 | 2020-03-28T00:00:47Z |=== The blog post from a couple of weeks ago looks like a good candidate. We can return a stream of the entities in that article by running the following query: [source,cypher] ---- MATCH (n:Article) WHERE size(n.body) <= 5000 WITH n ORDER BY n.date DESC LIMIT 1 CALL apoc.nlp.aws.entities.stream(n, { key: $apiKey, secret: $apiSecret, nodeProperty: "body" }) YIELD value UNWIND value.entities AS entity RETURN DISTINCT entity.text, entity.type LIMIT 10; ---- If we run this query, we'll see the following output: .Results [opts="header"] |=== | entity.text | entity.type | "this week" | "DATE" | "Lju" | "ORGANIZATION" | "BBC" | "ORGANIZATION" | "Rik Van Bruggen" | "PERSON" | "COVID-19" | "OTHER" | "SARS-Cov-2" | "OTHER" | "Martin Preusse" | "PERSON" | "Max De Marzi" | "PERSON" | "Neo4j" | "TITLE" | "Mark" | "PERSON" |=== This query actually returns 63 entities, but we're only showing the top 10 for brevity. The full set of entities is better visualised using the graph variant of the procedure, shown below: [source,cypher] ---- MATCH (n:Article) WHERE size(n.body) <= 5000 WITH n ORDER BY n.date DESC LIMIT 1 CALL apoc.nlp.aws.entities.graph(n, { key: $apiKey, secret: $apiSecret, nodeProperty: "body", write: false }) YIELD graph AS g RETURN g; ---- We've set `write: false`, which means a virtual graph is being returned. If we want to persist the graph we can run the query again with `write: true`. Running this query will result in the following Neo4j Browser visualisation: image::{{<siteurl>}}/uploads/2020/05/entities-graph.svg[title="TWIN4j Entities Graph"] Some of the entities that have been extracted make sense, like the nodes for the people and projects mentioned. Others are less useful - the node representing the `@` symbol and `-19` value for example. Let's now compute and store the entities for all applicable articles, by running the following query: [source,cypher] ---- MATCH (n:Article) WHERE size(n.body) <= 5000 WITH collect(n) AS articles CALL apoc.nlp.aws.entities.graph(articles, { key: $apiKey, secret: $apiSecret, nodeProperty: "body", writeRelationshipType: "ENTITY", write: true }) YIELD graph AS g RETURN g; ---- This query creates relationships of type `ENTITY` from the article nodes to each of the entity nodes created. The entity nodes have an `Entity` label, as well as a label based on their type. == Querying the Entity Graph Let's explore the entity graph that we've just created. == What are the most common entities? [source, cypher] ---- MATCH (e:Entity)<-[:ENTITY]-() RETURN e.text, labels(e) AS labels, count(*) AS occurrences ORDER BY occurrences DESC LIMIT 10; ---- .Results [opts="header"] |=== | e.text | labels | occurrences | "Neo4j" | ["Entity", "Title"] | 96 | "this week" | ["Date", "Entity"] | 95 | "This week" | ["Date", "Entity"] | 93 | "This Week" | ["Date", "Entity"] | 87 | "Mark" | ["Entity", "Person"] | 78 | "neo4j" | ["Entity", "Person"] | 43 | "Cypher" | ["Entity", "Title"] | 38 | "GraphConnect" | ["Entity", "Organization"] | 37 | "next week" | ["Date", "Entity"] | 37 | "Graph" | ["Entity", "Title"] | 37 |=== Not particularly revealing! We have several variants of the phrase 'this week', and it looks like Neo4j is sometimes a `Title`, but sometimes a `Person`. == Which people are mentioned most often? [source, cypher] ---- MATCH (e:Entity:Person)<-[:ENTITY]-(article) RETURN e.text, count(*) AS occurrences, date(max(article.date)) AS lastMention ORDER BY occurrences DESC LIMIT 10; ---- .Results [opts="header"] |=== | e.text | occurrences | lastMention | "Mark" | 78 | 2020-04-25 | "neo4j" | 43 | 2020-01-18 | "Max De Marzi" | 29 | 2020-04-25 | "@" | 28 | 2020-04-25 | "Michael Hunger" | 28 | 2019-10-12 | "Rik" | 27 | 2020-04-25 | "Will Lyon" | 27 | 2019-11-09 | "Michael" | 27 | 2020-04-11 | "Jennifer Reif" | 23 | 2020-02-15 | "David Allen" | 23 | 2020-03-28 |=== Max De Marzi is a prolific blogger, so it's not surprising to see him right up there at the top. There are three members of the Neo4j DevRel team in the top 10: Michael Hunger, Will Lyon, and Jennifer Reif. I would imagine that _Michael_ is also Michael Hunger, so he's actually in there twice. == When did Jennifer and Max both appear in TWIN4j? I quite like reading articles written by Jennifer and Max. How many versions of TWIN4j feature both of them? [source,cypher] ---- WITH ["Max De Marzi", "Jennifer Reif"] AS people MATCH (a:Article) WHERE all(person IN people WHERE exists((:Entity {text: person})<-[:ENTITY]-(a))) RETURN a.link, a.title, date(a.date) ORDER BY a.date DESC; ---- .Results [opts="header"] |=== | a.link | a.title | date(a.date) | "https://neo4j.com/blog/this-week-in-neo4j-nodes-keynote-cypher-eager-operator-releases-of-neo4j-ogm-and-jqassistant/" | "This Week in Neo4j &#8211; NODES Keynote, Cypher Eager Operator, Releases of Neo4j OGM and jQAssistant" | 2019-10-12 | "https://neo4j.com/blog/this-week-in-neo4j-nodes-2019-preview-grandstack-building-a-data-warehouse-with-neo4j-scale-up-your-d3-graph-visualisation/" | "This Week in Neo4j &#8211; NODES 2019 Preview: GRANDstack, Building a Data Warehouse with Neo4j,<br /> Scale up your D3 graph visualisation" | 2019-09-14 | "https://neo4j.com/blog/this-week-in-neo4j-explore-public-contracting-data-with-neo4j-rdbms-to-graph-page-overhaul-filtering-connected-dynamic-forms-graph-based-real-time-inventory/" | "This Week in Neo4j &#8211; Explore public contracting data with Neo4j, RDBMS to Graph Page Overhaul, Filtering Connected Dynamic Forms, Graph-Based Real Time Inventory" | 2019-05-11 | "https://neo4j.com/blog/this-week-in-neo4j-time-based-graph-versioning-pearson-coefficient-neo4j-multi-dc/" | "This Week in Neo4j &#8211; Time Based Graph Versioning, Pearson Coefficient, Neo4j Multi DC, Modeling Provenance" | 2019-02-16 |=== Just the 4, and we have to go back to https://neo4j.com/blog/this-week-in-neo4j-nodes-keynote-cypher-eager-operator-releases-of-neo4j-ogm-and-jqassistant/[October 2019^] to find the last time they both featured in TWIN4j. Jennifer was exploring Cypher's eager operator and Max was building a chat bot. == Finding the most relevant entities per article If we want to get a quick summary of the most important things in each TWIN4j article, we can use a technique called https://en.wikipedia.org/wiki/Tf%E2%80%93idf[tf-idf^]. This is a technique that I first learnt about 5 years ago when https://markhneedham.com/blog/2015/02/15/pythonscikit-learn-calculating-tfidf-on-how-i-met-your-mother-transcripts/[exploring How I met your mother transcripts^]. Let's refresh ourselves on the definition of tf-idf: [quote,https://en.wikipedia.org/wiki/Tf%E2%80%93idf] ____ tf–idf, short for term frequency–inverse document frequency, is a numerical statistic that is intended to reflect how important a word is to a document in a collection or corpus. It is often used as a weighting factor in information retrieval and text mining. The tf-idf value increases proportionally to the number of times a word appears in the document, but is offset by the frequency of the word in the corpus, which helps to adjust for the fact that some words appear more frequently in general. ____ Adam Cowley recently wrote a blog post https://adamcowley.co.uk/neo4j/calculating-tf-idf-score-cypher/[explaining how to calculate tf-idf scores using Cypher^], and we can use his query to compute scores on our entity graph. We'll have to tweak Adam's query to replace `Document` with `Article` and `Term` with `Entity`. Everything else remains the same. We can compute the tf-idf scores for the entities in one article by writing the following query: [source, cypher] ---- // Total number of articles MATCH (:Article) WITH count(*) AS totalArticles // Find article and all its entities MATCH (a:Article {id: 119258})-[entityRel:ENTITY]-(e:Entity) // Get Statistics on Article and Entity WITH a, e, totalArticles, size((a)-[:ENTITY]->(e)) AS occurrencesInArticle, size((a)-[:ENTITY]->()) AS entitiesInArticle, size(()-[:ENTITY]->(e)) AS articlesWithEntity // Calculate TF and IDF WITH a, e, totalArticles, 1.0 * occurrencesInArticle / entitiesInArticle AS tf, log10( totalArticles / articlesWithEntity ) AS idf, occurrencesInArticle, entitiesInArticle, articlesWithEntity // Combine together to return a result RETURN a.id, e.text, tf * idf as tfIdf ORDER BY tfIdf DESC LIMIT 10; ---- .Results [opts="header"] |=== | a.id | e.text | tfIdf | 119258 | "Neo4j 3.x" | 0.037311815666448325 | 119258 | "Yorghos Voutos" | 0.037311815666448325 | 119258 | "4.x" | 0.037311815666448325 | 119258 | "Neo4j Graph Data Science Library" | 0.037311815666448325 | 119258 | "April 20, 2020" | 0.037311815666448325 | 119258 | "Lambert Hogenhout" | 0.037311815666448325 | 119258 | "#graphtour 2020" | 0.037311815666448325 | 119258 | "pygds" | 0.037311815666448325 | 119258 | "7.1.0.M1" | 0.037311815666448325 | 119258 | "Groovy 3" | 0.037311815666448325 |=== This article was likely the first time that the https://neo4j.com/docs/graph-data-science/current/[Neo4j Graph Data Science Library^] was mentioned, as well as the related https://pypi.org/project/pygds/[pygds^] library. Let's apply these scores to the whole entity graph. We'll add the tf-idf score to the `score` property of each `ENTITY` relationship. The following query does this: [source, cypher] ---- CALL apoc.periodic.iterate( "MATCH (:Article) WITH count(*) AS totalArticles MATCH (a:Article) RETURN a, totalArticles", "MATCH (a)-[entityRel:ENTITY]-(e:Entity) WITH a, e, entityRel, totalArticles, size((a)-[:ENTITY]->(e)) AS occurrencesInArticle, size((a)-[:ENTITY]->()) AS entitiesInArticle, size(()-[:ENTITY]->(e)) AS articlesWithEntity WITH a, e, entityRel, totalArticles, 1.0 * occurrencesInArticle / entitiesInArticle AS tf, log10( totalArticles / articlesWithEntity ) AS idf, occurrencesInArticle, entitiesInArticle, articlesWithEntity SET entityRel.score = tf * idf", {} ); ---- Once this query has finished, we can find the highest ranking entities for each article by writing the following query: [source,cypher] ---- MATCH (a:Article)-[rel:ENTITY]->(e) WITH a, e, rel ORDER BY a.date DESC, rel.score DESC RETURN date(a.date), collect(e.text)[..10] AS entities ORDER BY date(a.date) DESC LIMIT 10; ---- .Results [opts="header"] |=== | date(a.date) | entities | 2020-04-25 | ["pygds", "April 20, 2020", "Lambert Hogenhout", "#graphtour 2020", "Yorghos Voutos", "4.x", "Neo4j Graph Data Science Library", "Neo4j 3.x", "Groovy 3", "7.1.0.M1"] | 2020-04-18 | ["(@Astayonix", "Last night", "Bloom Inzamam ul Haque", "Connected Components", "Spring Data Neo4j⚡", "Epidemic Simulator", "RX", "This Year", "Spring Data Neo4j RX 1.0 GA", ") April 16"] | 2020-04-11 | ["OGA", "Lucas Moda", "Library", "one of the organizers", "World Factbook", "Greg Woods’", "Markus Günther", "Michael Simons’", "Graph Data Science", "Neo4j Tech"] | 2020-04-04 | ["Ubuntu 18.0.4 LTE", "f4bl", "pic.twitter.com/8fMYAmS6Js", "Neo4j Dev Tools", "JiliJeanlouis", "Epimitheus", "JUnit Jupiter Causal Cluster Testcontainer", "March 29, 2020", "1.2.6", "Germany"] | 2020-03-28 | ["Logan Smith", "each one", "Nerd’s Lab", "March 24, 2020", "PAF-Karachi Institute of Economics & Technology", "Lynn Chiu", "CDC", "late last year", "WirvsVirusHackathon", "TIBCO"] | 2020-02-15 | ["Flights", "De Marzi", "#GraphTour Madrid", "Golven Leroy", "Arrows Hacks", "February 13, 2020", "grapheverywhere", "Eva Delier", "SPARQL API", "Global Graph Celebration Day 2020"] | 2020-02-08 | ["SDN", "GGCD 2020", "Australian Open Finals", "third beta", "IFCA MSC BHD", "about 30 minutes", "Malaysia", "Sinisa Drpa", "emileifrem", "8th year"] | 2020-01-25 | ["Personal Genome Project", "to Dine: Building Possibility Spaces", "Ten", "Melbourne", "Halfdan Rump", "Paul Drangeid", "ReactJS", "Kelson Smith", "January 22, 2020", "Tom Cruise"] | 2020-01-18 | ["Pablo José", "Daniel Murillo", "@mckenzma", "Flask Login", "Karim Shehadeh", "Laboratorio Internacional Web", "Oscar Arcia", "Vue.js", "Donald Knuth", "Atakan Güney"] | 2020-01-11 | ["100 Male", "NLTK", "QuickGraph: Christmas Messages Graph", "Footballers", "TriGraph", "Daniel Wilms", "2.4 miles", "Ben Albritton", "January 9, 2020", "Louise Söderström…"] |=== Or we could write a version of the query that only includes certain entities: [source,cypher] ---- MATCH (a:Article)-[rel:ENTITY]->(e) WHERE e:Title or e:Organization WITH a, e, rel ORDER BY a.date DESC, rel.score DESC RETURN date(a.date), collect(e.text)[..10] AS entities ORDER BY date(a.date) DESC LIMIT 10; ---- .Results [opts="header"] |=== | date(a.date) | entities | 2020-04-25 | ["Covid Graph Knowledge Graph", "Neo4j 3.x", "7.1.0.M1", "Grails", "Groovy 3", "pygds", "Neo4j Graph Data Science Library", "United Nations", "Goals", "-19"] | 2020-04-18 | ["Spring Data Neo4j⚡RX", "Inzamam", "Graphs4Good GraphHack", "Spring Data Neo4j RX 1.0 GA", "Connected Components", "Spring Data Neo4j⚡", "Spring Data Neo4j + Neo4j-OGM", "CypherDSL", "Exposure Tracker", "Project Domino"] | 2020-04-11 | ["Library", "Graph Data Science", "World Factbook", "SDN RX", "JDK 14", "Query Neo4j", "JShell", "OGA", "Mentum Systems Australia", "Neo4j Tech"] | 2020-04-04 | ["Sysmon Visualization", "Epimitheus", "BloodHound 3.0", "Graphlytic for Fraud", "Graphlytic", "JUnit Jupiter Causal Cluster Testcontainer", "Ubuntu 18.0.4 LTE", "Neo4j Dev Tools", "1.2.6", "f4bl"] | 2020-03-28 | ["Neo4j BI Connector", "Graph to the Rescue", "BI Connector", "Tableau", "Looker", "Spotfire Server", "PAF-Karachi Institute of Economics & Technology", "Nerd’s Lab", "WirvsVirusHackathon", "Upcode Academy"] | 2020-02-15 | ["SPARQL API", "Arrows Hacks", "Flights", "Cypher Shell", "Wikidata SPARQL API", "Django Software Foundation", "grapheverywhere", "3.5", "Arrows", "Wikidata"] | 2020-02-08 | ["Streamlit", "Lisk", "Ansible", "SDN", "IFCA MSC BHD", "Spring Data Neo4j RX", "Neo4j Graph", "QuickGraph", "Neo4j 4.0", "Lju"] | 2020-01-25 | ["to Dine: Building Possibility Spaces", "Personal Genome Project", "vCenter", "GCP", "ReactJS", "WordPress", "QuickGraph", "Javascript", "AWS", "Google"] | 2020-01-18 | ["Vue.js", "Monific", "Mitzu", "Algorithm X", "Flask Login", "Kafka Taiwo", "Graphistania 2.0", "Under Armour", "Laboratorio Internacional Web", "CMDX"] | 2020-01-11 | ["Ninja", "Heathers and Label", "TriGraph", "100 Male", "QuickGraph: Christmas Messages Graph", "F#", "Guardian", "Islamic Scientific Manuscripts Initiative", "Neo4j Ninja", "Sudoku"] |=== == What’s interesting about this QuickGraph? In this QuickGraph we've learnt how to build a graph based on content that initially didn't have any structure. There's a lot more data around that doesn't have structure than that with structure, so techniques that help make sense of unstructured data are very useful. This is not a new technique, in fact there are many videos explaining the value of this approach: * https://www.youtube.com/watch?v=k8Gu6GMbBtQ[Knowledge Graph Search with Elasticsearch — L. Misquitta and A. Negro, GraphAware^] * https://www.youtube.com/watch?v=BVMx24dtko0[Natural Language Processing with Graphs^] * https://www.youtube.com/watch?v=ySxgzBdM2jM[Content-Based Recommendations using Knowledge Graphs (Neo4j Online Meetup #59)^] The procedures described in this post aim to make the technique more easily accessible to graph practitioners.

Learn how to use the APOC Library to add NLP functionality to your graph applications.

uploads/2020/05/apoc-nlp.png

quick-graph-building-entity-graph-twin4j-apoc-nlp

https://markhneedham.com/blog/2020/05/05/quick-graph-building-entity-graph-twin4j-apoc-nlp

2020-05-12 00:21:00

Google Docs: Find and replace script

I keep track of the podcasts that I've listened to in a Google Doc, having pasted the episode title and podcast name from Player.FM. The format isn't exactly what I want so I've been running the `Find and Replace` command to update each entry. This is obviously a very boring task, so I wanted to see if I could automate it. An example entry in the Google Doc reads like this: [source, text] ---- * Listened to Worst of the Big 3 by The Tennis Podcast https://player.fm/1BBKmKQ #nowplaying ---- And I want it to read like this: [source, text] ---- * Listened to Worst of the Big 3 by The Tennis Podcast - https://player.fm/1BBKmKQ ---- We can do this by doing by replacing: * `\nht` with `&nbsp;- ht&nbsp;` * `#nowplaying` with nothing We can create a Google script by clicking `Tools` > `Script editor`, which will take us to an editor with the following text: [source,javascript] ---- function myFunction() { } ---- We can write the following code to update our Google Doc: [source,javascript] ---- function myFunction() { // https://docs.google.com/document/d/<document-id>/edit let documentId = "<document-id>" let document = DocumentApp.openById(documentId); let body = document.getBody().getText() document.getBody().setText(body.replace(/#nowplaying/g, "").replace(/\nht/g, " - ht")) } ---- I tried using the `replaceText` function that can be run against the body of the document, but I couldn't figure out how to get that to work with the new line character. We can then run that manually to update our document, but we can go one better and setup a trigger. We can setup a trigger via the `Edit` menu: image::{{<siteurl>}}/uploads/2020/05/triggers.png[title="Triggers"] Once the next screen loads, we can then click on `Add Trigger` to set everything up: image::{{<siteurl>}}/uploads/2020/05/add-trigger.png[title="Add Trigger"] This trigger will run our script once an hour, removing new lines and the `#nowplaying` phrase. Boredom removed!

Learn how to write a script to run find and replace on a Google Doc

google-docs-find-and-replace-script

https://markhneedham.com/blog/2020/05/12/google-docs-find-and-replace-script

2020-02-03 00:21:00

Neo4j: Cross database querying with Neo4j Fabric

A couple of weeks ago I wrote https://markhneedham.com/blog/2020/01/23/quick-graph-australian-open/[a QuickGraph blog post about the Australian Open^], in which I showed how to use Neo4j 4.0's multi database feature. In that post we focused on queries that could be run on one database, but the 4.0 release also contains another feature for doing cross database querying - https://neo4j.com/docs/operations-manual/current/fabric/introduction/[Neo4j Fabric^] - and we're going to learn how to use that in this post. image::{{<siteurl>}}/uploads/2020/02/neo4j-fabric-aus-open.png[title="Querying across databases using Neo4j Fabric"] == What is Fabric? To quote from the source: [quote, Introduction to Neo4j Fabric, https://neo4j.com/docs/operations-manual/current/fabric/introduction/] ____ Fabric, introduced in Neo4j 4.0, is a way to store and retrieve data in multiple databases, whether they are on the same Neo4j DBMS or in multiple DBMSs, using a single Cypher query. ____ That sounds like what we have. It goes on to say: [quote] ____ In practical terms, Fabric provides the infrastructure and tooling for: * Data Federation: the ability to access data available in distributed sources in the form of disjointed graphs. * Data Sharding: the ability to access data available in distributed sources in the form of a common graph partitioned on multiple databases. ____ Data Federation sounds closer to what we have in our Australian Open Graph. The nodes representing the tournaments are the same, but the player, matches, and all other relationships are completely different. A fabric database can be setup on a Neo4j instance of its own, or alongside other databases. The only requirement is that it must be on a Neo4j instance where `dbms.mode=SINGLE`. == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .Dockerfile [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4J_fabric_database_name=fabric - NEO4J_fabric_graph_0_name=mens - NEO4J_fabric_graph_0_uri=neo4j://localhost:7687 - NEO4J_fabric_graph_0_database=mens - NEO4J_fabric_graph_1_name=womens - NEO4J_fabric_graph_1_uri=neo4j://localhost:7687 - NEO4J_fabric_graph_1_database=womens ---- The Fabric specific config begins with the line `NEO4J_fabric_database_name`, which gives a name for our fabric database. We'll use that later on. We also provide details of the graphs that we'd like to query via Fabric: * `NEO4J_fabric_graph_<n>_name` specifies the name that we'll use when writing our Fabric queries. * `NEO4J_fabric_graph_<n>_database` specifies the name of the Neo4j database against which we'd like to execute queries. In our case, both these values are the same. == Querying across multiple databases Let's write some queries! == Who didn't drop a set in the whole tournament? If we wanted to find out which players didn't drop a set in the whole tournament, we could write the following query: [source,cypher] ---- :use mens; MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped where size(setDropped) = 0 RETURN winner, t; ---- .Results [opts="header"] |=== | winner | t | (:Player {name: "Roger Federer", id: "103819"}) | (:Tournament {name: "Australian Open", year: 2007}) |=== And we could do the same for the women's tournament as well by switching database: [source,cypher] ---- :use womens; MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped where size(setDropped) = 0 RETURN winner, t; ---- .Results [opts="header"] |=== | winner | t | (:Player {name: "Lindsay Davenport", id: "200128"}) | (:Tournament {name: "Australian Open", year: 2000}) | (:Player {name: "Maria Sharapova", id: "201345"}) | (:Tournament {name: "Australian Open", year: 2008}) | (:Player {name: "Serena Williams", id: "200033"}) | (:Tournament {name: "Australian Open", year: 2017}) |=== Fabric allows us to combine the results of these queries. Let's switch to the Fabric database: [source,cypher] ---- :use fabric; ---- Once we've done this we could write the following query to return all winners of the Australian Open who didn't drop a set: [source,cypher] ---- USE fabric.mens MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped where size(setDropped) = 0 RETURN winner.name AS winner, t.year AS year UNION ALL USE fabric.womens MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped where size(setDropped) = 0 RETURN winner.name AS winner, t.year AS year; ---- .Results [opts="header"] |=== | winner | year | "Lindsay Davenport" | 2000 | "Maria Sharapova" | 2008 | "Serena Williams" | 2017 | "Roger Federer" | 2007 |=== I'm not sure why the year hasn't ordered properly here, perhaps I've made a mistake somewhere. It's also a bit annoying having to repeat the query twice though, so an alternative is to use Fabric's https://neo4j.com/docs/operations-manual/current/fabric/queries/#fabric-built-in-functions[`<fabric database name>.graphIds`^] function in combinatin with the https://neo4j.com/docs/cypher-manual/4.0/clauses/call-subquery/[CALL sub query^] syntax. That gives us the following: [source,cypher] ---- WITH ["Men's", "Women's"] AS tournaments UNWIND fabric.graphIds() AS graphId CALL { USE fabric.graph(graphId) MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped where size(setDropped) = 0 RETURN winner, t } RETURN tournaments[graphId] AS event, winner.name AS winner, t.year AS year ORDER BY t.year ---- .Results [opts="header"] |=== | event | winner | year | "Women's" | "Lindsay Davenport" | 2000 | "Men's" | "Roger Federer" | 2007 | "Women's" | "Maria Sharapova" | 2008 | "Women's" | "Serena Williams" | 2017 |=== Sweet! The data's sorted correctly and we only had to specify the main part of the query once. == How long did players wait from their first final defeat until their first win? Let's use Fabric to look at one more query. In the initial blog post we wrote a query to find out how long it took from a player's first final defeat until their first win. While writing a blog post about https://markhneedham.com/blog/2020/01/29/neo4j-finding-longest-path/[longest path queries^] I realised that the query was incorrect as it didn't filter out players who had won the final before losing it, and it also returned each final a player had lost before finally winning, rather than just the first one. The following query finds the longest wait for players from their first final defeat until their first win: [source,cypher] ---- WITH ["Men's", "Women's"] AS tournaments UNWIND fabric.graphIds() AS graphId CALL { USE fabric.graph(graphId) MATCH (player)-[:LOSER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t)-[:NEXT_TOURNAMENT*]->(t2), (player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t2) // Exclude paths where the player has been in the final of an earlier tournament WHERE not ((player)-[:LOSER|WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT] ->()-[:NEXT_TOURNAMENT*]->(t)) RETURN player, t, t2 } RETURN player.name, t.year, t2.year, t2.year - t.year AS difference ORDER BY difference DESC ---- And if we run that query, we'll see the following results: .Results [opts="header"] |=== | player.name | t.year | t2.year | difference | "Kim Clijsters" | 2004 | 2011 | 7 | "Marat Safin" | 2002 | 2005 | 3 | "Na Li" | 2011 | 2014 | 3 | "Maria Sharapova" | 2007 | 2008 | 1 |=== So Clijsters had the longest wait, although there are many other players who are still waiting! That's all for now, but if you want to learn more about Neo4j Fabric, we've written https://neo4j.com/developer/multi-tenancy-worked-example/#querying-across-databases[a developer guide showing how to use it against a retail dataset^]. And don't forget https://neo4j.com/docs/operations-manual/current/fabric/[the docs^]!

Learn how to write cross database queries against an Australian Open Graph using Neo4j Fabric.

uploads/2020/02/neo4j-fabric-aus-open.png

neo4j-cross-database-querying-fabric

https://markhneedham.com/blog/2020/02/03/neo4j-cross-database-querying-fabric

2020-02-04 00:21:00

Neo4j: Enriching an existing graph by querying the Wikidata SPARQL API

This is the third post in a series about querying Wikidata's SPARQL API. In the first post we wrote some https://markhneedham.com/blog/2020/01/29/newbie-guide-querying-wikidata/[basic queries^], in the second we learnt about the https://markhneedham.com/blog/2020/02/02/querying-wikidata-construct-select/[SELECT and CONSTRUCT clauses^], and in this post we're going to import query results into an existing Neo4j graph. image::{{<siteurl>}}/uploads/2020/02/wiki-enrich-banner.png[title="Enriching a Neo4j Graph with Wikidata"] == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .Dockerfile [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4JLABS_PLUGINS=["apoc"] ---- Once we've created that file we need to open a terminal session where that file lives and then run `docker-compose up` to launch Neo4j. Let's connect to our Neo4j instance using the https://neo4j.com/docs/operations-manual/current/tools/cypher-shell/[Cypher Shell^] tool: [source,bash] ---- $ docker exec -it quickgraph-aus-open cypher-shell -u neo4j -p neo -d system Connected to Neo4j 4.0.0 at neo4j://localhost:7687 as user neo4j. Type :help for a list of available commands or :exit to exit the shell. Note that Cypher queries must end with a semicolon. neo4j@system> ---- And now let's create a database to use for this blog post: [source,cypher] ---- CREATE DATABASE enrichwikidata; :use enrichwikidata; ---- We're going to create nodes representing some popular tennis players: [source,cypher] ---- UNWIND ["Nick Kyrgios", "Lleyton Hewitt", "Stan Wawrinka", "Roger Federer"] AS name MERGE (:Player {name: name}); ---- .Results |=== | 0 rows available after 31 ms, consumed after another 0 ms Added 4 nodes, Set 4 properties, Added 4 labels |=== == Querying Wikidata Now we're reading to query Wikidata. We're going to execute the following query, which returns the data of birth and nationality of Nick Kyrgios, against Wikidata's SPARQL API: [source,sparql] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") } ---- where we'll substitute the third line of the query with the names of different tennis players. As a refresher, if we https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20.%0A%20%20%20%20%20%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%7D[run this query^], we'll get the following output: .Results [opts="header"] |=== | person | dateOfBirth | countryName | http://www.wikidata.org/entity/Q3720084 |1995-04-27T00:00:00Z | Australia |=== At the moment these results are in a tabular/CSV structure, but we can have the API return a JSON structure by providing the header `Accept: 'application/sparql-results+json'`. The following Cypher query uses the `apoc.load.jsonParams` procedure to execute a SPARQL query against Wikidata's SPARQL API: [source,cypher] ---- MATCH (player:Player) WHERE player.name = "Nick Kyrgios" WITH "SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label \"" + player.name + "\"@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = \"en\") }" AS sparql CALL apoc.load.jsonParams( "https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(sparql), { Accept: "application/sparql-results+json"}, null ) YIELD value RETURN value ---- If we run that query, we'll see the following output: .Results [opts="header"] |=== | value a| [source,cypher] ---- { head: { vars: ["person", "dateOfBirth", "countryName"] }, results: { bindings: [{ dateOfBirth: { type: "literal", datatype: "http://www.w3.org/2001/XMLSchema#dateTime", value: "1995-04-27T00:00:00Z" }, countryName: { `xml:lang`: "en", type: "literal", value: "Australia" }, person: { type: "uri", value: "http://www.wikidata.org/entity/Q3720084" } }] } } ---- |=== This looks like it should be reasonably easy to parse, so let's now do something with this data instead of just returning it! == Importing Wikidata into an existing graph We're going to add the date of birth to the `dateOfBirth` property of each `Player` node, create a `Country` node based on the nationality value, and then create a `NATIONALITY` relationship from the `Player` to the `Country`. We'll also add the `wikidataImportDone` property to each `Player` node so that we know when a node has already been processed. The following query does what we want: [source,cypher] ---- MATCH (player:Player) WHERE player.name = "Nick Kyrgios" WITH "SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label \"" + player.name + "\"@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = \"en\") }" AS sparql, player CALL apoc.load.jsonParams( "https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(sparql), { Accept: "application/sparql-results+json"}, null ) YIELD value // We use apoc.do.when here because the API might return no results for // our player and we need to handle that case CALL apoc.do.when( size(value.results.bindings) > 0, 'WITH value.results.bindings[0] AS result, player // Add date of birth and wikiDataImportDone properties SET player.dateOfBirth = date(datetime(result.dateOfBirth.value)), player.wikidataImportDone = true // Create country node MERGE (c:Country {name: result.countryName.value }) // Create relationship between player and country MERGE (player)-[:NATIONALITY]->(c) RETURN player', 'SET player.wikidataImportDone = true RETURN player', {value: value, player: player}) YIELD value AS result return player; ---- .Results [opts="header"] |=== | player | (:Player {name: "Nick Kyrgios", wikidataImportDone: TRUE, dateOfBirth: 1995-04-27, id: "106401"}) |=== The Neo4j visualisation below shows what our graph looks like after this query has run: image::{{<siteurl>}}/uploads/2020/02/kyrgios-imported.png[title="Nick Kyrgios enriched graph"] Let's enrich the rest of our graph from Wikidata, which we can do by running the following query: [source,cypher] ---- // Find all unprocessed players MATCH (player:Player) WHERE not(exists(player.wikidataImportDone)) WITH "SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label \"" + player.name + "\"@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = \"en\") }" AS sparql, player CALL apoc.load.jsonParams( "https://query.wikidata.org/sparql?query=" + apoc.text.urlencode(sparql), { Accept: "application/sparql-results+json"}, null ) YIELD value CALL apoc.do.when( size(value.results.bindings) > 0, 'WITH value.results.bindings[0] AS result, player SET player.dateOfBirth = date(datetime(result.dateOfBirth.value)), player.wikidataImportDone = true MERGE (c:Country {name: result.countryName.value }) MERGE (player)-[:NATIONALITY]->(c) RETURN player', 'SET player.wikidataImportDone = true RETURN player', {value: value, player: player}) YIELD value AS result return player; ---- .Results [opts="header"] |=== | player | (:Player {name: "Lleyton Hewitt", wikidataImportDone: TRUE, dateOfBirth: 1981-02-24}) | (:Player {name: "Stan Wawrinka", wikidataImportDone: TRUE, dateOfBirth: 1985-03-28}) | (:Player {name: "Roger Federer", wikidataImportDone: TRUE, dateOfBirth: 1981-08-08}) |=== And the Neo4j visualisation below shows what our graph looks like after this query has run: image::{{<siteurl>}}/uploads/2020/02/wikidata-enriched-graph.png[title="Wikidata enriched graph"] == Enriching the Australian Open Graph Now we're going to apply this same approach to enrich the Australian Open Graph. Let's switch to the database for the men's tournaments: [source,cypher] ---- :use mens ---- And now we'll tweak the query that iterates over all players, calls the Wikipedia API, and uses the results to update the graph. We're going to use the `apoc.periodic.iterate` procedure so that we can process the players in batches of 20 rather than committing all the meta data in one transaction: [source,cypher] ---- CALL apoc.periodic.iterate( "MATCH (player:Player) WHERE not(exists(player.wikidataImportDone)) RETURN player", " WITH 'SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label \"' + player.name + '\"@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = \"en\") }' AS sparql, player CALL apoc.load.jsonParams( \"https://query.wikidata.org/sparql?query=\" + apoc.text.urlencode(sparql), { Accept: \"application/sparql-results+json\"}, null ) YIELD value CALL apoc.do.when( size(value.results.bindings) > 0, 'WITH value.results.bindings[0] AS result, player SET player.dateOfBirth = date(datetime(result.dateOfBirth.value)), player.wikidataImportDone = true MERGE (c:Country {name: result.countryName.value }) MERGE (player)-[:NATIONALITY]->(c) RETURN player', 'SET player.wikidataImportDone = true RETURN player', {value: value, player: player}) YIELD value AS result RETURN count(*)", {batchSize: 20}); ---- After running a few exploratory queries, I realised that about 1/5 of the players weren't found in Wikidata. Some of those players aren't famous enough to have an entry in Wikidata, but some of them have a different spelling of their name in the two datasets. I updated the names of the finalists by running the following query: [source,cypher] ---- UNWIND [ {wrong: "Arnaud Clement", right: "Arnaud Clément"}, {wrong: "Rainer Schuettler", right: "Rainer Schüttler"}, {wrong: "Fernando Gonzalez", right: "Fernando González"}, {wrong: "Marin Cilic", right: "Marin Čilić"} ] AS name MATCH (p:Player {name: name.wrong}) SET p.name = name.right REMOVE p.wikidataImportDone ---- And then I re-ran the previous query to import Wikidata. == Querying the enriched graph And now that the graph's been updated, let's write some queries that uses this new data. == How many participants did each country have in the Australian Open? Let's start simple by running the following query which returns the number of players grouped by country: [source,cypher] ---- MATCH (country:Country)<-[:NATIONALITY]-(player) RETURN country.name, count(*) AS players ORDER BY players DESC LIMIT 10; ---- .Results [opts="header"] |=== | country.name | players | "Australia" | 49 | "United States of America" | 46 | "France" | 36 | "Germany" | 31 | "Italy" | 26 | "Argentina" | 22 | "Russia" | 20 | "Spain" | 17 | "United States" | 16 | "United Kingdom" | 12 |=== Unsurprisingly Australia have the most participants, although the United States aren't far behind. == How many finalists did each country have? Next, we're going to find out how many times a country had a player in the final: [source,cypher] ---- MATCH (country:Country)<-[:NATIONALITY]-(player)-->(match:Match {round: "F"}) WITH country, count(*) AS finals, collect(distinct player.name) AS players WHERE finals > 1 RETURN country.name, finals, players ORDER BY finals DESC; ---- .Results [opts="header"] |=== | country.name | finals | players | "Switzerland" | 8 | ["Stan Wawrinka", "Roger Federer"] | "Serbia" | 8 | ["Novak Djokovic"] | "Spain" | 5 | ["Rafael Nadal"] | "United Kingdom" | 5 | ["Andy Murray"] | "Russia" | 4 | ["Marat Safin", "Yevgeny Kafelnikov"] | "United States of America" | 3 | ["Andre Agassi"] | "France" | 2 | ["Arnaud Clément", "Jo-Wilfried Tsonga"] |=== Australia now don't even appear on the list. Their only finalist since 2000 was Lleyton Hewitt in the 2005 final, which he lost to Marat Safin. And it's painful to see Andy Murray in there with 5 finals for the United Kingdom, but unfortunately losing all of them. == What was the lowest average age of the finalists? Let's finish with a query that uses the date of birth property. The following query returns the top 10 finalists ordered by lowest average age: [source,cypher] ---- MATCH (match:Match {round: "F"})-[:IN_TOURNAMENT]-(tournament:Tournament), (winner)-[:WINNER]->(match), (loser)-[:LOSER]->(match), (winner)-[:NATIONALITY]-(winnerCountry), (loser)-[:NATIONALITY]-(loserCountry) WITH tournament, winner, loser, match, winnerCountry, loserCountry, duration.between(winner.dateOfBirth, date({year: tournament.year})) AS winnerAge, duration.between(loser.dateOfBirth, date({year: tournament.year})) AS loserAge RETURN tournament.year, winner.name, loser.name, match.score, winnerCountry.name, loserCountry.name, winnerAge.years + "y" + winnerAge.monthsOfYear + "m" AS winnerAgeFormatted, loserAge.years + "y" + loserAge.monthsOfYear + "m" AS loserAgeFormatted ORDER BY winnerAge + loserAge / 2 LIMIT 5; ---- .Results [opts="header"] |=== | tournament.year | winner.name | loser.name | match.score | winnerCountry.name | loserCountry.name | winnerAgeFormatted | loserAgeFormatted | 2008 | "Novak Djokovic" | "Jo-Wilfried Tsonga" | "4-6 6-4 6-3 7-6(2)" | "Serbia" | "France" | "20y7m" | "22y8m" | 2004 | "Roger Federer" | "Marat Safin" | "7-6(3) 6-4 6-2" | "Switzerland" | "Russia" | "22y4m" | "23y11m" | 2006 | "Roger Federer" | "Marcos Baghdatis" | "5-7 7-5 6-0 6-2" | "Switzerland" | "Republic of Cyprus" | "24y4m" | "20y6m" | 2011 | "Novak Djokovic" | "Andy Murray" | "6-4 6-2 6-3" | "Serbia" | "United Kingdom" | "23y7m" | "23y7m" | 2009 | "Rafael Nadal" | "Roger Federer" | "7-5 3-6 7-6(3) 3-6 6-2" | "Spain" | "Switzerland" | "22y6m" | "27y4m" |=== 4 of the top 5 youngest finals of the 21st century happened in the first decade. Since then the ages have been increasing as the tournament has been dominated by Djokovic and to a lesser extent Federer, both of whom are more than 30 years old now.

Learn how to enrich an existing Neo4j database with data from the Wikidata API

uploads/2020/02/wiki-enrich-banner.png

neo4j-enriching-existing-graph-wikidata-sparql-api

https://markhneedham.com/blog/2020/02/04/neo4j-enriching-existing-graph-wikidata-sparql-api

2020-02-02 00:21:00

Querying Wikidata: SELECT vs CONSTRUCT

In this blog post we're going to build upon the https://markhneedham.com/blog/2020/01/29/newbie-guide-querying-wikidata/[newbie's guide to querying Wikidata^], and learn all about the CONSTRUCT clause. image::{{<siteurl>}}/uploads/2020/02/wikidata-construct-select.png[title="SPARQL's CONSTRUCT and SELECT clauses"] In the newbie's guide, we wrote the following query to find a tennis player with the name "Nick Kyrgios" and return their date of birth: [source,sparql] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth } ---- where: * `wdt:P106` is occupation * `wd:Q10833314` is tennis player * `wdt:P569` is date of birth If we https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%0A%7D[run that query^], we'll see the following output: .Results [opts="header"] |=== | person | dateOfBirth | http://www.wikidata.org/entity/Q3720084 | 1995-04-27T00:00:00Z |=== But what if we want to return the results as a list of triples instead? == CONSTRUCT WHERE We can use the https://www.w3.org/TR/sparql11-query/#constructWhere[`CONSTRUCT WHERE`^] clause instead of `SELECT`. [quote] ____ A short form for the CONSTRUCT query form is provided for the case where the template and the pattern are the same and the pattern is just a basic graph pattern (no FILTERs and no complex graph patterns are allowed in the short form). The keyword WHERE is required in the short form. ____ I found https://www.futurelearn.com/courses/linked-data/0/steps/16104[a good article explaining the CONSTRUCT clause^] as part of FutureLearn's Introduction to Linked Data and the Semantic Web course. Our updated query looks like this: [source,sparql] ---- CONSTRUCT WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth } ---- And if we run that we'll get the following output: .Results [opts="header"] |=== | subject | predicate | object | http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P106 | http://www.wikidata.org/entity/Q10833314 | http://www.wikidata.org/entity/Q3720084 | http://www.w3.org/2000/01/rdf-schema#label | Nick Kyrgios | http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P569 | 1995-04-27T00:00:00Z |=== where: * _Q3720084_ is Nick Kyrgios * _P106_ is occupation * _Q10833314_ is tennis player * _P569_ is date of birth So if we translate the three triples returned, what we have is: .Translated results |=== | Nick Kyrgios | occupation | tennis player | Nick Kyrgios | label | Nick Kyrgios | Nick Kyrgios | date of birth | 1995-04-27T00:00:00Z |=== So far, so good. Let's extend our `SELECT` query to also return the person's nationality: [source, spaqrl] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") } ---- .Results [opts="header"] |=== | person | dateOfBirth | countryName | http://www.wikidata.org/entity/Q3720084 |1995-04-27T00:00:00Z | Australia |=== Now we want to do the same thing with our `CONSTRUCT` query: [source, spaqrl] ---- CONSTRUCT WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") } ---- If we run that query, we'll get the following error: [source,text] ---- SPARQL-QUERY: queryStr=CONSTRUCT WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") } java.util.concurrent.ExecutionException: org.openrdf.query.MalformedQueryException: CONSTRUCT WHERE only permits statement patterns in the WHERE clause. ---- As the error message indicates, we can only use statement patterns in the WHERE clause. The `filter` part of the WHERE clause is problematic, so let's remove that: [source, spaqrl] ---- CONSTRUCT WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] } ---- If we https://query.wikidata.org/#CONSTRUCT%0AWHERE%20%7B%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%0A%7D[run that query^], we'll get the following output: .Results [opts="header"] |=== | subject | predicate | object | http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P106 | http://www.wikidata.org/entity/Q10833314 | http://www.wikidata.org/entity/Q3720084 |http://www.w3.org/2000/01/rdf-schema#label | Nick Kyrgios | http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P569 | 1995-04-27T00:00:00Z | b0 | http://www.w3.org/2000/01/rdf-schema#label | Australia |http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P27 | b0 |b1 | http://www.w3.org/2000/01/rdf-schema#label | Awıstralya |http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P27 | b1 3+| ... | b5 |http://www.w3.org/2000/01/rdf-schema#label | ཨས་ཊེཡེ་ལི་ཡ | http://www.wikidata.org/entity/Q3720084 | http://www.wikidata.org/prop/direct/P27 | b5 |=== Hmm, the output isn't exactly what we wanted. We have two issues to try and figure out: * what are those values that prefixed with `b` all about? * we've got every single version of "Australia" instead of just the English version We can fix the first problem by pulling out the country and country name separately instead of doing it all in one statement. This means that: [source,sparql] ---- ?player wdt:P27 [ rdfs:label ?countryName ] ---- becomes: [source,sparql] ---- ?player wdt:P27 ?country . ?country rdfs:label ?countryName ---- If we do that, we'll have the following query: [source,sparql] ---- CONSTRUCT WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 ?country . ?country rdfs:label ?countryName } ---- And now let's https://query.wikidata.org/#CONSTRUCT%0AWHERE%20%7B%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20%20.%0A%20%20%20%20%20%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%0A%7D[run that query^]: .Results [opts="header"] |=== | subject | predicate | object |http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P106|http://www.wikidata.org/entity/Q10833314 |http://www.wikidata.org/entity/Q3720084|http://www.w3.org/2000/01/rdf-schema#label|Nick Kyrgios |http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P569|1995-04-27T00:00:00Z |http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P27|http://www.wikidata.org/entity/Q408 |http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label|Australia |http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label|Australië 3+| ... | http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label,Австралия, | http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label,Austràlia, |=== That's better, but we still have all versions of Australia instead of just the English version. == Plain old CONSTRUCT As far as I understand, to fix that we'll need to use the normal CONSTRUCT syntax, which requires us to specify all the triples that we'd like to return. Let's update our query to do that: [source,sparql] ---- CONSTRUCT { ?person wdt:P569 ?dateOfBirth; rdfs:label ?playerName; wdt:P27 ?country . ?country rdfs:label ?countryName } WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 ?country . ?country rdfs:label ?countryName . filter(lang(?countryName) = "en") } ---- And if we https://query.wikidata.org/#CONSTRUCT%20%7B%20%0A%20%20%3Fperson%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20.%0A%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%0A%7D%0AWHERE%20%7B%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20%20.%0A%20%20%20%20%20%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%20.%0A%20%20%20%20%20%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%7D%0A[run that query^], we'll see the following output: .Results [opts="header"] |=== | subject | predicate | object | http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P569 |1995-04-27T00:00:00Z | http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P27 |http://www.wikidata.org/entity/Q408 | http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label | Australia |=== That's better, but we're missing the statement that returns the player's name. We do have that statement in the CONSTRUCT clause, but we also need to have it in the WHERE clause. If we do that we'll also need to add a language filter so that we only return the English version of the name. Our query now looks like this: [source,sparql] ---- CONSTRUCT { ?person wdt:P569 ?dateOfBirth; rdfs:label ?playerName; wdt:P27 ?country . ?country rdfs:label ?countryName } WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; rdfs:label ?playerName; wdt:P569 ?dateOfBirth ; wdt:P27 ?country . ?country rdfs:label ?countryName . filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- Now let's https://query.wikidata.org/#CONSTRUCT%20%7B%20%0A%20%20%3Fperson%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20.%0A%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%0A%7D%0AWHERE%20%7B%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20%20.%0A%20%20%20%20%20%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%20.%0A%20%20%20%20%20%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20%20%20%20%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%7D%0A[run that query^]: .Results [opts="header"] |=== | subject | predicate | object | http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P569 | 1995-04-27T00:00:00Z | http://www.wikidata.org/entity/Q3720084|http://www.w3.org/2000/01/rdf-schema#label |Nick Kyrgios | http://www.wikidata.org/entity/Q3720084|http://www.wikidata.org/prop/direct/P27 |http://www.wikidata.org/entity/Q408 | http://www.wikidata.org/entity/Q408|http://www.w3.org/2000/01/rdf-schema#label |Australia |=== Much better. == Returning a custom RDF graph One https://jbarrasa.com/2019/12/05/quickgraph10-enrich-your-neo4j-knowledge-graph-by-querying-wikidata/[other neat thing^] about the `CONSTRUCT` clause is that we can change the RDF graph that our query returns. The following query uses vocabulary from schema.org in place of Wikidata predicates: [source,sparql] ---- PREFIX sch: <http://schema.org/> CONSTRUCT { ?person sch:birthDate ?dateOfBirth; sch:name ?playerName; sch:nationality ?country . ?country sch:name ?countryName } WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; rdfs:label ?playerName; wdt:P569 ?dateOfBirth ; wdt:P27 ?country . ?country rdfs:label ?countryName . filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- If we https://query.wikidata.org/#PREFIX%20sch%3A%20%3Chttp%3A%2F%2Fschema.org%2F%3E%20%0A%0ACONSTRUCT%20%7B%0A%20%20%3Fperson%20sch%3AbirthDate%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20sch%3Aname%20%3FplayerName%3B%0A%20%20%20%20%20%20%20%20%20%20sch%3Anationality%20%3Fcountry%20.%0A%20%20%3Fcountry%20sch%3Aname%20%3FcountryName%0A%7D%0AWHERE%20%7B%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%27Nick%20Kyrgios%27%40en%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%3Fcountry%20%20.%0A%20%20%3Fcountry%20rdfs%3Alabel%20%3FcountryName%20.%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%7D[run this query^], we get the following, much friendlier looking, output: .Results [opts="header"] |=== | subject | predicate | object |http://www.wikidata.org/entity/Q3720084|http://schema.org/birthDate | 1995-04-27T00:00:00Z |http://www.wikidata.org/entity/Q3720084|http://schema.org/name | Nick Kyrgios |http://www.wikidata.org/entity/Q3720084|http://schema.org/nationality | http://www.wikidata.org/entity/Q408 |http://www.wikidata.org/entity/Q408| http://schema.org/name | Australia |=== And that's all for now. If there's a better way to do anything that I described, do let me know in the comments, I'm still a SPARQL newbie.

Learn about the difference between SPARQL's SELECT and CONSTRUCT clauses when querying Wikidata.

uploads/2020/02/wikidata-construct-select.png

querying-wikidata-construct-select

https://markhneedham.com/blog/2020/02/02/querying-wikidata-construct-select

2020-02-07 00:21:00

SPARQL: OR conditions in a WHERE clause using the UNION clause

This is part 4 of my series of posts about querying the Wikidata API, in which I learn how to use SPARQL's `UNION` clause to handle an OR condition in a `WHERE` clause. image::{{<siteurl>}}/uploads/2020/02/sparql-or-conditions.png[title="Using SPARQL's UNION clause"] But first, some context! After https://markhneedham.com/blog/2020/02/04/neo4j-enriching-existing-graph-wikidata-sparql-api/[running queries against the Wikidata SPARQL API to pull the date of birth and nationality of tennis players into the Australian Open Graph^], I noticed that several players hadn't actually been updated. I ran some exploratory queries to work out why, and realised that the problem was that some players had anglicised names in my dataset, whereas Wikidata uses their real name. For example in my dataset we have 'Nicolas Escude', whereas in Wikidata we have 'Nicolas Escudé'. I wanted to figure out if there was a way to find players by an alternate name, or another name that they were known by, and found https://stackoverflow.com/questions/46850562/how-to-query-wikidata-for-also-known-as[a StackOverflow answer^] that suggested using the `skos.altLabel` predicate. If we wanted to return the date of birth and nationality for the alternate name 'Nicolas Escude', we can write the following query: .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%20%20%20%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20skos%3AaltLabel%20%22Nicolas%20Escude%22%40en%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20.%0A%20%20%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%20%20%20%20%20%20%20%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%20%20%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; skos:altLabel "Nicolas Escude"@en; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- If we run this query, we'll see the following output: .Results [opts="header"] |=== | person|playerName|dateOfBirth|countryName | http://www.wikidata.org/entity/Q470879|Nicolas Escudé|1976-04-03T00:00:00Z|France |=== So far so good. But not every player has an alternate name and we don't know whether the name that we have is an alternate name or actual name. For example, let's try and find the data of birth and nationality for the alternate name 'Roger Federer': .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%20%20%20%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20skos%3AaltLabel%20%22Roger%20Federer%22%40en%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20.%0A%20%20%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%20%20%20%20%20%20%20%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%20%20%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; skos:altLabel "Roger Federer"@en; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- If we run that query, we'll see the following output: .Results [opts="header"] |=== | person|playerName|dateOfBirth|countryName 4+| No matching records found |=== Not so good. So we actually want to be able to match triples if either `rdfs:label` or `skos:altLabel` equal the name of the player. I thought there might be a way to write an `OR` clause within the `WHERE` block, but as I understand it, the way to achieve this in SPARQL is via a `UNION` statement. I found https://www.w3.org/2009/Talks/0615-qbe/[Query #8 in SPARQL By Example^] helpful for understanding how to write such a query. Let's write a query that does this: .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%0A%20%20%7B%20%3Fperson%20rdfs%3Alabel%20%22Nicolas%20Escude%22%40en%20%7D%0A%20%20UNION%0A%20%20%7B%3Fperson%20skos%3AaltLabel%20%22Nicolas%20Escude%22%40en%7D%0A%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20%3B%0A%20%20%20%20%20%20%20%20%20%20skos%3AaltLabel%20%3FalternateName%0A%20%20%20%20%20%20%20%20%20%20%0A%20%20filter%28lang%28%3FalternateName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { { ?person rdfs:label "Nicolas Escude"@en } UNION {?person skos:altLabel "Nicolas Escude"@en} ?person wdt:P106 wd:Q10833314 ; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] ; skos:altLabel ?alternateName filter(lang(?alternateName) = "en") filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- And now let's try it out for 'Nicolas Escude': .Results [opts="header"] |=== |person|playerName|dateOfBirth|countryName|alternateName |http://www.wikidata.org/entity/Q470879|Nicolas Escudé|1976-04-03T00:00:00Z|France|Nicolas Escude |=== Cool, that works. And what about for 'Roger Federer'? .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%0A%20%20%7B%20%3Fperson%20rdfs%3Alabel%20%22Roger%20Federer%22%40en%20%7D%0A%20%20UNION%0A%20%20%7B%3Fperson%20skos%3AaltLabel%20%22Roger%20Federer%22%40en%7D%0A%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20%3B%0A%20%20%20%20%20%20%20%20%20%20skos%3AaltLabel%20%3FalternateName%0A%0A%20%20filter%28lang%28%3FalternateName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { { ?person rdfs:label "Roger Federer"@en } UNION {?person skos:altLabel "Roger Federer"@en} ?person wdt:P106 wd:Q10833314 ; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] ; skos:altLabel ?alternateName filter(lang(?alternateName) = "en") filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- .Results [opts="header"] |=== |person|playerName|dateOfBirth|countryName|alternateName 5+|No matching records found |=== D'oh, still no good. The problem this time is that we have the statement `?player skos:altLabel ?alternateLabel` in our `WHERE` clause, which means we'll only get back results where the player has an alternate name. So if we ran this query for 'Rafael Nadal', it would actually work because he has several alternate names: .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%0A%20%20%7B%20%3Fperson%20rdfs%3Alabel%20%22Rafael%20Nadal%22%40en%20%7D%0A%20%20UNION%0A%20%20%7B%3Fperson%20skos%3AaltLabel%20%22Rafael%20Nadal%22%40en%7D%0A%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20%3B%0A%20%20%20%20%20%20%20%20%20%20skos%3AaltLabel%20%3FalternateName%0A%20%20%20%20%20%20%20%20%20%20%0A%20%20filter%28lang%28%3FalternateName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { { ?person rdfs:label "Rafael Nadal"@en } UNION {?person skos:altLabel "Rafael Nadal"@en} ?person wdt:P106 wd:Q10833314 ; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] ; skos:altLabel ?alternateName filter(lang(?alternateName) = "en") filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- .Results [opts="header"] |=== |person|playerName|dateOfBirth|countryName|alternateName |http://www.wikidata.org/entity/Q10132|Rafael Nadal|1986-06-03T00:00:00Z|Spain|Rafa |http://www.wikidata.org/entity/Q10132|Rafael Nadal|1986-06-03T00:00:00Z|Spain|Rafa Nadal |http://www.wikidata.org/entity/Q10132|Rafael Nadal|1986-06-03T00:00:00Z|Spain|Rafael Nadal Parera |=== But let's go back to Federer. We're going to update the query to make the alternate name predicate optional, as shown below: .https://query.wikidata.org/#SELECT%20%2a%0AWHERE%20%7B%0A%20%20%7B%20%3Fperson%20rdfs%3Alabel%20%22Roger%20Federer%22%40en%20%7D%0A%20%20UNION%0A%20%20%7B%3Fperson%20skos%3AaltLabel%20%22Roger%20Federer%22%40en%7D%0A%0A%20%20%3Fperson%20wdt%3AP106%20wd%3AQ10833314%20%3B%0A%20%20%20%20%20%20%20%20%20%20rdfs%3Alabel%20%3FplayerName%20%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP569%20%3FdateOfBirth%3B%0A%20%20%20%20%20%20%20%20%20%20wdt%3AP27%20%5B%20rdfs%3Alabel%20%3FcountryName%20%5D%20.%0A%0A%20%20OPTIONAL%20%7B%0A%20%20%20%20%3Fperson%20skos%3AaltLabel%20%3FalternateName%0A%20%20%20%20%20%20%20%20%20%20%20%20filter%28lang%28%3FalternateName%29%20%3D%20%22en%22%29%0A%20%20%7D%0A%0A%20%20filter%28lang%28%3FcountryName%29%20%3D%20%22en%22%29%0A%20%20filter%28lang%28%3FplayerName%29%20%3D%20%22en%22%29%0A%0A%7D[Run this query on Wikidata^] [source,sparql] ---- SELECT * WHERE { { ?person rdfs:label "Roger Federer"@en } UNION {?person skos:altLabel "Roger Federer"@en} ?person wdt:P106 wd:Q10833314 ; rdfs:label ?playerName ; wdt:P569 ?dateOfBirth; wdt:P27 [ rdfs:label ?countryName ] . OPTIONAL { ?person skos:altLabel ?alternateName filter(lang(?alternateName) = "en") } filter(lang(?countryName) = "en") filter(lang(?playerName) = "en") } ---- .Results [opts="header"] |=== |person|playerName|dateOfBirth|countryName|alternateName |http://www.wikidata.org/entity/Q1426|Roger Federer|1981-08-08T00:00:00Z|Switzerland| |=== Sweet! And if we run this query for 'Nicolas Escude' or 'Rafael Nadal' we get the same results as before - good times!

Learn how to use SPARQL's UNION clause to handle OR conditions in a WHERE clause.

uploads/2020/02/sparql-or-conditions.png

sparql-or-conditions-where-union-query

https://markhneedham.com/blog/2020/02/07/sparql-or-conditions-where-union-query

2020-10-29 00:21:00

Neo4j: Cypher - FOREACH vs CALL {} (subquery)

I recently wanted to create a graph based on an adjacency list, and in this post we'll learn how to do that using the https://neo4j.com/docs/cypher-manual/current/clauses/foreach/[FOREACH^] clause and then with the new https://neo4j.com/docs/cypher-manual/current/clauses/call-subquery/#subquery-aggregation[CALL {}^] subquery clause. We'll start with the following map of ids -> arrays of ids: [source,cypher] ---- :param list => ({`0`: [7, 9], `1`: [2, 4, 5, 6, 8, 9], `2`: [0, 6, 8, 9], `3`: [1, 2, 6, 9], `4`: [1, 2, 3, 7], `5`: [8, 9], `6`: [2, 4, 5, 7, 8, 9], `7`: [0, 3, 4, 6, 8, 9], `8`: [1, 6, 9], `9`: [0, 1, 3, 5]}) ---- We want to create one node per id and create a relationship from each node to the nodes in its array. So for example, we'll have a relationship from `0` -> `7`, `0` -> `9`, `1` -> `2`, and so on. We can do this using the `FOREACH` clause, as shown in the following query [source,cypher] ---- UNWIND keys($list) AS key MERGE (n:Node {id: toInteger(key)}) FOREACH(item IN $list[key] | MERGE (m:Node {id: item}) MERGE (n)-[:CONNECTED_TO]->(m) ) RETURN n.id; ---- If we run this query, we'll see the following output: .Results [opts="header"] |=== | n.id | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |=== But what if along with the id, we'd also like to return the number of outgoing relationships from each node? One way to do this would be to use the `UNWIND` clause to iterate through the values in the array, as shown below: [source,cypher] ---- UNWIND keys($list) AS key MERGE (n:Node {id: toInteger(key)}) WITH n, key UNWIND $list[key] AS item MERGE (m:Node {id: item}) MERGE (n)-[:CONNECTED_TO]->(m) RETURN n.id, count(*); ---- If we run this query, we'll see the following output: .Results [opts="header"] |=== | n.id | count | 0 | 2 | 1 | 6 | 2 | 4 | 3 | 4 | 4 | 4 | 5 | 2 | 6 | 6 | 7 | 6 | 8 | 3 | 9 | 4 |=== This works, but we are creating a lot of extra rows between lines 4-6, before squashing them back again on line 7. In this example it's not too much of a problem, but in queries with multiple `UNWIND` clauses, we can simplify things by https://neo4j.com/docs/cypher-manual/current/clauses/call-subquery/#subquery-aggregation[isolating the side effects^] in a `CALL {}` subquery. If we do that, we'll have the query below: [source,cypher] ---- UNWIND keys($list) AS key MERGE (n:Node {id: toInteger(key)}) CALL { WITH key, n UNWIND $list[key] AS item MERGE (m:Node {id: item}) MERGE (n)-[:CONNECTED_TO]->(m) RETURN count(*) AS count } RETURN n.id, count ---- If we run that query, we'll see the following output: .Results [source,text] ---- WITH is required between MERGE and CALL (line 3, column 1 (offset: 62)) "CALL {" ^ ---- Hmmm, not quite. Let's add a `WITH` clause for `n` and `key`: [source,cypher] ---- UNWIND keys($list) AS key MERGE (n:Node {id: toInteger(key)}) WITH n, key CALL { UNWIND $list[key] AS item MERGE (m:Node {id: item}) MERGE (n)-[:CONNECTED_TO]->(m) RETURN count(*) AS count } RETURN n.id, count; ---- And run our query again: .Results [source,text] ---- Variable `key` not defined (line 5, column 16 (offset: 96)) " UNWIND $list[key] AS item" ^ ---- Not quite! We also need to add a `WITH` clause with each of these values to the start of the `CALL{}` clause: [source,cypher] ---- UNWIND keys($list) AS key MERGE (n:Node {id: toInteger(key)}) WITH n, key CALL { WITH key, n UNWIND $list[key] AS item MERGE (m:Node {id: item}) MERGE (n)-[:CONNECTED_TO]->(m) RETURN count(*) AS count } RETURN n.id, count ---- And now if we run the query, we'll see the following output: .Results [opts="header"] |=== | n.id | count | 0 | 2 | 1 | 6 | 2 | 4 | 3 | 4 | 4 | 4 | 5 | 2 | 6 | 6 | 7 | 6 | 8 | 3 | 9 | 4 |===

Learn how to use the CALL {} subquery syntax to create data in a graph.

neo4j-foreach-call-subquery

https://markhneedham.com/blog/2020/10/29/neo4j-foreach-call-subquery

2020-08-07 00:21:00

pipenv: ImportError: No module named 'virtualenv.seed.via_app_data'

I've been trying to install https://pipenv-fork.readthedocs.io/en/latest/[pipenv^] on a new computer and ran into a frustrating issue. After installing pipenv using pip, I tried to run the command below: [source, bash] ---- $ /home/markhneedham/.local/bin/pipenv shell Creating a virtualenv for this project… Pipfile: /tmp/Pipfile Using /usr/bin/python3.8 (3.8.2) to create virtualenv… ⠙ Creating virtual environment...ModuleNotFoundError: No module named 'virtualenv.seed.via_app_data' ✘ Failed creating virtual environment [pipenv.exceptions.VirtualenvCreationException]: Failed to create virtual environment. ---- Hmmm, for some reason it's unable to find one of the virtualenv modules. I found a https://github.com/pypa/virtualenv/issues/1875[GitHub issue on the virtualenv^] repository, which suggested the following: > It's a conflict between two existing virtualenv installation. You might have installed latest version, however if in the same python you also have an old version installed this error will pop up. Maybe you have a user and system installation in parallel. I uninstalled pipenv: [source, bash] ---- $ pip3 uninstall pipenv Found existing installation: pipenv 2020.6.2 Uninstalling pipenv-2020.6.2: Would remove: /home/markhneedham/.local/bin/pipenv /home/markhneedham/.local/bin/pipenv-resolver /home/markhneedham/.local/lib/python3.8/site-packages/pipenv-2020.6.2.dist-info/* /home/markhneedham/.local/lib/python3.8/site-packages/pipenv/* Proceed (y/n)? y Successfully uninstalled pipenv-2020.6.2 ---- And then thought I should check if there was anything left in the `~/.local/bin` directory: [source,bash] ---- $ ls -alh /home/markhneedham/.local/bin/ total 16K drwxrwxr-x 2 markhneedham markhneedham 4.0K Aug 7 11:27 . drwxr-xr-x 5 markhneedham markhneedham 4.0K Aug 7 11:19 .. -rwxrwxr-x 1 markhneedham markhneedham 238 Aug 7 11:19 virtualenv -rwxrwxr-x 1 markhneedham markhneedham 214 Aug 7 11:19 virtualenv-clone ---- virtualenv is still there! I thought it would have been removed when I uninstalled pipenv, but perhaps it was installed separately when I installed something else, I'm not sure. Anyway, let's get rid of virtualenv: [source,bash] ---- $ pip3 uninstall virtualenv Found existing installation: virtualenv 20.0.30 Uninstalling virtualenv-20.0.30: Would remove: /home/markhneedham/.local/bin/virtualenv /home/markhneedham/.local/lib/python3.8/site-packages/virtualenv-20.0.30.dist-info/* /home/markhneedham/.local/lib/python3.8/site-packages/virtualenv/* Proceed (y/n)? y Successfully uninstalled virtualenv-20.0.30 ---- And now we'll install pipenv again: [source,bash] ---- $ pip3 install pipenv Collecting pipenv Using cached pipenv-2020.6.2-py2.py3-none-any.whl (3.9 MB) Requirement already satisfied: setuptools>=36.2.1 in /usr/lib/python3/dist-packages (from pipenv) (45.2.0) Requirement already satisfied: pip>=18.0 in /usr/lib/python3/dist-packages (from pipenv) (20.0.2) Requirement already satisfied: virtualenv-clone>=0.2.5 in /home/markhneedham/.local/lib/python3.8/site-packages (from pipenv) (0.5.4) Requirement already satisfied: virtualenv in /usr/lib/python3/dist-packages (from pipenv) (20.0.17) Requirement already satisfied: certifi in /usr/lib/python3/dist-packages (from pipenv) (2019.11.28) Installing collected packages: pipenv WARNING: The scripts pipenv and pipenv-resolver are installed in '/home/markhneedham/.local/bin' which is not on PATH. Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location. Successfully installed pipenv-2020.6.2 ---- And now let's try to create a virtual environment: [source, bash] ---- $ pipenv shell Creating a virtualenv for this project… Pipfile: /tmp/Pipfile Using /usr/bin/python3.8 (3.8.2) to create virtualenv… ⠹ Creating virtual environment...created virtual environment CPython3.8.2.final.0-64 in 161ms creator CPython3Posix(dest=/home/markhneedham/.local/share/virtualenvs/tmp-XVr6zr33, clear=False, global=False) seeder FromAppData(download=False, pkg_resources=latest, idna=latest, distlib=latest, contextlib2=latest, requests=latest, distro=latest, retrying=latest, certifi=latest, urllib3=latest, ipaddr=latest, webencodings=latest, pip=latest, wheel=latest, setuptools=latest, pep517=latest, colorama=latest, html5lib=latest, msgpack=latest, six=latest, packaging=latest, lockfile=latest, pyparsing=latest, progress=latest, chardet=latest, CacheControl=latest, appdirs=latest, pytoml=latest, via=copy, app_data_dir=/home/markhneedham/.local/share/virtualenv/seed-app-data/v1.0.1.debian) activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator ✔ Successfully created virtual environment! Virtualenv location: /home/markhneedham/.local/share/virtualenvs/tmp-XVr6zr33 Creating a Pipfile for this project… Launching subshell in virtual environment… . /home/markhneedham/.local/share/virtualenvs/tmp-XVr6zr33/bin/activate markhneedham@markhneedham-Precision-5550:/tmp$ . /home/markhneedham/.local/share/virtualenvs/tmp-XVr6zr33/bin/activate ---- Success!

Learn how to fix an error when using pipenv

pipenv-import-file-no-module-named-virtualenv

https://markhneedham.com/blog/2020/08/07/pipenv-import-file-no-module-named-virtualenv

2020-08-24 00:21:00

Unix: Get file name without extension from file path

I recently found myself needing to extract the file name but not file extension from a bunch of file paths and wanted to share a neat technique that I learnt to do it. I started with a bunch of Jupyter notebook files, which I listed usign the following command; [source,bash] ---- $ find notebooks/ -maxdepth 1 -iname *ipynb notebooks/09_Predictions_sagemaker.ipynb notebooks/00_Environment.ipynb notebooks/05_Train_Evaluate_Model.ipynb notebooks/01_DataLoading.ipynb notebooks/05_SageMaker.ipynb notebooks/09_Predictions_sagemaker-Copy2.ipynb notebooks/09_Predictions_sagemaker-Copy1.ipynb notebooks/02_Co-Author_Graph.ipynb notebooks/04_Model_Feature_Engineering.ipynb notebooks/09_Predictions_scikit.ipynb notebooks/03_Train_Test_Split.ipynb ---- If we pick one of those files: [source,bash] ---- file="notebooks/05_Train_Evaluate_Model.ipynb" ---- I want to extract the file name from this file path, which would give us `05_Train_Evaluate_Model`. We can extract the file name using the `basename` function: [source,bash] ---- $ basename ${file} 05_Train_Evaluate_Model.ipynb ---- StackOverflow has https://stackoverflow.com/questions/12152626/how-can-i-remove-the-extension-of-a-filename-in-a-shell-script[many suggestions^] for stripping out the file extension, but my favourite is one that https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html[uses parameter expansion^]. [quote] _____ **${parameter#word}** **${parameter##word}** The word is expanded to produce a pattern and matched according to the rules described below (see Pattern Matching). If the pattern matches the beginning of the expanded value of parameter, then the result of the expansion is the expanded value of parameter with the shortest matching pattern (the "\#" case) or the longest matching pattern (the "##" case) deleted. If parameter is '@' or '*', the pattern removal operation is applied to each positional parameter in turn, and the expansion is the resultant list. If parameter is an array variable subscripted with ‘@’ or ‘*’, the pattern removal operation is applied to each member of the array in turn, and the expansion is the resultant list. _____ We can use it like this: [source, bash] ---- $ basename ${file%.*} 05_Train_Evaluate_Model ---- Because we've used the `%` variant, this will delete the shortest matching pattern. i.e. only one file extension If we had a file that ends with multiple file extensions, we'd need to use the `%%` variant instead: [source,bash] ---- $ filename="notebooks/05_Train_Evaluate_Model.ipynb.bak" $ echo ${filename%%.*} notebooks/05_Train_Evaluate_Model ---- Going back to our original problem, we can extract the file names for all of our Jupyter notebooks by running the following: [source, bash] ---- for file in `find notebooks -maxdepth 1 -iname *.ipynb`; do echo $(basename ${file%.*}) done ---- [source, text] ---- 09_Predictions_sagemaker 00_Environment 05_Train_Evaluate_Model 01_DataLoading 05_SageMaker 09_Predictions_sagemaker-Copy2 09_Predictions_sagemaker-Copy1 02_Co-Author_Graph 04_Model_Feature_Engineering 09_Predictions_scikit 03_Train_Test_Split ----

Learn how to extract the file name without extension from a file path using Unix command line tools.

unix-get-file-name-without-extension-from-file-path

https://markhneedham.com/blog/2020/08/24/unix-get-file-name-without-extension-from-file-path

2020-01-04 00:21:00

QuickGraph #4: UK Official Singles Chart 2019

For our first QuickGraph of the new decade we're going to explore data from the https://www.officialcharts.com/[Official UK Top 40 Chart^]. This chart ranks the top 100 songs of the week based on official sales of sales of downloads, CD, vinyl, audio streams and video streams. Every week BBC Radio 1 broadcast the top 40 songs, which explains the name of the chart. image::{{<siteurl>}}/uploads/2020/01/official-charts-header.png[title="The Official UK Charts"] == Scraping the Official Charts I couldn't find a dump of the dataset, so we're going to use our web scraping skills again. Below is a printscreen showing the page that we're going to scrape. image::{{<siteurl>}}/uploads/2020/01/uk-charts-raw-data.png[title="UK Charts Raw Data"] If we take a look at the underlying HTML, we'll see that each chart entry is conveniently represented by a row in a table: image::{{<siteurl>}}/uploads/2020/01/uk-charts-one-row.png[title="HTML of one chart entry in the UK Charts"] I wrote a couple of Python scripts to https://github.com/mneedham/uk-charts-neo4j/blob/master/scripts/download_charts.py[download each of the charts^] and then for each chart entry, https://github.com/mneedham/uk-charts-neo4j/blob/master/scripts/scrape.py[extract the position, track, artist, and record label^]. We generate one JSON document per chart entry, and below is an example of one of these documents: [source,json] ---- { "start": "01 March 2019", "end": "07 March 2019", "position": 2, "track_name": "Giant", "track_uri": "/search/singles/giant/", "track_file_name": "search-singles-giant", "artist_name": "Calvin Harris & Rag'N'Bone Man", "artist_uri": "/artist/54916/calvin-harris-and-ragnbone-man/", "label": "Columbia" } ---- For many of the tracks the data scraped from the Official Charts website is sufficient, but for some of them I found it difficult to figure out the names of all the collaborating artists. I thought this would be a good opportunity to use the Spotify API to enrich the dataset. == Enriching the data with the Spotify API We'll use https://developer.spotify.com/documentation/web-api/reference-beta/#category-search[Spotify's Search API^] to retrieve the names of all collaborating artists for a track. Instructions explaining how https://github.com/mneedham/uk-charts-neo4j#downloading-and-scraping-charts[how to download and enrich the data^] are described in the https://github.com/mneedham/uk-charts-neo4j[uk-charts-neo4j^] repository. == Exploring the data Let's have a quick look at the first few lines of this file using command line tools: [source,bash] ---- head -n3 import/items.json | jq '.' ---- If we run that command, we'll see the following output: [source,json] ---- { "start": "01 March 2019", "end": "07 March 2019", "position": 1, "track_name": "Someone You Loved", "track_uri": "/search/singles/someone-you-loved/", "track_file_name": "search-singles-someone-you-loved", "artist_name": "Lewis Capaldi", "artist_uri": "/artist/51369/lewis-capaldi/", "label": "Emi", "duration": 182160, "artists": [ { "id": "4GNC7GD6oZMSxPGyXy4MNB", "name": "Lewis Capaldi" } ] } { "start": "01 March 2019", "end": "07 March 2019", "position": 2, "track_name": "Giant", "track_uri": "/search/singles/giant/", "track_file_name": "search-singles-giant", "artist_name": "Calvin Harris & Rag'N'Bone Man", "artist_uri": "/artist/54916/calvin-harris-and-ragnbone-man/", "label": "Columbia", "duration": 229184, "artists": [ { "id": "7CajNmpbOovFoOoasH2HaY", "name": "Calvin Harris" }, { "id": "4f9iBmdUOhQWeP7dcAn1pf", "name": "Rag'n'Bone Man" } ] } { "start": "01 March 2019", "end": "07 March 2019", "position": 3, "track_name": "Break Up With Your Girlfriend I'M Bored", "track_uri": "/search/singles/break-up-with-your-girlfriend-i'm-bored/", "track_file_name": "search-singles-break-up-with-your-girlfriend-i'm-bored", "artist_name": "Ariana Grande", "artist_uri": "/artist/26221/ariana-grande/", "label": "Republic Records", "duration": 190440, "artists": [ { "id": "66CXWjxzNUsdJxJ2JdwvnR", "name": "Ariana Grande" } ] } ---- We can also use the https://neo4j.com/docs/labs/apoc/3.5/[APOC^] Library's https://neo4j.com/docs/labs/apoc/current/import/load-json/[`apoc.load.json`^] procedure to explore the data. The following query returns the 1st chart entry: [source,cypher] ---- CALL apoc.load.json("https://github.com/mneedham/uk-charts-neo4j/raw/master/import/items.json") YIELD value RETURN value LIMIT 1 ---- If we run that query we'll see the following output: .Exploring the data [opts="header"] |=== | value | {"duration":182160,"track_file_name":"search-singles-someone-you-loved","artist_uri":"/artist/51369/lewis-capaldi/","artist_name":"Lewis Capaldi","artists":[{"name":"Lewis Capaldi","id":"4GNC7GD6oZMSxPGyXy4MNB"}],"start":"01 March 2019","end":"07 March 2019","position":1,"label":"Emi","track_uri":"/search/singles/someone-you-loved/","track_name":"Someone You Loved"} |=== Next we're going to use the `apoc.load.json` procedure to load the data into Neo4j. == Importing the data We're going to import the data into the following graph model: image::{{<siteurl>}}/uploads/2020/01/uk-chart-model.png[title="Graph Model for the UK Charts"] The following statements set up indexes and constraints for our graph: [source, cypher] ---- CREATE INDEX ON :Chart(start); CREATE CONSTRAINT ON (l:Label) ASSERT l.name IS UNIQUE; CREATE CONSTRAINT ON (s:Song) ASSERT s.uri IS UNIQUE; CREATE CONSTRAINT ON (a:Artist) ASSERT a.id IS UNIQUE; ---- The following statement imports the charts, songs, artists, and labels into the graph: [source, cypher] ---- CALL apoc.load.json("file://items.json") YIELD value MERGE (chart:Chart { start: date(datetime({epochmillis: apoc.date.parse(value.start, "ms", "dd MMMM yyyy")})), end: date(datetime({epochmillis: apoc.date.parse(value.end, "ms", "dd MMMM yyyy")})) }) MERGE (label:Label {name: value.label}) MERGE (song:Song {uri: value.track_uri}) SET song.title = value.track_name, song.duration = CASE WHEN value.duration is null THEN null ELSE duration({milliseconds:value.duration}) END MERGE (song)-[:LABEL]->(label) MERGE (song)-[inChart:IN_CHART]->(chart) SET inChart.position = value.position FOREACH(artist IN value.artists | MERGE (a:Artist {id: artist.id}) SET a.name = artist.name MERGE (song)-[:ARTIST]->(a) ); ---- We can see a sample of the imported graph in the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/01/uk-chart-preview.png[title="Sample of the UK Charts Graph"] == Querying the graph Now let's explore the data using Neo4j's https://neo4j.com/developer/cypher-basics-i/[Cypher^] query language. == Which song was number 1 for the most weeks? [source, cypher] ---- MATCH (song:Song)-[inChart:IN_CHART {position: 1}]->(chart), (song)-[:ARTIST]->(artist) // order the chart dates so that they show in order when // we collect them in the RETURN statement WITH song, collect(artist.name) AS artists, inChart, chart ORDER BY chart.start RETURN song.title AS song, artists, apoc.date.format(song.duration.milliseconds, 'ms', 'mm:ss') AS duration, count(*) AS count, collect(toString(chart.end)) AS weeks ORDER By count DESC; ---- .Which song was number 1 for the most weeks? [opts="header",cols="1,2,1,1,5"] |=== | song | artists | duration | count | weeks | "Dance Monkey" | ["Tones and I"] | "03:29" | 11 | ["2019-10-10", "2019-10-17", "2019-10-24", "2019-10-31", "2019-11-07", "2019-11-14", "2019-11-21", "2019-11-28", "2019-12-05", "2019-12-12", "2019-12-19"] | "I Don'T Care" | ["Ed Sheeran", "Justin Bieber"] | "03:39" | 8 | ["2019-05-23", "2019-05-30", "2019-06-06", "2019-06-13", "2019-06-20", "2019-06-27", "2019-07-04", "2019-07-11"] | "Someone You Loved" | ["Lewis Capaldi"] | "03:02" | 7 | ["2019-03-07", "2019-03-14", "2019-03-21", "2019-03-28", "2019-04-04", "2019-04-11", "2019-04-18"] | "Senorita" | ["Shawn Mendes", "Camila Cabello"] | "03:10" | 6 | ["2019-07-18", "2019-08-01", "2019-08-08", "2019-08-15", "2019-08-22", "2019-08-29"] | "Take Me Back To London" | ["Ed Sheeran", "Stormzy"] | "03:09" | 5 | ["2019-09-05", "2019-09-12", "2019-09-19", "2019-09-26", "2019-10-03"] | "Sweet But Psycho" | ["Ava Max"] | "03:07" | 4 | ["2019-01-03", "2019-01-10", "2019-01-17", "2019-01-24"] | "7 Rings" | ["Ariana Grande"] | "02:58" | 4 | ["2019-01-31", "2019-02-07", "2019-02-14", "2019-02-28"] | "Old Town Road" | ["Billy Ray Cyrus", "Lil Nas X"] | "02:37" | 2 | ["2019-04-25", "2019-05-02"] | "Vossi Bop" | ["Stormzy"] | "03:16" | 2 | ["2019-05-09", "2019-05-16"] | "Break Up With Your Girlfriend I'M Bored" | ["Ariana Grande"] | "03:10" | 1 | ["2019-02-21"] | "Beautiful People" | ["Khalid", "Ed Sheeran"] | "03:17" | 1 | ["2019-07-25"] | "I Love Sausage Rolls" | ["LadBaby"] | "03:23" | 1 | ["2019-12-26"] |=== The extremely catchy Dance Monkey was number 1 for 11 weeks, or just less than 3 months of the year. We can see Ed Sheeran show up in the _artists_ column a few times as well, so let's next see which artist was number 1 for the most weeks. == Which artist was number 1 for the most weeks? [source,cypher] ---- MATCH (song:Song)-[inChart:IN_CHART {position: 1}]->(chart), (song)-[:ARTIST]->(artist:Artist) WITH artist, song, count(*) AS weeks RETURN artist.name, apoc.map.fromPairs(collect([song.title, weeks])) AS songs, count(*) AS count, sum(weeks) AS weeks ORDER BY weeks DESC; ---- .Which artist was number 1 for the most weeks? [opts="header",cols="1,5,1,1"] |=== | artist | songs | count | weeks | "Ed Sheeran" | {`Take Me Back To London`: 5, `I Don'T Care`: 8, `Beautiful People`: 1} | 3 | 14 | "Tones and I" | {`Dance Monkey`: 11} | 1 | 11 | "Justin Bieber" | {`I Don'T Care`: 8} | 1 | 8 | "Lewis Capaldi" | {`Someone You Loved`: 7} | 1 | 7 | "Stormzy" | {`Take Me Back To London`: 5, `Vossi Bop`: 2} | 2 | 7 | "Shawn Mendes" | {Senorita: 6} | 1 | 6 | "Camila Cabello" | {Senorita: 6} | 1 | 6 | "Ariana Grande" | {`7 Rings`: 4, `Break Up With Your Girlfriend I'M Bored`: 1} | 2 | 5 | "Ava Max" | {`Sweet But Psycho`: 4} | 1 | 4 | "Billy Ray Cyrus" | {`Old Town Road`: 2} | 1 | 2 | "Lil Nas X" | {`Old Town Road`: 2} | 1 | 2 | "Khalid" | {`Beautiful People`: 1} | 1 | 1 | "LadBaby" | {`I Love Sausage Rolls`: 1} | 1 | 1 |=== Ed Sheeran had 3 number 1's last year, giving him a total of 14 weeks at number 1. I was surprised not to see what I thought was his most popular song of the year, South Of The Border. Let's see what happened there. == How did South Of The Border do on the charts? [source,cypher] ---- MATCH (song:Song {title: "South Of The Border"}) MATCH (song)-[inChart:IN_CHART]->(chart) WITH song, chart, inChart ORDER BY chart.start RETURN inChart.position AS position, collect(toString(chart.end)) AS charts ORDER BY position ---- .How did South Of The Border do on the charts? [opts="header",cols="1,3"] |=== | position | charts | 4 | ["2019-10-31", "2019-11-14", "2019-11-21"] | 5 | ["2019-11-07"] | 7 | ["2019-10-24", "2019-11-28"] | 9 | ["2019-12-05", "2019-12-12"] | 13 | ["2019-12-19"] | 24 | ["2019-10-17"] | 40 | ["2019-10-10"] | 55 | ["2019-12-26"] |=== Hmmm, it peaked at number 4 back in October and November, before falling down the chart after that. I wonder if Ed Sheeran released any other songs last year? == How did Ed Sheeran's other songs do? [source,cypher] ---- MATCH (artist:Artist {name: "Ed Sheeran"}) MATCH (artist)<-[:ARTIST]-(song)-[inChart:IN_CHART]->(chart) WITH song, artist, min(inChart.position) AS bestPosition, toString(min(chart.end)) AS chart OPTIONAL MATCH (artist)<-[:ARTIST]-(song)-[:ARTIST]->(collaborator) RETURN song.title AS song, collect(collaborator.name) AS collaborators, bestPosition, chart ORDER BY bestPosition ---- .How did Ed Sheeran's other songs do? [opts="header",cols="1,2,1,1"] |=== | song | collaborators | bestPosition | chart | "I Don'T Care" | ["Justin Bieber"] | 1 | "2019-05-23" | "Take Me Back To London" | ["Stormzy"] | 1 | "2019-07-25" | "Beautiful People" | ["Khalid"] | 1 | "2019-07-11" | "Own It" | ["Burna Boy", "Stormzy"] | 2 | "2019-12-05" | "South Of The Border" | ["Camila Cabello", "Cardi B"] | 4 | "2019-10-10" | "Cross Me" | ["Chance the Rapper", "PnB Rock"] | 4 | "2019-06-06" | "Perfect" | [] | 40 | "2019-01-10" | "Shape Of You" | [] | 82 | "2019-01-10" |=== The last two on this list are hangovers from 2018. I expect they charted much higher during that year. We can create a visual representation of this data by tweaking our query slightly: [source,cypher] ---- MATCH (artist:Artist {name: "Ed Sheeran"}) MATCH (artist)<-[:ARTIST]-(song)-[inChart:IN_CHART]->(chart) WITH song, artist, min(inChart.position) AS bestPosition, toString(min(chart.end)) AS chart // Create virtual nodes and relationships to represent // the best chart position for a song CALL apoc.create.vNode(["Chart"], {end: chart}) YIELD node AS bestChart CALL apoc.create.vRelationship(song, "IN_CHART", {position: bestPosition}, bestChart) YIELD rel OPTIONAL MATCH (artist)<-[:ARTIST]-(song)-[:ARTIST]->(collaborator) RETURN * ---- We could probably achieve the same result by tweaking the first part of the query, but I never like to miss an opportunity to use virtual nodes and relationships. image::{{<siteurl>}}/uploads/2020/01/ed-sheeran-songs.png[title="Ed Sheeran songs in the UK Charts of 2019"] It's interesting that he's had a collaborator on all his other songs in 2019, and all of his songs charted in the top 5. Let's explore artist collaborations a bit more. == How many collaborators did artists have during the year? The following query computes the number of collaborators each artist had and then creates a histogram of those counts: [source,cypher] ---- MATCH (artist:Artist) OPTIONAL MATCH (artist)<-[:ARTIST]-(song)-[:ARTIST]->(otherArtist) WITH artist, count(otherArtist) AS count RETURN count, count(*) ORDER BY count ---- This data is easiest to interpret as a chart, which we can create using https://www.chartgo.com/[chartgo.com^]. image::{{<siteurl>}}/uploads/2020/01/collaborations-count.png[title="Artist Collaborations"] Although the majority of artists mostly worked alone or had only one collaborator, there are a reasonable number who had 6 or more collaborators over the year. In all the queries that we're written so far, we've been looking at the chart position for a song in a single week. We haven't written any queries that look at how a song's chart position changes over the weeks. What if we want to do this? == Which song had the biggest climb between weeks? We're going to work out which song had the biggest climb between weeks, but first we'll create relationships between consecutive charts to make it easier to write this query. So for example we'll create a `NEXT` relationship between: * The _Chart_ nodes with _end_ properties `2019-02-14` and `2019-02-21` * The _Chart_ nodes with _end_ properties `2019-02-21` and `2019-02-28` And so on. The following query collects all the _Chart_ nodes in order by date and then creates `NEXT` relationships between consecutive nodes using the `apoc.nodes.link` procedure: [source,cypher] ---- MATCH (chart:Chart) WITH chart ORDER BY chart.start WITH collect(chart) AS charts CALL apoc.nodes.link(charts, "NEXT") RETURN count(*) ---- The Neo4j Browser visualisation below shows the linked list that we've now created: image::{{<siteurl>}}/uploads/2020/01/charts-linked-list.png[title="Linked list of consecutive Chart nodes"] We can now write the following query to return the 5 songs that made the biggest climb in the charts in consecutive weeks: [source,cypher] ---- MATCH (song:Song)-[inChart:IN_CHART]->(chart)<-[:NEXT]-(previousChart), (previousChart)<-[inChartPrevious:IN_CHART]-(song), (song)-[:ARTIST]->(artist) WITH song, collect(artist.name) AS artists, inChartPrevious.position AS firstPosition, inChart.position AS secondPosition, previousChart, chart RETURN song.title AS song, artists, firstPosition, secondPosition, firstPosition - secondPosition AS change, toString(previousChart.end) AS firstChart, toString(chart.end) AS secondChart ORDER BY change DESC LIMIT 5 ---- .Which song had the biggest climb between weeks? [opts="header"] |=== | song | artists | firstPosition | secondPosition | change | firstChart | secondChart | "Bruises" | ["Lewis Capaldi"] | 82 | 11 | 71 | "2019-10-03" | "2019-10-10" | "Playing Games" | ["Summer Walker", "Bryson Tiller"] | 93 | 25 | 68 | "2019-10-10" | "2019-10-17" | "Girls Like You" | ["Maroon 5", "Cardi B"] | 97 | 34 | 63 | "2019-01-03" | "2019-01-10" | "Lose You To Love Me" | ["Selena Gomez"] | 65 | 3 | 62 | "2019-10-31" | "2019-11-07" | "Play" | ["Years & Years", "Jax Jones"] | 80 | 19 | 61 | "2019-01-03" | "2019-01-10" |=== There are some big climbers there, but I think it'll be more interesting to look at number 1 songs in this context. == Which songs went straight in at number 1? Let's start by seeing whether any of our number 1 songs went straight in at number 1. The following query will tell us the answer to this question: [source,cypher] ---- // Find songs that charted at position 1 MATCH (song:Song)-[inChart:IN_CHART {position: 1}]->(chart) // And didn't have an entry on a chart before this one WHERE not((chart)<-[:NEXT*]-()<-[:IN_CHART]-(song)) WITH song, chart ORDER BY chart.end RETURN song.title AS song, [(song)-[:ARTIST]->(artist) | artist.name] AS artists, collect(toString(chart.end)) AS chart ---- .Which songs went straight in at number 1? [opts="header"] |=== | song | artists | chart | "Sweet But Psycho" | ["Ava Max"] | ["2019-01-03"] | "7 Rings" | ["Ariana Grande"] | ["2019-01-31"] | "Break Up With Your Girlfriend I'M Bored" | ["Ariana Grande"] | ["2019-02-21"] | "Vossi Bop" | ["Stormzy"] | ["2019-05-09"] | "I Don'T Care" | ["Ed Sheeran", "Justin Bieber"] | ["2019-05-23"] | "I Love Sausage Rolls" | ["LadBaby"] | ["2019-12-26"] |=== 6 songs went straight in at the top. That means we still have 6 songs that came in at a lower position and then climbed to number 1. == Which songs didn't go straight to number 1? The following query will help us figure out what position they charted on their first entry: [source,cypher] ---- // Find the first week that the song got to number 1 MATCH (song:Song)-[inChart:IN_CHART {position: 1}]->(chart) WITH song, chart ORDER BY song, chart.end WITH song, collect(chart)[0] AS firstWeekAtNumber1 // Find the earliest week that the song charted MATCH (firstWeekAtNumber1)<-[:NEXT*]-(previous)<-[previousInChart:IN_CHART]-(song) WITH song, firstWeekAtNumber1, previous, previousInChart ORDER BY song, previous.end WITH song, firstWeekAtNumber1, collect(previousInChart.position)[0] AS firstPosition, collect(previous)[0] AS firstWeek RETURN song.title AS song, [(song)-[:ARTIST]->(artist) | artist.name] AS artists, toString(firstWeekAtNumber1.end) AS firstWeekAtNumber1, firstPosition AS firstPosition, toString(firstWeek.end) AS firstWeek, [path = (firstWeekAtNumber1)<-[:NEXT*]-(firstWeek) | length(path)][0] AS weeksToReachNumber1 ---- .Which songs didn't go straight to number 1? [opts="header"] |=== | song | artists | firstWeekAtNumber1 | firstPosition | firstWeek | weeksToReachNumber1 | "Someone You Loved" | ["Lewis Capaldi"] | "2019-03-07" | 66 | "2019-01-17" | 7 | "Dance Monkey" | ["Tones and I"] | "2019-10-10" | 82 | "2019-08-15" | 8 | "Take Me Back To London" | ["Ed Sheeran", "Stormzy"] | "2019-09-05" | 3 | "2019-07-25" | 6 | "Senorita" | ["Shawn Mendes", "Camila Cabello"] | "2019-07-18" | 2 | "2019-07-04" | 2 | "Beautiful People" | ["Khalid", "Ed Sheeran"] | "2019-07-25" | 3 | "2019-07-11" | 2 | "Old Town Road" | ["Billy Ray Cyrus", "Lil Nas X"] | "2019-04-25" | 67 | "2019-04-04" | 3 |=== Interestingly the longest running number 1, Dance Monkey, started at the lowest position. And not only that, it took almost 2 months for it to get up to the number 1 spot. So if you start with a low chart position, all is not lost! == What’s interesting about this QuickGraph? This post has gone on for much longer than I intended, but I'll conclude with some thoughts on what makes this QuickGraph interesting. There's a lot of analysis of the charts in the UK, but it's often done along one dimension, be that a song or an artist. By modelling the data as a graph we can easily query the data along multiple dimensions. I especially enjoyed writing the queries that looked at how songs did across multiple charts. We could certainly extend our analysis further by adding in Wiki data, as Jesús Barrasa did in his https://jbarrasa.com/2019/12/05/quickgraph10-enrich-your-neo4j-knowledge-graph-by-querying-wikidata/[QuickGraph #10^], but that can wait for another blog post!

Learn how to build a graph of the UK's Official Singles Chart

uploads/2020/01/official-charts-header.png

quick-graph-uk-official-charts

https://markhneedham.com/blog/2020/01/04/quick-graph-uk-official-charts

2020-01-02 00:21:00

Spotify API: Making my first call

:icons: font I wanted to enrich the data for a little music application I'm working on and realised it would be a perfect opportunity to try out the https://developer.spotify.com/documentation/[Spotify API^]. I want to extract data about individual tracks (via the https://developer.spotify.com/documentation/web-api/reference-beta/#category-tracks[Tracks API^]), but before we do that we'll need to create an app and have it approved for access to the Spotify API. image::{{<siteurl>}}/uploads/2020/01/spotify-logo.png[] == Registering an application After logging into the https://developer.spotify.com/dashboard/applications[Spotify Dashboard^] using my usual Spotify credentials, I was prompted to create an application: image::{{<siteurl>}}/uploads/2020/01/create-app.png[] We then have to fill in a three part form, providing some information about the application that we want to build: image::{{<siteurl>}}/uploads/2020/01/spotify-sign-up.png[] Once we submit that form, we will be redirected to a screen similar to the following: image::{{<siteurl>}}/uploads/2020/01/dashboard.png[] Before we start using the API in the next section, we'll need to have our Client ID and Client Secret handy. The Client ID is already visible, and we can retrieve our Client Secret by clicking on the _Show Client Secret_ link: image::{{<siteurl>}}/uploads/2020/01/dashboard-secret.png[] Once we click on that link, we'll see the following screen: image::{{<siteurl>}}/uploads/2020/01/spotify-show-secret.png[] We're now ready to start using the API. == Requesting access token Since we're not interested in accessing user information via the API, we can use the _Client Credentials Flow_ described in the https://developer.spotify.com/documentation/general/guides/authorization-guide/#client-credentials-flow[Authorization Developer Guide^]. The diagram below, taken from this guide, explains how this works: image::{{<siteurl>}}/uploads/2020/01/spotify-AuthG_ClientCredentials.png[] We're going to use the https://requests.readthedocs.io/en/master/[Python requests library ^] to call the `/api/token` endpoint. This endpoint expects to receive the `Authorization` header parameter with a value set to a Base 64 encoded string of our Client ID and Client Secret, which we saw on our Dashboard in the previous section. Let's create environment variables containing these values, by running the commands below on our terminal window: [NOTE] == Don't forget to change the placeholder values to your Client ID and Client Secret. == [source, bash] ---- export CLIENT_ID="<our-client-id>" export CLIENT_SECRET="<our-client-secret>" ---- Once we've done that, we can write the following Python script to get an access token: _spotify_exploration.py_ [source,python] ---- import requests import base64 import os import json credentials = f"{os.environ['CLIENT_ID']}:{os.environ['CLIENT_SECRET']}" encoded_credentials = str(base64.b64encode(credentials.encode("utf-8")), "utf-8") payload = {"grant_type": "client_credentials"} headers = {"Authorization": f"Basic {encoded_credentials}"} response = requests.post("https://accounts.spotify.com/api/token", headers=headers, data=payload).json() print("Response:", response) ---- If we run that script, we'll see the following output: .python spotify_exploration.py |=== | Response: {'access_token': '<our-access-token>', 'token_type': 'Bearer', 'expires_in': 3600, 'scope': ''} |=== == Calling the Tracks API We can now extend our script to make a call to the Tracks API to retrieve information about the UK's longest running number 1 song of 2019, Dance Monkey: [source,python] ---- token = response["access_token"] headers = {"Authorization": f"Bearer {token}"} track_response = requests.get("https://api.spotify.com/v1/tracks/2XU0oxnq2qxCpomAAuJY8K", headers=headers).json() print("Track Response:", json.dumps(track_response)) ---- If we run our script again, we'll see the following output: .python spotify_exploration.py |=== | Track Response: {"album": {"album_type": "single", "artists": [{"external_urls": {"spotify": "https://open.spotify.com/artist/2NjfBq1NflQcKSeiDooVjY"}, "href": "https://api.spotify.com/v1/artists/2NjfBq1NflQcKSeiDooVjY", "id": "2NjfBq1NflQcKSeiDooVjY", "name": "Tones and I", "type": "artist", "uri": "spotify:artist:2NjfBq1NflQcKSeiDooVjY"}], "available_markets": ["AD", "AE", "AR", "AT", "BE", "BG", "BH", "BO", "BR", "CA", "CH", "CL", "CO", "CR", "CY", "CZ", "DE", "DK", "DO", "DZ", "EC", "EE", "EG", "ES", "FI", "FR", "GB", "GR", "GT", "HK", "HN", "HU", "ID", "IE", "IL", "IS", "IT", "JO", "JP", "KW", "LB", "LI", "LT", "LU", "LV", "MA", "MC", "MT", "MX", "MY", "NI", "NL", "NO", "OM", "PA", "PE", "PH", "PL", "PS", "PT", "PY", "QA", "RO", "SA", "SE", "SG", "SK", "SV", "TH", "TN", "TR", "TW", "US", "UY", "VN", "ZA"], "external_urls": {"spotify": "https://open.spotify.com/album/0UywfDKYlyiu1b38DRrzYD"}, "href": "https://api.spotify.com/v1/albums/0UywfDKYlyiu1b38DRrzYD", "id": "0UywfDKYlyiu1b38DRrzYD", "images": [{"height": 640, "url": "https://i.scdn.co/image/b98ddadfe65507738699fa7f80dc654f7f4d022d", "width": 640}, {"height": 300, "url": "https://i.scdn.co/image/2610e3524ce08c4d6ad16e7b9327f46998e1b821", "width": 300}, {"height": 64, "url": "https://i.scdn.co/image/93740961697e111d69fbbb8a16af64b354528cce", "width": 64}], "name": "Dance Monkey (Stripped Back) / Dance Monkey", "release_date": "2019-10-17", "release_date_precision": "day", "total_tracks": 2, "type": "album", "uri": "spotify:album:0UywfDKYlyiu1b38DRrzYD"}, "artists": [{"external_urls": {"spotify": "https://open.spotify.com/artist/2NjfBq1NflQcKSeiDooVjY"}, "href": "https://api.spotify.com/v1/artists/2NjfBq1NflQcKSeiDooVjY", "id": "2NjfBq1NflQcKSeiDooVjY", "name": "Tones and I", "type": "artist", "uri": "spotify:artist:2NjfBq1NflQcKSeiDooVjY"}], "available_markets": ["AD", "AE", "AR", "AT", "BE", "BG", "BH", "BO", "BR", "CA", "CH", "CL", "CO", "CR", "CY", "CZ", "DE", "DK", "DO", "DZ", "EC", "EE", "EG", "ES", "FI", "FR", "GB", "GR", "GT", "HK", "HN", "HU", "ID", "IE", "IL", "IS", "IT", "JO", "JP", "KW", "LB", "LI", "LT", "LU", "LV", "MA", "MC", "MT", "MX", "MY", "NI", "NL", "NO", "OM", "PA", "PE", "PH", "PL", "PS", "PT", "PY", "QA", "RO", "SA", "SE", "SG", "SK", "SV", "TH", "TN", "TR", "TW", "US", "UY", "VN", "ZA"], "disc_number": 1, "duration_ms": 209438, "explicit": false, "external_ids": {"isrc": "QZES71982312"}, "external_urls": {"spotify": "https://open.spotify.com/track/2XU0oxnq2qxCpomAAuJY8K"}, "href": "https://api.spotify.com/v1/tracks/2XU0oxnq2qxCpomAAuJY8K", "id": "2XU0oxnq2qxCpomAAuJY8K", "is_local": false, "name": "Dance Monkey", "popularity": 100, "preview_url": "https://p.scdn.co/mp3-preview/535ffea66207a0fc07d57fbaea7b5594be797f9b?cid=<our-client-id>", "track_number": 2, "type": "track", "uri": "spotify:track:2XU0oxnq2qxCpomAAuJY8K"} |=== We've now successfully made our first call to the Spotify API. And it's onwards with the rest of our application!

Learn how to call the Spotify API to retrieve details about a particular song.

uploads/2020/01/spotify-logo.png

spotify-api-making-my-first-call

https://markhneedham.com/blog/2020/01/02/spotify-api-making-my-first-call

2020-01-27 00:21:00

Neo4j: Exporting a subset of data from one database to another

As part of the preparation for another blog post, I wanted to export a subset of data from one Neo4j database to another one, which seemed like a blog post in its own right. image::{{<siteurl>}}/uploads/2020/01/apoc-export-json.png[title="Exporting data using APOC's Export JSON"] == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .Dockerfile [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4J_apoc_import_file_use__neo4j__config=true - NEO4J_apoc_import_file_enabled=true - NEO4J_apoc_export_file_enabled=true - NEO4JLABS_PLUGINS=["apoc"] ---- Once we've created that file we need to open a terminal session where that file lives and then run the following command to spin up Neo4j: [source,bash] ---- docker-compose up ---- If we run that command, we'll see the following (truncated) output: [source,text] ---- Started quickgraph-aus-open ... done Attaching to quickgraph-aus-open quickgraph-aus-open | Changed password for user 'neo4j'. quickgraph-aus-open | Fetching versions.json for Plugin 'apoc' from https://neo4j-contrib.github.io/neo4j-apoc-procedures/versions.json quickgraph-aus-open | Installing Plugin 'apoc' from https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.0.0.0/apoc-4.0.0.0-all.jar to /plugins/apoc.jar quickgraph-aus-open | Applying default values for plugin apoc to neo4j.conf quickgraph-aus-open | Directories in use: quickgraph-aus-open | home: /var/lib/neo4j quickgraph-aus-open | config: /var/lib/neo4j/conf quickgraph-aus-open | logs: /logs quickgraph-aus-open | plugins: /plugins quickgraph-aus-open | import: /import quickgraph-aus-open | data: /var/lib/neo4j/data quickgraph-aus-open | certificates: /var/lib/neo4j/certificates quickgraph-aus-open | run: /var/lib/neo4j/run quickgraph-aus-open | Starting Neo4j. quickgraph-aus-open | 2020-01-21 22:24:29.976+0000 INFO ======== Neo4j 4.0.0 ======== quickgraph-aus-open | 2020-01-21 22:24:29.982+0000 INFO Starting... quickgraph-aus-open | 2020-01-21 22:24:35.656+0000 INFO Called db.clearQueryCaches(): Query cache already empty. quickgraph-aus-open | 2020-01-21 22:24:40.765+0000 INFO Sending metrics to CSV file at /var/lib/neo4j/metrics quickgraph-aus-open | 2020-01-21 22:24:40.790+0000 INFO Bolt enabled on 0.0.0.0:7687. quickgraph-aus-open | 2020-01-21 22:24:40.791+0000 INFO Started. quickgraph-aus-open | 2020-01-21 22:24:40.879+0000 INFO Server thread metrics have been registered successfully quickgraph-aus-open | 2020-01-21 22:24:41.723+0000 INFO Remote interface available at http://0.0.0.0:7474/ ---- Once we see that last line we're ready to roll. == Exporting data In the https://markhneedham.com/blog/2020/01/23/quick-graph-australian-open/[Australian Open QuickGraph^] blog post we imported all the matches from the Australian Open tennis tournament. We can see a sample of the imported graph in the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/01/aus-open-preview.png[title="Sample of the Australian Open Graph"] Let's quickly check how much data this graph contains. We'll query the database via the Cypher Shell command, which we can launch by running the following: [source,bash] ---- $ docker exec -it quickgraph-aus-open cypher-shell -u neo4j -p neo -d womens Connected to Neo4j 4.0.0 at neo4j://localhost:7687 as user neo4j. Type :help for a list of available commands or :exit to exit the shell. Note that Cypher queries must end with a semicolon. neo4j@womens> ---- We'll use APOC's `apoc.meta.stats` procedure to get back a summary of what's in this database: [source,cypher] ---- CALL apoc.meta.stats() YIELD nodeCount, relCount, labels, relTypesCount RETURN nodeCount, relCount, labels, relTypesCount ---- .apoc.meta.stats [opts="header"] |=== | nodeCount | relCount | labels | relTypesCount | 9013 | 27727 | {Player: 571, Set: 5882, Tournament: 20, Match: 2540} | {WINNER: 8383, IN_TOURNAMENT: 2540, NEXT_MATCH: 2520, NEXT_TOURNAMENT: 19, LOSER: 8383, IN_MATCH: 5882} |=== There's not much data in there, but we only want to export the `Tournament` nodes, `NEXT_TOURNAMENT` relationships, `Match` nodes for the finals, and the `Player` nodes that competed in those finals. We're going to export the data with a little help from https://neo4j.com/docs/labs/apoc/3.5/[APOC^]'s https://neo4j.com/docs/labs/apoc/current/export/json/[export to JSON procedures^]. P.S. 👇 ++++ <blockquote class="twitter-tweet" data-theme="light"><p lang="en" dir="ltr">Finally finished refactoring the <a href="https://twitter.com/hashtag/Neo4j?src=hash&amp;ref_src=twsrc%5Etfw">#Neo4j</a> <a href="https://twitter.com/hashtag/APOC?src=hash&amp;ref_src=twsrc%5Etfw">#APOC</a> export documentation - <a href="https://t.co/RXTjV9n5rV">https://t.co/RXTjV9n5rV</a><br><br>Let us know what&#39;s missing/what else can be improved!</p>&mdash; Mark Needham (@markhneedham) <a href="https://twitter.com/markhneedham/status/1220813924360163328?ref_src=twsrc%5Etfw">January 24, 2020</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script> ++++ When we're using the export procedures, we need to specify some properties that enable this functionality. In our Dockerfile, we have the following lines: [source,yaml] ---- - NEO4J_apoc_import_file_use__neo4j__config=true - NEO4J_apoc_export_file_enabled=true ---- These properties are the equivalent of adding the following values to the `apoc.conf` file: [source,yaml] ---- apoc.import.file.use_neo4j_config=true apoc.export.file.enabled=true ---- * `apoc.export.file.enabled=true` enables writing export files to disk * `apoc.import.file.use_neo4j_config=true` writes those export files to the `import` directory We'll export the data in two parts using the `apoc.export.json.query` procedure, writing: * one query to export the `Tournament` nodes and the `NEXT_TOURNAMENT` relationships between them * one query to export the `Match` nodes where `round: "F"` and the associated `Player` and `Tournament` nodes and any relationships .The following query exports the tournaments to the file `tournaments.json` [source,cypher] ---- WITH "MATCH path = (t1:Tournament)-[rel:NEXT_TOURNAMENT]->(t2) RETURN t1, t2, rel" AS query CALL apoc.export.json.query(query, "tournaments.json", {format: "plain"}) YIELD file RETURN file ---- The contents of `tournaments.json`, truncated for brevity, are shown below: .import/tournaments.json [source,json] ---- {"t1":{"type":"node","id":"256","labels":["Tournament"],"properties":{"year":2000,"name":"Australian Open"}},"t2":{"type":"node","id":"257","labels":["Tournament"],"properties":{"year":2001,"name":"Australian Open"}},"rel":{"id":"10266","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"256","labels":["Tournament"]},"end":{"id":"257","labels":["Tournament"]}}} {"t1":{"type":"node","id":"257","labels":["Tournament"],"properties":{"year":2001,"name":"Australian Open"}},"t2":{"type":"node","id":"258","labels":["Tournament"],"properties":{"year":2002,"name":"Australian Open"}},"rel":{"id":"10267","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"257","labels":["Tournament"]},"end":{"id":"258","labels":["Tournament"]}}} {"t1":{"type":"node","id":"258","labels":["Tournament"],"properties":{"year":2002,"name":"Australian Open"}},"t2":{"type":"node","id":"259","labels":["Tournament"],"properties":{"year":2003,"name":"Australian Open"}},"rel":{"id":"10268","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"258","labels":["Tournament"]},"end":{"id":"259","labels":["Tournament"]}}} ... {"t1":{"type":"node","id":"265","labels":["Tournament"],"properties":{"year":2009,"name":"Australian Open"}},"t2":{"type":"node","id":"266","labels":["Tournament"],"properties":{"year":2010,"name":"Australian Open"}},"rel":{"id":"10275","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"265","labels":["Tournament"]},"end":{"id":"266","labels":["Tournament"]}}} {"t1":{"type":"node","id":"266","labels":["Tournament"],"properties":{"year":2010,"name":"Australian Open"}},"t2":{"type":"node","id":"267","labels":["Tournament"],"properties":{"year":2011,"name":"Australian Open"}},"rel":{"id":"10276","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"266","labels":["Tournament"]},"end":{"id":"267","labels":["Tournament"]}}} {"t1":{"type":"node","id":"267","labels":["Tournament"],"properties":{"year":2011,"name":"Australian Open"}},"t2":{"type":"node","id":"268","labels":["Tournament"],"properties":{"year":2012,"name":"Australian Open"}},"rel":{"id":"10277","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"267","labels":["Tournament"]},"end":{"id":"268","labels":["Tournament"]}}} ... {"t1":{"type":"node","id":"274","labels":["Tournament"],"properties":{"year":2018,"name":"Australian Open"}},"t2":{"type":"node","id":"0","labels":["Tournament"],"properties":{"year":2019,"name":"Australian Open"}},"rel":{"id":"10284","type":"relationship","label":"NEXT_TOURNAMENT","start":{"id":"274","labels":["Tournament"]},"end":{"id":"0","labels":["Tournament"]}}} ---- .The following query exports the final matches and surrounding nodes and relationships to the file `finalists.json` [source,cypher] ---- WITH "MATCH (t:Tournament)<-[tournRel:IN_TOURNAMENT]-(match:Match {round: 'F'})<-[winnerRel:WINNER]-(winner), (loser)-[loserRel:LOSER]->(match) RETURN t, tournRel, winner, winnerRel, loser, loserRel, match" AS query CALL apoc.export.json.query(query, "finalists.json", {format: "plain"}) YIELD file RETURN file ---- The contents of `finalists.json`, truncated for brevity, are shown below: .import/finalists.json [source,json] ---- {"t":{"type":"node","id":"0","labels":["Tournament"],"properties":{"year":2019,"name":"Australian Open"}},"tournRel":{"id":"380","type":"relationship","label":"IN_TOURNAMENT","start":{"id":"191","labels":["Match"]},"end":{"id":"0","labels":["Tournament"]}},"winner":{"type":"node","id":"34","labels":["Player"],"properties":{"name":"Naomi Osaka","id":"211768"}},"winnerRel":{"id":"378","type":"relationship","label":"WINNER","start":{"id":"34","labels":["Player"]},"end":{"id":"191","labels":["Match"]}},"loser":{"type":"node","id":"66","labels":["Player"],"properties":{"name":"Petra Kvitova","id":"201520"}},"loserRel":{"id":"379","type":"relationship","label":"LOSER","start":{"id":"66","labels":["Player"]},"end":{"id":"191","labels":["Match"]}},"match":{"type":"node","id":"191","labels":["Match"],"properties":{"score":"7-6(2) 5-7 6-4","round":"F","id":"20190114_226"}}} {"t":{"type":"node","id":"256","labels":["Tournament"],"properties":{"year":2000,"name":"Australian Open"}},"tournRel":{"id":"887","type":"relationship","label":"IN_TOURNAMENT","start":{"id":"464","labels":["Match"]},"end":{"id":"256","labels":["Tournament"]}},"winner":{"type":"node","id":"401","labels":["Player"],"properties":{"name":"Lindsay Davenport","id":"200128"}},"winnerRel":{"id":"885","type":"relationship","label":"WINNER","start":{"id":"401","labels":["Player"]},"end":{"id":"464","labels":["Match"]}},"loser":{"type":"node","id":"276","labels":["Player"],"properties":{"name":"Martina Hingis","id":"200001"}},"loserRel":{"id":"886","type":"relationship","label":"LOSER","start":{"id":"276","labels":["Player"]},"end":{"id":"464","labels":["Match"]}},"match":{"type":"node","id":"464","labels":["Match"],"properties":{"score":"6-1 7-5","round":"F","id":"20000117_127"}}} ... {"t":{"type":"node","id":"260","labels":["Tournament"],"properties":{"year":2004,"name":"Australian Open"}},"tournRel":{"id":"2405","type":"relationship","label":"IN_TOURNAMENT","start":{"id":"1054","labels":["Match"]},"end":{"id":"260","labels":["Tournament"]}},"winner":{"type":"node","id":"278","labels":["Player"],"properties":{"name":"Justine Henin","id":"200003"}},"winnerRel":{"id":"2403","type":"relationship","label":"WINNER","start":{"id":"278","labels":["Player"]},"end":{"id":"1054","labels":["Match"]}},"loser":{"type":"node","id":"547","labels":["Player"],"properties":{"name":"Kim Clijsters","id":"200079"}},"loserRel":{"id":"2404","type":"relationship","label":"LOSER","start":{"id":"547","labels":["Player"]},"end":{"id":"1054","labels":["Match"]}},"match":{"type":"node","id":"1054","labels":["Match"],"properties":{"score":"6-3 4-6 6-3","round":"F","id":"20040119_127"}}} ... {"t":{"type":"node","id":"274","labels":["Tournament"],"properties":{"year":2018,"name":"Australian Open"}},"tournRel":{"id":"7745","type":"relationship","label":"IN_TOURNAMENT","start":{"id":"2984","labels":["Match"]},"end":{"id":"274","labels":["Tournament"]}},"winner":{"type":"node","id":"96","labels":["Player"],"properties":{"name":"Caroline Wozniacki","id":"201496"}},"winnerRel":{"id":"7743","type":"relationship","label":"WINNER","start":{"id":"96","labels":["Player"]},"end":{"id":"2984","labels":["Match"]}},"loser":{"type":"node","id":"2","labels":["Player"],"properties":{"name":"Simona Halep","id":"201594"}},"loserRel":{"id":"7744","type":"relationship","label":"LOSER","start":{"id":"2","labels":["Player"]},"end":{"id":"2984","labels":["Match"]}},"match":{"type":"node","id":"2984","labels":["Match"],"properties":{"score":"7-6(2) 3-6 6-4","round":"F","id":"20180115_701"}}} ---- == Importing data We're now ready to import the data into a new database. Let's first create a new database and start using it: [source,cypher] ---- :use system; CREATE DATABASE blog; :use blog ---- Before we import any data, let's create the constraints that we had on our original database: [source, cypher] ---- CREATE CONSTRAINT ON (p:Player) ASSERT p.id IS UNIQUE; CREATE CONSTRAINT ON (m:Match) ASSERT m.id IS UNIQUE; CREATE CONSTRAINT ON (t:Tournament) ASSERT (t.name, t.year) IS NODE KEY; ---- We can check that those have been created by running the following command: [source,cypher] ---- CALL db.indexes(); ---- .CALL db.indexes() [opts="header"] |=== | id | name | state | populationPercent | uniqueness | type | entityType | labelsOrTypes | properties | provider | 5 | "constraint_989cb13a" | "ONLINE" | 100.0 | "UNIQUE" | "BTREE" | "NODE" | ["Tournament"] | ["name", "year"] | "native-btree-1.0" | 3 | "constraint_a016a763" | "ONLINE" | 100.0 | "UNIQUE" | "BTREE" | "NODE" | ["Match"] | ["id"] | "native-btree-1.0" | 1 | "constraint_cbe92269" | "ONLINE" | 100.0 | "UNIQUE" | "BTREE" | "NODE" | ["Player"] | ["id"] | "native-btree-1.0" |=== Alright, it's time to import the data! We're going to use the `apoc.load.json` procedure to do this, and we'll start with `tournaments.json`. When we're using the import procedures, we need to specify some properties that enable importing from local files. In our Dockerfile, we have the following lines: [source,yaml] ---- - NEO4J_apoc_import_file_use__neo4j__config=true - NEO4J_apoc_import_file_enabled=true ---- These properties are the equivalent of adding the following values to the `apoc.conf` file: [source,yaml] ---- apoc.import.file.use_neo4j_config=true apoc.import.file.enabled=true ---- * `apoc.import.file.enabled=true` enables reading files to disk * `apoc.import.file.use_neo4j_config=true` reads those files from the `import` directory Let's quickly run an exploratory query to remind ourselves the data that we'll be working with: [source,cypher] ---- CALL apoc.load.json("tournaments.json") YIELD value RETURN value.t1, value.t2, value.rel LIMIT 1; ---- .Exploring `tournaments.json` [opts="header"] |=== | value.t1 | value.t2 | value.rel | {id: "256", type: "node", properties: {name: "Australian Open", year: 2000}, labels: ["Tournament"]} | {id: "257", type: "node", properties: {name: "Australian Open", year: 2001}, labels: ["Tournament"]} | {start: {id: "256", labels: ["Tournament"]}, end: {id: "257", labels: ["Tournament"]}, id: "10266", label: "NEXT_TOURNAMENT", type: "relationship"} |=== where: * `t1` and `t2` represent `Tournament` nodes * `rel` represents the `NEXT_TOURNAMENT` relationship We can recreate the original graph structure by running the following query: [source,cypher] ---- CALL apoc.load.json("tournaments.json") YIELD value CALL apoc.merge.node(value.t1.labels, value.t1.properties) YIELD node AS t1 CALL apoc.merge.node(value.t2.labels, value.t2.properties) YIELD node AS t2 CALL apoc.merge.relationship(t1, value.rel.label, {}, {}, t2, {}) YIELD rel RETURN count(*); ---- We're using the `apoc.merge.node` and `apoc.merge.relationship` procedures to create the nodes and relationships. These procedures are the equivalent of Cypher's https://neo4j.com/docs/cypher-manual/current/clauses/merge/[`MERGE`^] clause, and come in handy when we're importing data from a dynamic source e.g. a JSON file .Results [opts="header"] |=== | count(*) | 19 |=== Everything looks good, but let's quickly check the contents of our database by running the `apoc.meta.stats` procedure that we ran earlier: [source,cypher] ---- CALL apoc.meta.stats() YIELD nodeCount, relCount, labels, relTypesCount RETURN nodeCount, relCount, labels, relTypesCount; ---- .apoc.meta.stats [opts="header"] |=== | nodeCount | relCount | labels | relTypesCount | 20 | 19 | {Tournament: 20} | {NEXT_TOURNAMENT: 19} |=== So we've got 20 nodes representing the 20 tournaments from 2000 to 2019 and 19 relationships between them. So far so good. Time to import `finalists.json`. We'll start with an exploratory query: [source,cypher] ---- CALL apoc.load.json("finalists.json") YIELD value RETURN value.t, value.tournRel, value.winner, value.winnerRel, value.loser, value.loserRel, value.match LIMIT 1; ---- .Exploring `finalists.json` [opts="header"] |=== | value.t | value.tournRel | value.winner | value.winnerRel | value.loser | value.loserRel | value.match | {id: "0", type: "node", properties: {name: "Australian Open", year: 2019}, labels: ["Tournament"]} | {start: {id: "191", labels: ["Match"]}, end: {id: "0", labels: ["Tournament"]}, id: "380", label: "IN_TOURNAMENT", type: "relationship"} | {id: "34", type: "node", properties: {name: "Naomi Osaka", id: "211768"}, labels: ["Player"]} | {start: {id: "34", labels: ["Player"]}, end: {id: "191", labels: ["Match"]}, id: "378", label: "WINNER", type: "relationship"} | {id: "66", type: "node", properties: {name: "Petra Kvitova", id: "201520"}, labels: ["Player"]} | {start: {id: "66", labels: ["Player"]}, end: {id: "191", labels: ["Match"]}, id: "379", label: "LOSER", type: "relationship"} | {id: "191", type: "node", properties: {score: "7-6(2) 5-7 6-4", id: "20190114_226", round: "F"}, labels: ["Match"]} |=== where: * `t` represents the `Tournament` node * `winner` and `loser` represent `Player` nodes * `match` represents the `Match` node * `winnerRel` represents the `WINNER` relationship between a `Player` and a `Match` * `loserRel` represents the `LOSER` relationship between a `Player` and a `Match` * `tournRel` represents the `IN_TOURNAMENT` relationship between a `Match` and a `Tournament` Let's now run the following query to import our matches: [source,cypher] ---- CALL apoc.load.json("finalists.json") yield value CALL apoc.merge.node(value.winner.labels, value.winner.properties) YIELD node AS winner CALL apoc.merge.node(value.loser.labels, value.loser.properties) YIELD node AS loser CALL apoc.merge.node(value.match.labels, value.match.properties) YIELD node AS match CALL apoc.merge.node(value.t.labels, value.t.properties) YIELD node AS tournament CALL apoc.merge.relationship(winner, value.winnerRel.label, {}, {}, match, {}) YIELD rel AS winnerRel CALL apoc.merge.relationship(loser, value.loserRel.label, {}, {}, match, {}) YIELD rel AS loserRel CALL apoc.merge.relationship(match, value.tournRel.label, {}, {}, tournament, {}) YIELD rel AS tournRel return count(*); ---- .Results [opts="header"] |=== | count(*) | 20 |=== Let's do one last call to `apoc.meta.stats`: [source,cypher] ---- CALL apoc.meta.stats() YIELD nodeCount, relCount, labels, relTypesCount RETURN nodeCount, relCount, labels, relTypesCount; ---- .apoc.meta.stats [opts="header"] |=== | nodeCount | relCount | labels | relTypesCount | 59 | 79 | {Player: 19, Tournament: 20, Match: 20} | {WINNER: 20, LOSER: 20, IN_TOURNAMENT: 20, NEXT_TOURNAMENT: 19} |=== And finally, let's run one of the queries from the original QuickGraph post to check that everything's in order: [source,cypher] ---- MATCH (winner:Player)-[:WINNER]->(match:Match {round: "F"})<-[:LOSER]-(loser), (match)-[:IN_TOURNAMENT]->(tournament) RETURN tournament.year AS year, winner.name AS winner, loser.name AS loser, match.score AS score ORDER BY tournament.year ---- .Results [opts="header"] |=== | year | winner | loser | score | 2000 | "Lindsay Davenport" | "Martina Hingis" | "6-1 7-5" | 2001 | "Jennifer Capriati" | "Martina Hingis" | "6-4 6-3" | 2002 | "Jennifer Capriati" | "Martina Hingis" | "4-6 7-6(7) 6-2" | 2003 | "Serena Williams" | "Venus Williams" | "7-6(4) 3-6 6-4" | 2004 | "Justine Henin" | "Kim Clijsters" | "6-3 4-6 6-3" | 2005 | "Serena Williams" | "Lindsay Davenport" | "2-6 6-3 6-0" | 2006 | "Amelie Mauresmo" | "Justine Henin" | "6-1 2-0 RET" | 2007 | "Serena Williams" | "Maria Sharapova" | "6-1 6-2" | 2008 | "Maria Sharapova" | "Ana Ivanovic" | "7-5 6-3" | 2009 | "Serena Williams" | "Dinara Safina" | "6-0 6-3" | 2010 | "Serena Williams" | "Justine Henin" | "6-4 3-6 6-2" | 2011 | "Kim Clijsters" | "Na Li" | "3-6 6-3 6-3" | 2012 | "Victoria Azarenka" | "Maria Sharapova" | "6-3 6-0" | 2013 | "Victoria Azarenka" | "Na Li" | "4-6 6-4 6-3" | 2014 | "Na Li" | "Dominika Cibulkova" | "7-6(3) 6-0" | 2015 | "Serena Williams" | "Maria Sharapova" | "6-3 7-6(5)" | 2016 | "Angelique Kerber" | "Serena Williams" | "6-4 3-6 6-4" | 2017 | "Serena Williams" | "Venus Williams" | "6-4 6-4" | 2018 | "Caroline Wozniacki" | "Simona Halep" | "7-6(2) 3-6 6-4" | 2019 | "Naomi Osaka" | "Petra Kvitova" | "7-6(2) 5-7 6-4" |=== Same results as before, which I think classifies as a #win!

Learn how to export a subset of data from one Neo4j database to another one

uploads/2020/01/apoc-export-json.png

neo4j-exporting-subset-database

https://markhneedham.com/blog/2020/01/27/neo4j-exporting-subset-database

2020-01-29 00:21:00

A newbie's guide to querying Wikidata

After reading one of Jesús Barrasa's recent QuickGraph posts about https://jbarrasa.com/2019/12/05/quickgraph10-enrich-your-neo4j-knowledge-graph-by-querying-wikidata/[enriching a knowledge graph with data from Wikidata^], I wanted to learn how to query the Wikidata API so that I could pull in the data for my own QuickGraphs. I want to look up information about tennis players, and one of my favourite players is https://en.wikipedia.org/wiki/Nick_Kyrgios[Nick Kyrgios^], so this blog post is going to be all about him. image::{{<siteurl>}}/uploads/2020/01/wiki-logo.png[title="Wikidata"] So what is Wikidata? [quote, Jesús Barrasa, QuickGraph#10 Enrich your Neo4j Knowledge Graph by querying Wikidata] ____ Wikidata is a collaboratively edited knowledge base. It is a source of open data that you may want to use in your projects. Wikidata offers a query service for integrations. ____ The query service can be accessed by navigating to https://query.wikidata.org/[query.wikidata.org] If we go there, we'll see the following screen: image::{{<siteurl>}}/uploads/2020/01/wikidata-newbie.png[title="Wikidata Query Service"] There are a bunch of examples that we can pick from, but we're going to start with something even simpler than that. Wikidata stores data in triples of the form (subject, predicate, object), so we'll start with a query that returns one such triple: [source,sparql] ---- SELECT * WHERE { ?subject ?predicate ?object } LIMIT 1 ---- .Results [opts="header"] |=== |subject|predicate|object |http://wikiba.se/ontology#Dump|http://creativecommons.org/ns#license|http://creativecommons.org/publicdomain/zero/1.0/ |=== Admittedly it's not a very interesting triple, but we're off and running. What we actually want to do is find triples about Nick Kyrgios, so let's update our query to do that: [source,sparql] ---- SELECT * WHERE { ?subject ?predicate "Nick Kyrgios"@en } ---- This query finds any triples in Wikidata that have an object that matches the English language string "Nick Kyrgios". If we run this query, we'll get the following results: .Results [opts="header"] |=== | subject |predicate | https://en.wikipedia.org/wiki/Nick_Kyrgios | http://schema.org/name | http://www.wikidata.org/entity/Q3720084 | http://www.w3.org/2000/01/rdf-schema#label |=== So there are two triples that find Nick. I think we'll filter our query further to keep the one that returns a Wikidata URI, which means that we need to update the predicate in our query to be `rdfs:label`. Let's do that: [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en } ---- .Results [opts="header"] |=== | person | http://www.wikidata.org/entity/Q3720084 |=== We can navigate to that URI to see all the statements about Nick Kyrgios. One piece of information that we'd like to extract is his date of birth: image::{{<siteurl>}}/uploads/2020/01/sparql-query-1.png[title="Nick Kyrgios' date of birth"] We can see from this screenshot that date of birth can be accessed via the property https://www.wikidata.org/wiki/Property:P569[`P569`^]. To do this we'll construct the predicate `wdt:P569`, where: [quote, Wikidata:SPARQL query service/queries, https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries] ____ In line with the SPARQL model of everything as a triple, the wdt: namespace contains manifestations of properties as simple predicates that can directly connect an item to a value. ____ Let's update our query to return date of birth: [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en . ?person wdt:P569 ?dateOfBirth } ---- We can simplify this query by using the `;` syntax to construct multiple statements around `?person`. A more concise version is shown below: [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth } ---- .Results [opts="header"] |=== | person | dateOfBirth | http://www.wikidata.org/entity/Q3720084 | 1995-04-27T00:00:00Z |=== Next we'd like to pull in the country of citizenship, which is property https://www.wikidata.org/wiki/Property:P27[`P27`^]. [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth; wdt:P27 ?country } ---- .Results [opts="header"] |=== | person | dateOfBirth | country | http://www.wikidata.org/entity/Q3720084 | 1995-04-27T00:00:00Z | http://www.wikidata.org/entity/Q408 |=== This query returns the entity representing Australia, but what if we want to return the name of that page rather than the URI? We can return this by using the `rdfs:label` predicate: [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth; wdt:P27 ?country . ?country rdfs:label ?countryName } ---- .Results [opts="header"] |=== | person | dateOfBirth | country |countryName | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Australia | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Awıstralya | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Awstralska | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|अस्ट्रेलिया 4+| ... | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Аѵстралїꙗ | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Австрали | http://www.wikidata.org/entity/Q3720084|1995-04-27T00:00:00Z|http://www.wikidata.org/entity/Q408|Awstralia |=== Wow, that returned a lot more rows than we were expecting! The problem is that we've returned country names in every single language when actually we only want the English version. We can fix that by applying a filter on the language of `countryName`: [source,sparql] ---- SELECT * WHERE { ?person rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth; wdt:P27 ?country . ?country rdfs:label ?countryName filter(lang(?countryName) = "en") } ---- .Results [opts="header"] |=== | person | dateOfBirth | country |countryName | http://www.wikidata.org/entity/Q3720084 |1995-04-27T00:00:00Z | http://www.wikidata.org/entity/Q408 | Australia |=== That's more like it! But we're still returning the URI for Australia when we only want the country name. We can fix that by changing the fields returned in our `SELECT` statement, or we could use the `[]` operator to go from the person to country name in one statement, without needing to bind the `country` variable. The following query does this: [source] ---- SELECT * WHERE { ?person wdt:P106 wd:Q10833314 ; rdfs:label 'Nick Kyrgios'@en ; wdt:P569 ?dateOfBirth ; wdt:P27 [ rdfs:label ?countryName ] . filter(lang(?countryName) = "en") } ---- .Results [opts="header"] |=== | person | dateOfBirth | countryName | http://www.wikidata.org/entity/Q3720084 |1995-04-27T00:00:00Z | Australia |=== That's all the data that we want to extract for now, but if we wanted to get more stuff it wouldn't be too difficult to extend our query. And thanks to https://twitter.com/barrasadv[Jesus^] for his help with understanding the SPARQL syntax enough to get my queries working.

Learn how to query Wikidata's SPARQL API

uploads/2020/01/wiki-logo.png

newbie-guide-querying-wikidata

https://markhneedham.com/blog/2020/01/29/newbie-guide-querying-wikidata

2020-01-29 15:21:00

Neo4j: Finding the longest path

One on my favourite things about storing data in a graph database is executing path based queries against that data. I've been trying to find a way to write such queries against the https://markhneedham.com/blog/2020/01/23/quick-graph-australian-open/[Australian Open QuickGraph^], and in this blog post we're going to write what I think of as longest path queries against this graph. image::{{<siteurl>}}/uploads/2020/01/longest-path.png[title="Finding longest paths in Neo4j"] == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .Dockerfile [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4J_apoc_import_file_use__neo4j__config=true - NEO4J_apoc_import_file_enabled=true - NEO4J_apoc_export_file_enabled=true - NEO4JLABS_PLUGINS=["apoc"] ---- Once we've created that file we need to open a terminal session where that file lives and then run `docker-compose up` to launch Neo4j. == Importing our dataset We're going to learn how to write longest path queries using a dataset that contains the finalists of the Australian Open tennis tournament. [source,cypher] ---- :use system; CREATE DATABASE blog; :use blog ---- .The following query creates tournaments and relationships between them [source,cypher] ---- CALL apoc.load.json("https://github.com/mneedham/australian-open-neo4j/raw/master/blog_data/tournaments.json") YIELD value CALL apoc.merge.node(value.t1.labels, value.t1.properties) YIELD node AS t1 CALL apoc.merge.node(value.t2.labels, value.t2.properties) YIELD node AS t2 CALL apoc.merge.relationship(t1, value.rel.label, {}, {}, t2, {}) YIELD rel RETURN count(*); ---- .The following query creates matches and players and associated relationships [source,cypher] ---- CALL apoc.load.json("https://github.com/mneedham/australian-open-neo4j/raw/master/blog_data/finalists.json") YIELD value CALL apoc.merge.node(value.winner.labels, value.winner.properties) YIELD node AS winner CALL apoc.merge.node(value.loser.labels, value.loser.properties) YIELD node AS loser CALL apoc.merge.node(value.match.labels, value.match.properties) YIELD node AS match CALL apoc.merge.node(value.t.labels, value.t.properties) YIELD node AS tournament CALL apoc.merge.relationship(winner, value.winnerRel.label, {}, {}, match, {}) YIELD rel AS winnerRel CALL apoc.merge.relationship(loser, value.loserRel.label, {}, {}, match, {}) YIELD rel AS loserRel CALL apoc.merge.relationship(match, value.tournRel.label, {}, {}, tournament, {}) YIELD rel AS tournRel return count(*); ---- We can see the imported graph in the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/01/aus-open-finalists.png[title="Australian Open Womens Finalists"] == Finding longest paths Let's start with a https://neo4j.com/docs/cypher-manual/current/syntax/patterns/#cypher-pattern-varlength[variable length path query^] that starts with the `Tournament` in the year 2000 and follows the `NEXT_TOURNAMENT` relationship as many times as possible by using the `*` syntax after the relationship type: [source,cypher] ---- MATCH path = (:Tournament {year: 2000})-[:NEXT_TOURNAMENT*]->(next) RETURN [t in nodes(path) | t.year] AS allTournaments ---- If we run this query, we'll see the following output: .Results [opts="header"] |=== | allTournaments | [2000, 2001] | [2000, 2001, 2002] | [2000, 2001, 2002, 2003] | [2000, 2001, 2002, 2003, 2004] | [2000, 2001, 2002, 2003, 2004, 2005] | [2000, 2001, 2002, 2003, 2004, 2005, 2006] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018] | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019] |=== As we can see from the results, we've returned all the intermediate paths between the tournament in the year 2000 and the one in the year 2019. But what if we only want to return the longest path? i.e the last one in the above results table. We can tweak our query to do this by adding a `WHERE` clause that filters out any paths where the last node in that path has a `NEXT_TOURNAMENT` relationship. The following query does this: [source,cypher] ---- MATCH path = (:Tournament {year: 2000})-[:NEXT_TOURNAMENT*]->(next) WHERE not((next)-[:NEXT_TOURNAMENT]->()) RETURN [t in nodes(path) | t.year] AS allTournaments ---- And if we run that query, we only get one row back, as expected: .Results [opts="header"] |=== | allTournaments | [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019] |=== Now let's see how we can use this technique for a more complex query. We want to find which players have lost multiple finals in a row. So we need to find all the `Match` nodes that have `round "F"` where the `Player` has a `LOSER` relationship to that match. And we then want to see if that same player had a `LOSER` relationship to the final match in tournaments in the following years. The following query is our first attempt to do this: [source,cypher] ---- // Find losing finalists in a tournament and a path of all the tournaments // after that tournament MATCH path = (t:Tournament)-[:NEXT_TOURNAMENT*]->(t2:Tournament), (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player) // Check that the player lost the final in every subsequent tournament WITH nodes(path) AS tournaments, player WHERE all(t in tournaments[1..] WHERE (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player) ) RETURN player.name, [t IN tournaments | t.year] AS years ---- If we run this query, we'll see the following results: .Results [opts="header"] |=== | player.name | years | "Martina Hingis" | [2000, 2001] | "Martina Hingis" | [2000, 2001, 2002] | "Martina Hingis" | [2001, 2002] |=== Poor Martina Hingis! But despite telling us all the finals that Martina lost, we're still returning some rows that we want to exclude. Ideally we only want to return the longest path, which contains `[2000,2001,2002]`. We need to update our query to filter out any paths where the losing finalist didn't lose the final the year before [source,cypher] ---- // Find losing finalists in a tournament and a path of all the tournaments // after that tournament MATCH path = (t:Tournament)-[:NEXT_TOURNAMENT*]->(t2:Tournament), (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player) // Get the first and last tournaments in the list WITH nodes(path) AS tournaments, player WITH tournaments, tournaments[0] AS first, tournaments[-1] AS last, player // Get the tournament that happened immediately before the first one in the list and // the tournament that happened immediately after the last one in the list WITH tournaments, player, [(last)-[:NEXT_TOURNAMENT]->(next) | next][0] AS next, [(previous)-[:NEXT_TOURNAMENT]->(first) | previous][0] AS previous // Check that the player lost the final in every subsequent tournament and // that the player lost the final in the tournament immediately before and // that the player lost the final in the tournament immediately after WHERE all(t in tournaments[1..] WHERE (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player) AND not((next)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player)) AND not((previous)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[:LOSER]-(player)) ) RETURN player.name, [t IN tournaments | t.year] AS years; ---- If we run this query, we'll see the following results: .Results [opts="header"] |=== | player.name | years | "Martina Hingis" | [2000, 2001, 2002] |=== Perfect, that's exactly what we want the results to look like! We can now extend this query to find the players who reached consecutive finals: [source,cypher] ---- // Find finalists in a tournament and a path of all the tournaments // after that tournament MATCH path = (t:Tournament)-[:NEXT_TOURNAMENT*]->(t2:Tournament), (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<--(player) // Get the first and last tournaments in the list WITH nodes(path) AS tournaments, player WITH tournaments, tournaments[0] AS first, tournaments[-1] AS last, player // Get the tournament that happened immediately before the first one in the list and // the tournament that happened immediately after the last one in the list WITH tournaments, player, [(last)-[:NEXT_TOURNAMENT]->(next) | next][0] AS next, [(previous)-[:NEXT_TOURNAMENT]->(first) | previous][0] AS previous // Check that the player reached the final in every subsequent tournament and // that the player reached the final in the tournament immediately before and // that the player reached the final in the tournament immediately after WHERE all(t in tournaments[1..] WHERE (t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<--(player) AND not((next)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<--(player)) AND not((previous)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<--(player)) ) RETURN player.name, // Create a list containing the year of the final and the relationship type from the // player to the final match in that tournament apoc.coll.flatten( [t IN tournaments | [(t)<-[:IN_TOURNAMENT]-(:Match {round: "F"})<-[type]-(player) | [t.year, type(type)]][0]] ) AS years ORDER BY years[0] ---- If we run that query, we'll see the following results: .Results [opts="header"] |=== | player.name | years | "Martina Hingis" | [2000, "LOSER", 2001, "LOSER", 2002, "LOSER"] | "Jennifer Capriati" | [2001, "WINNER", 2002, "WINNER"] | "Maria Sharapova" | [2007, "LOSER", 2008, "WINNER"] | "Serena Williams" | [2009, "WINNER", 2010, "WINNER"] | "Victoria Azarenka" | [2012, "WINNER", 2013, "WINNER"] | "Na Li" | [2013, "LOSER", 2014, "WINNER"] | "Serena Williams" | [2015, "WINNER", 2016, "LOSER", 2017, "WINNER"] |=== There are a lot more players who reached multiple finals, but noone won more than 2 finals in a row. I was expecting to see more dominance by a single player! It would be interesting to run a similar query that looked at the finalists of all Grand Slam tournaments and not sure just consecutive Australian Opens. Perhaps that can be the topic of another blog post.

Learn how to write a Cypher query to find the longest path in a graph.

uploads/2020/01/longest-path.png

neo4j-finding-longest-path

https://markhneedham.com/blog/2020/01/29/neo4j-finding-longest-path

2020-01-16 00:21:00

Creating an Interactive UK Official Charts Data App with Streamlit and Neo4j

I recently came across https://www.streamlit.io/[Streamlit^], a tool that makes it easy to https://towardsdatascience.com/coding-ml-tools-like-you-code-ml-models-ddba3357eace[build data based single page web applications^]. I wanted to give it a try, and the https://markhneedham.com/blog/2020/01/04/quick-graph-uk-official-charts/[UK Charts QuickGraph^] that I recently wrote about seemed like a good opportunity for that. This blog post starts from where we left off. The data is loaded into Neo4j and we've written some queries to explore different aspects of the dataset. Let's see what we can do if we integrate Neo4j and Streamlit. image::{{<siteurl>}}/uploads/2020/01/streamlit-neo4j-banner.png[title="Streamlit and Neo4j. Background from https://www.freepik.com/free-photo/3d-network-background-with-connecting-lines-dots_3961382.htm"] == Setting up our environment The first thing we need to do is setup our environment. Streamlit is a Python library, so we'll be using it alongside the https://neo4j.com/docs/api/python-driver/current/[Neo4j Python driver^], as well as some other dependencies. I like to use https://github.com/pypa/pipenv[Pipenv^] for my Python projects. Our _Pipfile_ is defined below: .Pipfile [source,text] ---- [[source]] name = "pypi" url = "https://pypi.org/simple" verify_ssl = true [dev-packages] [packages] streamlit = "*" neo4j = "*" vega-datasets = "*" selenium = "*" vegascope = "*" [requires] python_version = "3.7" ---- If we create that file in a directory, we can install all our dependencies by running the following command: [source,bash] ---- pipenv install ---- If we run that command, we'll see the following output: [source,bash] ---- Pipfile.lock not found, creating… Locking [dev-packages] dependencies… Locking [packages] dependencies… ✔ Success! Updated Pipfile.lock (0882a9)! Installing dependencies from Pipfile.lock (0882a9)… 🐍 ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 84/84 — 00:00:11 To activate this project's virtualenv, run pipenv shell. Alternatively, run a command inside the virtualenv with pipenv run. ---- We'll follow those instructions, and now we're ready to build our Streamlit application. == Streamlit Application We're going to create our Streamlit application in a file called `visualise.py`. Let's import the libraries that we're going to be using: .visualise.py [source,python] ---- import streamlit as st from neo4j import GraphDatabase import pandas as pd import altair as alt import datetime from PIL import Image ---- We'll also instantiate our Neo4j Driver and give our Streamlit application a title and an image to make it look a bit prettier: .visualise.py [source,python] ---- driver = GraphDatabase.driver("bolt://localhost", auth=("neo4j", "neo")) st.title("UK Charts 2019") st.write("In this Streamlit application we're going to explore data from the UK Official Singles Chart.") st.image(Image.open("images/uk-charts.png")) ---- We can now launch our application by running the following command from the terminal: [source,bash] ---- streamlit run visualise.py ---- When we run this command, we'll see the following output: [source,bash] ---- You can now view your Streamlit app in your browser. Local URL: http://localhost:8501 Network URL: http://192.168.86.25:8501 ---- If we navigate to the Local URL, we'll see a page that looks like this: image::{{<siteurl>}}/uploads/2020/01/streamlit-header.png[title="Our first Streamlit Application"] So far so good! Let's add some more content to the page based on the queries that we ran in the QuickGraph blog post. == Which song was number 1 for the most weeks? The first thing we did in our previous post was work out which song was number 1 for the most weeks. We'll start by returning all the numbers 1 songs in 2019. The following code sample uses the Neo4j Python driver to execute a Cypher query that finds all the number 1 songs, puts them in a DataFrame, and then displays that DataFrame: [source,python] ---- with driver.session() as session: st.subheader("Number 1s") st.write("The chart below shows the number 1 charting songs of 2019.") result = session.run(""" MATCH (chart:Chart)<-[inChart:IN_CHART {position: 1}]-(song)-[:ARTIST]->(artist) WITH chart, song, collect(artist.name) AS artists RETURN toString(chart.end) AS date, song.title AS song, artists ORDER BY chart.end """) df = pd.DataFrame(result.data()) st.dataframe(df.style.hide_index()) ---- If we refresh the page in our web browser, we'll see the following output: image::{{<siteurl>}}/uploads/2020/01/streamlit-number1s.png[title="A DataFrame displaying Number 1 songs"] We want to know which song was number 1 for the most weeks, and a bar chart seems like a good way of displaying this data. Let's create one: [source,python] ---- result = session.run(""" MATCH (song:Song)-[inChart:IN_CHART {position: 1}]->(chart) RETURN song.title AS song, count(*) AS count ORDER By count DESC; """) df = pd.DataFrame(result.data()) c = alt.Chart(df, width=500, height=400).mark_bar(clip=True).encode(x='song', y='count') st.altair_chart(c) ---- image::{{<siteurl>}}/uploads/2020/01/streamlit-number1s-count.png[title="An Altair chart showing the Number 1 songs"] == Which song was number 1 on a specific date? As well as returning the results of a hard coded query like this, we can also execute dynamic queries based on user input. The `date_input` component gives us a calendar from which the user can select a date that we use in a query. The code below runs a query that returns the chart for a given date: [source,python] ---- st.subheader("Top songs by week") date = st.date_input("Search by date", datetime.date(2019, 12, 12)) result = session.run(""" MATCH (chart:Chart)<-[inChart:IN_CHART]-(song) WHERE chart.start <= $date <= chart.end RETURN inChart.position AS position, song.title AS song, [(song)-[:ARTIST]->(artist) | artist.name] AS artists ORDER BY position """, {"date": date}) df = pd.DataFrame(result.data()) st.dataframe(df.style.hide_index()) ---- Let's have a look which songs were at the top of the chart in June 2019: image::{{<siteurl>}}/uploads/2020/01/streamlit-chart-by-date.png[title="The top of the chart on 12th June 2019"] == How did a song chart over the year? In the QuickGraph blog post we wrote a query to find out which number 1 songs didn't go straight in at number 1. One of my favourite songs, Dance Monkey, took 8 weeks from its first appearance in the chart until it got to the top. We can use Streamlit to create a DataFrame and scatterplot showing how a song charted over the year: [source,python] ---- st.subheader("Songs charting over time") name = st.text_input('Search by song title', 'All I Want For Christmas') if name: result = session.run(""" MATCH (chart:Chart)<-[inChart:IN_CHART]-(song)-[:ARTIST]->(artist) WHERE song.title contains $songTitle WITH song, inChart, chart, collect(artist.name) AS artists RETURN song.title AS song, artists, inChart.position AS position, chart.end AS date ORDER BY chart.end """, {"songTitle": name}) df = pd.DataFrame(result.data()) st.dataframe(df.style.hide_index()) if df.shape[0] > 0: c = alt.Chart(df, title=f"Chart positions for {name}", width=500, height=300).mark_point().encode( x=alt.X('date:T', timeUnit='yearmonthdate', scale=alt.Scale(domain=list(domain_pd))), y=alt.Y('position', sort="descending") ) st.altair_chart(c) ---- And let's see how Dance Monkey fared: image::{{<siteurl>}}/uploads/2020/01/streamlit-dance-monkey.png[title="Dance Monkey's chart positions over the year"] We can see from this chart that the song had a very gradual climb to the top. I'd always assumed that songs achieved their top position when they were first released, but this is an interesting counter example. That's all for this blog post, but I'm looking forward to combining Streamlit and Neo4j on future datasets.

Learn how to use Streamlit and Neo4j to create an interactive data app of the UK Official Charts Graph.

uploads/2020/01/streamlit-neo4j-banner.png

interactive-uk-charts-quickgraph-neo4j-streamlit

https://markhneedham.com/blog/2020/01/16/interactive-uk-charts-quickgraph-neo4j-streamlit

2020-01-28 00:21:00

Neo4j: Performing a database dump within a Docker container

Before the release of https://neo4j.com/release-notes/neo4j-4-0-0/[Neo4j 4.0^], https://serverfault.com/questions/835092/how-do-you-perform-a-dump-of-a-neo4j-database-within-a-docker-container[taking a dump of a database running within a Docker container^] was a tricky affair. We'd need to stop the container and remove it, run the container again in bash mode, and finally take a dump of the database. With 4.0 things are simpler. image::{{<siteurl>}}/uploads/2020/01/neo4j-docker.png[title="Neo4j on Docker"] We'll be using the following Docker Compose configuration in this blog post: .Dockerfile [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/var/lib/neo4j/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" ---- Once we’ve created that file we need to open a terminal session where that file lives and then run `docker-compose up` to spin up Neo4j. When that's finished running, we can then run the following command to check on the status of our container: [source,bash] ---- $ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 77b91b30aa88 neo4j:4.0.0-enterprise "/sbin/tini -g -- /d…" 8 seconds ago Up 6 seconds 0.0.0.0:7474->7474/tcp, 7473/tcp, 0.0.0.0:7687->7687/tcp quickgraph-aus-open ---- Let's check which databases our Neo4j instance contains by running the https://neo4j.com/docs/operations-manual/current/manage-databases/queries/#manage-databases-queries-stop-database[`SHOW DATABASES`^] command: [source,bash] ---- $ docker exec -it quickgraph-aus-open cypher-shell -u neo4j -p neo -d system "SHOW DATABASES;" ---- .SHOW DATABASES [opts="header"] |=== | name | address | role | requestedStatus | currentStatus | error | default | "neo4j" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | TRUE | "system" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | FALSE | "womens" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | FALSE |=== We're going to take a dump of the `womens` database using the https://neo4j.com/docs/operations-manual/current/tools/dump-load/[Neo4j Admin dump command^]. We can call that command by running the following: [source, bash] ---- $ docker exec -it quickgraph-aus-open neo4j-admin dump --database=womens --to=/tmp/womens-aus-open.dump The database is in use. Stop database 'womens' and try again. ---- Let's stop that database using the https://neo4j.com/docs/operations-manual/current/manage-databases/queries/#manage-databases-queries-stop-database[`STOP DATABASE`^] command: [source,bash] ---- $ docker exec -it quickgraph-aus-open cypher-shell -u neo4j -p neo -d system "STOP DATABASE womens;" 0 rows available after 268 ms, consumed after another 0 ms ---- And now let's re-run the dump command: [source, bash] ---- $ docker exec -it quickgraph-aus-open neo4j-admin dump --database=womens --to=/tmp/womens-aus-open.dump Done: 75 files, 252.9MiB processed. ---- The dump file is written to the Docker container, so now we need to https://stackoverflow.com/questions/22049212/copying-files-from-docker-container-to-host[copy that file onto the host^]: [source, bash] ---- docker cp quickgraph-aus-open:/tmp/womens-aus-open.dump . ---- And finally let's start our database back up again: [source,bash] ---- $ docker exec -it quickgraph-aus-open cypher-shell -u neo4j -p neo -d system "START DATABASE womens;" 0 rows available after 238 ms, consumed after another 0 ms ---- And we're done!

Learn how to take a dump of a Neo4j database that's running within a Docker container.

uploads/2020/01/neo4j-docker.png

neo4j-database-dump-docker-container

https://markhneedham.com/blog/2020/01/28/neo4j-database-dump-docker-container

2020-01-10 00:21:00

Python: Altair - TypeError: Object of type date is not JSON serializable

I've been playing with the https://altair-viz.github.io/index.html[Altair statistical visualisation library^] and recently ran into an error while trying to render a DataFrame that contained dates. I was trying to render a scatterplot containing the chart position of a song on a certain date, as seen in the code below: [source,python] ---- # pip install altair pandas import altair as alt import pandas as pd import datetime df = pd.DataFrame( [ {"position": 2, "date": datetime.date(2019,1,3)}, {"position": 77, "date": datetime.date(2019,11,21)}, {"position": 59, "date": datetime.date(2019,11,28)}, {"position": 34, "date": datetime.date(2019,12,5)}, {"position": 8, "date": datetime.date(2019,12,12)}, {"position": 6, "date": datetime.date(2019,12,19)}, {"position": 8, "date": datetime.date(2019,12,26)}, ]) chart = alt.Chart(df).mark_point(color="red").encode(x='date', y='position') chart.save("chart.html") ---- If we run this script, we'll see the following error message: [source,cypher] ---- Traceback (most recent call last): File "scripts/blog.py", line 22, in <module> chart.save("chart.html") File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/vegalite/v4/api.py", line 447, in save result = save(**kwds) File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/utils/save.py", line 68, in save spec = chart.to_dict() File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/vegalite/v4/api.py", line 355, in to_dict copy.data = _prepare_data(original_data, context) File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/vegalite/v4/api.py", line 92, in _prepare_data data = _consolidate_data(data, context) File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/vegalite/v4/api.py", line 59, in _consolidate_data name = _dataset_name(values) File "/home/markhneedham/.local/share/virtualenvs/uk-charts-gqTVV0T1/lib/python3.7/site-packages/altair/vegalite/v4/api.py", line 35, in _dataset_name values_json = json.dumps(values, sort_keys=True) File "/home/markhneedham/anaconda3/lib/python3.7/json/__init__.py", line 238, in dumps **kw).encode(obj) File "/home/markhneedham/anaconda3/lib/python3.7/json/encoder.py", line 199, in encode chunks = self.iterencode(o, _one_shot=True) File "/home/markhneedham/anaconda3/lib/python3.7/json/encoder.py", line 257, in iterencode return _iterencode(o, 0) File "/home/markhneedham/anaconda3/lib/python3.7/json/encoder.py", line 179, in default raise TypeError(f'Object of type {o.__class__.__name__} ' TypeError: Object of type date is not JSON serializable ---- On a GitHub issue for a similar problem, Jake Vanderplas suggested that the issue might be that the column type was object. We can check this by calling the following function on our DataFrame: [source,python] ---- print(df.dtypes) ---- We can see the output of executing this function below: [source,text] ---- position int64 date object dtype: object ---- As Jake predicted, our `date` column has the type `object`, despite only containing dates. We can fix that by coercing that column to the type `datetime` using the https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html[`pd.to_datetime` function^]: [source, python] ---- df["date"] = pd.to_datetime(df["date"]) ---- If we output the types of our DataFrame now, we'll see the following output: [source,text] ---- position int64 date datetime64[ns] dtype: object ---- We now have the following script: [source,python] ---- df = pd.DataFrame( [ {"position": 2, "date": datetime.date(2019,1,3)}, {"position": 77, "date": datetime.date(2019,11,21)}, {"position": 59, "date": datetime.date(2019,11,28)}, {"position": 34, "date": datetime.date(2019,12,5)}, {"position": 8, "date": datetime.date(2019,12,12)}, {"position": 6, "date": datetime.date(2019,12,19)}, {"position": 8, "date": datetime.date(2019,12,26)}, ]) df["date"] = pd.to_datetime(df["date"]) chart = alt.Chart(df).mark_point(color="red").encode( x='date', y='position') print(df.dtypes) chart.save("chart.html") ---- And if we run that script, we'll have the following chart in the file `chart.html`: image::{{<siteurl>}}/uploads/2020/01/altair-chart.png[title="Chart showing chart positions"]

Learn how to solve the TypeError: Object of type date is not JSON serializable error when rendering Altair charts.

uploads/2020/01/altair-chart.png

altair-typeerror-object-type-date-not-json-serializable

https://markhneedham.com/blog/2020/01/10/altair-typeerror-object-type-date-not-json-serializable

2020-01-23 00:21:00

QuickGraph #5: Australian Open

It's time for another QuickGraph, this one based on data from the Australian Open tennis tournament. We're going to use data curated by Jeff Sackmann in the https://github.com/JeffSackmann/tennis_wta/[tennis_wta^] and https://github.com/JeffSackmann/tennis_atp/[tennis_atp^] repositories. image::{{<siteurl>}}/uploads/2020/01/aus-open-banner.png[title="Australian Open Graph (Background from https://www.freepik.com/free-photo/3d-network-background-with-connecting-lines-dots_3961382.htm)"] == Setting up Neo4j We're going to use the following Docker Compose configuration in this blog post: .docker-compose.yml [source,yaml] ---- version: '3.7' services: neo4j: image: neo4j:4.0.0-enterprise container_name: "quickgraph-aus-open" volumes: - ./plugins:/plugins - ./data:/data - ./import:/import ports: - "7474:7474" - "7687:7687" environment: - "NEO4J_ACCEPT_LICENSE_AGREEMENT=yes" - "NEO4J_AUTH=neo4j/neo" - NEO4J_apoc_import_file_use__neo4j__config=true - NEO4J_apoc_import_file_enabled=true - NEO4JLABS_PLUGINS=["apoc"] ---- We'll then run the following command to spin up Neo4j: [source,bash] ---- docker-compose up ---- If we run that command, we'll see the following output: [source,text] ---- Started quickgraph-aus-open ... done Attaching to quickgraph-aus-open quickgraph-aus-open | Changed password for user 'neo4j'. quickgraph-aus-open | Fetching versions.json for Plugin 'apoc' from https://neo4j-contrib.github.io/neo4j-apoc-procedures/versions.json quickgraph-aus-open | Installing Plugin 'apoc' from https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.0.0.0/apoc-4.0.0.0-all.jar to /plugins/apoc.jar quickgraph-aus-open | Applying default values for plugin apoc to neo4j.conf quickgraph-aus-open | Directories in use: quickgraph-aus-open | home: /var/lib/neo4j quickgraph-aus-open | config: /var/lib/neo4j/conf quickgraph-aus-open | logs: /logs quickgraph-aus-open | plugins: /plugins quickgraph-aus-open | import: /import quickgraph-aus-open | data: /var/lib/neo4j/data quickgraph-aus-open | certificates: /var/lib/neo4j/certificates quickgraph-aus-open | run: /var/lib/neo4j/run quickgraph-aus-open | Starting Neo4j. quickgraph-aus-open | 2020-01-21 22:24:29.976+0000 INFO ======== Neo4j 4.0.0 ======== quickgraph-aus-open | 2020-01-21 22:24:29.982+0000 INFO Starting... quickgraph-aus-open | 2020-01-21 22:24:35.656+0000 INFO Called db.clearQueryCaches(): Query cache already empty. quickgraph-aus-open | 2020-01-21 22:24:35.656+0000 INFO Called db.clearQueryCaches(): Query cache already empty. quickgraph-aus-open | 2020-01-21 22:24:35.656+0000 INFO Called db.clearQueryCaches(): Query cache already empty. quickgraph-aus-open | 2020-01-21 22:24:40.765+0000 INFO Sending metrics to CSV file at /var/lib/neo4j/metrics quickgraph-aus-open | 2020-01-21 22:24:40.790+0000 INFO Bolt enabled on 0.0.0.0:7687. quickgraph-aus-open | 2020-01-21 22:24:40.791+0000 INFO Started. quickgraph-aus-open | 2020-01-21 22:24:40.879+0000 INFO Server thread metrics have been registered successfully quickgraph-aus-open | 2020-01-21 22:24:41.723+0000 INFO Remote interface available at http://0.0.0.0:7474/ ---- Once we see that last line we're ready to roll. == Exploring the data Jeff's repositories includes CSV files containing all the matches on the Women's WTA tour and Men's ATP tour. We won't be interested in most of the data in these files, but let's have a look at the 2019 version. We'll use the https://neo4j.com/docs/cypher-manual/current/clauses/load-csv/[`LOAD CSV`^] command to do this: [source,cypher] ---- LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeffSackmann/tennis_wta/master/wta_matches_2019.csv' AS row RETURN row LIMIT 1; ---- .Exploring the data [opts="header"] |=== | row a| [source,json] ---- { "l_1stWon": null, "loser_ioc": "USA", "w_ace": null, "loser_age": "32.2737850787", "l_df": null, "winner_id": "211901", "winner_hand": "R", "score": "6-3 6-3", "l_bpFaced": null, "winner_rank_points": "350", "match_num": "001", "winner_seed": null, "best_of": "3", "loser_name": "Jennifer Elie", "w_bpFaced": null, "winner_ht": null, "l_1stIn": null, "tourney_level": "S", "draw_size": "32", "surface": "Hard", "l_svpt": null, "minutes": null, "tourney_date": "20181231", "l_ace": null, "loser_rank": "450", "l_SvGms": null, "l_2ndWon": null, "w_1stIn": null, "loser_id": "202495", "winner_rank": "168", "winner_ioc": "MDA", "winner_age": "21.1498973306", "tourney_id": "2019-W-ITF-AUS-01A-2019", "tourney_name": "W25 Playford", "loser_rank_points": "59", "loser_ht": null, "winner_entry": null, "winner_name": "Aliona Bolsova", "w_SvGms": null, "loser_hand": "R", "l_bpSaved": null, "w_svpt": null, "loser_seed": null, "w_1stWon": null, "w_bpSaved": null, "round": "R32", "w_df": null, "w_2ndWon": null, "loser_entry": "Q" } ---- |=== We've got lots of information to work with here. We'll filter the data using the `tourney_name` so that we only have matches from the Australian Open. `winner_id` and `loser_id` will act as the primary keys for our players and we can combine `match_num` and `tourney_date` as the primary key for matches. `winner_name` and `loser_name` give us the human readable version of the players and the `score` property tells us the result of the match. == Configuring our databases We're going to create one database for the men's matches and one for the women's matches, with a bit of help from https://neo4j.com/release-notes/neo4j-4-0-0/[Neo4j 4.0^]'s https://neo4j.com/developer/manage-multiple-databases/[multi database feature^]. [source,cypher] ---- :use system ---- image::{{<siteurl>}}/uploads/2020/01/aus-open-neo4j-4-use-system.png[title="Neo4j 4.0: System Database"] We can then run the following commands to create our databases: [source,cypher] ---- CREATE DATABASE womens; CREATE DATABASE mens; ---- Once we've done that, let's return a list of our databases: [source,cypher] ---- SHOW DATABASES; ---- .SHOW DATABASES [opts="header"] |=== | name | address | role | requestedStatus | currentStatus | error | default | "neo4j" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | TRUE | "system" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | FALSE | "womens" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | FALSE | "mens" | "0.0.0.0:7687" | "standalone" | "online" | "online" | "" | FALSE |=== Everything's looking good, we're ready to start importing the data! Before we do that let's change from the `system` database to the `womens` database, using the following command: [source,cypher] ---- :use womens ---- == Importing the data We're going to import the data into the following graph model: image::{{<siteurl>}}/uploads/2020/01/aus-open-graph-model.png[title="Our Graph Model"] Now let's set up https://neo4j.com/docs/cypher-manual/current/administration/constraints/[constraints^] for our graph. We're going to create: * a unique node property constraint on the `Player` label, `id` property and `Match` label, `id` property. * a node key constraint on the `Tournament` label `name` and `year` properties Those constraints will ensure that we don't accidentally create duplicate nodes when we import our data. When we create a constraint we also get an index on the label and properties, which will help reduce our import time. Let's run the following statements: [source, cypher] ---- CREATE CONSTRAINT ON (p:Player) ASSERT p.id IS UNIQUE; CREATE CONSTRAINT ON (m:Match) ASSERT m.id IS UNIQUE; CREATE CONSTRAINT ON (t:Tournament) ASSERT (t.name, t.year) IS NODE KEY; ---- And now we'll import the data for the 2019 tournament: [source,cypher] ---- // Only keep Australian open matches LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeffSackmann/tennis_wta/master/wta_matches_2019.csv' AS row WITH row, split(row.score, ' ') AS rawSets WHERE row.tourney_name = 'Australian Open' WITH row, row.tourney_date + '_' + row.match_num AS matchId // Create nodes for Tournaments, Matches, and Players MERGE (t:Tournament {name: row.tourney_name, year: date(row.tourney_date).year}) MERGE (m:Match {id: matchId}) SET m.round = row.round, m.score = row.score MERGE (p1:Player {id: row.winner_id}) SET p1.name = row.winner_name MERGE (p2:Player {id: row.loser_id}) SET p2.name = row.loser_name // Create relationships between nodes MERGE (p1)-[:WINNER]->(m) MERGE (p2)-[:LOSER]->(m) MERGE (m)-[:IN_TOURNAMENT]->(t) ---- .Results |=== a| 0 rows available after 1218 ms, consumed after another 0 ms Added 256 nodes, Created 381 relationships, Set 765 properties, Added 256 labels |=== We can see a sample of the imported graph in the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/01/aus-open-preview.png[title="Sample of the Australian Open Graph"] Let's now load in the data for some of the other years. Jeff Sackmann has curated data going back to 1968, but we'll only load data from the year 2000 onwards. We could import all the tournaments in one transaction, but our import will be much quicker if we use the `apoc.periodic.iterate` procedure from https://neo4j.com/docs/labs/apoc/3.5/[APOC^], Neo4j's standard library. [source,cypher] ---- CALL apoc.periodic.iterate( "UNWIND range(2000, 2019) AS year RETURN year", "WITH 'https://raw.githubusercontent.com/JeffSackmann/tennis_wta/master/wta_matches_' AS base, year LOAD CSV WITH HEADERS FROM base + year + '.csv' AS row WITH row, split(row.score, ' ') AS rawSets WHERE row.tourney_name = 'Australian Open' WITH row, row.tourney_date + '_' + row.match_num AS matchId MERGE (t:Tournament {name: row.tourney_name, year: date(row.tourney_date).year}) MERGE (m:Match {id: matchId}) SET m.round = row.round, m.score = row.score MERGE (p1:Player {id: row.winner_id}) SET p1.name = row.winner_name MERGE (p2:Player {id: row.loser_id}) SET p2.name = row.loser_name MERGE (p1)-[:WINNER]->(m) MERGE (p2)-[:LOSER]->(m) MERGE (m)-[:IN_TOURNAMENT]->(t) ", {}) ---- .Results [opts="header"] |=== | batches | total | timeTaken | committedOperations | failedOperations | failedBatches | retries | errorMessages | batch | operations | wasTerminated | failedParams | 1 | 20 | 13 | 20 | 0 | 0 | 0 | {} | {total: 1, committed: 1, failed: 0, errors: {}} | {total: 20, committed: 20, failed: 0, errors: {}} | FALSE | {} |=== One interesting thing about this dataset is that it has implicit relationships between tournaments and between matches. For example, the 2019 tournament is the `NEXT_TOURNAMENT` after the 2018 tournament and if a player wins their 1st round match, there could be a `NEXT_MATCH` relationship to their 2nd round match. I think having these explicit relationships will enable some cool path based queries. We'll need to write a query that collects these nodes in order and uses the https://neo4j.com/docs/labs/apoc/current/graph-updates/data-creation/#linked-lists[`apoc.nodes.link`^] procedure to create the new relationships. The following Cypher statements create the relationships: [source, cypher] ---- // Store the rounds in a list that will be used to sort matches :params rounds: ["R128", "R64", "R32", "R16", "QF", "SF", "F"]; // Build a map from that list WITH apoc.map.fromLists( $rounds, range(0, size($rounds)-1)) AS rounds // Collect matches grouped by player and tournament, ordered by round MATCH (t:Tournament)<-[:IN_TOURNAMENT]-(m:Match)<--(player) WITH player, m, t ORDER BY player, rounds[m.round] WITH player, t, collect(m) AS matches WHERE size(matches) > 1 // Add NEXT_MATCH relationship between adjacent matches CALL apoc.nodes.link(matches, "NEXT_MATCH") RETURN count(*); // Collect tournaments ordered by year MATCH (t:Tournament) WITH t ORDER BY t.year WITH collect(t) AS tournaments // Add NEXT_TOURNAMENT between adjacent matches CALL apoc.nodes.link(tournaments, "NEXT_TOURNAMENT") RETURN count(*); ---- image::{{<siteurl>}}/uploads/2020/01/aus-open-linked-lists.png[title="Linked Lists in the Australian Open Graph"] The full import script for the women's tournament is available in the https://github.com/mneedham/australian-open-neo4j/blob/master/scripts/import_womens.cypher[import_womens.cypher^] file. And there is an equivalent import script for the men's tournament in the https://github.com/mneedham/australian-open-neo4j/blob/master/scripts/import_mens.cypher[import_mens.cypher^] file. == Querying the graph Alright, it's time to start writing some queries! == Who won each of the tournaments? Let's start with a simple query to find out the finalists in each tournament and the result of the final match: [source,cypher] ---- MATCH (winner:Player)-[:WINNER]->(match:Match {round: "F"})<-[:LOSER]-(loser), (match)-[:IN_TOURNAMENT]->(tournament) RETURN tournament.year AS year, winner.name AS winner, loser.name AS loser, match.score AS score ORDER BY tournament.year ---- .Who won each of the tournaments? [opts="header"] |=== | year | winner | loser | score | 2000 | "Lindsay Davenport" | "Martina Hingis" | "6-1 7-5" | 2001 | "Jennifer Capriati" | "Martina Hingis" | "6-4 6-3" | 2002 | "Jennifer Capriati" | "Martina Hingis" | "4-6 7-6(7) 6-2" | 2003 | "Serena Williams" | "Venus Williams" | "7-6(4) 3-6 6-4" | 2004 | "Justine Henin" | "Kim Clijsters" | "6-3 4-6 6-3" | 2005 | "Serena Williams" | "Lindsay Davenport" | "2-6 6-3 6-0" | 2006 | "Amelie Mauresmo" | "Justine Henin" | "6-1 2-0 RET" | 2007 | "Serena Williams" | "Maria Sharapova" | "6-1 6-2" | 2008 | "Maria Sharapova" | "Ana Ivanovic" | "7-5 6-3" | 2009 | "Serena Williams" | "Dinara Safina" | "6-0 6-3" | 2010 | "Serena Williams" | "Justine Henin" | "6-4 3-6 6-2" | 2011 | "Kim Clijsters" | "Na Li" | "3-6 6-3 6-3" | 2012 | "Victoria Azarenka" | "Maria Sharapova" | "6-3 6-0" | 2013 | "Victoria Azarenka" | "Na Li" | "4-6 6-4 6-3" | 2014 | "Na Li" | "Dominika Cibulkova" | "7-6(3) 6-0" | 2015 | "Serena Williams" | "Maria Sharapova" | "6-3 7-6(5)" | 2016 | "Angelique Kerber" | "Serena Williams" | "6-4 3-6 6-4" | 2017 | "Serena Williams" | "Venus Williams" | "6-4 6-4" | 2018 | "Caroline Wozniacki" | "Simona Halep" | "7-6(2) 3-6 6-4" | 2019 | "Naomi Osaka" | "Petra Kvitova" | "7-6(2) 5-7 6-4" |=== We've got lots of different winners here and a few players who have won the tournament multiple times. Serena Williams has won the tournament an incredible 7 times in 20 years! == What was Osaka's route to the 2019 final? The final is the most important match, but what route did the winner take to get there? Let's have a look at Naomi Osaka's journey to the 2019 final: [source,cypher] ---- // Find all the matches that the winner of the tournament played MATCH path = (p:Player)-[:WINNER]->(match:Match {round: "F"})<-[:NEXT_MATCH*]-(m)<-[:WINNER]-(p) // Only get the winner of the 2019 tournament // Only get the longest path of NEXT_MATCH relationships that includes all matches // played by the winner WHERE not((m)<-[:NEXT_MATCH]-()) AND (match)-[:IN_TOURNAMENT]-(:Tournament {year: 2019}) // Find the winners and losers of all the matches in which the winner participated RETURN path, [node in nodes(path) WHERE node:Match | [p = (p1)-[:WINNER]->(node)<-[:LOSER]-(p2) | p]]; ---- image::{{<siteurl>}}/uploads/2020/01/aus-open-osaka.png[title="Naomi Osaka's path to the 2019 final"] == Who lost the final, but won it the next year? In this query we're going to try and find players that lost the final, but then won the tournament the following year: [source,cypher] ---- MATCH (player)-[:LOSER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t)-[:NEXT_TOURNAMENT]->(t2), (player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t2) RETURN player.name AS player, t.year, t2.year ---- .Who lost the final, but won it the next year? [opts="header"] |=== | player | t.year | t2.year | "Maria Sharapova" | 2007 | 2008 | "Na Li" | 2013 | 2014 | "Serena Williams" | 2016 | 2017 |=== Just the three players fixed their heart break at losing the final as quickly as possible. == Who lost the final, but subsequently won the tournament? Are there any players who lost the final but won it at some future tournament even if it wasn't the next year? To do that we'll add a `*` to the `NEXT_TOURNAMENT` part of the query, which will cause the Cypher engine to look at all future tournaments rather than just the following year: [source,cypher] ---- MATCH (player)-[:LOSER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t)-[:NEXT_TOURNAMENT*]->(t2), (player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t2) RETURN player.name, t.year, t2.year ---- .Who lost the final, but subsequently won it? [opts="header"] |=== | player | t.year | t2.year | "Maria Sharapova" | 2007 | 2008 | "Kim Clijsters" | 2004 | 2011 | "Na Li" | 2013 | 2014 | "Na Li" | 2011 | 2014 | "Serena Williams" | 2016 | 2017 |=== We get the 3 players from the previous query as well as Kim Clijsters and Li Na. Li Na actually lost the final twice before winning it in 2014. == How long did players wait from their first final defeat until their first win? We could tweak this query slightly to find the number of years that passed between a player losing their first final and winning their first final. We'll also add an additional filter so that we exclude players who have already won the tournament before they lost in the final. [source,cypher] ---- // Find the first year that a player lost the final MATCH (player)-[:LOSER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) // Where they haven't previously won the tournament WHERE not((player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->()-[:NEXT_TOURNAMENT*]->(t)) WITH player, t ORDER BY player, t.year WITH player, collect(t)[0] AS firstLoss // Find the first year that a player won the final after that loss MATCH (firstLoss)-[:NEXT_TOURNAMENT*]->(t2), (player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t2) WITH player, firstLoss, t2 ORDER BY player, t2.year WITH player, firstLoss, collect(t2)[0] AS firstWin RETURN player.name, firstLoss.year, firstWin.year, firstWin.year - firstLoss.year AS theWait ORDER BY theWait DESC ---- .How long did players wait from their first final defeat until their first win? [opts="header"] |=== | player.name | firstLoss.year | firstWin.year | theWait | "Kim Clijsters" | 2004 | 2011 | 7 | "Na Li" | 2011 | 2014 | 3 | "Maria Sharapova" | 2007 | 2008 | 1 |=== Clijsters had to wait the longest and Serena had in fact previously won the tournament, so she isn't returned in the results anymore. We can run this query against the Men's database as well by switching to that database using the command `:use mens` and re-running the query. .How long did players wait from their first final defeat until their first win? [opts="header"] |=== | player.name | firstLoss.year | firstWin.year | theWait | "Marat Safin" | 2002 | 2005 | 3 |=== Marat Safin is the only one, and he didn't have to wait too long to win the tournament. == What about sets? Tennis commentators often talk about the number of sets that the winner of the tournament lost along the way, so that's what we're going to explore next. At the moment the sets won is hidden inside the `score` property on the `Match` nodes. We're going to create one node per set played and connect those sets to the existing graph, as shown in the diagram below: image::{{<siteurl>}}/uploads/2020/01/aus-open-graph-model-sets.png[title="Our Graph Model including sets"] We can update the graph with the following Cypher statement: [source,cypher] ---- CALL apoc.periodic.iterate( "UNWIND range(2000, 2019) AS year RETURN year", "WITH 'https://raw.githubusercontent.com/JeffSackmann/tennis_wta/master/wta_matches_' AS base, year LOAD CSV WITH HEADERS FROM base + year + '.csv' AS row WITH row, split(row.score, ' ') AS rawSets WHERE row.tourney_name = 'Australian Open' WITH row, rawSets, [set in rawSets | apoc.text.regexGroups(set, \"(\\\\d{1,2})-(\\\\d{1,2})\")[0][1..]] AS sets, row.tourney_date + '_' + row.match_num AS matchId MATCH (m:Match {id: matchId}) MATCH (p1:Player {id: row.winner_id}) MATCH (p2:Player {id: row.loser_id}) WITH m, sets, rawSets, matchId, p1, p2 UNWIND range(0, size(sets)-1) AS setNumber MERGE (s:Set {id: matchId + '_' + setNumber}) SET s.matchWinnerScore = toInteger(sets[setNumber][0]), s.matchLoserScore = toInteger(sets[setNumber][1]), s.score = rawSets[setNumber], s.number = setNumber +1 MERGE (s)-[:IN_MATCH]->(m) FOREACH(ignoreMe IN CASE WHEN s.matchWinnerScore >= s.matchLoserScore THEN [1] ELSE [] END | MERGE (p1)-[:WINNER]->(s) MERGE (p2)-[:LOSER]->(s)) FOREACH(ignoreMe IN CASE WHEN s.matchWinnerScore < s.matchLoserScore THEN [1] ELSE [] END | MERGE (p1)-[:LOSER]->(s) MERGE (p2)-[:WINNER]->(s)) ", {}); ---- We can see a sample of the graph with sets included in the Neo4j Browser visualisation below: image::{{<siteurl>}}/uploads/2020/01/aus-open-sets.png[title="Sample of the Graph with sets added"] Now let's write some queries against the updated model. == Querying the graph: Sets Edition == Did anyone win the tournament without losing a set? Let's start by finding out if any players had a perfect tournament i.e. they won it without losing a set. The following query reveals all: [source,cypher] ---- MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t) WITH winner, match, t ORDER BY t.year WITH winner, t, collect([(match)<-[:IN_MATCH]-(set:Set) WHERE (winner)-[:LOSER]->(set) | set ][0]) AS setDropped WHERE size(setDropped) = 0 RETURN winner.name AS winner, t.year AS year ---- .Did anyone win the tournament without losing a set? [opts="header"] |=== | winner | year | "Roger Federer" | 2007 |=== Just the one on the men's side. What about the women's? .Did anyone win the tournament without losing a set? [opts="header"] |=== | winner | year | "Lindsay Davenport" | 2000 | "Maria Sharapova" | 2008 | "Serena Williams" | 2017 |=== Only three players here. So that means in most tournaments the winner loses a set somewhere along the way. == Did the winner drop any sets? Let's tweak that previous query a bit to return the number of matches in which the winner lost a set and the total number of sets lost: [source,cypher] ---- WITH apoc.map.fromLists( $rounds, range(0, size($rounds)-1)) AS rounds MATCH (winner:Player)-[:WINNER]->(:Match {round: "F"})-[:IN_TOURNAMENT]->(t) MATCH (winner)-[:WINNER]->(match)-[:IN_TOURNAMENT]->(t), (match)<-[:LOSER]-(opponent) WHERE (winner)-[:LOSER]->(:Set)-[:IN_MATCH]->(match) WITH * ORDER BY rounds[match.round] WITH winner, t, collect({round: match.round, opponent: opponent.name, score: match.score }) AS matches, collect([(match)<-[:IN_MATCH]-(set)<-[:LOSER]-(winner) | set]) AS sets RETURN winner.name AS winner, t.year AS year, size(matches) AS count, size(apoc.coll.flatten(sets)) AS sets, matches ORDER BY count DESC LIMIT 5 ---- .Did the winner drop any sets? [opts="header", cols="2,1,1,1,5"] |=== | winner | year | count | sets | matches | "Thomas Johansson" | 2002 | 6 | 7 | [{score: "6-1 3-6 7-6(2) 6-4", round: "R128", opponent: "Jacobo Diaz"}, {score: "5-7 6-2 6-2 6-4", round: "R32", opponent: "Younes El Aynaoui"}, {score: "6-7(8) 6-2 6-0 6-4", round: "R16", opponent: "Adrian Voinea"}, {score: "6-0 2-6 6-3 6-4", round: "QF", opponent: "Jonas Bjorkman"}, {score: "7-6(5) 0-6 4-6 6-3 6-4", round: "SF", opponent: "Jiri Novak"}, {score: "3-6 6-4 6-4 7-6(4)", round: "F", opponent: "Marat Safin"}] | "Roger Federer" | 2017 | 4 | 7 | [{score: "7-5 3-6 6-2 6-2", round: "R128", opponent: "Jurgen Melzer"}, {score: "6-7(4) 6-4 6-1 4-6 6-3", round: "R16", opponent: "Kei Nishikori"}, {score: "7-5 6-3 1-6 4-6 6-3", round: "SF", opponent: "Stanislas Wawrinka"}, {score: "6-4 3-6 6-1 3-6 6-3", round: "F", opponent: "Rafael Nadal"}] | "Marat Safin" | 2005 | 4 | 5 | [{score: "6-4 3-6 6-3 6-4", round: "R32", opponent: "Mario Ancic"}, {score: "4-6 7-6(1) 7-6(5) 7-6(2)", round: "R16", opponent: "Olivier Rochus"}, {score: "5-7 6-4 5-7 7-6(6) 9-7", round: "SF", opponent: "Roger Federer"}, {score: "1-6 6-3 6-4 6-4", round: "F", opponent: "Lleyton Hewitt"}] | "Roger Federer" | 2006 | 4 | 5 | [{score: "6-4 6-0 3-6 4-6 6-2", round: "R16", opponent: "Tommy Haas"}, {score: "6-4 3-6 7-6(7) 7-6(5)", round: "QF", opponent: "Nikolay Davydenko"}, {score: "6-3 5-7 6-0 6-2", round: "SF", opponent: "Nicolas Kiefer"}, {score: "5-7 7-5 6-0 6-2", round: "F", opponent: "Marcos Baghdatis"}] | "Stanislas Wawrinka" | 2014 | 4 | 5 | [{score: "6-3 6-3 6-7(4) 6-4", round: "R64", opponent: "Alejandro Falla"}, {score: "2-6 6-4 6-2 3-6 9-7", round: "QF", opponent: "Novak Djokovic"}, {score: "6-3 6-7(1) 7-6(3) 7-6(4)", round: "SF", opponent: "Tomas Berdych"}, {score: "6-3 6-2 3-6 6-3", round: "F", opponent: "Rafael Nadal"}] |=== So Thomas Johansson had the toughest route to the title, dropping a set in every match except for the 2nd round (R64). We could probably think of some other set based queries to execute against this dataset, but this blog post has already got much longer than I expected so I think we'll leave it there for now. == What’s interesting about this QuickGraph? I've always wanted to put tennis matches into a graph, but I was always struggling to think what type of graphy queries could be run against such a dataset. And for most of this blog post I wasn't really convinced that a graph was allowing us to write very interesting queries. Things got more interesting in the last section where we did set analysis. I found having the data in a graph structure made was helpful for answering these questions, especially when we were looking for the non existence of a relationship. I do still wonder if there's a cleaner way to write those queries. Thanks against to Jeff Sackmann for curating the datasets. You saved me a lot of work preparing the data!

Learn how to build a graph of the Australian Open tennis tournament

uploads/2020/01/aus-open-banner.png

quick-graph-australian-open

https://markhneedham.com/blog/2020/01/23/quick-graph-australian-open

2020-01-14 00:21:00

Python: Altair - Setting the range of Date values for an axis

In my continued experiments with the https://altair-viz.github.io/index.html[Altair visualisation library], I wanted to set a custom range of data values on the x axis of a chart. In this blog post we'll learn how to do that. We'll start where we left off in the https://markhneedham.com/blog/2020/01/10/altair-typeerror-object-type-date-not-json-serializable/[last blog post^], with the following code that renders a scatterplot containing the chart position of a song on a certain date: [source,python] ---- import altair as alt import pandas as pd import datetime df = pd.DataFrame( [ {"position": 40, "date": datetime.date(2019,9,5)}, {"position": 31, "date": datetime.date(2019,9,12)}, {"position": 19, "date": datetime.date(2019,9,19)}, {"position": 14, "date": datetime.date(2019,9,26)}, {"position": 7, "date": datetime.date(2019,10,3)}, {"position": 1, "date": datetime.date(2019,10,10)}, {"position": 1, "date": datetime.date(2019,10,17)}, {"position": 1, "date": datetime.date(2019,10,24)}, ]) df["date"] = pd.to_datetime(df["date"]) chart = alt.Chart(df).mark_point(color="red").encode( x='date', y='position') chart.save("chart.html") ---- If we run this script, we'll have the following chart in `chart.html`: image::{{<siteurl>}}/uploads/2020/01/altair-dance-monkey.png[title="Chart showing chart positions"] At the moment the x axis of our chart covers the range of dates included in our DataFrame. I wanted to have that axis start from 1st January 2019 and end on 31st December 2019, and came across https://github.com/altair-viz/altair/issues/1005[a GitHub issue^] describing how to do this. One way to do this is to create a Pandas index and then define a custom domain for the `scale` of the x axis. The code below does this: [source,python] ---- domain_pd = pd.to_datetime(['2019-01-01', '2019-12-31']).astype(int) / 10 ** 6 chart = alt.Chart(df).mark_point(color="red").encode( x=alt.X('date:T', timeUnit='yearmonthdate', scale=alt.Scale(domain=list(domain_pd))), y='position') chart.save("chart.html") ---- If we run this script, we'll have the following chart in `chart.html`: image::{{<siteurl>}}/uploads/2020/01/altair-dance-monkey-full-year.png[title="Chart showing chart positions"] Another, simpler way, is to pass in a list containing the start and end dates, as shown below: [source,python] ---- domain = ["2019-01-01", "2019-12-31"] chart = alt.Chart(df).mark_point(color="red").encode( x=alt.X('date:T', timeUnit='yearmonthdate', scale=alt.Scale(domain=domain)), y='position') chart.save("chart.html") ---- All the code from this blog post is available in a https://gist.github.com/mneedham/e5d347cbffe0b04584a267c0d961e1a1[GitHub Gist^].

Learn how to set the range of date values on the x axis of an Altair chart

uploads/2020/01/altair-dance-monkey-full-year.png

altair-range-values-dates-axis

https://markhneedham.com/blog/2020/01/14/altair-range-values-dates-axis

2020-12-20 00:21:00

Strava: Export all activities to JSON file

In my continued playing around with the http://developers.strava.com/[Strava API^], I wanted to write a script to download all of my Strava activities to a JSON file. As I mentioned in https://markhneedham.com/blog/2020/12/15/strava-authorization-error-missing-read-permission/[a previous blog post^], the approach to authenticating requests has changed in the last two years, so we first need to generate an access token via the OAuth endpoint. Luckily Odd Eirik Igland https://stackoverflow.com/questions/60873575/how-to-access-authentication-by-strava-api-using-python[shared a script^] showing how to solve most of the problem, and I've adapted it to do what I want. == Pre-requisites First we need to install the following libraries: [source,bash] ---- pip install stravalib fastapi uvicorn jsonlines ---- And the script that we're going to execute next relies on the `CLIENT_ID` and `CLIENT_SECRET` environment variables. We can get those values from the https://www.strava.com/settings/api[Strava API application page^], and set them by running the following commands: [source,bash] ---- export CLIENT_ID="client_id" export CLIENT_SECRET="client_secret" ---- == Generate access token Now we're ready to generate a Strava access token, using the following script: .https://github.com/mneedham/materialize-sandbox/blob/main/strava/authenticate.py[authenticate.py^] [source,python] ---- import os import pickle from fastapi import FastAPI from fastapi.responses import RedirectResponse from stravalib.client import Client CLIENT_ID = os.getenv("CLIENT_ID") CLIENT_SECRET = os.getenv("CLIENT_SECRET") REDIRECT_URL = 'http://localhost:8000/authorized' app = FastAPI() client = Client() def save_object(obj, filename): with open(filename, 'wb') as output: # Overwrites any existing file. pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL) @app.get("/") def read_root(): authorize_url = client.authorization_url(client_id=CLIENT_ID, redirect_uri=REDIRECT_URL) return RedirectResponse(authorize_url) @app.get("/authorized/") def get_code(state=None, code=None, scope=None): token_response = client.exchange_code_for_token(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, code=code) access_token = token_response['access_token'] refresh_token = token_response['refresh_token'] expires_at = token_response['expires_at'] client.access_token = access_token client.refresh_token = refresh_token client.token_expires_at = expires_at save_object(client, 'auth/client.pkl') return {"state": state, "code": code, "scope": scope} ---- If we run the following command, it will launch a web server on port 8000: [source,bash] ---- uvicorn authenticate:app --reload ---- .Output [source,text] ---- INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [850840] using statreload INFO: Started server process [850842] INFO: Waiting for application startup. INFO: Application startup complete. ---- Next we need to navigate to http://localhost:8000, from where we'll be redirected to the Strava login page: image::{{<siteurl>}}/uploads/2020/12/strava-1.png[title="Strava Authorisation"] Once we click on 'Authorize', the web browser will redirect to http://localhost:8000/authorized, and we'll see something like the following: [source,json] ---- { "state": "", "code": "<our-code>", "scope": "read,activity:read" } ---- The script will also save a Strava client containing an access token to `auth/client.pkl`. == Download Strava activities We're now ready to download our Strava activites, which we'll do using the following script: .https://github.com/mneedham/materialize-sandbox/blob/main/strava/download_activities.py[download_activities.py] [source,python] ---- import os import pickle import time import jsonlines CLIENT_ID = os.getenv("CLIENT_ID") CLIENT_SECRET = os.getenv("CLIENT_SECRET") def check_token(): if time.time() > client.token_expires_at: refresh_response = client.refresh_access_token(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, refresh_token=client.refresh_token) access_token = refresh_response['access_token'] refresh_token = refresh_response['refresh_token'] expires_at = refresh_response['expires_at'] client.access_token = access_token client.refresh_token = refresh_token client.token_expires_at = expires_at def load_object(filename): with open(filename, 'rb') as input: loaded_object = pickle.load(input) return loaded_object try: client = load_object('auth/client.pkl') check_token() athlete = client.get_athlete() print("For {id}, I now have an access token {token}".format(id=athlete.id, token=client.access_token)) with jsonlines.open('data/activities-all.json', mode='w') as writer: for activity in client.get_activities(): writer.write({ "id": activity.id, "distance": activity.distance.get_num(), "moving_time": activity.moving_time.seconds, "elapsed_time": activity.elapsed_time.seconds, "total_elevation_gain": activity.total_elevation_gain.get_num(), "elev_high": activity.elev_high, "elev_low": activity.elev_low, "average_speed": activity.average_speed.get_num(), "max_speed": activity.max_speed.get_num(), "average_heartrate": activity.average_heartrate, "max_heartrate": activity.max_heartrate, "start_date": str(activity.start_date) }) except FileNotFoundError: print( "No access token stored yet, run uvicorn authenticate:app --reload and visit http://localhost:8000/ to get it") print("After visiting that url, a pickle file is stored, run this file again to download your activities") ---- This script does the following: * Loads the Strava client object from `auth/client.pkl` * Uses the refresh token to generate a new access token if the old one has expired * Iterates through all of our activities and writes them to `data/activities-all.json` We can run the script like so: [source,python] ---- python download_activities.py ---- After it's finished running, `data/activities-all.json` has the following contents: [source, bash] ---- head -n3 data/activities-all.json ---- .Output [source,json] ---- {"id": 4489569395, "distance": 13751.9, "moving_time": 4150, "elapsed_time": 4155, "total_elevation_gain": 96.9, "elev_high": 79.3, "elev_low": 25.0, "average_speed": 3.314, "max_speed": 4.6, "average_heartrate": 149.8, "max_heartrate": 176, "start_date": "2020-12-19 07:05:51+00:00"} {"id": 4485841116, "distance": 12881.6, "moving_time": 3890, "elapsed_time": 3946, "total_elevation_gain": 90.7, "elev_high": 74.3, "elev_low": 22.9, "average_speed": 3.311, "max_speed": 4.4, "average_heartrate": 155.0, "max_heartrate": 191, "start_date": "2020-12-18 05:35:08+00:00"} {"id": 4478032915, "distance": 13148.8, "moving_time": 3998, "elapsed_time": 4039, "total_elevation_gain": 100.4, "elev_high": 69.9, "elev_low": 22.9, "average_speed": 3.289, "max_speed": 5.3, "average_heartrate": 156.6, "max_heartrate": 183, "start_date": "2020-12-16 05:35:09+00:00"} ----

In this blog post we'll learn how export all activities from Strava to a JSON file

strava-export-all-activities-json

https://markhneedham.com/blog/2020/12/20/strava-export-all-activities-json

2020-12-18 00:44:37

git: Ignore local changes on committed (env) file

Whenever I've writing scripts that rely on credentials defined as environment variables, I like to create a `.env` (or equivalent) file containing those variables. I then seed that file with placeholder values for each variable and make local changes that aren't checked in. I recently created the https://github.com/mneedham/materialize-sandbox/tree/main/strava[mneedham/materialize-sandbox/strava^] repository where I'm using this approach with a https://github.com/mneedham/materialize-sandbox/blob/main/strava/.envsettings[`.envsettings`^] file that has the following contents: .envsettings [source,text] ---- export CLIENT_ID="client_id" export CLIENT_SECRET="client_secret" ---- I have that file checked in so that anybody else can clone the repository and update this file with their own credentials. But I don't want local changes to that file to be tracked, as I might then accidentally commit my credentials. I'd previously achieved this by adding `.envsettings` to the `.gitignore` file, but that technique doesn't seem to work anymore! Luckily there is a way around this, using git's https://stackoverflow.com/questions/13630849/git-difference-between-assume-unchanged-and-skip-worktree#[`update-index`^] command, which I learnt about from https://stackoverflow.com/a/13631525/1093511[Borealid's answer on StackOverflow^]. So once I've committed the `.envsettings` file, I can have git ignore any changes by running the following command: [source,bash] ---- git update-index --skip-worktree strava/.envsettings ---- And now git will ignore any local changes made to this file, which is exactly what I want!

In this post we'll learn how ignore local changes to a committed (environment) file.

git-ignore-local-changes-committed-env-file

https://markhneedham.com/blog/2020/12/18/git-ignore-local-changes-committed-env-file

2020-12-29 00:44:37

Materialize: Querying JSON arrays

In https://markhneedham.com/blog/2020/12/17/materialize-querying-json-file/[a blog post I wrote a couple of weeks ago^], we learned how to analyse JSON files using the https://materialize.com/[Materialize^] SQL streaming database. In this post we're going to build on that knowledge to analyse a JSON file of tweets that contain arrays of hashtags. It took me a while to figure out to do this, so I wanted to share what I learnt along the way. image::{{<siteurl>}}/uploads/2020/12/materialize-banner-json-arrays.png[] The JSON file that we're going to analyse looks like this and we'll save that file in a `data` directory locally. .https://github.com/mneedham/materialize-sandbox/blob/main/twitter/data/covid_sample.json[covid_sample.json^] [source,json] ---- {"id": "1341755954614861826", "conversation_id": "1341755954614861826", "created_at": "2020-12-23 14:42:02 GMT", "date": "2020-12-23", "time": "14:42:02", "timezone": "+0000", "user_id": 856240505826496513, "username": "suriyasubraman", "name": "Suriya Subramanian", "place": "", "tweet": "Impact of COVID-19 On Internet of Things (IoT) Networks Market 2020 Industry Challenges ... https://t.co/ndGN2xRKzv #iot #data #internetofthings", "language": "en", "mentions": [], "urls": ["http://dlvr.it/RpCyyv"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["iot", "data", "internetofthings"], "cashtags": [], "link": "https://twitter.com/SuriyaSubraman/status/1341755954614861826", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} {"id": "1341755827158441984", "conversation_id": "1341755827158441984", "created_at": "2020-12-23 14:41:32 GMT", "date": "2020-12-23", "time": "14:41:32", "timezone": "+0000", "user_id": 26450334, "username": "nickkeca", "name": "Nick Keca", "place": "", "tweet": "Non-compliance is the only thing ordinary people have to fight against the agenda hiding behind this #covid cloak. BUT, we are fighting against financial interests that are so powerful that only strength of numbers &amp; people power can prevail", "language": "en", "mentions": [], "urls": [], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["covid"], "cashtags": [], "link": "https://twitter.com/nickkeca/status/1341755827158441984", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} {"id": "1341755981420703744", "conversation_id": "1341755981420703744", "created_at": "2020-12-23 14:42:09 GMT", "date": "2020-12-23", "time": "14:42:09", "timezone": "+0000", "user_id": 147562101, "username": "jasonjamesstone", "name": "Jason Stone 🔶 🇪🇺🇬🇧🏴󠁧󠁢󠁥󠁮󠁧󠁿🇧🇷", "place": "", "tweet": "We can't afford to have a damaging #Brexit and an out of control Coronavirus pandemic at the same time. Sign the petition: Extend the #BrexitTransition Period until the virus is under control https://t.co/yyI3miEJLg", "language": "en", "mentions": [], "urls": ["https://www.londonlibdems.org.uk/extendbrexit?e=13bee6003ca0b15761a0a8e71e926169&utm_source=ldlondon&utm_medium=email&utm_campaign=brexit_extension&n=3"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["brexit", "brexittransition"], "cashtags": [], "link": "https://twitter.com/jasonjamesstone/status/1341755981420703744", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} {"id": "1341754919896948736", "conversation_id": "1341754919896948736", "created_at": "2020-12-23 14:37:56 GMT", "date": "2020-12-23", "time": "14:37:56", "timezone": "+0000", "user_id": 14508711, "username": "beecee", "name": "Brigid Coady 🌈", "place": {"type": "Point", "coordinates": [51.49594393, -0.13355317]}, "tweet": "Finish work. Give blood. My Xmas present to the world! #morningcommute #xmas #giveblood #plasma #platelets #covid19 #coronavirus #tier4 #lockdown #London @ Westminster https://t.co/Tq42OaN811", "language": "en", "mentions": [], "urls": ["https://www.instagram.com/p/CJJNIidgG4M/?igshid=1hu20v1xohrce"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["morningcommute", "xmas", "giveblood", "plasma", "platelets", "covid19", "coronavirus", "tier4", "lockdown", "london"], "cashtags": [], "link": "https://twitter.com/beecee/status/1341754919896948736", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} {"id": "1341753938333237253", "conversation_id": "1341753938333237253", "created_at": "2020-12-23 14:34:02 GMT", "date": "2020-12-23", "time": "14:34:02", "timezone": "+0000", "user_id": 820537716798619648, "username": "amprouk", "name": "AMPro", "place": "", "tweet": "Motability provides #coronavirus update for customers https://t.co/dRX6xXEtOM", "language": "en", "mentions": [], "urls": ["http://dlvr.it/RpCxYZ"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["coronavirus"], "cashtags": [], "link": "https://twitter.com/amprouk/status/1341753938333237253", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} ---- == Connecting to Materialize We're going to query that data using Materialize, which we'll set up using the following Docker Compose configuration: .docker-compose.yml [source,yaml] ---- version: '3' services: materialize: image: materialize/materialized:v0.5.3 container_name: "materialize-sandbox-docker-compose" volumes: - ./data:/data ports: - "6875:6875" ---- The `data` directory containing the https://github.com/mneedham/materialize-sandbox/blob/main/twitter/data/covid_sample.json[`covid_sample.json`^] file is in the https://github.com/mneedham/materialize-sandbox/tree/main/twitter[mneedham/materialize-sandbox/twitter^] GitHub repository. The repository also contains setup instructions. Once we've cloned that repository, we can launch Materialize by running the following command: [source, bash] ---- docker-compose up ---- We're now ready to connect to Materialize, which we can do using the https://www.postgresql.org/docs/9.3/app-psql.html[`psql` CLI tool^]: [source, bash] ---- psql -h localhost -p 6875 materialize ---- .Results [source,text] ---- psql (12.5 (Ubuntu 12.5-0ubuntu0.20.04.1), server 9.5.0) Type "help" for help. materialize=> ---- == Creating a materialized view Now we're to create a source around the file and then a materialized view on top of that source. .CREATE SOURCE [source,sql] ---- CREATE SOURCE covid_sample_source FROM FILE '/data/covid_sample.json' WITH(tail=true) FORMAT TEXT; ---- .CREATE MATERIALIZED VIEW [source,sql] ---- CREATE MATERIALIZED VIEW covid_sample AS SELECT (val->>'id')::float::bigint AS id, (val->>'username')::text AS username, (val->>'hashtags')::text AS hashtags, (val->>'tweet')::text AS tweet FROM (SELECT text::jsonb AS val FROM covid_sample_source); ---- We can describe the view by running the following query: [source,sql] ---- SHOW COLUMNS FROM covid_sample; ---- .Results [opts="header"] |=== |name | nullable | type |hashtags | t | text |id | t | int8 |tweet | t | text |username | t | text |=== The interesting thing here is that the `hashtags` column is storing data in the `text` type. == Querying a materialized view Now it's time to write some queries. Let's start with a query that returns all columns and rows in the `covid_sample` view: [source,sql] ---- SElECT * FROM covid_sample; ---- .Results [opts="header", cols="1,1,1,2"] |=== |id | username | hashtags | tweet |1341753938333237248 | amprouk | ["coronavirus"] | Motability provides #coronavirus update for customers https://t.co/dRX6xXEtOM |1341755954614861824 | suriyasubraman | ["iot","data","internetofthings"] | Impact of COVID-19 On Internet of Things (IoT) Networks Market 2020 Industry Challenges ... https://t.co/ndGN2xRKzv #iot #data #internetofthings |1341755981420703744 | jasonjamesstone | ["brexit","brexittransition"] | We can't afford to have a damaging #Brexit and an out of control Coronavirus pandemic at the same time. Sign the petition: Extend the #BrexitTransition Period until the virus is under control https://t.co/yyI3miEJLg |1341755827158441984 | nickkeca | ["covid"] | Non-compliance is the only thing ordinary people have to fight against the agenda hiding behind this #covid cloak. BUT, we are fighting against financial interests that are so powerful that only strength of numbers &amp; people power can prevail |1341754919896948736 | beecee | ["morningcommute","xmas","giveblood","plasma","platelets","covid19","coronavirus","tier4","lockdown","london"] | Finish work. Give blood. My Xmas present to the world! #morningcommute #xmas #giveblood #plasma #platelets #covid19 #coronavirus #tier4 #lockdown #London @ Westminster https://t.co/Tq42OaN811 |=== I wanted to write a query that shows how many tweets each hashtag appears in, so we'll need to 'explode' the values in `hashtags` column into rows, which we can do using the https://materialize.com/docs/sql/types/jsonb/#jsonb_array_elements[`jsonb_array_elements`] function. My first attempt was the following: [source,sql] ---- SELECT jsonb_array_elements(hashtags) AS ht FROM covid_sample LIMIT 5; ---- .Results [source,text] ---- ERROR: table function (jsonb_array_elements) in scalar position not yet supported, see https://github.com/MaterializeInc/materialize/issues/1546 for more details ---- This error indicates that we need to use the `json_array_elements` function in the `FROM` part of the query. Let's try that: [source,sql] ---- SELECT ht FROM covid_sample, jsonb_array_elements(hashtags) AS ht LIMIT 5; ---- .Results [source,text] ---- ERROR: Cannot call function jsonb_array_elements(string): arguments cannot be implicitly cast to any implementation's parameters; try providing explicit casts ---- Hmmm, still no good. The problem this time is that the `jsonb_array_elements` function excepts to receive values of type `jsonb` and the `hashtags` column returns values of type `text`. We can fix that by casting to the correct type, like this: [source,sql] ---- SELECT ht FROM covid_sample, jsonb_array_elements(hashtags :: jsonb) AS ht LIMIT 5; ---- .Results [opts="header" ] |=== |ht |"iot" |"data" |"xmas" |"covid" |"tier4" |=== Success! Now we can write a query that shows how many times each hashtag has been used: [source,sql] ---- SELECT ht, count(*) AS count FROM covid_sample, jsonb_array_elements(hashtags :: jsonb) AS ht GROUP BY ht ORDER BY count DESC LIMIT 5; ---- .Results [opts="header" ] |=== |ht | count | "coronavirus" | 2 |"iot" | 1 |"data" | 1 |"xmas" | 1 |"covid" | 1 |=== We could even go further than this and create a view that returns hashtags and their counts: [source,sql] ---- CREATE MATERIALIZED VIEW covid_hashtags AS SELECT ht, count(*) AS count FROM covid_sample, jsonb_array_elements(hashtags :: jsonb) AS ht GROUP BY ht ORDER BY count DESC; ---- Which we can query like this: [source,sql] ---- SELECT * FROM covid_hashtags LIMIT 5; ---- .Results [opts="header" ] |=== |ht | count |"iot" | 1 |"data" | 1 |"xmas" | 1 |"covid" | 1 |"tier4" | 1 |=== Interestingly the `ORDER BY` doesn't seem to be reflected in the results. I learnt from https://twitter.com/frankmcsherry[Frank McSherry^] that it's actually a feature of SQL that the `ORDER BY` clause isn't inherited from the view. Now let's add a couple of extra tweets to the end of `covid_sample.json`: [source,json] ---- {"id": "1341759529520926722", "conversation_id": "1341759529520926722", "created_at": "2020-12-23 14:56:15 GMT", "date": "2020-12-23", "time": "14:56:15", "timezone": "+0000", "user_id": 368587842, "username": "piterk68", "name": "Peter Lewis", "place": "", "tweet": "A quick thread reflecting on two themes of my year : #COVID &amp; #Inequality particularly race inequality, with a few thank yous at the end:", "language": "en", "mentions": [], "urls": [], "photos": [], "replies_count": 1, "retweets_count": 0, "likes_count": 1, "hashtags": ["covid", "inequality"], "cashtags": [], "link": "https://twitter.com/piterk68/status/1341759529520926722", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} {"id": "1341759301908631554", "conversation_id": "1341759301908631554", "created_at": "2020-12-23 14:55:20 GMT", "date": "2020-12-23", "time": "14:55:20", "timezone": "+0000", "user_id": 57581622, "username": "lamuscle", "name": "LA Muscle", "place": "", "tweet": "Fitter &amp; Stronger With Minimal Equipment Try This Excellent Pump Workout Full article here: https://t.co/HY3e9wfX0P #lamuscle #bodyweight #coronavirus #covid19 #isolation #training #fitness #health #muscle #exercise #workout #homeworkout #outdoors #healthy #dumbbells #lean #diet https://t.co/91wU7DcZRA", "language": "en", "mentions": [], "urls": ["https://www.lamuscle.com/knowledge/lose-fat/fitter-stronger-pump-workout"], "photos": ["https://pbs.twimg.com/media/Ep7i9fvXYAIb5Ay.jpg"], "replies_count": 0, "retweets_count": 0, "likes_count": 1, "hashtags": ["lamuscle", "bodyweight", "coronavirus", "covid19", "isolation", "training", "fitness", "health", "muscle", "exercise", "workout", "homeworkout", "outdoors", "healthy", "dumbbells", "lean", "diet"], "cashtags": [], "link": "https://twitter.com/LAMuscle/status/1341759301908631554", "retweet": false, "quote_url": "", "video": 1, "thumbnail": "https://pbs.twimg.com/media/Ep7i9fvXYAIb5Ay.jpg", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} ---- And if we run the query against `covid_hashtags` again: [source,sql] ---- SELECT * FROM covid_hashtags ORDER BY count DESC LIMIT 5; ---- The hashtags from those tweets will be reflected in the results returned: .Results [opts="header" ] |=== | ht | count | "coronavirus" | 3 |"covid" | 2 |"covid19" | 2 |"iot" | 1 |"data" | 1 |===

In this post we'll learn how to query a JSON file that contains arrays using the Materialize SQL streaming database.

uploads/2020/12/materialize-banner-json-arrays.png

materialize-json-arrays

https://markhneedham.com/blog/2020/12/29/materialize-json-arrays

2020-12-17 00:44:37

Materialize: Querying JSON files

I recently learnt about https://materialize.com/[Materialize^], a SQL streaming database, via their https://techcrunch.com/2020/11/30/materialize-scores-40-million-investment-for-sql-streaming-database/[Series B fundraising announcement^], and thought I'd take it for a spin. My go-to dataset for new databases is Strava, an app that I use to record my runs. It has an API that returns a JSON representation of each run, containing information like the distance covered, elapsed time, heart rate metrics, and more. I've extracted my latest 30 activities to a file in the JSON lines format and in this post we're going to analyse that data using Materialize. image::{{<siteurl>}}/uploads/2020/12/materialize-banner.png[] The data is stored in the https://github.com/mneedham/materialize-sandbox/blob/main/strava/data/activities-clean.json[`activities-clean.json`^] file on the https://github.com/mneedham/materialize-sandbox/tree/main/strava[mneedham/materialize-sandbox^] repository. Below is an example of the first line in this file: [source,json] ---- {"resource_state":2,"athlete":{"id":6958432,"resource_state":1},"name":"Morning Run","distance":14175.1,"moving_time":4222,"elapsed_time":4391,"total_elevation_gain":105.4,"type":"Run","workout_type":null,"id":4470124807,"upload_id":4776694342,"start_date":"2020-12-14T05:31:43Z","start_date_local":"2020-12-14T05:31:43Z","timezone":"(GMT+00:00) Europe/London","utc_offset":0,"location_city":null,"location_state":null,"location_country":"United Kingdom","achievement_count":0,"kudos_count":2,"comment_count":0,"athlete_count":1,"photo_count":0,"trainer":false,"commute":false,"manual":false,"private":false,"visibility":"everyone","flagged":false,"gear_id":"g7064038","from_accepted_tag":false,"upload_id_str":"4776694342","average_speed":3.357,"max_speed":4.3,"average_cadence":87.4,"has_heartrate":true,"average_heartrate":150.3,"max_heartrate":168,"heartrate_opt_out":false,"display_hide_heartrate_option":true,"elev_high":76.2,"elev_low":25,"pr_count":0,"total_photo_count":0,"has_kudoed":false,"suffer_score":116} ---- == Connecting to Materialize We're going to query that data using Materialize, which we'll set up using the following Docker Compose configuration: .docker-compose.yml [source,yaml] ---- version: '3' services: materialize: image: materialize/materialized:v0.5.3 container_name: "materialize-sandbox-docker-compose" volumes: - ./data:/data ports: - "6875:6875" ---- The `data` directory containing the `activities-clean.json` file is in the https://github.com/mneedham/materialize-sandbox/tree/main/strava[mneedham/materialize-sandbox/strava^] GitHub repository. The repository also contains setup instructions. Once we've cloned that repository, we can launch Materialize by running the following command: [source, bash] ---- docker-compose up ---- We should see the following output: .Results [source,text] ---- Dec 16 16:13:15.027 INFO materialized: booting server materialized v0.5.3 (f56c5a8a3) OpenSSL 1.1.1g 21 Apr 2020 librdkafka v1.5.0 .... ======================================================================= Thank you for trying Materialize! We are interested in any and all feedback you have, which may be able to improve both our software and your queries! Please reach out at: Web: https://materialize.com GitHub issues: https://github.com/MaterializeInc/materialize/issues Email: [email protected] Twitter: @MaterializeInc ======================================================================= materialized v0.5.3 (f56c5a8a3) listening on 0.0.0.0:6875... ---- We're now ready to connect to Materialize, which we can do using the https://www.postgresql.org/docs/9.3/app-psql.html[`psql` CLI tool^]: [source, bash] ---- psql -h localhost -p 6875 materialize ---- .Results [source,text] ---- psql (12.5 (Ubuntu 12.5-0ubuntu0.20.04.1), server 9.5.0) Type "help" for help. materialize=> ---- == Creating a materialized view To query this file using Materialize we'll need to create a source around the file and then a materialized view on top of that source. My understanding of the architecture at a high level is shown in the diagram below: image::{{<siteurl>}}/uploads/2020/12/materialize-architecture.png[title="Materialize Architecture"] Let's now create a source on top of the file. We can do this using the https://materialize.com/docs/sql/create-source/[`CREATE SOURCE`^] clause, as shown below: [source, sql] ---- CREATE SOURCE activities FROM FILE '/data/activities-clean.json' FORMAT TEXT; ---- We need to indicate where the file lives on the server, as well as the format of its contents. We also need to specify the format of the file, which in this case is https://materialize.com/docs/sql/create-source/text-file/[`TEXT`^]. We'll be able to describe the JSON structure in more detail when we create the view. We can describe the source by running the following query: [source, sql] ---- SHOW COLUMNS FROM activities; ---- .Results [opts="header"] |=== | name | nullable | type | mz_line_no | f | int8 | text | f | text |=== So the main field we're interested in is the `text` one, which contains our JSON documents. Next we're going to create a materialized view, in which we can use https://materialize.com/docs/sql/functions/#json[JSON functions^] to extract fields from the JSON documents and cast them to appropriate types. By default fields are imported as the `text` type. We can pull out the interesting data from the activities by creating the following materialized view: [source, sql] ---- CREATE MATERIALIZED VIEW activities_view AS SELECT (val->>'id')::float::bigint AS id, (val->>'distance')::float AS distance, (val->>'moving_time')::float::int AS moving_time, (val->>'elapsed_time')::float::int AS elapsed_time, (val->>'total_elevation_gain')::float AS total_elevation_gain, (val->>'elev_high')::float AS elev_high, (val->>'elev_low')::float AS elev_low, (val->>'average_speed')::float AS average_speed, (val->>'max_speed')::float AS max_speed, (val->>'average_heartrate')::float AS average_heartrate, (val->>'max_heartrate')::float AS max_heartrate, (val->>'start_date')::timestamp AS start_date FROM (SELECT text::json AS val FROM activities); ---- While I was working out which fields to extract, I found myself repeatedly creating and dropping the view. We can drop the view using the `DROP VIEW` clause: [source, sql] ---- DROP VIEW activities_view; ---- And once we're happy with it, we can use the `SHOW COLUMNS` clause to describe the view, as shown below: [source, sql] ---- SHOW COLUMNS FROM activities_view; ---- .Results [opts="header"] |=== |name | nullable | type |average_heartrate | t | float8 |average_speed | t | float8 |distance | t | float8 |elapsed_time | t | int4 |elev_high | t | float8 |elev_low | t | float8 |id | t | int8 |max_heartrate | t | float8 |max_speed | t | float8 |moving_time | t | int4 |start_date | t | timestamp |total_elevation_gain | t | float8 |=== == Querying a materialized view Ok, now it's time for some fun, let's query the materialized view that we've just created. We'll start with a SQL query that returns the latest 10 activities, sorted in descending order by `start_date`: [source,sql] ---- SELECT * FROM activities_view ORDER BY start_date DESC LIMIT 10; ---- .Results [opts="header"] |=== | id | distance | moving_time | elapsed_time | total_elevation_gain | elev_high | elev_low | average_speed | max_speed | average_heartrate | max_heartrate | start_date |470124807 | 14175.1 | 4222 | 4391 | 105.4 | 76.2 | 25 | 3.357 | 4.3 | 150.3 | 168 | 2020-12-14 05:31:43 |460808499 | 13132.6 | 3794 | 3935 | 81.4 | 67.4 | 25 | 3.461 | 4.6 | 147.3 | 163 | 2020-12-12 06:28:06 |456998655 | 12244.8 | 3580 | 3643 | 74.4 | 67.4 | 25 | 3.42 | 4.4 | 156.2 | 190 | 2020-12-11 04:15:32 |448905703 | 12304.8 | 3567 | 3889 | 87.7 | 69.9 | 25 | 3.45 | 4.4 | 153.5 | 182 | 2020-12-09 05:17:29 |440554208 | 12239.9 | 3856 | 3987 | 87 | 69.8 | 28.1 | 3.174 | 4 | 154.4 | 178 | 2020-12-07 05:38:44 |431429475 | 13116.8 | 3992 | 4049 | 111.8 | 122.3 | 57 | 3.286 | 4.3 | 156.1 | 185 | 2020-12-05 08:41:17 |427493338 | 12253.2 | 3756 | 3814 | 73.3 | 67.4 | 29.1 | 3.262 | 4.5 | 158.8 | 182 | 2020-12-04 05:33:21 |419097799 | 12305 | 3852 | 4013 | 93.9 | 74.6 | 29.6 | 3.194 | 4.6 | 143.5 | 174 | 2020-12-02 05:36:33 |410708776 | 10916.3 | 3456 | 3645 | 87.8 | 67.3 | 22.9 | 3.159 | 4.1 | 145.7 | 178 | 2020-11-30 05:40:06 |400404590 | 12926.9 | 4142 | 4243 | 123.1 | 74.6 | 28.5 | 3.121 | 6.4 | 150.6 | 193 | 2020-11-28 07:17:00 |=== We can use all the SQL aggregation functions that we're used to. So if we wanted to work out the distance run, grouped by month, we could write the following query that uses the https://materialize.com/docs/sql/functions/date-trunc/[`date_trunc`^] function: [source,sql] ---- SELECT date_trunc('month', start_date) AS month, sum(distance) AS totalDistance FROM activities_view GROUP BY month ORDER BY month; ---- .Results [opts="header"] |=== |month | totaldistance |2020-10-01 00:00:00 | 75149.69999992847 |2020-11-01 00:00:00 | 194009.49999952316 |2020-12-01 00:00:00 | 101772.19999974966 |=== I ran a lot more in November than the other two months, but admittedly we don't have complete data for October or December (so far). If we pull in all that data, the total distance covered would likely be similar. What about the fastest run and the pace per mile on that run? We can compute with a little help from the https://materialize.com/docs/sql/functions/to_char/[`to_char`^] function: [source,sql] ---- SELECT start_date, distance, to_char(to_timestamp(moving_time / distance * 1609.34), 'MI:SS') AS pacePerMile, to_char(to_timestamp(moving_time), 'HH24:MI:SS') AS time FROM activities_view ORDER BY moving_time / distance LIMIT 10; ---- .Results [opts="header"] |=== | start_date | distance | pacepermile | time |2020-12-12 06:28:06 | 13132.6 | 07:44 | 01:03:14 |2020-12-09 05:17:29 | 12304.8 | 07:46 | 00:59:27 |2020-10-21 04:34:38 | 12624.5 | 07:48 | 01:01:14 |2020-10-23 03:49:00 | 13762.7 | 07:49 | 01:06:57 |2020-12-11 04:15:32 | 12244.8 | 07:50 | 00:59:40 |2020-12-14 05:31:43 | 14175.1 | 07:59 | 01:10:22 |2020-10-24 06:04:41 | 13703.4 | 08:01 | 01:08:21 |2020-10-30 05:43:05 | 8172.7 | 08:02 | 00:40:49 |2020-10-28 05:33:27 | 14494.7 | 08:05 | 01:12:52 |2020-11-18 05:42:50 | 11968.1 | 08:06 | 01:00:16 |=== It looks like my fastest run was just a few days ago, but I have had a few others that were at a similar pace. We could combine the previous two queries together to find the fastest pace per month, as shown in the following query: [source,sql] ---- SELECT to_char(date_trunc('month', start_date), 'YYYY-MM') AS month, to_char(to_timestamp(min(moving_time / distance * 1609.34)), 'MI:SS') AS pacePerMile, to_char(to_timestamp(min(moving_time)), 'HH24:MI:SS') AS time FROM activities_view GROUP BY month; ---- .Results [opts="header"] |=== | month | pacepermile | time |2020-10 | 07:48 | 00:40:49 |2020-11 | 08:06 | 00:39:39 |2020-12 | 07:44 | 00:59:27 |=== If we wanted to also show the average pace per mile, we could do this using the `avg` function instead of the `min` function on the 2nd line of the query: [source,sql] ---- SELECT to_char(date_trunc('month', start_date), 'YYYY-MM') AS month, to_char(to_timestamp(min(moving_time / distance * 1609.34)), 'MI:SS') AS bestPacePerMile, to_char(to_timestamp(avg(moving_time / distance * 1609.34)), 'MI:SS') AS averagePacePerMile FROM activities_view GROUP BY month; ---- .Results [opts="header"] |=== |month | bestpacepermile | averagepacepermile |2020-10 | 07:48 | 08:00 |2020-11 | 08:06 | 08:23 |2020-12 | 07:44 | 08:04 |=== == In summary I've only skimmed the surface of what we can do with Materialize. From my understanding, a more common use case is to execute SQL queries over streaming data, whereas what we have here is a flat file with static content. I guess querying streaming data is the next thing for me to explore! //// materialize=> select * from activities; ERROR: Unable to automatically determine a timestamp for your query; this can happen if your query depends on non-materialized sources CREATE MATERIALIZED VIEW activities_view AS SELECT (val->>'id')::float::bigint AS id, (val->>'distance')::float AS distance, (val->>'moving_time')::float::int AS moving_time, (val->>'elapsed_time')::float::int AS elapsed_time FROM (SELECT text::json AS val FROM activities); CREATE MATERIALIZED VIEW activities_view AS SELECT (val->>'id')::float::bigint AS id, (val->>'distance')::float AS distance, (val->>'moving_time')::float::int AS moving_time, (val->>'elapsed_time')::float::int AS elapsed_time, (val->>'elev_high')::float AS elev_high, (val->>'elev_low')::float AS elev_low, (val->>'total_elevation_gain')::float AS total_elevation_gain FROM (SELECT text::json AS val FROM activities); ////

In this post we'll learn how to query a JSON file of Strava activites using the Materialize SQL streaming database.

uploads/2020/12/materialize-banner.png

materialize-querying-json-file

https://markhneedham.com/blog/2020/12/17/materialize-querying-json-file

2020-12-31 00:44:37

Materialize: Unable to automatically determine a timestamp for your query; this can happen if your query depends on non-materialized sources

This is another post describing https://markhneedham.com/blog/tag/materialize/[my exploration^] of https://materialize.com/[Materialize^], a SQL streaming database. In this post I'm going to explain a confusing (to me at least) error message that you might come across when you're getting started. As I mentioned in https://markhneedham.com/blog/2020/12/17/materialize-querying-json-file/[my first post about Materialize^], the general idea is that you create a source around a data resource and then a view on top of that. Those views can either be https://materialize.com/docs/overview/api-components/#materialized-views[materialized^] or https://materialize.com/docs/overview/api-components/#non-materialized-views[non-materialized^]. * A materialized view embeds a query like a traditional SQL view, but—unlike a SQL view—compute and incrementally update the results of the embedded query. * A non-materialized view stores a verbatim query, and provides a shorthand for performing the query. Before we decide what query the view is going to embed, we need to create a source. In this post, we'll use the following file that contains one JSON document: .data/covid_sample_small.json [source,json] ---- {"id": "1341755954614861826", "conversation_id": "1341755954614861826", "created_at": "2020-12-23 14:42:02 GMT", "date": "2020-12-23", "time": "14:42:02", "timezone": "+0000", "user_id": 856240505826496513, "username": "suriyasubraman", "name": "Suriya Subramanian", "place": "", "tweet": "Impact of COVID-19 On Internet of Things (IoT) Networks Market 2020 Industry Challenges ... https://t.co/ndGN2xRKzv #iot #data #internetofthings", "language": "en", "mentions": [], "urls": ["http://dlvr.it/RpCyyv"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["iot", "data", "internetofthings"], "cashtags": [], "link": "https://twitter.com/SuriyaSubraman/status/1341755954614861826", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} ---- [NOTE] ==== For brevity's sake, I'm not including instructions for how to install or connect to Materialize in this post. If you want to learn how to do that, see https://markhneedham.com/blog/2020/12/17/materialize-querying-json-file/[my post about querying JSON files with Materialize^]. ==== We can create a source for this file by running the following query: .CREATE SOURCE [source,sql] ---- CREATE SOURCE covid_sample_source FROM FILE '/data/covid_sample_small.json' WITH(tail=true) FORMAT TEXT; ---- Next, we're going to create a materialized view on top of this source so that we can query the data. At the moment we don't know which fields to include in that view, so let's see what we've got to work with, by running the following query: [source,sql] ---- SELECT * FROM covid_sample_source; ---- .Results |=== | ERROR: Unable to automatically determine a timestamp for your query; this can happen if your query depends on non-materialized sources |=== Hmmm, that's not what I expected to happen! I couldn't find any documentation explaining what to do about this error, so a trip to the https://materialize.com/s/chat[Materialize User Slack^] was needed! In a message on there, https://twitter.com/frankmcsherry[Frank McSherry^] pointed out that Materialize needs to determine a time for the query since the source represents a changing source of data. If we wrap the query in a materialized view this problem is taken care for us, otherwise we need to specify a timestamp using the `AS OF` syntax. Let's give that a try: [source,sql] ---- SELECT * FROM covid_sample_source AS OF 1; ---- .Results [opts="header", cols="5,1"] |=== | text | mz_line_no | {"id": "1341755954614861826", "conversation_id": "1341755954614861826", "created_at": "2020-12-23 14:42:02 GMT", "date": "2020-12-23", "time": "14:42:02", "timezone": "+0000", "user_id": "856240505826496513", "username": "suriyasubraman", "name": "Suriya Subramanian", "place": "", "tweet": "Impact of COVID-19 On Internet of Things (IoT) Networks Market 2020 Industry Challenges ... https://t.co/ndGN2xRKzv #iot #data #internetofthings", "language": "en", "mentions": [], "urls": ["http://dlvr.it/RpCyyv"], "photos": [], "replies_count": 0, "retweets_count": 0, "likes_count": 0, "hashtags": ["iot", "data", "internetofthings"], "cashtags": [], "link": "https://twitter.com/SuriyaSubraman/status/1341755954614861826", "retweet": false, "quote_url": "", "video": 0, "thumbnail": "", "near": "London", "geo": "", "source": "", "user_rt_id": "", "user_rt": "", "retweet_id": "", "reply_to": [], "retweet_date": "", "translate": "", "trans_src": "", "trans_dest": ""} | 1 |=== That's more like it! Now we can update our query to extract just the fields that we want using the https://materialize.com/docs/sql/functions/#json[JSON operators^]: [source,sql] ---- SELECT val->>'id' AS id, val->>'tweet' AS tweet, val->'hashtags' AS hashtags, val->>'date' AS date FROM (SELECT text::jsonb AS val FROM covid_sample_source) AS OF 1; ---- .Results [opts="header"] |=== |id | tweet | hashtags | date |1341755954614861826 | Impact of COVID-19 On Internet of Things (IoT) Networks Market 2020 Industry Challenges ... https://t.co/ndGN2xRKzv #iot #data #internetofthings | ["iot","data","internetofthings"] | 2020-12-23 |=== Once we're happy with our query, we can create a materialized view around the query, making sure to remove the `AS OF` bit: [source, sql] ---- CREATE MATERIALIZED VIEW covid_sample AS SELECT val->>'id' AS id, val->>'tweet' AS tweet, val->'hashtags' AS hashtags, val->>'date' AS date FROM (SELECT text::jsonb val FROM covid_sample_source); ---- We can now query the materialized view like so: [source,sql] ---- SELECT * FROM covid_sample; ----

In this post we'll learn how to workaround an initially confusing error message when querying with the Materialize SQL Streaming database.

materialize-unable-automatically-determine-timestamp-query

https://markhneedham.com/blog/2020/12/31/materialize-unable-automatically-determine-timestamp-query

2020-12-29 00:44:37

jq: How to change the value of keys in JSON documents

https://stedolan.github.io/jq/[jq^], the command-line JSON processor, is my favourite tool for transforming JSON documents. In this post we're going to learn how to use it to transform the values for specific keys in a document, while leaving everything else untouched. image::{{<siteurl>}}/uploads/2020/12/jq-banner.png[] We have the following file, which contains one JSON document: ./tmp/foo.json [source,json] ---- {"id":1341735877953904600,"conversation_id":"1341735877953904641","created_at":"2020-12-23 13:22:16 GMT","date":"2020-12-23","time":"13:22:16","timezone":"+0000","user_id":"972709154329591800","username":"dondaconceicao","name":"T N Biscuits","place":"","tweet":"Can’t imagine being sick with covid while living alone","language":"en","mentions":[],"urls":[],"photos":[],"replies_count":0,"retweets_count":0,"likes_count":1,"hashtags":[],"cashtags":[],"link":"https://twitter.com/dondaconceicao/status/1341735877953904641","retweet":false,"quote_url":"","video":0,"thumbnail":"","near":"London","geo":"","source":"","user_rt_id":"","user_rt":"","retweet_id":"","reply_to":[],"retweet_date":"","translate":"","trans_src":"","trans_dest":""} ---- We want to update the `id` field so that its value is a string rather than numeric value. We can do this using the https://stedolan.github.io/jq/manual/#tostring[`tostring`^] function, as shown below: [source,bash] ---- cat /tmp/foo.json | jq -c '.id=(.id|tostring)' ---- .Output [source,json] ---- {"id":"1341735877953904600","conversation_id":"1341735877953904641","created_at":"2020-12-23 13:22:16 GMT","date":"2020-12-23","time":"13:22:16","timezone":"+0000","user_id":"972709154329591800","username":"dondaconceicao","name":"T N Biscuits","place":"","tweet":"Can’t imagine being sick with covid while living alone","language":"en","mentions":[],"urls":[],"photos":[],"replies_count":0,"retweets_count":0,"likes_count":1,"hashtags":[],"cashtags":[],"link":"https://twitter.com/dondaconceicao/status/1341735877953904641","retweet":false,"quote_url":"","video":0,"thumbnail":"","near":"London","geo":"","source":"","user_rt_id":"","user_rt":"","retweet_id":"","reply_to":[],"retweet_date":"","translate":"","trans_src":"","trans_dest":""} ---- All the other fields are left as they were before. So far so good. But what if we want to change the `user_id` key as well? My first attempt was to comma separate the two filters: [source,bash] ---- cat /tmp/foo.json | jq -c '.id=(.id|tostring),.user_id=(.user_id|tostring)' ---- .Output [source,json] ---- {"id":"1341735877953904600","conversation_id":"1341735877953904641","created_at":"2020-12-23 13:22:16 GMT","date":"2020-12-23","time":"13:22:16","timezone":"+0000","user_id":"972709154329591800","username":"dondaconceicao","name":"T N Biscuits","place":"","tweet":"Can’t imagine being sick with covid while living alone","language":"en","mentions":[],"urls":[],"photos":[],"replies_count":0,"retweets_count":0,"likes_count":1,"hashtags":[],"cashtags":[],"link":"https://twitter.com/dondaconceicao/status/1341735877953904641","retweet":false,"quote_url":"","video":0,"thumbnail":"","near":"London","geo":"","source":"","user_rt_id":"","user_rt":"","retweet_id":"","reply_to":[],"retweet_date":"","translate":"","trans_src":"","trans_dest":""} {"id":1341735877953904600,"conversation_id":"1341735877953904641","created_at":"2020-12-23 13:22:16 GMT","date":"2020-12-23","time":"13:22:16","timezone":"+0000","user_id":"972709154329591800","username":"dondaconceicao","name":"T N Biscuits","place":"","tweet":"Can’t imagine being sick with covid while living alone","language":"en","mentions":[],"urls":[],"photos":[],"replies_count":0,"retweets_count":0,"likes_count":1,"hashtags":[],"cashtags":[],"link":"https://twitter.com/dondaconceicao/status/1341735877953904641","retweet":false,"quote_url":"","video":0,"thumbnail":"","near":"London","geo":"","source":"","user_rt_id":"","user_rt":"","retweet_id":"","reply_to":[],"retweet_date":"","translate":"","trans_src":"","trans_dest":""} ---- Hmmm, now we have two rows instead of one, which isn't what we want! Each filter has been applied individually rather than one after the other. We can fix this by piping one filter into the other using the `|` operator. Let's give that a try: [source,bash] ---- cat /tmp/foo.json | jq -c '.id=(.id|tostring) | .user_id=(.user_id|tostring)' ---- .Output [source,json] ---- {"id":"1341735877953904600","conversation_id":"1341735877953904641","created_at":"2020-12-23 13:22:16 GMT","date":"2020-12-23","time":"13:22:16","timezone":"+0000","user_id":"972709154329591800","username":"dondaconceicao","name":"T N Biscuits","place":"","tweet":"Can’t imagine being sick with covid while living alone","language":"en","mentions":[],"urls":[],"photos":[],"replies_count":0,"retweets_count":0,"likes_count":1,"hashtags":[],"cashtags":[],"link":"https://twitter.com/dondaconceicao/status/1341735877953904641","retweet":false,"quote_url":"","video":0,"thumbnail":"","near":"London","geo":"","source":"","user_rt_id":"","user_rt":"","retweet_id":"","reply_to":[],"retweet_date":"","translate":"","trans_src":"","trans_dest":""} ---- Much better!

In this post we'll learn how to change the values of specific keys in a JSON document using the jq command-line JSON processor.

uploads/2020/12/jq-banner.png

jq-change-value-multiple-keys

https://markhneedham.com/blog/2020/12/30/jq-change-value-multiple-keys

2020-12-15 00:44:37

Strava: Authorization Error - Missing activity:read_permission

I'm revisiting the Strava API after a two year absence and the approach to authenticating requests has changed in that time. You now need to generate an access token via OAuth 2.0, as described in the 'How to authenticate with OAuth 2.0' section of the http://developers.strava.com/docs/getting-started/#oauth[Getting Started with the Strava API^] guide. I want to generate a token that lets me retrieve all of my activities via the http://developers.strava.com/docs/reference/#api-Activities-getLoggedInAthleteActivities[`/athlete/activities`^] end point. I tried to do this by following these steps: . Go to https://www.strava.com/settings/api and copy your Client ID . Paste your Client ID into this URL: http://www.strava.com/oauth/authorize?client_id=[REPLACE_WITH_YOUR_CLIENT_ID]&response_type=code&redirect_uri=http://localhost/exchange_token&approval_prompt=force&scope=read . Go to a browser . Paste the URL you edited into the browser window (step 1 and 2 from the graph) . Hit enter . When you see the authorization page, click “Authorize” (step 3a from the graph) image::{{<siteurl>}}/uploads/2020/12/strava-1.png[title="Strava Authorisation"] Once we click on 'Authorize', the web browser redirects to a localhost URL that contains an authorisation code. For me, this URL looks like this: [source, text] ---- http://localhost/exchange_token?state=&code=b55003496d87a9f0b694ca1680cd5690d27d9d28&scope=read ---- We then take that code and feed it into another request, which will generate a refresh token, access token, and access token expiration date: [source,bash] ---- curl -X POST https://www.strava.com/oauth/token \ -F client_id=YOURCLIENTID \ -F client_secret=YOURCLIENTSECRET \ -F code=b55003496d87a9f0b694ca1680cd5690d27d9d28 \ -F grant_type=authorization_code ---- This request will will return a JSON response that looks like this: [source,json] ---- { "token_type": "Bearer", "expires_at": 1608060738, "expires_in": 18068, "refresh_token": "<refresh-token>", "access_token": "<access-token>", "athlete": { "id": 6958432, "username": null, "resource_state": 2, "firstname": "Mark", "lastname": "Needham", "city": "London", "state": "England", "country": "United Kingdom", "sex": "M", "premium": true, "summit": true, "created_at": "2014-11-01T10:48:26Z", "updated_at": "2020-08-10T06:23:51Z", "badge_type_id": 1, "profile_medium": "https://dgalywyr863hv.cloudfront.net/pictures/athletes/6958432/17352912/1/medium.jpg", "profile": "https://dgalywyr863hv.cloudfront.net/pictures/athletes/6958432/17352912/1/large.jpg", "friend": null, "follower": null } } ---- We can then take the `access_token` and use that on requests against other API endpoints. For example, to retrieve my activities, we can make the following request: [source, bash] ---- curl -X GET https://www.strava.com/api/v3/athlete/activities -H 'Authorization: Bearer <access-token>' ---- When I ran that, I got the following response: [source, json] ---- { "message": "Authorization Error", "errors": [ { "resource": "AccessToken", "field": "activity:read_permission", "code": "missing" } ] } ---- The mistake I've made was https://www.reddit.com/r/learnpython/comments/g135yz/strava_api_code_missing/[right at the beginning of the authentication process^], when selecting the 'scope' on the initial request. We used the following URL: [source,text] ---- http://www.strava.com/oauth/authorize?client_id=[REPLACE_WITH_YOUR_CLIENT_ID]&response_type=code&redirect_uri=http://localhost/exchange_token&approval_prompt=force&scope=read ---- The `scope` is set to `read` when this API end point requires `activity:read_all` permissions, so the URL should instead read like this: [source,text] ---- http://www.strava.com/oauth/authorize?client_id=[REPLACE_WITH_YOUR_CLIENT_ID]&response_type=code&redirect_uri=http://localhost/exchange_token&approval_prompt=force&scope=activity:read_all ---- And if we do that and use the authorisation code that it returns to generate an access token, it all works as expected. Now it's time to analyse those runs!

In this post we'll learn how to get an access token with appropriate permissions for the Strava API.

strava-authorization-error-missing-read-permission

https://markhneedham.com/blog/2020/12/15/strava-authorization-error-missing-read-permission

2018-03-20 17:51:10

Neo4j Desktop: undefined: Unable to extract host from undefined

During a training session I facilitated today one of the attendees got the following error message while trying to execute a query inside the Neo4j Desktop. image::{{<siteurl>}}/uploads/2018/03/2018-03-20_17-49-35.png[width="600px"] This error message happens if we try to run a query when the database hasn't been started, and would usually be accompanied by this screen: image::{{<siteurl>}}/uploads/2018/03/2018-03-20_17-56-48.png[width="600px"] On this occasion that wasn't happening, but we can easily fix it by going back to the project screen and starting the database: image::{{<siteurl>}}/uploads/2018/03/2018-03-20_17-58-54.png[width="600px"] Once we do that we'll be able to execute queries again.

Learn how to work around a weird message in the Neo4j browser.

neo4j-undefined-unable-to-extract-host-from-undefined

https://markhneedham.com/blog/2018/03/20/neo4j-undefined-unable-to-extract-host-from-undefined

2018-03-07 03:11:12

Neo4j Import: java.lang.IllegalStateException: Mixing specified and unspecified group belongings in a single import isn't supported

I've been working with the https://neo4j.com/docs/operations-manual/current/tools/import/[Neo4j Import Tool] recently after a bit of a break and ran into an interesting error message that I initially didn't understand. I had some CSV files containing nodes that I wanted to import into Neo4j. Their contents look like this: [source,bash] ---- $ cat people_header.csv name:ID(Person) $ cat people.csv "Mark" "Michael" "Ryan" "Will" "Jennifer" "Karin" $ cat companies_header.csv name:ID(Company) $ cat companies.csv "Neo4j" ---- I find it easier to use separate header files because I often make typos with my column names and it's easier to update a single line file than to open a multi-million line file and change the first line. I ran the following command to create a new Neo4j database from these files: [source,bash] ---- $ ./bin/neo4j-admin import \ --database=blog.db \ --mode=csv \ --nodes:Person people_header.csv,people.csv \ --nodes:Company companies_heade.csv,companies.csv ---- which resulted in this error message: [source,bash] ---- Neo4j version: 3.3.3 Importing the contents of these files into /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/data/databases/blog.db: Nodes: :Person /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/people_header.csv /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/people.csv :Company /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/companies.csv ... Import error: Mixing specified and unspecified group belongings in a single import isn't supported Caused by:Mixing specified and unspecified group belongings in a single import isn't supported java.lang.IllegalStateException: Mixing specified and unspecified group belongings in a single import isn't supported at org.neo4j.unsafe.impl.batchimport.input.Groups.getOrCreate(Groups.java:52) at org.neo4j.unsafe.impl.batchimport.input.csv.InputNodeDeserialization.initialize(InputNodeDeserialization.java:60) at org.neo4j.unsafe.impl.batchimport.input.csv.InputEntityDeserializer.initialize(InputEntityDeserializer.java:68) at org.neo4j.unsafe.impl.batchimport.input.csv.ParallelInputEntityDeserializer.lambda$new$0(ParallelInputEntityDeserializer.java:104) at org.neo4j.unsafe.impl.batchimport.staging.TicketedProcessing.lambda$submit$1(TicketedProcessing.java:103) at org.neo4j.unsafe.impl.batchimport.executor.DynamicTaskExecutor$Processor.run(DynamicTaskExecutor.java:237) ---- The output actually helpfully indicates which files it's importing from and we can see under the 'Company' section that the header file is missing. As a result of the typo I made when trying to type +++<cite>+++companies_header.csv+++</cite>+++, the tool now treats the first line of +++<cite>+++companies.csv+++</cite>+++ as the header and since we haven't specified a group (e.g. Company, Person) on that line we receive this error. Let's fix the typo and try again: [source,bash] ---- $ ./bin/neo4j-admin import \ --database=blog.db \ --mode=csv \ --nodes:Person people_header.csv,people.csv \ --nodes:Company companies_header.csv,companies.csv Neo4j version: 3.3.3 Importing the contents of these files into /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/data/databases/blog.db: Nodes: :Person /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/people_header.csv /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/people.csv :Company /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/companies_header.csv /Users/markneedham/Library/Application Support/Neo4j Desktop/Application/neo4jDatabases/database-b59e33d5-2060-4a5d-bdb8-0b9f6dc919fa/installation-3.3.3/companies.csv ... IMPORT DONE in 1s 5ms. Imported: 7 nodes 0 relationships 7 properties Peak memory usage: 480.00 MB ---- Success!

neo4j-import-java-lang-illegalstateexception-mixing-specified-unspecified-group-belongings-single-import-isnt-supported

https://markhneedham.com/blog/2018/03/07/neo4j-import-java-lang-illegalstateexception-mixing-specified-unspecified-group-belongings-single-import-isnt-supported

2018-03-13 21:57:14

Running asciidoctor-pdf on TeamCity

I've been using https://asciidoctor.org/docs/asciidoctor-pdf/[asciidoctor-pdf] to generate PDF and while I was initially running the tool locally I eventually decided to setup a build on TeamCity. It was a bit trickier than I expected, mostly because I'm not that familiar with deploying Ruby applications, but I thought I'd capture what I've done for future me. I have the following +++<cite>+++Gemfile+++</cite>+++ that installs asciidoctor-pdf and its dependencies: +++<cite>+++Gemfile+++</cite>+++ [source,text] ---- source 'https://rubygems.org' gem 'prawn' gem 'addressable' gem 'prawn-svg' gem 'prawn-templates' gem 'asciidoctor-pdf' ---- I don't have permissions to install gems globally on the build agents so I'm bundling those up into the +++<cite>+++vendor+++</cite>+++ directory. It's been a long time since I worked on a Ruby application so perhaps that's par for the course. [source,bash] ---- bundle install --path vendor/ bundle package ---- On the build agent I'm running the following script: [source,bash] ---- export PATH="$PATH:/home/teamcity/.gem/ruby/2.3.0/bin" mkdir $PWD/gems export GEM_HOME="$PWD/gems" gem install bundler --user-install --no-rdoc --no-ri && bundle install ./vendor/ruby/2.3.0/bin/asciidoctor-pdf -a allow-uri-read blog.adoc ---- I override where gems should be installed and then execute the +++<cite>+++asciidoctor-pdf+++</cite>+++ executable from the vendor directory. It all seems to work quite nicely but if there's a better approach that I should be taking so let me know in the comments.

running-asciidoctor-pdf-teamcity

https://markhneedham.com/blog/2018/03/13/running-asciidoctor-pdf-teamcity

2018-03-14 16:53:33

Neo4j: Cypher - Neo.ClientError.Statement.TypeError: Don't know how to add Double and String

I recently upgraded a Neo4j backed application from Neo4j 3.2 to Neo4j 3.3 and came across an interesting change in behaviour around type coercion which led to my application throwing a bunch of errors. In Neo4j 3.2 and earlier if you added a String to a Double it would coerce the Double to a String and concatenate the values. The following would therefore be valid Cypher: [source,cypher] ---- RETURN toFloat("1.0") + " Mark" ╒══════════╕ │"result" │ ╞══════════╡ │"1.0 Mark"│ └──────────┘ ---- This behaviour has changed in the 3.3 series and will instead throw an exception: [source,cypher] ---- RETURN toFloat("1.0") + " Mark" Neo.ClientError.Statement.TypeError: Don't know how to add `Double(1.000000e+00)` and `String(" Mark")` ---- We can workaround that by forcing our query to run in 3.2 mode: [source,cypher] ---- CYPHER 3.2 RETURN toFloat("1.0") + " Mark" AS result ---- or we can convert the Double to a String in our Cypher statement: [source,cypher] ---- RETURN toString(toFloat("1.0")) + " Mark" AS result ----

neo4j-cypher-neo-clienterror-statement-typeerror-dont-know-add-double-string

https://markhneedham.com/blog/2018/03/14/neo4j-cypher-neo-clienterror-statement-typeerror-dont-know-add-double-string

2018-03-14 08:53:04

Yelp: Reverse geocoding businesses to extract detailed location information

I've been playing around with the https://www.yelp.co.uk/dataset[Yelp Open Dataset] and wanted to extract more detailed location information for each business. This is an example of the JSON representation of one business: [source,bash] ---- $ cat dataset/business.json | head -n1 | jq { "business_id": "FYWN1wneV18bWNgQjJ2GNg", "name": "Dental by Design", "neighborhood": "", "address": "4855 E Warner Rd, Ste B9", "city": "Ahwatukee", "state": "AZ", "postal_code": "85044", "latitude": 33.3306902, "longitude": -111.9785992, "stars": 4, "review_count": 22, "is_open": 1, "attributes": { "AcceptsInsurance": true, "ByAppointmentOnly": true, "BusinessAcceptsCreditCards": true }, "categories": [ "Dentists", "General Dentistry", "Health & Medical", "Oral Surgeons", "Cosmetic Dentists", "Orthodontists" ], "hours": { "Friday": "7:30-17:00", "Tuesday": "7:30-17:00", "Thursday": "7:30-17:00", "Wednesday": "7:30-17:00", "Monday": "7:30-17:00" } } ---- The businesses reside in different countries so I wanted to extract the area/county/state and the country for each of them. I found the https://github.com/thampiman/reverse-geocoder[reverse-geocoder] library which is perfect for this problem. You give the library a lat/long or list of lat/longs and it returns you back a list containing the nearest lat/long to your points along with the name of the place, Admin regions, and country code. It's way quicker to pass in a list of lat/longs than to call the function individually for each lat/long so we'll do that. We can write the following code to extract location information for a list of lat/longs: [source,python] ---- import reverse_geocoder as rg lat_longs = { "FYWN1wneV18bWNgQjJ2GNg": (33.3306902, -111.9785992), "He-G7vWjzVUysIKrfNbPUQ": (40.2916853, -80.1048999), "KQPW8lFf1y5BT2MxiSZ3QA": (33.5249025, -112.1153098) } business_ids = list(lat_longs.keys()) locations = rg.search(list(lat_longs.values())) for business_id, location in zip(business_ids, locations): print(business_id, lat_longs[business_id], location) ---- This is the output we get from running the script: [source,bash] ---- $ python blog.py Loading formatted geocoded file... FYWN1wneV18bWNgQjJ2GNg (33.3306902, -111.9785992) OrderedDict([('lat', '33.37088'), ('lon', '-111.96292'), ('name', 'Guadalupe'), ('admin1', 'Arizona'), ('admin2', 'Maricopa County'), ('cc', 'US')]) He-G7vWjzVUysIKrfNbPUQ (40.2916853, -80.1048999) OrderedDict([('lat', '40.2909'), ('lon', '-80.10811'), ('name', 'Thompsonville'), ('admin1', 'Pennsylvania'), ('admin2', 'Washington County'), ('cc', 'US')]) KQPW8lFf1y5BT2MxiSZ3QA (33.5249025, -112.1153098) OrderedDict([('lat', '33.53865'), ('lon', '-112.18599'), ('name', 'Glendale'), ('admin1', 'Arizona'), ('admin2', 'Maricopa County'), ('cc', 'US')]) ---- It seems to work fairly well! Now we just need to tweak our script to read in the values from the Yelp JSON file and generate a new JSON file containing the locations: [source,python] ---- import json import reverse_geocoder as rg lat_longs = {} with open("dataset/business.json") as business_json: for line in business_json.readlines(): item = json.loads(line) if item["latitude"] and item["longitude"]: lat_longs[item["business_id"]] = { "lat_long": (item["latitude"], item["longitude"]), "city": item["city"] } result = {} business_ids = list(lat_longs.keys()) locations = rg.search([value["lat_long"] for value in lat_longs.values()]) for business_id, location in zip(business_ids, locations): result[business_id] = { "country": location["cc"], "name": location["name"], "admin1": location["admin1"], "admin2": location["admin2"], "city": lat_longs[business_id]["city"] } with open("dataset/businessLocations.json", "w") as business_locations_json: json.dump(result, business_locations_json, indent=4, sort_keys=True) ---- And that's it!

yelp-reverse-geocoding-businesses-extract-detailed-location-information

https://markhneedham.com/blog/2018/03/14/yelp-reverse-geocoding-businesses-extract-detailed-location-information

2018-04-29 11:54:02

PyData London 2018 Conference Experience Report

Over the last few days I attended https://pydata.org/london2018/schedule/[PyData London 2018^] and wanted to share my experience. The PyData series of conferences aim to bring together users and developers of data analysis tools to share ideas and learn from each other. I presented a talk on https://www.youtube.com/watch?v=VGCCVNlZmRI[building a recommendation with Python and Neo4j^] at the 2016 version but didn't attend last year. The organisers said there were ~ 550 attendees spread over 1 day of tutorials and 2 days of talks. From what I could tell most attendees were Data Scientists so I was in the minority as a Software Developer. == tl;dr * Text Analysis using Tensorflow is the (new) hotness. * Everything else seems to centre around scikit-learn's API. * The on site childcare the conference provided was a great idea. Hopefully that will catch on at other conferences. * This is a great conference for learning how to apply technology to solve data problems. There were a lot of talks so I'll just give a shoutout to a few of my favourite ones. == Friday Gilbert François Duivesteijn's tutorial about https://pydata.org/london2018/schedule/presentation/9/[tagging his team's Slack messages^] was very interesting and something that I hadn't thought about before. Gilbert's team have a channel where they indicate if they're working from home, off sick, at a client meeting, etc and he wanted to automatically classify these messages. It was mostly standard scikit-learn stuff except Gilbert wrote his own tokenizer because people often don't punctuate Slack messages properly and this was messing up the classifier. After getting an introduction to text analysis by Gilbert I was hoping to attend Kajal Puri's talk about https://pydata.org/london2018/schedule/presentation/12/[building text classification models^], but that one was cancelled. At the last minute Vincent D. Warmerdam stepped in and did a mini tutorial showing how to use the https://github.com/jmschrei/pomegranate[pomegranate^] library to do probabilistic modelling. It was very cool but I'm not sure that I have a problem to use it on at the moment. In the afternoon I attended a session on https://pydata.org/london2018/schedule/presentation/8/[Network Science with NetworkX^] run by https://twitter.com/mridul_seth[Mridul Seth^] which used the https://www.macalester.edu/~abeverid/thrones.html[Game of Thrones^] dataset - the exact same one that we've been using in our network science training sessions, so I was quite excited about that. The room was absolutely packed for this one and most people hadn't done anything with graphs yet based on a show of hands at the beginning of the session. Most of the session was spent https://github.com/MridulS/pydata-networkx/blob/master/Game%20of%20Thrones%20-%20Lecture%20.ipynb[exploring the changing influence of Game of Thrones characters^] over the different books. I'm currently working on a NetworkX API for Neo4j Graph Algorithms so if you like NetworkX and want to try out Neo4j take a look at the https://github.com/neo4j-graph-analytics/networkx-neo4j[neo4j-graph-analytics/networkx-neo4j^] repository and let me know what you think. == Saturday http://theowindebank.co.uk/cv.html[Theo Windebank^] spoke about https://pydata.org/london2018/schedule/presentation/26/[how the BBC are using semantic web and linked data technologies to build a content graph^] of the data they have inside the BBC. There was an interesting discussion about why these technologies haven't taken off as they were expected to, and Theo observed that companies probably aren't going to open up all their data but that the tools are still useful for making sense of data inside an organisation. image::{{<siteurl>}}/uploads/2018/04/IMG_20180428_144134.jpg[width="600px", alt="BBC Connected Data"] Mike Walmsley explained how the https://www.zooniverse.org/[Zooniverse^] are https://pydata.org/london2018/schedule/presentation/33/[using a combination of deep learning and humans to help label galaxies^]. This is a technique called Active Learning, which I first came across when playing around with the https://github.com/dedupeio/dedupe[dedupe^] library. I also watched https://twitter.com/arplynn/[Alistair Lynn^]'s https://pydata.org/london2018/schedule/presentation/19/[talk about A/B testing^] in which he talked through his experience A/B testing features https://www.thread.com/[thread.com^]. My main take away was that it's much easier to manage multiple tests if you assign users into buckets and assign the control or test based on the bucket rather than dealing with users individually. He also emphasised the need to be aware of our own tendency to confirmation bias when looking at test results. https://thuijskens.github.io/about/[Thomas Huijskens^] gave a great overview of the different ways that we can https://pydata.org/london2018/schedule/presentation/31/[select features for our machine learning models^]. Apart from scikit-learn he suggested using http://rasbt.github.io/mlxtend/[mlxtend^] and https://github.com/skggm/skggm[skggm^] to help with this process. Now I need to enter some Kaggle competitions so I can give them a try! == Sunday Sunday opened with a https://pydata.org/london2018/schedule/presentation/51/[keynote^] by https://twitter.com/EGouillart[Emmanuelle Gouillart^] about her experience working on http://scikit-image.org/[scikit-image^] and encouraged others to get involved with open source science. There was also an excellent section on the importance of well written documentation to help get people ramped up on your project. Emmanuelle also thanked the PyData organisers for having onsite childcare, without which she may have been unable to attend. image::{{<siteurl>}}/uploads/2018/04/IMG_20180429_090920_small.jpg[width="600px", alt="On Site Childcare #ftw"] As one of my side projects I'm trying to work out how to parse ingredient names from recipes and I'm not sure where to start, so I was quite happy to attend a talk by Carsten van Weelden where he https://pydata.org/london2018/schedule/presentation/55/[showed how to use Tensorflow to solve a similar problem^]. https://www.textkernel.com/[Carsten's team^] are pulling job titles and company names out of resumes using Recurrent Neural Networks and I think I now know enough to get started with my problem. The https://drive.google.com/file/d/1dJ4nKTvoxslMsckgPMzgG23WPbeEK32T/view[slides from this talk^] were very helpful. https://twitter.com/astroadamh[Adam Hill^] presented https://pydata.org/london2018/schedule/presentation/17/[Searching for Shady Patterns: Shining a light on UK corporate ownership^], in which he showed how DataKind and Global Witness used Neo4j to find leads for investigative journalism to expose corrupt practices from the corporate ownership dataset. Adam presented his early work on this project at the https://www.meetup.com/graphdb-london/[Neo4j London Meetup^] in March 2017 so it was really cool to see how far it's come along. I also attended Aileen Nielsen's talk about fairness and inclusion in our work. Aileen went through many different examples of how unconscious bias can creep into algorithms if we're not careful. It reminded me of a book I recently read - https://www.amazon.co.uk/Weapons-Math-Destruction-Increases-Inequality-ebook/dp/B01LDFCP0S/[Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy^] - which was actually referenced towards the end of the talk. Overall it was a really enjoyable conference and I'm looking forward to the 2019 version! If you can't wait that long there's always https://pydata.org/berlin2018/[PyData Berlin^] which is on 6-8 July 2018.

pydata-london-2018

https://markhneedham.com/blog/2018/04/29/pydata-london-2018

2018-05-04 22:03:08

Python via virtualenv on Mac OS X: RuntimeError: Python is not installed as a framework.

I've previously written https://markhneedham.com/blog/2016/08/14/python-matplotlibseabornvirtualenv-python-is-not-installed-as-a-framework/[a couple^] https://markhneedham.com/blog/2015/03/26/python-matplotlib-hangs-and-shows-nothing-mac-os-x/[of blog posts^] about my troubles getting matplotlib to play nicely and I run into a slightly different variant today while following Sidath Asiri's https://towardsdatascience.com/hello-world-in-tensorflow-973e6c38e8ed[Hello World in TensorFlow^] tutorial. When I ran the script using a version of Python installed via virtualenv I got the following exception: [source,bash] ---- Traceback (most recent call last): File "iris.py", line 4, in <module> from matplotlib import pyplot as plt File "/Users/markneedham/projects/tensorflow-playground/a/lib/python3.6/site-packages/matplotlib/pyplot.py", line 116, in <module> _backend_mod, new_figure_manager, draw_if_interactive, _show = pylab_setup() File "/Users/markneedham/projects/tensorflow-playground/a/lib/python3.6/site-packages/matplotlib/backends/__init__.py", line 60, in pylab_setup [backend_name], 0) File "/Users/markneedham/projects/tensorflow-playground/a/lib/python3.6/site-packages/matplotlib/backends/backend_macosx.py", line 17, in <module> from matplotlib.backends import _macosx RuntimeError: Python is not installed as a framework. The Mac OS X backend will not be able to function correctly if Python is not installed as a framework. See the Python documentation for more information on installing Python as a framework on Mac OS X. Please either reinstall Python as a framework, or try one of the other backends. If you are using (Ana)Conda please install python.app and replace the use of 'python' with 'pythonw'. See 'Working with Matplotlib on OSX' in the Matplotlib FAQ for more information. ---- The solution this time was actually the same as it was in my post where I https://markhneedham.com/blog/2015/03/26/python-matplotlib-hangs-and-shows-nothing-mac-os-x/[described matplotlib hanging^]. Instead of: [source,python] ---- from matplotlib import pyplot as plt ---- We need to define a different backend, like this: [source,python] ---- import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt ---- I also learnt an even simpler way of solving the problem via https://stackoverflow.com/questions/34977388/matplotlib-runtimeerror-python-is-not-installed-as-a-framework[this StackOverflow post^]. We can achieve the same outcome by creating a file at `~/.matplotlib/matplotlibrc` and populating it with the following text: [source,bash] ---- $ cat ~/.matplotlib/matplotlibrc backend: TkAgg ---- Now we can go back to importing matplotlib without the need to define the backend each time. Success!

Learn how to work around the RuntimeError: Python is not installed as a framework. error that you might see running matplotlib on Mac OS X.

python-runtime-error-osx-matplotlib-not-installed-as-framework-mac

https://markhneedham.com/blog/2018/05/04/python-runtime-error-osx-matplotlib-not-installed-as-framework-mac

2018-05-05 00:31:34

Tensorflow 1.8: Hello World using the Estimator API

Over the last week I've been going over various Tensorflow tutorials and one of the best ones when getting started is Sidath Asiri's https://towardsdatascience.com/hello-world-in-tensorflow-973e6c38e8ed[Hello World in TensorFlow^], which shows how to build a simple linear classifier on the Iris dataset. I'll use the same data as Sidath, so if you want to follow along you'll need to download these files: * http://download.tensorflow.org/data/iris_training.csv[iris_training.csv^] * http://download.tensorflow.org/data/iris_test.csv[iris_test.csv] == Loading data The way we load data will remain exactly the same - we'll still be reading it into a Pandas dataframe: [source,python] ---- import pandas as pd import tensorflow as tf train_data = pd.read_csv("iris_training.csv", names=['f1', 'f2', 'f3', 'f4', 'f5']) test_data = pd.read_csv("iris_test.csv", names=['f1', 'f2', 'f3', 'f4', 'f5']) ---- The next bit is slightly different though. We want to split these dataframes into features ('X') and labels ('Y'). The label is a value 1, 2, or 3, which indicates which type of flower that row represents. In Sidath's tutorial he created a one hot encoding for those values, such that: [source,text] ---- 0 -> [1,0,0] 1 -> [0,1,0] 2 -> [0,0,1] ---- We won't do that. Instead we'll leave that column as a single value. [source,python] ---- train_x = train_data[['f1', 'f2', 'f3', 'f4']] train_y = train_data.ix[:, 'f5'] test_x = test_data[['f1', 'f2', 'f3', 'f4']] test_y = test_data.ix[:, 'f5'] ---- == Defining features Next we need to define our features in terms of Tensors. There are some quite nice helper functions that can help us out here: [source,python] ---- feature_columns = [tf.feature_column.numeric_column(key=key) for key in train_x.keys()] ---- == Creating the classifier And finally we can create our classifier! [source,python] ---- classifier = tf.estimator.LinearClassifier(feature_columns=feature_columns, n_classes=3) ---- We feed in the features that we created above and we tell the classifier that it should be predicting 3 classes. == Training the classifier Now we need to train our model. To do this we need to https://www.tensorflow.org/programmers_guide/estimators[create an input function^] that returns a tuple containing: * a dictionary in which the keys are feature names and the values are Tensors (or SparseTensors) containing the corresponding feature data * a Tensor containing one or more labels I spent a while going around in circles trying to figure out how to do this but eventually stumbled across a helpful example from the https://github.com/tensorflow/models/blob/master/samples/core/get_started/iris_data.py#L30[Tensorflow samples^] repository. This is what our function looks like: [source,python] ---- def train_input_fn(features, labels, batch_size): dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) return dataset.shuffle(1000).repeat().batch(batch_size) ---- And now we can use it to feed data into the `train` function: [source,python] ---- classifier.train( input_fn=lambda: train_input_fn(train_x, train_y, 100), steps=2000) ---- So far so good! == Evaluating the classifier Finally we can evaluate how well our model is doing. We'll create another input function, but this one won't bother shuffling the data: [source,python] ---- def eval_input_fn(features, labels, batch_size): features = dict(features) inputs = (features, labels) dataset = tf.data.Dataset.from_tensor_slices(inputs) assert batch_size is not None, "batch_size must not be None" return dataset.batch(batch_size) ---- And now we can call the `evaluate` function: [source,python] ---- eval_result = classifier.evaluate( input_fn=lambda: eval_input_fn(test_x, test_y, 100)) print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result)) ---- If we run the program we'll see the following output: [source,python] ---- $ python iris_estimator.py Test set accuracy: 0.967 ---- == All the codez Below you can see https://gist.github.com/mneedham/12754c600fc99c8cbaa626e126337966[all the code in one script^] that you can try out yourself. ++++ <script src="https://gist.github.com/mneedham/12754c600fc99c8cbaa626e126337966.js"></script> ++++

A simple tutorial to help you get started with Tensorflow using the Estimator API released in Tensorflow 1.4, using the Iris dataset.

tensorflow-18-hello-world-using-estimator-api

https://markhneedham.com/blog/2018/05/05/tensorflow-18-hello-world-using-estimator-api

2018-05-11 08:08:21

Exploring node2vec - a graph embedding algorithm

In my explorations of graph based machine learning, one algorithm I came across is called http://snap.stanford.edu/node2vec/[node2Vec^]. The https://cs.stanford.edu/~jure/pubs/node2vec-kdd16.pdf[paper^] describes it as "an algorithmic framework for learning continuous feature representations for nodes in networks". So what does the algorithm do? From the website: ____ The node2vec framework learns low-dimensional representations for nodes in a graph by optimizing a neighborhood preserving objective. The objective is flexible, and the algorithm accommodates for various definitions of network neighborhoods by simulating biased random walks. ____ [[running-node2vec]] == Running node2Vec We can try out an implementation of the algorithm by executing the following instructions: [source, bash] ---- git clone [email protected]:snap-stanford/snap.git cd snap/examples/node2vec make ---- We should end up with an executable file named `node2vec`: [source, bash] ---- $ ls -alh node2vec -rwxr-xr-x 1 markneedham staff 4.3M 11 May 08:14 node2vec ---- The download includes the https://en.wikipedia.org/wiki/Zachary%27s_karate_club[Zachary Karate Club^] dataset. We can inspect that dataset to see what format of data is expected. The data lives in `graph/karate.edgelist`. The contents of that file are as follows: [source, bash] ---- cat graph/karate.edgelist | head -n10 1 32 1 22 1 20 1 18 1 14 1 13 1 12 1 11 1 9 1 8 ---- The algorithm is then executed like this: [source, bash] ---- ./node2vec -i:graph/karate.edgelist -o:emb/karate.emb -l:3 -d:24 -p:0.3 -dr -v ---- [source, bash] ---- $ cat emb/karate.emb | head -n5 35 24 31 -0.0419165 0.0751558 0.0777881 -0.13651 -0.0723484 0.131121 -0.133643 0.0329049 0.0891693 0.0898324 0.0177763 -0.0947387 0.0152228 -0.00862188 0.0383254 0.222333 0.117794 0.189328 0.0327467 0.142506 -0.0787722 0.0757344 -0.0127497 -0.0305164 33 -0.105675 0.287809 0.20373 -0.247271 -0.222551 0.257689 -0.258127 0.0844224 0.182316 0.178839 0.0792992 -0.166362 0.114856 0.0422123 0.152787 0.551674 0.332224 0.487846 0.0619851 0.386913 -0.142459 0.173472 0.0184598 -0.100818 34 0.0121748 0.0941794 0.20482 -0.430609 -0.08399 0.293788 -0.322655 0.0704057 0.116873 0.214754 0.138378 -0.207141 -0.0159013 -0.238914 0.037141 0.541439 0.324653 0.458905 0.0216556 0.270057 -0.204671 0.135203 -0.0818273 -0.122353 14 -0.0722407 0.162659 0.111612 -0.20907 -0.11984 0.15896 -0.175391 0.0642012 0.094021 0.125609 0.0465577 -0.131715 0.0683675 -0.0097801 0.0467595 0.340551 0.210111 0.279932 0.0283343 0.231359 -0.112208 0.114253 0.00908989 -0.0907061 ---- We now have an embedding for each of our people. These embeddings aren't very interesting on their own but we can do interesting things with them. One approach when doing exploratory data analysis is to reduce each of the vectors to 2 dimensions so that we can visualise them more easily. == t-SNE https://lvdmaaten.github.io/tsne/[t-Distributed Stochastic Neighbor Embedding^] (t-SNE) is a popular technique for doing this and has implementations in many languages. We'll give the https://lvdmaaten.github.io/tsne/code/tsne_python.zip[Python version^] a try, but there is also a https://github.com/lejon/T-SNE-Java[Java version^] if you prefer that. Once we've downloaded that we can create a script containing the following code: [source, bash] ---- from tsne import tsne import numpy as np import pylab X = np.loadtxt("karate.emb", skiprows=1) X = np.array([x[1:] for x in X]) Y = tsne(X, 2, 50, 20.0) pylab.scatter(Y[:, 0], Y[:, 1], 20) pylab.show() ---- We load the embeddings from the file we created earlier, making sure to skip the first row since that contains the node id which we aren't interested in here. If we run the script it will output this chart: image::{{<siteurl>}}/uploads/2018/05/2018-05-11_09-46-36.png[] It's not all that interesting to be honest! This type of visualisation will often reveal a clustering between items but that isn't the case here. Now I need to give this a try on a bigger dataset to see if I can find some interesting insights!

A worked example showing how to run the node2Vec algorithm and visualise the output using the t-SNE algorithm.

exploring-node2vec-graph-embedding-algorithm

https://markhneedham.com/blog/2018/05/11/exploring-node2vec-graph-embedding-algorithm

2018-05-11 08:12:21

Predicting movie genres with node2Vec and Tensorflow

In my previous post we looked at how to get https://www.markhneedham.com/blog/2018/05/exploring-node2vec-graph-embedding-algorithm[up and running with the node2Vec algorithm^], and in this post we'll learn how we can feed graph embeddings into a simple Tensorflow model. Recall that node2Vec takes in a list of edges (or relationships) and gives us back an embedding (array of numbers) for each node. This time we're going to run the algorithm over a movies recommendation dataset from the https://neo4j.com/sandbox-v2/[Neo4j Sandbox^]. If you want to follow along you'll need to launch the 'recommendations' sandbox. You should see something like this once it's started: image::{{<siteurl>}}/uploads/2018/05/2018-05-11_10-02-20.png[] == Building an edge list Our first job is to generate a file containing edges that we can feed to node2Vec. The following code will do the trick: [source, python] ---- import csv from neo4j.v1 import GraphDatabase, basic_auth host = "bolt://localhost" # replace this with your Sandbox host password = "neo" # replace this with your Sandbox password driver = GraphDatabase.driver(, auth=basic_auth("neo4j", password)) with driver.session() as session, open("graph/movies.edgelist", "w") as edges_file: result = session.run("""\ MATCH (m:Movie)--(other) RETURN id(m) AS source, id(other) AS target """) writer = csv.writer(edges_file, delimiter=" ") for row in result: writer.writerow([row["source"], row["target"]]) ---- We're getting back all the relationships from movies to anything else. The `id()` function returns the internal identifier for each of the nodes returned in the `MATCH` clause. We end up with a file that looks like this: [source, bash] ---- $ cat graph/movies.edgelist | head -n10 0 1 0 2 0 3 0 4 0 6 0 9774 0 9780 0 9785 0 9791 0 9790 ---- == Running node2Vec Now we're ready to run node2Vec to get embeddings for each of our nodes. I explained https://www.markhneedham.com/blog/2018/05/exploring-node2vec-graph-embedding-algorithm[how to install the Stanford implementation of the algorithm in the previous post^] so revisit that one if you want to follow along. Running the following script will create an embedding of 100 elements for each node. The length of the random walk component of the algorithm will be 80 hops. These numbers are guesswork so it might be that some other values would work better. [source, bash] ---- ./node2vec -i:graph/movies.edgelist -o:emb/movies.emb -l:80 -d:100 -p:0.3 -dr -v ---- Our output should look like this: [source, bash] ---- $ cat emb/movies.emb | head -n5 32314 100 14243 0.002886 -0.0009521 0.0224149 0.0211797 -0.0234808 0.0465503 -0.0242661 -0.0108606 0.0124484 -0.0342895 0.0115387 0.0243817 0.00805514 0.0080248 0.0051944 0.025798 -0.00788376 -0.0251952 -0.048099 0.0127707 0.0194209 0.00763978 -0.0130131 -0.0230401 0.0147994 -0.00373403 0.00196932 -0.000321203 0.0118537 0.00496018 -0.0114329 0.00832536 0.00903396 -0.00277039 0.0143092 0.0031493 -0.016161 -0.0124357 0.00809057 0.0129928 -0.0158231 0.0282883 -0.0114194 0.00480747 -0.000219177 0.0172819 -0.0402172 -0.0281593 -0.00179042 0.0272349 -0.00990981 -0.00709573 -0.0323773 0.0208203 -0.0316696 0.00452456 -0.0253643 0.00837943 -0.0234769 0.00504737 0.0120566 -0.00537971 -0.00255093 0.0209391 0.020711 0.016786 0.0271043 0.00830118 0.0131981 0.00775244 -0.00629482 -0.0149914 0.0269024 -0.00378804 0.00938015 0.0264441 0.00919089 0.0158234 0.00182008 0.00721888 0.0101987 -0.00948434 -0.00220668 0.00522284 -0.00246156 0.0209852 -0.0178339 -0.0028442 0.00806226 -0.0066889 -0.00723828 0.0461259 0.00875541 0.0062631 0.0104947 -0.0140804 0.0241079 -0.026269 0.0136609 -0.00429287 0 0.14308 0.573671 0.696905 0.382039 -0.63165 0.690953 -0.127411 -0.325989 0.219356 -0.810672 0.0769492 0.69869 0.475756 0.56377 0.0867368 0.243866 -0.495199 0.10085 -0.759924 0.500157 0.693239 0.508205 -0.861352 -0.919493 0.537185 0.176292 0.146458 -0.413557 0.408049 0.0471144 -0.14392 0.20072 0.470296 0.197094 0.238148 -0.296311 -0.275903 0.248415 0.00279996 0.204512 0.415326 0.658922 0.576313 0.364277 -0.515041 0.387918 -0.566269 -0.46252 0.125421 0.734148 -0.0903596 -0.313846 -0.741623 0.428222 -0.534838 0.0441242 -0.6724 0.513446 -0.71289 -0.0973926 0.269651 0.179949 0.495639 0.56465 0.79435 0.708972 0.947383 -0.124569 0.420107 0.559592 -0.19149 -0.440302 0.657272 -0.0282963 -0.100281 0.251455 0.251974 0.646931 -0.29645 -0.175667 -0.459531 -0.269747 -0.182972 0.345404 0.0459218 0.676589 -0.38854 0.0952728 0.623066 0.323733 0.426018 0.569366 0.670057 0.796834 0.778748 -0.850252 0.674652 -0.857651 0.466597 -0.184641 6881 -0.0069373 -0.0182842 -0.00250641 -0.014827 0.0238218 -0.0157951 0.0105609 0.0134582 -0.000478559 0.0159776 0.0134371 -0.0187747 -0.0202883 -0.0192247 0.00997851 -0.0037014 0.0228678 -0.0110792 0.0168576 -0.00694089 -0.0279912 -0.00846954 0.032771 0.0334678 -0.00983781 -0.0208949 -0.00198547 0.0237212 -0.00677631 -0.000485477 -0.00211323 0.00385676 -0.00488553 -0.00991322 0.00616214 0.0130523 -0.00123142 -0.00466244 -0.000123816 -0.00937801 -0.0159647 -0.0217866 -0.0255627 -0.00232269 0.00521148 0.00464528 0.00146591 0.0133423 -0.0116764 -0.0231797 0.001886 0.0194517 0.00968319 -0.013389 0.00238838 -0.00150677 0.0145389 -0.00695154 0.0159505 0.0100921 -0.0126679 -0.00703088 -0.0191637 -0.0116676 -0.0216134 -0.0155858 -0.0348786 0.00824809 -0.0160402 -0.0156108 0.00222316 0.00565494 -0.0203139 -0.00169975 0.0151738 0.000105578 -0.00196151 -0.0137246 0.00352464 0.00306386 0.03115 -0.000200159 0.00276833 -0.013697 -0.00134814 -0.0108099 0.014244 -0.00102111 -0.016965 -0.00954926 -0.0113966 -0.0187811 -0.0243734 -0.032553 -0.0277708 0.0208017 -0.0119544 0.0282654 -0.00253335 0.00411899 9192 -0.0418675 -0.0748957 -0.0349762 -0.0232418 0.0997403 -0.080086 0.0267859 0.00144486 -0.0365908 0.109965 0.0383626 -0.0673113 -0.0882356 -0.0720804 0.0537256 0.012303 0.0671034 -0.00490223 0.094077 -0.0517411 -0.100004 -0.0413149 0.182336 0.156172 -0.0471807 -0.052455 -0.00689152 0.115385 -0.0458524 0.0432888 -0.000982105 -0.00449935 -0.0189335 -0.0173315 -0.011708 0.0074369 -0.000439496 -0.0179856 0.0218096 -0.046571 -0.0639089 -0.146104 -0.0937443 0.0258947 0.049675 0.011432 0.0380184 0.08526 -0.0637881 -0.134194 -0.0146248 0.125638 0.0744331 -0.0212793 0.0790646 0.0457259 0.0857937 -0.0283405 0.0413922 0.0467135 -0.0517976 -0.032048 -0.105124 -0.0454983 -0.133484 -0.0705029 -0.170737 0.0544806 -0.0954872 -0.108356 0.0558612 0.0175526 -0.0754161 -0.0118317 0.0332381 -0.016054 0.0207899 -0.0376508 0.0160112 0.0250085 0.140147 0.0043331 -0.0227054 -0.0986077 -0.0284764 -0.0404766 0.0583791 -0.00450137 -0.0354385 -0.0644349 -0.0747603 -0.0906304 -0.128325 -0.175729 -0.0978647 0.119311 -0.0859975 0.137831 0.00438728 0.000827815 ---- == Storing node2Vec embeddings Next we're going to store these embeddings back into Neo4j so that we can use them later. The following code will do the trick: [source, cypher] ---- with open("movies.emb", "r") as movies_file, driver.session() as session: next(movies_file) reader = csv.reader(movies_file, delimiter=" ") params = [] for row in reader: movie_id = row[0] params.append({ "id": int(movie_id), "embedding": [float(item) for item in row[1:]] }) session.run("""\ UNWIND {params} AS param MATCH (m:Movie) WHERE id(m) = param.id SET m.embedding = param.embedding """, {"params": params}) ---- Now we're ready to do some machine learning. [[pandas]] == Loading our data into Pandas Each of the movies in our dataset has one or more genres and we're going to create a Tensorflow model that tries to predict the genres for a given movie. We'll first load our dataset into a Pandas DataFrame. Each row will represent a movie and will have 100 columns containing the embeddings we created above, as well as another column containing an array indicating which genres it has. That array will be a variant of a https://hackernoon.com/what-is-one-hot-encoding-why-and-when-do-you-have-to-use-it-e3c6186d008f[one hot encoding^] (multi hot encoding?!). The following code will construct our DataFrame: [source, python] ---- import pandas as pd movies_genres_query = """\ MATCH (genre:Genre) WITH genre ORDER BY genre.name WITH collect(id(genre)) AS genres MATCH (m:Movie)-[:IN_GENRE]->(genre) WITH genres, id(m) AS source, m.embedding AS embedding, collect(id(genre)) AS target RETURN source, embedding, [g in genres | CASE WHEN g in target THEN 1 ELSE 0 END] AS genres """ with driver.session() as session: result = session.run(movies_genres_query) df = pd.DataFrame([dict(row) for row in result]) ---- What does our DataFrame look like at the moment? [source, python] ---- >>> everything.head() embedding source \ 0 [0.14308, 0.573671, 0.696905, 0.382039, -0.631... 0 1 [-0.0069373, -0.0182842, -0.00250641, -0.01482... 6881 2 [-0.000760393, -0.00128913, -0.0139862, -0.006... 8435 3 [-0.00199855, -0.00427414, -0.0113419, -0.0027... 4009 4 [0.00647937, -0.00590963, -0.00502976, 0.00046... 3057 genres 0 [0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, ... 1 [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, ... 2 [0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ... 3 [0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, ... 4 [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, ... ---- At the moment the embeddings are in an array within one column. We'll fix that in the next step. == Splitting training/test sets We're going to split our DataFrame into training and test sets. We'll just do a simple 90/10 split here but if we were doing this for real we'd want to do something more sophisticated such as http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html[K-Fold validation^]. [source,python] ---- train_index = int(len(df) * 0.9) train_data = df[:train_index] test_data = df[train_index:] train_x = train_data.ix[:, "embedding"] train_x = pd.DataFrame(np.array([np.array(item) for item in train_x.values])) train_x.columns = [str(col) for col in train_x.columns.get_values()] train_y = train_data.ix[:, 'genres'] # separate test data test_x = test_data.ix[:, "embedding"] test_x = pd.DataFrame(np.array([np.array(item) for item in test_x.values])) test_x.columns = [str(col) for col in train_x.columns.get_values()] test_y = test_data.ix[:, 'genres'] ---- The reason for this slightly insane data massaging is so that we can easily feed our data into a https://www.tensorflow.org/programmers_guide/datasets[Tensorflow DataSet^] in the next section. If there's an easier way to do this please let me know in the comments and I'll update the example. == Building Tensorflow model Now we're ready to create our Tensorflow model. First up, our imports: [source, python] ---- import tensorflow as tf from tensorflow.python.feature_column import feature_column_lib from tensorflow.python.training import training_util from tensorflow.python.training.ftrl import FtrlOptimizer ---- We're going to create a simple multi label classifier because a movie can have more than one genre associated with it. [source, python] ---- feature_columns = [tf.feature_column.numeric_column(key=key) for key in train_x.keys()] LEARNING_RATE = 0.3 loss_reduction = tf.losses.Reduction.SUM_OVER_BATCH_SIZE head = tf.contrib.estimator.multi_label_head(20, weight_column=none, label_vocabulary=none, loss_reduction=loss_reduction) classifier = tf.estimator.Estimator(model_fn=model_fn) classifier.train( input_fn=lambda: train_input_fn(train_x, train_y, 100), steps=2000) eval_result = classifier.evaluate( input_fn=lambda: eval_input_fn(test_x, test_y, 100)) print(eval_result) print('\nTest set AUC: {auc:0.3f}\n'.format(**eval_result)) ---- We called a few functions in the previous section so let's look into those in more detail. We have two functions for passing data into the `train` and `eval` functions of our classifier: [source, python] ---- def train_input_fn(features, labels, batch_size): labels = tf.constant(np.array([np.array(item) for item in labels.values])) dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) return dataset.shuffle(1000).repeat().batch(batch_size) def eval_input_fn(features, labels, batch_size): labels = tf.constant(np.array([np.array(item) for item in labels.values])) features = dict(features) inputs = (features, labels) dataset = tf.data.Dataset.from_tensor_slices(inputs) assert batch_size is not none, "batch_size must not be None" return dataset.batch(batch_size) ---- I took most of this directly from the Tensorflow documentation and https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/learn/python/learn/estimators/head_test.py#L380[tests^], except the first line which I ended up with after a lot of trial and error. We also have a model function: [source, python] ---- def model_fn(features, labels, mode, config): def train_op_fn(loss): opt = FtrlOptimizer(learning_rate=LEARNING_RATE) return opt.minimize(loss, global_step=training_util.get_global_step()) def logit_fn(features): return feature_column_lib.linear_model( features=features, feature_columns=feature_columns, units=head.logits_dimension) return head.create_estimator_spec( features=features, mode=mode, logits=logit_fn(features=features), labels=labels, train_op_fn=train_op_fn) ---- I got most of this code from reverse engineering the https://www.tensorflow.org/api_docs/python/tf/estimator/LinearClassifier[LinearClassifier^] that I wrote about in https://markhneedham.com/blog/2018/05/05/tensorflow-18-hello-world-using-estimator-api/[a previous post^]. Now it's time to actually run this thing! This is the output we get: [source,bash] ---- $ python movies_multi_label_custom_estimator.py {'auc': 0.7855524, 'auc_precision_recall': 0.354057, 'average_loss': 0.29183877, 'loss': 0.2946557, 'global_step': 2000} Test set AUC: 0.786 ---- The `auc_precision_recall` is probably the most interesting one here and we're not doing very well in that respect, which is perhaps not surprising given the simplicity of our model. The next step would be to replace the model with a more complex Deep Neural Network that might be able to find some patterns in the embeddings. I'll leave that for another post, but we'll concluded by looking at how we could use this model to predict which genres a movie should have. The following code does the trick: [source,python] ---- genres_query = """\ MATCH (genre:Genre) WITH genre ORDER BY genre.name RETURN collect(genre.name) AS genres """ with driver.session() as session: result = session.run(genres_query) genres = result.peek()["genres"] movies_genres_predict_query = """\ MATCH (genre:Genre) WITH genre ORDER BY genre.name WITH collect(id(genre)) AS genres MATCH (m:Movie)-[:IN_GENRE]->(genre) WITH genres, m.title AS movie, id(m) AS source, m.embedding AS embedding, collect(id(genre)) AS target RETURN source, movie, embedding, [g in genres | CASE WHEN g in target THEN 1 ELSE 0 END] AS genres ORDER BY rand() LIMIT 3 """ with driver.session() as session: result = session.run(movies_genres_predict_query) predict_df = pd.DataFrame([dict(row) for row in result]) expected_df = predict_df[["genres", "source", "movie"]] predict_x = predict_df.ix[:, "embedding"] predict_x = pd.DataFrame(np.array([np.array(item) for item in predict_x.values])) predict_x.columns = [str(col) for col in predict_x.columns.get_values()] predictions = classifier.predict( input_fn=lambda: predict_input_fn(predict_x, 100)) for pred_dict, expec in zip(predictions, expected_df.as_matrix()): expected, source, movie = expec print("Movie: {0}".format(movie)) for idx, label in enumerate(expected): print(label, genres[idx], pred_dict["probabilities"][idx]) print("--") ---- And if we run it we'll see this output: [source, bash] ---- Movie: Someone Like You 0 (no genres listed) 0.013719821 0 Action 0.16868685 0 Adventure 0.119703874 0 Animation 0.049339224 0 Children 0.06293545 1 Comedy 0.3655233 0 Crime 0.119378164 0 Documentary 0.05467411 0 Drama 0.47860712 0 Fantasy 0.07273513 0 Film-Noir 0.021085216 0 Horror 0.09513151 0 IMAX 0.022415701 0 Musical 0.044788927 0 Mystery 0.060783025 1 Romance 0.16936173 0 Sci-Fi 0.08559853 0 Thriller 0.18862277 0 War 0.042249877 0 Western 0.024629481 -- Movie: Cyrus 0 (no genres listed) 0.013714926 0 Action 0.16862866 0 Adventure 0.11968786 0 Animation 0.04933899 0 Children 0.06292239 1 Comedy 0.36660013 0 Crime 0.1192929 0 Documentary 0.05456238 1 Drama 0.47862184 0 Fantasy 0.072761126 0 Film-Noir 0.021083448 0 Horror 0.09523407 0 IMAX 0.022410033 0 Musical 0.044797856 0 Mystery 0.060746994 1 Romance 0.1696445 0 Sci-Fi 0.085707955 0 Thriller 0.18862824 0 War 0.042215005 0 Western 0.024633398 -- Movie: Hugo 0 (no genres listed) 0.013695647 0 Action 0.16891125 0 Adventure 0.11970882 0 Animation 0.049290065 1 Children 0.062867686 0 Comedy 0.36590067 0 Crime 0.11941985 0 Documentary 0.05452773 1 Drama 0.4786238 0 Fantasy 0.07270951 0 Film-Noir 0.021058151 0 Horror 0.09517987 0 IMAX 0.022390224 0 Musical 0.04475778 1 Mystery 0.06075114 0 Romance 0.169593 0 Sci-Fi 0.08562877 0 Thriller 0.18874636 0 War 0.04222341 0 Western 0.024609018 -- ---- The movies we've used to test the model already have a node2Vec embedding. I'm not sure how we'd make predictions for a brand new movie that wasn't included in our initial embedding calculation. That's my next thing to research but let me know if you have any ideas. If you want to play with this all the code is in my https://github.com/mneedham/tensorflow-playground/blob/master/movies_multi_label_custom_estimator.py#L122[tensorflow-playground^] repository

Learn how to combine the node2Vec feature representation algorithm and Tensorflow machine learning library.

node2vec-tensorflow

https://markhneedham.com/blog/2018/05/11/node2vec-tensorflow

2018-05-19 09:47:21

Interpreting Word2vec or GloVe embeddings using scikit-learn and Neo4j graph algorithms

A couple of weeks I came across a paper titled http://aclweb.org/anthology/W/W17/W17-2404.pdf[Parameter Free Hierarchical Graph-Based Clustering for Analyzing Continuous Word Embeddings^] via https://twitter.com/abigail_e_see?lang=en[Abigail See^]'s http://www.abigailsee.com/2017/08/30/four-deep-learning-trends-from-acl-2017-part-2.html[blog post about ACL 2017^]. ++++ <div style="float:right; padding: 2px "> <img src="{{<siteurl>}}/uploads/2018/05/word_hierarchy.png" alt="Interpreting word embeddings" width="200px" /> </div> ++++ The paper explains an algorithm that helps to make sense of word embeddings generated by algorithms such as Word2vec and https://nlp.stanford.edu/projects/glove/[GloVe^]. I'm fascinated by how graphs can be used to interpret seemingly black box data, so I was immediately intrigued and wanted to try and reproduce their findings using Neo4j. This is my understanding of the algorithm: 1. Create a nearest neighbour graph (NNG) of our embedding vectors, where each vector can only have one relationship to its nearest neighbour 2. Run the connected components algorithm over that NNG to derive clusters of words 3. For each cluster define a `macro vertex` - this could be the most central word in the cluster or the most popular word 4. Create a NNG of the macro vertices 5. Repeat steps 2 and 3 until we have only one cluster left We can use the https://neo4j.com/docs/graph-algorithms/current/[Neo4j graph algorithms library^] for Step 2 and I initially tried to brute force Step 1 before deciding to use http://scikit-learn.org[scikit-learn^] for this part of the algorithm. [source, bash] ---- $ head -n1 data/small_glove.txt the -0.038194 -0.24487 0.72812 -0.39961 0.083172 0.043953 -0.39141 0.3344 -0.57545 0.087459 0.28787 -0.06731 0.30906 -0.26384 -0.13231 -0.20757 0.33395 -0.33848 -0.31743 -0.48336 0.1464 -0.37304 0.34577 0.052041 0.44946 -0.46971 0.02628 -0.54155 -0.15518 -0.14107 -0.039722 0.28277 0.14393 0.23464 -0.31021 0.086173 0.20397 0.52624 0.17164 -0.082378 -0.71787 -0.41531 0.20335 -0.12763 0.41367 0.55187 0.57908 -0.33477 -0.36559 -0.54857 -0.062892 0.26584 0.30205 0.99775 -0.80481 -3.0243 0.01254 -0.36942 2.2167 0.72201 -0.24978 0.92136 0.034514 0.46745 1.1079 -0.19358 -0.074575 0.23353 -0.052062 -0.22044 0.057162 -0.15806 -0.30798 -0.41625 0.37972 0.15006 -0.53212 -0.2055 -1.2526 0.071624 0.70565 0.49744 -0.42063 0.26148 -1.538 -0.30223 -0.073438 -0.28312 0.37104 -0.25217 0.016215 -0.017099 -0.38984 0.87424 -0.72569 -0.51058 -0.52028 -0.1459 0.8278 0.27062 ---- == Imports First let's load in the libraries that we're going to use: [source, python] ---- import sys from neo4j.v1 import GraphDatabase, basic_auth from sklearn.neighbors import KDTree ---- == Setup database constraints and indexes Before we import any data into Neo4j we're going to setup constraints and indexes: [source, python] ---- with driver.session() as session: session.run("""\ CREATE CONSTRAINT ON (c:Cluster) ASSERT (c.id, c.round) IS NODE KEY""") session.run("""\ CREATE CONSTRAINT ON (t:Token) ASSERT t.id IS UNIQUE""") session.run("""\ CREATE INDEX ON :Cluster(round)""") ---- == Loading the data Now we'll load the words into Neo4j - one node per word. I'm using a subset of the word embeddings from the GloVe algorithm, but the format is similar to what you'd get from Word2vec. [source, python] ---- driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "neo")) with open("data/medium_glove.txt", "r") as glove_file, driver.session() as session: rows = glove_file.readlines() params = [] for row in rows: parts = row.split(" ") id = parts[0] embedding = [float(part) for part in parts[1:]] params.append({"id": id, "embedding": embedding}) session.run("""\ UNWIND {params} AS row MERGE (t:Token {id: row.id}) ON CREATE SET t.embedding = row.embedding """, {"params": params}) ---- == Nearest Neighbour Graph Now we want to create a nearest neighbour graph of our words. We'll use http://scikit-learn.org/stable/modules/neighbors.html[scikit-learn's nearest neighbours module^] to help us out here. We want to end up with these relationships added to the graph: image::{{<siteurl>}}/uploads/2018/05/nng.png[width="400px"] Each node will have an outgoing relationship to one other node, where the nearest neighbour is determine by comparing their embedding vectors with the euclidean distance function. This function does the trick: [source, python] ---- def nearest_neighbour(label): with driver.session() as session: result = session.run("""\ MATCH (t:`%s`) RETURN id(t) AS token, t.embedding AS embedding """ % label) points = {row["token"]: row["embedding"] for row in result} items = list(points.items()) X = [item[1] for item in items] kdt = KDTree(X, leaf_size=10000, metric='euclidean') distances, indices = kdt.query(X, k=2, return_distance=True) params = [] for index, item in enumerate(items): nearest_neighbour_index = indices[index][1] distance = distances[index][1] t1 = item[0] t2 = items[nearest_neighbour_index][0] params.append({"t1": t1, "t2": t2, "distance": distance}) session.run("""\ UNWIND {params} AS param MATCH (token) WHERE id(token) = param.t1 MATCH (closest) WHERE id(closest) = param.t2 MERGE (token)-[nearest:NEAREST_TO]->(closest) ON CREATE SET nearest.weight = param.distance """, {"params": params}) ---- We would call the function like this: [source, cypher] ---- nearest_neighbour("Token") ---- We can write a query to see what our graph looks like: [source, cypher] ---- MATCH path = (:Token {id: "sons"})-[:NEAREST_TO]-(neighbour) RETURN * ---- ++++ <img src="{{<siteurl>}}/uploads/2018/05/neighbours.png" alt="neighbours" style="padding-top: 10px;"> ++++ == Connected components After we've done that we need to run the connected components algorithm over the NNG. We'll use the Union Find algorithm from the Neo4j Graph Algorithms library to help us out. This is the graph we want to have after this algorithm has run: image::{{<siteurl>}}/uploads/2018/05/cc.png[width="400px"] The following function finds the clusters: [source, python] ---- def union_find(label, round=None): print("Round:", round, "label: ", label) with driver.session() as session: result = session.run("""\ CALL algo.unionFind.stream( "MATCH (n:`%s`) RETURN id(n) AS id", "MATCH (a:`%s`)-[:NEAREST_TO]->(b:`%s`) RETURN id(a) AS source, id(b) AS target", {graph: 'cypher'} ) YIELD nodeId, setId MATCH (token) WHERE id(token) = nodeId MERGE (cluster:Cluster {id: setId, round: {round} }) MERGE (cluster)-[:CONTAINS]->(token) """ % (label, label, label), {"label": label, "round": round}) print(result.summary().counters) ---- We would call the function like this: [source, cypher] ---- round = 0 union_find("Token", round) ---- We can now write a function to find the cluster for our `sons` node and all of its sibling nodes: [source, cypher] ---- MATCH path = (:Token {id: "sons"})<-[:CONTAINS]-()-[:CONTAINS]->(sibling) RETURN * ---- image::{{<siteurl>}}/uploads/2018/05/cc_sons.png[] Now we need to make this process recursive. == Macro vertices In the next part of the algorithm we need to find the central node for each of the clusters and then repeat the previous two steps using those nodes instead of all the nodes in the graph. We will consider the macro vertex node of each cluster to be the node that has the lowest cumulative distance to all other nodes in the cluster. The following function does this calculation: [source, python] ---- def macro_vertex(macro_vertex_label, round=None): with driver.session() as session: result = session.run("""\ MATCH (cluster:Cluster) WHERE cluster.round = {round} RETURN cluster """, {"round": round}) for row in result: cluster_id = row["cluster"]["id"] session.run("""\ MATCH (cluster:Cluster {id: {clusterId}, round: {round} })-[:CONTAINS]->(token) WITH cluster, collect(token) AS tokens UNWIND tokens AS t1 UNWIND tokens AS t2 WITH t1, t2, cluster WHERE t1 <> t2 WITH t1, cluster, reduce(acc = 0, t2 in collect(t2) | acc + apoc.algo.euclideanDistance(t1.embedding, t2.embedding)) AS distance WITH t1, cluster, distance ORDER BY distance LIMIT 1 SET cluster.centre = t1.id WITH t1 CALL apoc.create.addLabels(t1, [{newLabel}]) YIELD node RETURN node """, {"clusterId": cluster_id, "round": round, "newLabel": macro_vertex_label}) ---- This function also sets a `centre` property on each `Cluster` node so that we can more easily visualise the central node for a cluster. We would call it like this: [source, python] ---- round = 0 macro_vertex("MacroVertex1", round) ---- Once this function has run we can write a query to find the similar words to `sons` at level 2: [source, cypher] ---- MATCH path = (:Token {id: "sons"})<-[:CONTAINS]-()-[:CONTAINS]->(sibling) OPTIONAL MATCH nextLevelPath = (sibling:MacroVertex0)<-[:CONTAINS]-()-[:CONTAINS]->(other) RETURN * ---- image::{{<siteurl>}}/uploads/2018/05/graph100.png[] The output is quite cool - `siblings` is the representative node for our initial cluster and it takes us into a 2nd level cluster containing words such as `uncles`, `sister-in-law`, and `nieces` which do seem similar. There are some other words which are less so but I've only run this with a small sample of words so it'd be interesting to see how the algorithm fares if I load in a bigger dataset. == Next steps I've run this over a set of 10,000 words, which took 23 seconds, and 50,000 words, which took almost 10 minutes. The slowest bit of the process is the construction of the Nearest Neighbour Graph. Thankfully this looks like a parallelisable problem so I'm hopeful that I can speed that up. The code for this post is in the https://github.com/mneedham/interpreting-word2vec[mneedham/interpreting-word2vec^] GitHub repository so feel free to experiment with me and let me know if it's helpful or if there are ways that it could be more helpful.

Learn how to use graph algorithms to explore the word embeddings from algorithm such as Word2vec and GloVe

interpreting-word2vec-glove-embeddings-sklearn-neo4j-graph-algorithms

https://markhneedham.com/blog/2018/05/19/interpreting-word2vec-glove-embeddings-sklearn-neo4j-graph-algorithms

2018-02-19 20:51:31

Asciidoctor: Creating a macro

I've been writing the https://neo4j.com/tag/twin4j/[TWIN4j blog] for almost a year now and during that time I've written a few different http://asciidoc.org/chunked/ch21.html[asciidoc macros] to avoid repetition. The most recent one I wrote does the formatting around the Featured Community Member of the Week. I call it like this from the asciidoc, passing in the name of the person and a link to an image: [source,text] ---- featured::https://s3.amazonaws.com/dev.assets.neo4j.com/wp-content/uploads/20180202004247/this-week-in-neo4j-3-february-2018.jpg[name="Suellen Stringer-Hye"] ---- The code for the macro has two parts. The first is some wiring code that registers the macro with Asciidoctor: +++<cite>+++lib/featured-macro.rb+++</cite>+++ [source,ruby] ---- RUBY_ENGINE == 'opal' ? (require 'featured-macro/extension') : (require_relative 'featured-macro/extension') Asciidoctor::Extensions.register do if (@document.basebackend? 'html') && (@document.safe < SafeMode::SECURE) block_macro FeaturedBlockMacro end end ---- And this is the code for the macro itself: +++<cite>+++lib/featured-macro/extension.rb+++</cite>+++ [source,ruby] ---- require 'asciidoctor/extensions' unless RUBY_ENGINE == 'opal' include ::Asciidoctor class FeaturedBlockMacro < Extensions::BlockMacroProcessor use_dsl named :featured def process parent, target, attrs name = attrs["name"] html = %(<div class="imageblock image-heading"> <div class="content"> <img src="#{target}" alt="#{name} - This Week’s Featured Community Member" width="800" height="400"> </div> </div> <p style="font-size: .8em; line-height: 1.5em;" align="center"> <strong>#{name} - This Week's Featured Community Member</strong> </p> ) create_pass_block parent, html, attrs, subs: nil end end ---- When we convert the asciidoc into HTML we need to tell asciidoctor about the macro, which we can do like this: [source,bash] ---- asciidoctor template.adoc \ -r ./lib/featured-macro.rb \ -o - ---- And that's it!

asciidoctor-creating-macro

https://markhneedham.com/blog/2018/02/19/asciidoctor-creating-macro

2018-11-05 06:15:00

Neo4j: Storing inferred relationships with APOC triggers

One of my favourite things about modelling data in graphs is how easy it makes it to infer relationships between pieces of data based on other relationships. In this post we're going to learn how to compute and store those inferred relationships using the https://neo4j-contrib.github.io/neo4j-apoc-procedures/#_triggers[triggers^] feature from the APOC library. == Meetup Graph Before we get to that, let's first understand what we mean when we say inferred relationship. We'll create a small graph containing `Person`, `Meetup`, and `Topic` nodes with the following query: [source, cypher] ---- MERGE (mark:Person {name: "Mark"}) MERGE (neo4jMeetup:Meetup {name: "Neo4j London Meetup"}) MERGE (bigDataMeetup:Meetup {name: "Big Data Meetup"}) MERGE (dataScienceMeetup:Meetup {name: "Data Science Meetup"}) MERGE (dataScience:Topic {name: "Data Science"}) MERGE (databases:Topic {name: "Databases"}) MERGE (neo4jMeetup)-[:HAS_TOPIC]->(dataScience) MERGE (neo4jMeetup)-[:HAS_TOPIC]->(databases) MERGE (bigDataMeetup)-[:HAS_TOPIC]->(dataScience) MERGE (bigDataMeetup)-[:HAS_TOPIC]->(databases) MERGE (dataScienceMeetup)-[:HAS_TOPIC]->(dataScience) MERGE (dataScienceMeetup)-[:HAS_TOPIC]->(databases) MERGE (mark)-[:MEMBER_OF]->(neo4jMeetup) MERGE (mark)-[:MEMBER_OF]->(bigDataMeetup) ---- This is what the graph looks like in the Neo4j browser: image::{{<siteurl>}}/uploads/2018/11/meetup-explicit.svg[] == Finding implicit interests At the moment there are no relationships between `Person` and `Topic` nodes, so we don't know which topics a person is interested in. There is, however, an indirect relationship between these nodes via `Group` nodes. image::{{<siteurl>}}/uploads/2018/11/inferred-rels.png[width="300px"] Let's say that a person is interested in a topic if they're a member of at least 3 groups tagged with that topic. In other words, we want to create an `INTERESTED_IN` relationship between a `Person` and `Topic` if a person is a member of at least 3 groups tagged with that topic. We could do this with the following Cypher query: [source, cypher] ---- MATCH (start:Person {name: "Mark"})-[:MEMBER_OF]->()-[:HAS_TOPIC]->(topic) WHERE not((start)-[:INTERESTED_IN]->(topic)) WITH start, topic, count(*) AS count WHERE count >= 3 MERGE (start)-[interestedIn:INTERESTED_IN]->(topic) SET interestedIn.tentative = true ---- If we run this query at the moment it won't create any `INTERESTED_IN` relationships, because none of the topics that Mark has an implicit interest in have a count of 3. We can fix that by creating a relationship from Mark to the Data Science meetup with the following query: [source,cypher] ---- MATCH (p:Person {name: "Mark"}) MATCH (meetup:Meetup {name: "Data Science Meetup"}) MERGE (p)-[:MEMBER_OF]->(meetup) ---- If we run this query and then repeat the previous one we'll get this output: [source, cypher] ---- Created 2 relationships, completed after 2 ms. ---- Cool! We now know that Mark has an interest in `Data Science` and `Databases` image::{{<siteurl>}}/uploads/2018/11/interestedin.svg[] We put a `tentative` property with a value `true` to indicate that this is an inferred relationship. We could then ask the user to confirm that this is a topic they're interested in, or indeed deny any interest at all! == Triggers This works well, but it's a painful workflow at the moment. Each time we add a new membership we need to run the inferred relationship query as well. Can we automate that? Yes we can, using triggers from the APOC library, which are described like this: ____ In a trigger you register Cypher statements that are called when data in Neo4j is changed, you can run them before or after commit. ____ We want to setup a trigger that executes a piece of Cypher whenever a relationship is created. We can do this with the following code: [source,cypher] ---- CALL apoc.trigger.add("interests", "UNWIND [rel in $createdRelationships WHERE type(rel) = 'MEMBER_OF'] AS rel WITH startNode(rel) AS start, endNode(rel) AS end MATCH (start)-[:MEMBER_OF]->()-[:HAS_TOPIC]->(topic) WHERE not((start)-[:INTERESTED_IN]->(topic)) WITH start, topic, count(*) AS count WHERE count >= 3 MERGE (start)-[interestedIn:INTERESTED_IN]->(topic) SET interestedIn.tentative = true ", {phase:'before'}) ---- This code is based on the assumption that we usually only create one `MEMBER_OF` relationship per `Person` in a transaction. Our trigger receives a list of all the relationships created in a transaction, filters the list to only include the `MEMBER_OF` ones, and then runs a piece of Cypher that creates an `INTERESTED_IN` relationship from a user to topics that they may have an interest in. If we want to change the threshold at which we create the relationships we'd only need to change this line of code: [source,cypher] ---- WHERE count >= 3 ---- And that's it!

Learn how to store inferred relationships with APOC triggers.

neo4j-inferred-relationships-apoc-triggers

https://markhneedham.com/blog/2018/11/05/neo4j-inferred-relationships-apoc-triggers

2018-10-31 18:12:00

Neo4j Graph Algorithms: Visualising Projected Graphs

A few weeks ago I wrote a blog post showing how to https://medium.com/neo4j/finding-the-best-tennis-players-of-all-time-using-weighted-pagerank-6950ed5fc98e[work out the best tennis player of all time using the Weighted PageRank algorithm^], and in the process created a projected credibility graph which I want to explore in more detail in this post. As I pointed out in that post, sometimes the graph model doesn't fit well with what the algorithm expects, so we need to project the graph on which we run graph algorithms. In this case, the PageRank algorithm works on top of a 'credibility graph' where nodes receive credibility from their incoming relationships. The amount of credibility a relationship gives is determined by the weight property on that relationship. For our tennis graph we started with a graph of matches, winners, and losers, and then derived a credibility graph using the following query: [source, cypher] ---- MATCH (p1)<-[:WINNER]-(match)-[:LOSER]->(p2) RETURN id(p2) AS source, id(p1) AS target, count(*) as weight ---- We then used the example of Roger Federer playing Rafael Nadal to see how this worked in practice. If we feed their names into the query we'd the following results, starting with matches that Federer won: [source, cypher] ---- MATCH (p1:Player {name: "Roger Federer"})<-[:WINNER]-(match)-[:LOSER]->(p2:Player {name: "Rafael Nadal"}) RETURN id(p2) AS source, id(p1) AS target, count(*) as weight ---- If we run that we'll get this output: [source, text] ---- ╒════════╤════════╤════════╕ │"source"│"target"│"weight"│ ╞════════╪════════╪════════╡ │7 │124 │15 │ └────────┴────────┴────────┘ ---- And now for matches that Nadal won: [source, cypher] ---- MATCH (p1:Player {name: "Rafael Nadal"})<-[:WINNER]-(match)-[:LOSER]->(p2:Player {name: "Roger Federer"}) RETURN id(p2) AS source, id(p1) AS target, count(*) as weight ---- And if we run that we'll get this output: [source, text] ---- ╒════════╤════════╤════════╕ │"source"│"target"│"weight"│ ╞════════╪════════╪════════╡ │124 │7 │23 │ └────────┴────────┴────────┘ ---- It can be easier to understand how this works by visualising the projected graph. We can use a procedure from the APOC library to help us do this. The following query shows how to do this: [source, cypher] ---- MATCH (p1)<-[:WINNER]-(match)-[:LOSER]->(p2) WITH p2, p1, count(*) AS count CALL apoc.create.vRelationship(p2,"BEATEN_BY",{count:count},p1) yield rel RETURN p2, p1, rel ---- The first two lines of the query are the same as before, but on the 3rd line we create a virtual relationship between the two player nodes. That returns a big graph, so let's cheat a bit and just show the projected graph for some famous players. First let's create a parameter containing an array of players: [source, cypher] ---- :params players => ["Roger Federer", "Andy Murray", "Novak Djokovic", "Rafael Nadal", "Alexander Zverev", "Pete Sampras", "Andre Agassi", "John McEnroe", "Yevgeny Kafelnikov"] ---- And now let's visualise the matches between those players: [source, cypher] ---- MATCH (p1)<-[:WINNER]-(match)-[:LOSER]->(p2) WHERE p1.name in $players AND p2.name IN $players WITH p2, p1, count(*) AS count CALL apoc.create.vRelationship(p2,"BEATEN_BY",{count:count},p1) yield rel RETURN p2, p1, rel ---- And if we run that query we'll get back this graph: image::{{<siteurl>}}/uploads/2018/10/tennis-projected-now.svg[]

Learn how to visualise projected graphs using the APOC library.

neo4j-graph-algorithms-visualise-projected-graph

https://markhneedham.com/blog/2018/10/31/neo4j-graph-algorithms-visualise-projected-graph

2018-07-16 05:25:00

QuickGraph #1: Analysing Python Dependency Graph with PageRank, Closeness Centrality, and Betweenness Centrality

I've always wanted to build a dependency graph of libraries in the Python ecosytem but I never quite got around to it...until now! I thought I might be able to get a dump of all the libraries and their dependencies, but while searching I came across this article which does a good job of explaining https://dustingram.com/articles/2018/03/05/why-pypi-doesnt-know-dependencies[why that's not possible^]. == Finding Python Dependencies The best we can do is generate a dependency graph of our locally installed packages using the excellent https://github.com/naiquevin/pipdeptree[pipdeptree^] tool. I installed the library... [source,bash] ---- pip install pipdeptree ---- And then ran this command to generate a JSON file containing all the dependencies: [source,bash] ---- pipdeptree --json-tree > /tmp/deps.json ---- The resulting file is uploaded as a https://gist.github.com/mneedham/4ac262fa5a369de4d3ceb1f3eb1b8c08/raw[GitHub gist^] in case you want to take a look. == Importing Python Dependencies into Neo4j My initial plan was to process the JSON using APOC's Load JSON procedure, but after looking at the JSON file I realised that there was a recursive dependency chain and it'd be much easier to process it in a programming language. image::{{<siteurl>}}/uploads/2018/07/python-deps.png[] We can write a function that returns https://stackoverflow.com/questions/38254304/can-generators-be-recursive[a recursive generator^] of libraries and their immediate parent. First let's import our dependencies: [source, python] ---- import requests import csv from neo4j.v1 import GraphDatabase ---- And now for the recursive generator: [source, python] ---- def process_deps(items, parent=None): for item in items: yield (parent, item["key"]) yield from process_deps(item["dependencies"], item["key"]) ---- Now let's process the JSON file using the requests library and pass our `library, parent` pairs to a Cypher query: [source, python] ---- driver = GraphDatabase.driver("bolt://localhost", auth=("neo4j", "neo")) r = requests.get("https://gist.github.com/mneedham/4ac262fa5a369de4d3ceb1f3eb1b8c08/raw") response = r.json() with driver.session() as session: for parent, library in process_deps(response): params = { "library": library, "parent": parent } result = session.run("""\ MERGE (l:Library {name: $library}) WITH l CALL apoc.do.when( $parent is null, "RETURN library, null as parent", "WITH $library AS library MERGE (parent:Library {name: $parent}) MERGE (parent)-[:DEPENDS_ON]->(library) RETURN library, parent", {library: l, parent: $parent}) YIELD value RETURN value """, params) print(result.peek()) ---- == Which library is directly depended on the most? [source,cypher] ---- MATCH (l:Library) RETURN l.name AS dependency, size((l)<-[:DEPENDS_ON]-()) AS dependOnMe ORDER BY dependOnMe DESC LIMIT 5 ---- [source,text] ---- +--------------------------+ | dependency | dependOnMe | +--------------------------+ | "six" | 22 | | "numpy" | 20 | | "traitlets" | 9 | | "pandas" | 6 | | "ipykernel" | 5 | +--------------------------+ ---- == Which library is indirectly depended on the most? [source,cypher] ---- MATCH (l:Library) RETURN l.name AS dependency, size((l)<-[:DEPENDS_ON*]-()) AS dependOnMe ORDER BY dependOnMe DESC LIMIT 5 ---- [source,text] ---- +---------------------------------+ | dependency | dependOnMe | +---------------------------------+ | "six" | 386 | | "ipython-genutils" | 252 | | "decorator" | 247 | | "traitlets" | 215 | | "jupyter-core" | 80 | +---------------------------------+ ---- == What's the most important library? [source,cypher] ---- CALL algo.pageRank.stream("Library", "DEPENDS_ON") YIELD nodeId, score MATCH (l) WHERE id(l) = nodeId RETURN l.name AS library, apoc.math.round(score,5) AS score, size((l)<-[:DEPENDS_ON*]-()) AS deps ORDER BY score DESC LIMIT 5 ---- [source,text] ---- +-------------------------------+ | library | score | deps | +-------------------------------+ | "six" | 2.0916 | 386 | | "numpy" | 1.54518 | 70 | | "traitlets" | 0.63128 | 215 | | "decorator" | 0.47954 | 247 | | "setuptools" | 0.40907 | 42 | +-------------------------------+ ---- Most of the libraries in the top 5 are indirectly depended on by many other libraries but `numpy` and `setuptools` have fewer dependencies. This tells us that those libraries are either being depended on by other important libraries or the libraries that do depend on it don't depend on many other libraries. Let's explore, but first we'll store the `pagerank` on each node rather than returning it: [source,cypher] ---- CALL algo.pageRank("Library", "DEPENDS_ON") ---- And now let's have a look at numpy's direct dependencies: [source,cypher] ---- MATCH (l:Library {name: "numpy"})<-[:DEPENDS_ON*]-(library) RETURN DISTINCT library.name AS library, apoc.math.round(library.pagerank,5) AS pagerank, size((library)-[:DEPENDS_ON]->()) AS directDependencies ORDER BY pagerank DESC LIMIT 5 ---- [source,text] ---- +----------------------------------------------+ | library.name | pagerank | directDependencies | +----------------------------------------------+ | "scipy" | 0.39481 | 1 | | "pandas" | 0.37213 | 3 | | "pyarrow" | 0.27975 | 2 | | "patsy" | 0.23685 | 2 | | "matplotlib" | 0.20419 | 7 | +----------------------------------------------+ ---- The first 4 don't have many direct dependencies so numpy will be picking up a decent amount of page rank when they diffuse their score to their neighbours. == Which libraries are closest to the others? Another metric we can calculate is Closeness Centrality which will tell us how far a library is from all the others. A score of `1.0` would indicate that a library has a direct relationship to all other libraries. [source,cypher] ---- CALL algo.closeness.harmonic.stream("Library", "DEPENDS_ON") YIELD nodeId, centrality MATCH (l) WHERE id(l) = nodeId RETURN l.name, centrality ORDER BY centrality DESC LIMIT 5 ---- [source,text] ---- +-----------------------------------+ | l.name | centrality | +-----------------------------------+ | "fastai" | 0.5948412698412698 | | "numpy" | 0.49034391534391536 | | "six" | 0.4850529100529101 | | "traitlets" | 0.4510582010582011 | | "ipython" | 0.4337301587301587 | +-----------------------------------+ ---- Most of our usual suspects but a surprise entry in 1st place, what's going on there?! Presumably `fastai` has lots of dependencies, but let's write a query to find out: [source,cypher] ---- MATCH (l:Library) RETURN l.name AS library, size((l)-[:DEPENDS_ON]->()) AS dependencies ORDER BY dependencies DESC LIMIT 5 ---- [source,text] ---- +---------------------------+ | library | dependencies | +---------------------------+ | "fastai" | 48 | | "spacy" | 15 | | "thinc" | 14 | | "notebook" | 11 | | "ipython" | 11 | +---------------------------+ ---- 3x as many as the next library - that explains the high Closeness Centrality score then! == Which libraries are local bridges? A local bridge in graph theory is a node that connects together what would otherwise be separate sets of nodes. In a social graph this would be the person that floats between different groups of people and connects those groups together. The Betweenness Centrality algorithm calculates the shortest paths between all pairs of nodes in the graph and works out how many times a node exists on those shortest paths. The following query will calculate this for our dataset: [source, cypher] ---- CALL algo.betweenness.stream("Library", "DEPENDS_ON", {direction: "BOTH"}) YIELD nodeId, centrality MATCH (l) WHERE id(l) = nodeId RETURN l.name, centrality ORDER BY centrality DESC LIMIT 5 ---- We're passing in the parameter `direction:BOTH` to this one because we want to consider shortest paths that follow the `DEPENDS_ON` relationship in both directions. [source,text] ---- +-------------------------------+ | l.name | centrality | +-------------------------------+ | "fastai" | 3070.7207126421904 | | "six" | 1775.4608218578815 | | "numpy" | 1266.0317694087814 | | "thinc" | 800.7187125911584 | | "spacy" | 744.5286608128714 | +-------------------------------+ ---- `fastai` comes out top again, but it was a bit skewed in terms of its number of direct dependencies. What if we run the algorithm again but this time excluding `fastai`? [source,cypher] ---- CALL algo.betweenness.stream( "MATCH (l:Library) WHERE l.name <> 'fastai' RETURN id(l) AS id", "MATCH (l1)-[:DEPENDS_ON]-(l2) RETURN id(l1) AS source, id(l2) AS target", {direction: "BOTH", graph: "cypher"}) YIELD nodeId, centrality MATCH (l) WHERE id(l) = nodeId RETURN l.name, centrality ORDER BY centrality DESC LIMIT 5 ---- [source,cypher] ---- +----------------------------------+ | l.name | centrality | +----------------------------------+ | "six" | 3388.1133979422216 | | "traitlets" | 1623.367944728101 | | "numpy" | 1213.7796551878075 | | "spacy" | 1125.8103540366847 | | "ipython" | 999.9845917367674 | +----------------------------------+ ---- We're mostly back to our usual suspects. `spacy` is the only one in this list that didn't appear in the top 5 for either of the other measures of centrality. We could do a lot more exploration on this dataset but this is meant to be a QuickGraph so I'll leave it there. And if anyone has more packages installed locally send me a link to your JSON file and I'll run it over that and we'll see what we can discover!

Learn how to apply Neo4j Graph Algorithms to a graph of the Python ecosystem.

quick-graph-python-dependency-graph

https://markhneedham.com/blog/2018/07/16/quick-graph-python-dependency-graph

2018-07-10 04:21:00

Neo4j 3.4: Grouping Datetimes

In my continued link:/blog/2018/06/12/neo4j-building-strava-graph/[analysis of Strava runs^] I wanted to try and find my best runs grouped by different time components, which was actually much easier than I was expecting. == Importing the dataset If you want to try out the examples below you can execute the following `LOAD CSV` commands to load the data: [source,cypher] ---- LOAD CSV WITH HEADERS FROM "https://github.com/mneedham/strava/raw/master/runs.csv" AS row MERGE (run:Run {id: toInteger(row.id)}) SET run.distance = toFloat(row.distance), run.movingTime = duration(row.movingTime), run.elapsedTime = duration(row.elapsedTime), run.startDate = datetime(row.startDate), run.averageSpeed = toFloat(run.averageSpeed), run.totalElevationGain = toInteger(run.totalElevationGain) ---- [source,cypher] ---- LOAD CSV WITH HEADERS FROM "https://github.com/mneedham/strava/raw/master/efforts.csv" AS row MATCH (run:Run {id: toInteger(row.runId)}) MERGE (effort:Effort {id: toInteger(row.effortId)}) SET effort.movingTime = duration(row.movingTime), effort.elapsedTime = duration(row.elapsedTime) MERGE (distance:Distance {name: row.name}) SET distance.distance = toFloat(row.distance) MERGE (distance)<-[:DISTANCE]-(effort) MERGE (effort)<-[:DISTANCE_EFFORT]-(run) ---- == Finding best segment efforts I want to find the best efforts at running 10km. We can write the following query to find the most recent attempts: [source,cypher] ---- MATCH (distance:Distance {name: "10k"})<-[:DISTANCE]-(effort)<-[:DISTANCE_EFFORT]-(run) WITH effort { .elapsedTime, pace: duration({seconds: effort.elapsedTime.seconds / distance.distance * 1000 }), startDate: run.startDate } RETURN apoc.date.format(effort.startDate.epochSeconds, 's', 'MMM d yyyy') AS dateOfRun, apoc.date.format(effort.elapsedTime.milliseconds, 'ms', 'mm:ss') AS time, apoc.date.format(effort.pace.milliseconds, "ms", "mm:ss") AS pace ORDER BY effort.startDate DESC LIMIT 10 ---- We're using the https://neo4j-contrib.github.io/neo4j-apoc-procedures/[APOC library^] to format the results a bit more cleanly. If we run that query we'll see the following output: [source,text] ---- +-----------------------------------+ | dateOfRun | time | pace | +-----------------------------------+ | "Jul 7 2018" | "46:07" | "04:36" | | "Jul 6 2018" | "46:10" | "04:37" | | "Jul 4 2018" | "45:53" | "04:35" | | "Jul 2 2018" | "46:34" | "04:39" | | "Jun 30 2018" | "49:13" | "04:55" | | "Jun 29 2018" | "48:02" | "04:48" | | "Jun 27 2018" | "44:48" | "04:28" | | "Jun 25 2018" | "45:24" | "04:32" | | "Jun 23 2018" | "46:00" | "04:36" | | "Jun 22 2018" | "45:15" | "04:31" | +-----------------------------------+ ---- We could tweak that query to filter and sort the results in different ways, but what if I want to find my quickest 10km effort per month or per quarter? == `date.truncate` We can use the https://neo4j.com/docs/developer-manual/current/cypher/functions/temporal/#functions-temporal-truncate-overview[`date.truncate`^] function to do this. For example, the following query will find the month for today's date: [source,cypher] ---- RETURN date.truncate("month", datetime()) AS value ---- [source,text] ---- +------------+ | value | +------------+ | 2018-07-01 | +------------+ ---- == Group by month Let's update our query to fastest 10km effort per month. The following query will calculate this: [source,cypher] ---- MATCH (distance:Distance {name: "10k"})<-[:DISTANCE]-(effort)<-[:DISTANCE_EFFORT]-(run) WITH effort { .elapsedTime, pace: duration({seconds: effort.elapsedTime.seconds / distance.distance * 1000 }), startDate: run.startDate } WITH date.truncate("month", effort.startDate) AS month, effort ORDER BY effort.pace WITH month, collect(effort)[0] AS effort RETURN month, apoc.date.format(effort.startDate.epochSeconds, 's', 'MMM d yyyy') AS dateOfRun, apoc.date.format(effort.elapsedTime.milliseconds, 'ms', 'mm:ss') AS time, apoc.date.format(effort.pace.milliseconds, "ms", "mm:ss") AS pace ORDER BY month ---- The three lines in the middle of the query do most of the work: [source, cypher] ---- WITH date.truncate("month", effort.startDate) AS month, effort ORDER BY effort.pace WITH month, collect(effort)[0] AS effort ---- We truncate the `startDate` of the effort to pull out the month and then sort the efforts by `pace`. The lower the pace the quicker the effort. We then use the `collect` function to take all our efforts and put them into an array grouped by `month`. Finally we take the first one in that collection, which will be the fastest one! This is the output from running that query: [source,text] ---- +------------------------------------------------+ | month | dateOfRun | time | pace | +------------------------------------------------+ | 2016-01-01 | "Jan 10 2016" | "54:08" | "05:24" | | 2017-01-01 | "Jan 22 2017" | "52:50" | "05:17" | | 2017-12-01 | "Dec 29 2017" | "47:49" | "04:46" | | 2018-01-01 | "Jan 27 2018" | "46:17" | "04:37" | | 2018-02-01 | "Feb 3 2018" | "46:48" | "04:40" | | 2018-03-01 | "Mar 17 2018" | "46:13" | "04:37" | | 2018-05-01 | "May 19 2018" | "45:02" | "04:30" | | 2018-06-01 | "Jun 9 2018" | "44:05" | "04:24" | | 2018-07-01 | "Jul 4 2018" | "45:53" | "04:35" | +------------------------------------------------+ ---- My best run was in June, but I wasn't too far behind in May. There's still some work to do this month - my best effort this month is much slower than the previous two. == Group by quarter We can find the fastest run by quarter as well by changed the first parameter we pass to the `date.truncate` function: [source,cypher] ---- MATCH (distance:Distance {name: "10k"})<-[:DISTANCE]-(effort)<-[:DISTANCE_EFFORT]-(run) WITH effort { .elapsedTime, pace: duration({seconds: effort.elapsedTime.seconds / distance.distance * 1000 }), startDate: run.startDate } WITH date.truncate("quarter", effort.startDate) AS quarter, effort ORDER BY effort.pace WITH quarter, collect(effort)[0] AS effort RETURN "Q" + quarter.quarter + " " + quarter.year AS date, apoc.date.format(effort.startDate.epochSeconds, 's', 'MMM d yyyy') AS dateOfRun, apoc.date.format(effort.elapsedTime.milliseconds, 'ms', 'mm:ss') AS time, apoc.date.format(effort.pace.milliseconds, "ms", "mm:ss") AS pace ORDER BY quarter ---- For this one we do a little bit of extra work so that the quarter date displays in a nicer way: [source,text] ---- +-----------------------------------------------+ | date | dateOfRun | time | pace | +-----------------------------------------------+ | "Q1 2016" | "Jan 10 2016" | "54:08" | "05:24" | | "Q1 2017" | "Jan 22 2017" | "52:50" | "05:17" | | "Q4 2017" | "Dec 29 2017" | "47:49" | "04:46" | | "Q1 2018" | "Mar 17 2018" | "46:13" | "04:37" | | "Q2 2018" | "Jun 9 2018" | "44:05" | "04:24" | | "Q3 2018" | "Jul 4 2018" | "45:53" | "04:35" | +-----------------------------------------------+ ---- I've clearly got a bit of work to do this quarter to match my best effort in Q2 2018! We could continue grouping by different components but this will probably do for now!

Learn how to query a Strava activity graph using Py2neo v4.

neo4j-grouping-datetimes

https://markhneedham.com/blog/2018/07/10/neo4j-grouping-datetimes

2018-07-09 18:21:00

Neo4j 3.4: Syntax Error - Text cannot be parsed to a Duration (aka dealing with empty durations)

As I continued with my travels with Neo4j 3.4's https://neo4j.com/docs/developer-manual/current/cypher/functions/temporal/#functions-duration-create-components[temporal data type^] I came across some fun edge cases when dealing with empty durations while importing data. Imagine we're trying to create 3 nodes from the following array of input data. Two of the rows have invalid durations! [source, cypher] ---- UNWIND [ {id: 12345, duration: "PT2M20S"}, {id: 12346, duration: ""}, {id: 12347, duration: null} ] AS row MERGE (run:Run {id: row.id}) SET run.duration = duration(row.duration) ---- If we run that query we'll get this error message: [source,text] ---- Neo.ClientError.Statement.SyntaxError: Text cannot be parsed to a Duration "" ^ ---- It doesn't like the empty string. Let's see how we can detect that: [source,cypher] ---- UNWIND [ {id: 12345, duration: "PT2M20S"}, {id: 12346, duration: ""}, {id: 12347, duration: null} ] AS row return row.duration AS value, trim(row.duration) = "" AS isEmpty ---- [source,text] ---- +---------------------+ | value | isEmpty | +---------------------+ | "PT2M20S" | FALSE | | "" | TRUE | | NULL | NULL | +---------------------+ ---- Now let's use our conditional statement in the import query: [source, cypher] ---- UNWIND [ {id: 12345, duration: "PT2M20S"}, {id: 12346, duration: ""}, {id: 12347, duration: null} ] AS row MERGE (run:Run {id: row.id}) SET run.duration = CASE WHEN trim(row.duration) = "" THEN null ELSE duration(row.duration) END ---- [source, text] ---- Invalid call signature ---- Hmmm still not happy. This time the null is the issue - passing a null value to the duration function returns an `Invalid call signature` response. Let's update our conditonal check to detect null values as well: [source,cypher] ---- UNWIND [ {id: 12345, duration: "PT2M20S"}, {id: 12346, duration: ""}, {id: 12347, duration: null} ] AS row return row.duration AS value, exists(row.duration) AS isNotNull, trim(row.duration) = "" AS isEmpty ---- [source,text] ---- +---------------------------------+ | value | isNotNull | isEmpty | +---------------------------------+ | "PT2M20S" | TRUE | FALSE | | "" | TRUE | TRUE | | NULL | FALSE | NULL | +---------------------------------+ ---- Now let's use those conditional checks in our first query: [source, cypher] ---- UNWIND [ {id: 12345, duration: "PT2M20S"}, {id: 12346, duration: ""}, {id: 12347, duration: null} ] AS row MERGE (run:Run {id: row.id}) SET run.duration = CASE WHEN not(exists(row.duration)) THEN null WHEN trim(row.duration) = "" THEN null ELSE duration(row.duration) END ---- [source,text] ---- Added 3 nodes, Set 4 properties, Added 3 labels ---- Looks happy. Let's find our newly created nodes: [source,cypher] ---- MATCH (run:Run) WHERE run.id IN range(12345,12347) RETURN run ---- [source,text] ---- +------------------------------------------+ | run | +------------------------------------------+ | (:Run {duration: P0M0DT140S, id: 12345}) | | (:Run {id: 12346}) | | (:Run {id: 12347}) | +------------------------------------------+ ---- As expected two of them don't have a duration since none was provided.

Learn how to handle empty durations when using Neo4j 3.4's new temporal data type

neo4j-text-cannot-be-parsed-to-duration

https://markhneedham.com/blog/2018/07/09/neo4j-text-cannot-be-parsed-to-duration

2018-07-15 15:10:00

Python: Parallel download files using requests

I often find myself downloading web pages with Python's http://docs.python-requests.org/en/master/[requests library^] to do some local scrapping when building datasets but I've never come up with a good way for downloading those pages in parallel. Below is the code that I use. First we'll import the required libraries: [source,python] ---- import os import requests from time import time as timer ---- And now a function that streams a response into a local file: [source,python] ---- def fetch_url(entry): path, uri = entry if not os.path.exists(path): r = requests.get(uri, stream=True) if r.status_code == 200: with open(path, 'wb') as f: for chunk in r: f.write(chunk) return path ---- Let's download some web pages: [source,python] ---- urls = [ ("/tmp/1.html", "https://markhneedham.com/blog/2018/07/10/neo4j-grouping-datetimes/"), ("/tmp/2.html", "https://markhneedham.com/blog/2018/07/09/neo4j-text-cannot-be-parsed-to-duration/"), ("/tmp/3.html", "https://markhneedham.com/blog/2018/06/15/neo4j-querying-strava-graph-py2neo/"), ("/tmp/4.html", "https://markhneedham.com/blog/2018/06/12/neo4j-building-strava-graph/"), ("/tmp/5.html", "https://markhneedham.com/blog/2018/06/05/neo4j-apoc-loading-data-strava-paginated-json-api/"), ("/tmp/6.html", "https://markhneedham.com/blog/2018/06/03/neo4j-3.4-gotchas-working-with-durations/"), ("/tmp/7.html", "https://markhneedham.com/blog/2018/06/03/neo4j-3.4-formatting-instances-durations-dates/"), ("/tmp/8.html", "https://markhneedham.com/blog/2018/06/02/neo4j-3.4-comparing-durations/"), ("/tmp/9.html", "https://markhneedham.com/blog/2018/05/19/interpreting-word2vec-glove-embeddings-sklearn-neo4j-graph-algorithms/"), ("/tmp/10.html", "https://markhneedham.com/blog/2018/05/11/node2vec-tensorflow/") ] start = timer() for entry in urls: fetch_url(entry) print(f"Elapsed Time: {timer() - start}") Elapsed Time: 2.0800578594207764 ---- Great! That code does the job but how do we parallelise it? I came across https://stackoverflow.com/questions/16181121/a-very-simple-multithreading-parallel-url-fetching-without-queue/27986480#27986480[a neat approach in a StackOverflow reply^] which can be plugged into my existing code really easily. We'll use the https://docs.python.org/2/library/multiprocessing.html[multiprocessing^] library to help us out so let's get that imported: [source,python] ---- from multiprocessing.pool import ThreadPool ---- And now we create a thread pool and then call out to our `fetch_url` function with the list of URLs that we created earlier on: [source,python] ---- results = ThreadPool(8).imap_unordered(fetch_url, urls) for path in results: print(path) print(f"Elapsed Time: {timer() - start}") Elapsed Time: 0.47546887397766113 ---- Cool! It's 5x quicker and that's just for 10 pages - as we download more pages we'll see even more benefit from this approach. This post is more for future Mark than anyone else so...to future me, you're welcome!

Learn how to download multiple files at the same time.

python-parallel-download-files-requests

https://markhneedham.com/blog/2018/07/15/python-parallel-download-files-requests

2018-09-05 07:26:00

Neo4j: Using LOAD CSV to process csv.gz files from S3

I've been building some training material for the https://graphconnect.com/[GraphConnect^] conference that happens in a couple of weeks time and I wanted to load gzipped CSV files. I got this working using Cypher's LOAD CSV command with the file stored locally, but when I uploaded it to S3 it didn't work as I expected. I uploaded the file to an S3 bucket and then tried to read it back like this: [source, cypher] ---- LOAD CSV with headers from "https://guides.neo4j.com/listings/data/nyc/listings.csv.gz" AS row RETURN row LIMIT 1 ---- I was expecting to get back a map of key/value pairs, but instead I got this: [source, text] ---- ╒══════════════════════════════════════════════════════════════════════╕ │"row" │ ╞══════════════════════════════════════════════════════════════════════╡ │{"\u001f�?�i[\u0002�listings.csv\u0000��r�H�.�{\u001c��ҩ)ۻA�\u0000�8│ │q��([e�Z���gb�\u0001���6�\u0001P2�Ď��0�N��K�#̣�'�����\u0000(ɦˮ�ݻ\\u00│ │17["qI$V�\�o}+�9Q��a|�~�FN6M�U�>�O�":"Mo8\u000f�q2�h�g�Wi2\u000f�\u000│ │074\u0013\u0013�y�o� ���<","\/��U8��i�?�ޗ]$4l\u001a>�m?���OYH��\u001│ │f�d��{�o�$Y��c\u001ad�$�a�9�~�����_�>]��a����4\u0019�E>�>\u0004to�z�│ │�<Yzp�R���d\u001d�K%�\u001f=�":null,"/�Μ�_\u0006N�^.�t�d+\u001a8���│ │Wy��N�q\u0015�a\u0010O��}2�\u0007)N ›�$I\u0017I2{��\u0006�m\u0018�9q�\│ │u0007���~����O�� �<H�)_j����}��p�b���~\u0018�Ж�":null} │ └──────────────────────────────────────────────────────────────────────┘ ---- After a bit of reading, I realised that the problem is to do with the meta data associated with the file. On initial upload it had `Content-Type` set to `application/x-gzip`. image::{{<siteurl>}}/uploads/2018/09/default_metadata.png[] We want the file to be processed as if it's a CSV file, so to start with we need to change that to `text/csv`. But that isn't quite enough as I found out by changing that value and running the command again! We also need to set `Content-Encoding` to `gzip`, something that I learnt that from Vince Veselosky's https://gist.github.com/veselosky/9427faa38cee75cd8e27[handy gist^] Our meta data should now look like this: image::{{<siteurl>}}/uploads/2018/09/metadata.png[] And if we run our query again we get more familiar output: [source, text] ---- ╒══════════════════════════════════════════════════════════════════════╕ │"row" │ ╞══════════════════════════════════════════════════════════════════════╡ │{"host_verifications":"['email', 'phone', 'facebook', 'reviews', 'jumi│ │o', 'government_id']","country":"United States","notes":"Please no coo│ │king at night but you can warm up food in the microwave and use the ki│ │tchen ","is_business_travel_ready":"f","picture_url":"https://a0.musca│ │che.com/im/pictures/d0489e42-4333-4360-911f-413d503fe146.jpg?aki_polic│ │y=large","house_rules":"no-smoking/please take off your shoes: cleanin│ │g fees $40","requires_license":"f","calendar_last_scraped":"2018-08-07│ │","first_review":"2008-10-13","neighborhood_overview":"","review_score│ │s_cleanliness":"9","number_of_reviews":"170","is_location_exact":"t","│ │space":"-PLEASE BOOK DIRECTLY. NO NEED TO SEND A REQUEST FOR DATES CAL│ │ENDAR IS UP TO DATE ALL AIRBNB RESERVATIONS WILL BE HONORED Nice, comf│ │ortable, and clean private guest room with shared bathroom (2 people m│ │ax) - full size bed. In very nice apartment on central Park North 4th │ │floor walk-up. same place as Chez chic #2, max capacity of the rooms 2│ │ people). You will share the apt with me and my little family. Daily c│ │leaning in common areas. Located one block from Subway 2/3,B/C on 110t│ │h street, Bus M1,2,3,4 at the corner, central park across the street. │ │ Your room: full size bed (sleeps two), desk, Digital Tv/DVD, wifi int│ │ernet, A/C, closet and desk. Sheets/Towels provided. Iron/air dryer pr│ │ovided. Separate Full bathroom shared with guestroom room #2. Access t│ │o the Kitchen from 8AM weekdays or anytime during the weekend and ligh│ │t cooking, access to kitchen at all times but no cooking in the evenin│ │g. The apartment: spacious newly renovated, hardwood floors,3BD, 2Bat│ │h apartment with Living room","review_scores_checkin":"10","cleaning_f│ │ee":"$60.00","host_location":"New York, New York, United States","pric│ │e":"$59.00","experiences_offered":"none","reviews_per_month":"1.42","n│ │eighbourhood":"Harlem","review_scores_location":"9","square_feet":null│ │,"state":"NY","id":"2515","host_identity_verified":"t","longitude":"-7│ │3.95367574543542","weekly_price":"$720.00","bed_type":"Real Bed","revi│ │ew_scores_accuracy":"9","review_scores_value":"9","host_response_time"│ │:"within a day","host_about":" loves to host and welcome travelers fro│ │m around the world in our family Apt.","bathrooms":"1.0","bedrooms":"1│ │","zipcode":"10026","market":"New York","extra_people":"$39.00","licen│ │se":null,"country_code":"US","transit":"Subway 2.3.B.C. at 110th stree│ │t around the corner and bus M.2.3.4 at the corner","xl_picture_url":nu│ │ll,"name":"Stay at Chez Chic budget room #1","availability_60":"22","h│ │ost_thumbnail_url":"https://a0.muscache.com/im/users/2758/profile_pic/│ │1338267836/original.jpg?aki_policy=profile_small","host_neighbourhood"│ │:"Harlem","cancellation_policy":"strict_14_with_grace_period","beds":"│ │2","instant_bookable":"f","scrape_id":"20180806171147","amenities":"{T│ │V,"Cable TV",Internet,Wifi,"Air conditioning",Kitchen,"Free street par│ │king","Buzzer/wireless intercom",Heating,"Family/kid friendly","Smoke │ │detector","Carbon monoxide detector","Fire extinguisher",Essentials,Sh│ │ampoo,"Lock on bedroom door",Hangers,"Hair dryer",Iron,"Laptop friendl│ │y workspace","Children’s books and toys","Window guards","Pack ’n Play│ │/travel crib","Hot water",Microwave,"Coffee maker",Refrigerator,"Dishe│ │s and silverware","Cooking basics",Oven,Stove,"Host greets you"}","hos│ │t_url":"https://www.airbnb.com/users/show/2758","neighbourhood_cleanse│ │d":"Harlem","access":"Guests will have their PRIVATE BATHROOM (NOTE: S│ │hared between June 22-Aug 22) (shared with 2nd guestroom if there are │ │guests), and the kitchen","city":"New York","latitude":"40.79920479936│ │168","description":"Step into our artistic spacious apartment and enjo│ │y your artistic Guest room with original artwork from NY artists. Shar│ │ed with my little family however we often out and you won't see us muc│ │h. across the street from Central Park - the busy city minutes away bu│ │t sleeping in quiet at night! -PLEASE BOOK DIRECTLY. NO NEED TO SEND A│ │ REQUEST FOR DATES CALENDAR IS UP TO DATE ALL AIRBNB RESERVATIONS WILL│ │ BE HONORED Nice, comfortable, and clean private guest room with share│ │d bathroom (2 people max) - full size bed. In very nice apartment on c│ │entral Park North 4th floor walk-up. same place as Chez chic #2, max c│ │apacity of the rooms 2 people). You will share the apt with me and my │ │little family. Daily cleaning in common areas. Located one block from │ │Subway 2/3,B/C on 110th street, Bus M1,2,3,4 at the corner, central pa│ │rk across the street. Your room: full size bed (sleeps two), desk, Di│ │gital Tv/DVD, wifi internet, A/C, closet and desk. Sheets/Towels provi│ │ded. Iron/air dryer provided. Separate F","require_guest_phone_verific│ │ation":"f","thumbnail_url":null,"review_scores_communication":"9","nei│ │ghbourhood_group_cleansed":"Manhattan","jurisdiction_names":null,"stre│ │et":"New York, NY, United States","has_availability":"t","medium_url":│ │null,"property_type":"Apartment","host_response_rate":"86%","availabil│ │ity_90":"52","require_guest_profile_picture":"f","summary":"Step into │ │our artistic spacious apartment and enjoy your artistic Guest room wit│ │h original artwork from NY artists. Shared with my little family howev│ │er we often out and you won't see us much. across the street from Cent│ │ral Park - the busy city minutes away but sleeping in quiet at night!"│ │,"monthly_price":"$1,690.00","security_deposit":"$0.00","availability_│ │365":"317","smart_location":"New York, NY","availability_30":"6","cale│ │ndar_updated":"5 days ago","listing_url":"https://www.airbnb.com/rooms│ │/2515","guests_included":"2","maximum_nights":"21","host_has_profile_p│ │ic":"t","host_picture_url":"https://a0.muscache.com/im/users/2758/prof│ │ile_pic/1338267836/original.jpg?aki_policy=profile_x_medium","host_id"│ │:"2758","host_listings_count":"3","host_total_listings_count":"3","hos│ │t_acceptance_rate":"N/A","review_scores_rating":"93","minimum_nights":│ │"2","last_review":"2018-07-05","calculated_host_listings_count":"3","a│ │ccommodates":"3","interaction":"We will have a list of Harlem restaura│ │nts and points of interest ready for you, as well as a subway map of N│ │YC and pratical infos.","host_is_superhost":"f","host_since":"2008-09-│ │06","host_name":"Steph","last_scraped":"2018-08-07","room_type":"Priva│ │te room"} │ └──────────────────────────────────────────────────────────────────────┘ ----

Learn how to apply Neo4j Graph Algorithms to a graph of the Python ecosystem.

neo4j-load-csv-gz-s3

https://markhneedham.com/blog/2018/09/05/neo4j-load-csv-gz-s3

2018-09-18 07:56:00

matplotlib - MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned.

In my last post I showed how to link:/blog/2018/09/18/matplotlib-remove-axis-legend/[remove axes legends from a matplotlib chart^], and while writing the post I actually had the change the code I used as my initial approach is now deprecated. As in the previous post, we'll first import pandas and matplotlib: [source, python] ---- import pandas as pd import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') ---- And we'll still use this DataFrame: [source, python] ---- df = pd.DataFrame({"label": ["A", "B", "C", "D"], "count": [12, 19, 5, 10]}) ---- My initial approach to remove all legends was this: [source, python] ---- df.plot(kind='bar', x='label', y='count', legend=None) plt.axes().xaxis.set_label_text("") plt.tight_layout() plt.savefig("/tmp/matplotlib_no_x_no_y.svg") plt.close() ---- If we run this code the chart will still be generated, but we'll also receive the following error message: [source, text] ---- /Users/markneedham/projects/matplotlib-examples/a/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance. warnings.warn(message, mplDeprecation, stacklevel=1) ---- The problem is on the 2nd line. Instead of mutating the axes via the `plt` object, we need to capture the `AxesSubplot` object returned by the `plot()` function and update that instead: [source, python] ---- ax = df.plot(kind='bar', x='label', y='count', legend=None) ax.xaxis.set_label_text("") plt.tight_layout() plt.savefig("/tmp/matplotlib_no_x_no_y.svg") plt.close() ---- If we run this version of the code our chart will be generated and we won't have that deprecation message anymore.

Learn how to avoid a MatplotlibDeprecationWarning message when editing axes.

matplotlib-matplotlib-deprecation-adding-axes

https://markhneedham.com/blog/2018/09/18/matplotlib-matplotlib-deprecation-adding-axes

2018-09-18 07:55:00

matplotlib - Remove axis legend

I've been working with matplotlib a bit recently, and I wanted to remove all axis legends from my chart. It took me a bit longer than I expected to figure it out so I thought I'd write it up. Before we do anything let's import matplotlib as well as pandas, since we're going to plot data from a pandas DataFrame. [source, python] ---- import pandas as pd import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') ---- Next we'll create a DataFrame with one column called `label` and another called `count`: [source, python] ---- df = pd.DataFrame({"label": ["A", "B", "C", "D"], "count": [12, 19, 5, 10]}) ---- We want to plot a bar chart with the label on the x-axis and the count on the y-axis. The following code will plot a chart and store it in an SVG file: [source, python] ---- df.plot(kind='bar', x='label', y='count') plt.tight_layout() plt.savefig("/tmp/matplotlib_legends.svg") plt.close() ---- This is what the chart looks like: image::{{<siteurl>}}/uploads/2018/09/matplotlib_legends.svg[] We've got legends for both axes, but we can pass in `legend=None` to the `plot()` function which should sort that out: [source, python] ---- df.plot(kind='bar', x='label', y='count', legend=None) plt.tight_layout() plt.savefig("/tmp/matplotlib_no_y.svg") plt.close() ---- This is what the chart looks like now: image::{{<siteurl>}}/uploads/2018/09/matplotlib_no_y.svg[] The y-axis legend has been removed, but the x-axis one is still there. After a bit of searching I found the https://matplotlib.org/api/_as_gen/matplotlib.axis.Axis.set_label_text.html[set_label_text^] function, which we can use like this: [source, python] ---- ax = df.plot(kind='bar', x='label', y='count', legend=None) ax.xaxis.set_label_text("") plt.tight_layout() plt.savefig("/tmp/matplotlib_no_x_no_y.svg") plt.close() ---- And now we finally have a chart with all legends removed: image::{{<siteurl>}}/uploads/2018/09/matplotlib_no_x_no_y.svg[] Success!

Learn how to remove all axis legends from a matplotlib chart.

matplotlib-remove-axis-legend

https://markhneedham.com/blog/2018/09/18/matplotlib-remove-axis-legend

2018-09-28 07:55:00

Neo4j Graph Algorithms: Calculating the cosine similarity of Game of Thrones episodes

A couple of years ago I wrote a blog post showing how to https://markhneedham.com/blog/2016/08/22/neo4jscikit-learn-calculating-the-cosine-similarity-of-game-of-thrones-episodes/[calculate cosine similarity on Game of Thrones episodes^] using scikit-learn, and with the release of https://neo4j.com/docs/graph-algorithms/current/algorithms/similarity/[Similarity Algorithms^] in the Neo4j Graph Algorithms library I thought it was a good time to revisit that post. The dataset contains characters and episodes, and we want to calculate episode similarity based on the characters that appear in each episode. Before we run any algorithms we need to get the data into Neo4j. == Import the data There are three CSV files that contain everything we need. First we'll create one node per character: [source, cypher] ---- LOAD CSV WITH HEADERS FROM "https://raw.githubusercontent.com/mneedham/neo4j-got/master/data/import/characters.csv" AS row MERGE (c:Character {id: row.link}) ON CREATE SET c.name = row.character ---- Next let's create one node per episode: [source, cypher] ---- LOAD CSV WITH HEADERS FROM "https://raw.githubusercontent.com/mneedham/neo4j-got/master/data/import/overview.csv" AS row MERGE (episode:Episode {id: toInteger(row.episodeId)}) ON CREATE SET episode.season = toInteger(row.season), episode.number = toInteger(row.episode), episode.title = row.title ---- And finally let's create a relationship for each episode in which a character appeared: [source, cypher] ---- LOAD CSV WITH HEADERS FROM "https://raw.githubusercontent.com/mneedham/neo4j-got/master/data/import/characters_episodes.csv" AS row MATCH (episode:Episode {id: TOINT(row.episodeId)}) MATCH (character:Character {id: row.character}) MERGE (character)-[:APPEARED_IN]->(episode) ---- == Calculating Cosine Similarity Now that the data's loaded we're ready to calculate Cosine Similarity. To do this we first need to create a vector indicating whether a character appeared in an episode or not. e.g. imagine that we have 3 characters - A, B, and C - and 2 episodes. A and B appear in the first episode and B and C appear in the second episode. We would represent that with the following vectors: ``` Episode 1 = [1, 1, 0] Episode 2 = [0, 1, 1] ``` We could then calculate the Cosine Similarity between those two episodes like this: [source,cypher] ---- WITH [ {item: 1, weights: [1,1,0]}, {item: 2, weights: [0,1,1]}] AS data CALL algo.similarity.cosine.stream(data) YIELD item1, item2, similarity RETURN item1, item2, similarity ---- If we run that query we'll get this output: [source,text] ---- +----------------------------+ | item1 | item2 | similarity | +----------------------------+ | 1 | 2 | 0.5 | +----------------------------+ ---- The output tells us that these episodes are 50% similar to each other. In this example we've used the Cosine Similarity procedure, but we could also use the function since we're only calculating the similarity of a small number of items: [source, cypher] ---- RETURN algo.similarity.cosine([1,1,0], [0,1,1]) AS similarity ---- Now that we've covered the fundamentals of Cosine Similarity in Neo4j, let's see how to run it on our dataset. == Creating One Hot Encodings for Episodes We need to generate one vector per episode which we did in Python in the previous post. We also added the https://neo4j.com/docs/graph-algorithms/current/algorithms/one-hot-encoding/[One Hot Encoding^] function makes it easy for us to now do this directly from Cypher. If you want to read up on One Hot Encodings Rakshith Vasudev has https://hackernoon.com/what-is-one-hot-encoding-why-and-when-do-you-have-to-use-it-e3c6186d008f[a great blog post^] explaining it in more detail, but let's quickly see how it works in Neo4j. Imagine that we have 3 characters: Mark, Praveena, and Arya. We only want Praveena to be selected. We can do this by running the following function: [source, cypher] ---- RETURN algo.ml.oneHotEncoding(["Mark", "Praveena", "Arya"], ["Praveena"]) AS embedding ---- The first parameter contains a list of all the possible values. The second parameter contains a list of the ones that should be selected. If we run the query we'll see the following output: [source, cypher] ---- +-----------+ | embedding | +-----------+ | [0, 1, 0] | +-----------+ ---- Remember that a 1 indicates that the character appears and a 0 indicates that they don't. So in this case Mark and Arya didn't appear, but Praveena did. Great! Onto Game of Thrones! We can create a One Hot Encoding for our episodes by collecting lists of all characters and lists of characters by episode. The code to do that is as follows: [source, cypher] ---- MATCH (c:Character) WITH collect(c) AS characters MATCH (e:Episode) RETURN e, algo.ml.oneHotEncoding(characters, [(e)<-[:APPEARED_IN]-(c) | c]) AS embedding LIMIT 1 ---- If we run that query we'll see the following output: image::{{<siteurl>}}/uploads/2018/09/got.png[] == Calculating Cosine Similarity on Game of Thrones Now we're ready to run the Cosine Similarity algorithm. We extend the code above to do this: [source, cypher] ---- MATCH (c:Character) WITH collect(c) AS characters MATCH (e:Episode) WITH e, algo.ml.oneHotEncoding(characters, [(e)<-[:APPEARED_IN]-(c) | c]) AS embedding WITH {item:id(e), weights: embedding} as userData WITH collect(userData) as data CALL algo.similarity.cosine.stream(data) YIELD item1, item2, count1, count2, similarity WITH algo.getNodeById(item1) AS episode1, algo.getNodeById(item2) AS episode2, similarity RETURN "S" + episode1.season + "E" + episode1.number AS ep1, "S" + episode2.season + "E" + episode2.number AS ep2, similarity ORDER BY similarity DESC LIMIT 10 ---- The above code shows us the 10 most similar episodes. If we run that we'll see this output: [source, text ] ---- +---------------------------------------+ | ep1 | ep2 | similarity | +---------------------------------------+ | "S1E1" | "S1E2" | 0.6963730592072542 | | "S1E3" | "S1E4" | 0.6914173051223087 | | "S1E8" | "S1E9" | 0.6869464497590778 | | "S2E8" | "S2E10" | 0.6869037302955033 | | "S3E6" | "S3E7" | 0.6819943394704735 | | "S2E6" | "S2E7" | 0.6813598225089799 | | "S1E9" | "S1E10" | 0.6796436827080402 | | "S1E4" | "S1E5" | 0.6698105143372366 | | "S1E8" | "S1E10" | 0.6624062584864754 | | "S4E4" | "S4E5" | 0.6518358737330703 | +---------------------------------------+ ---- This query streamed the results back, but we can also run a non streaming version which by default will just return statistics about the similarity scores. We can run the non streaming version like this: [source, cypher] ---- MATCH (c:Character) WITH collect(c) AS characters MATCH (e:Episode) WITH e, algo.ml.oneHotEncoding(characters, [(e)<-[:APPEARED_IN]-(c) | c]) AS embedding WITH {item:id(e), weights: embedding} as userData WITH collect(userData) as data CALL algo.similarity.cosine(data) YIELD nodes, p50, p75, p90, p99, p999, p100 RETURN nodes, p50, p75, p90, p99, p999, p100 ---- And we'll see these results: [source, text] ---- +-------------------------------------------------------------------------------------------------------------------------------------+ | nodes | p50 | p75 | p90 | p99 | p999 | p100 | +-------------------------------------------------------------------------------------------------------------------------------------+ | 60 | 0.2863004207611084 | 0.3595731258392334 | 0.4467923641204834 | 0.6070897579193115 | 0.6869466304779053 | 0.6963765621185303 | +-------------------------------------------------------------------------------------------------------------------------------------+ ---- The fields starting with `p` represent percentiles. So 50% of the similarity scores are 0.2863 or higher, and 99% of them are 0.607 or higher. We probably aren't that interested in the lower similarity scores so we can filter those out by passing in the `similarityCutoff` parameter. We can also choose to create relationships between similar episodes by passing in the `write: true` parameter. The `write` parameter must be used in combination with a `similarityCutoff` value greater than 0 as we don't want to create relationships between nodes that are not similar at all. We can also pass in the `topK` parameter to limit the number of similar relationships we create per node. Let's say that we want to find the 3 most similar episodes. The following query does this: [source, cypher] ---- MATCH (c:Character) WITH collect(c) AS characters MATCH (e:Episode) WITH e, algo.ml.oneHotEncoding(characters, [(e)<-[:APPEARED_IN]-(c) | c]) AS embedding WITH {item:id(e), weights: embedding} as userData WITH collect(userData) as data CALL algo.similarity.cosine(data, {similarityCutoff: 0.2863, write: true, topK: 3}) YIELD nodes, p50, p75, p90, p99, p999, p100 RETURN nodes, p50, p75, p90, p99, p999, p100 ---- We can now write a query to find the most similar episodes: [source, cypher] ---- MATCH (e:Episode {season: 1, number: 1})-[similar:SIMILAR]->(other) RETURN "S" + other.season + "E" + other.number AS episode, similar.score AS score ---- That will return the following output: [source, text] ---- +-------------------------------+ | episode | score | +-------------------------------+ | "S1E2" | 0.6963730592072542 | | "S1E4" | 0.5467175210508692 | | "S1E3" | 0.48196269271187986 | +-------------------------------+ ---- Hopefully that gives you some ideas of what you can do with the similarity algorithms. If you have any suggestions for other things you'd like to see let me know in the comments and I'll see what I can do.

Learn how to calculate the Cosine Similarity of Game of Thrones episodes using Neo4j Graph Algorithms

neo4j-graph-algorithms-cosine-game-of-thrones

https://markhneedham.com/blog/2018/09/28/neo4j-graph-algorithms-cosine-game-of-thrones

2018-09-24 07:55:00

matplotlib - Create a histogram/bar chart for ratings/full numbers

In my continued work with matplotlib I wanted to plot a histogram (or bar chart) for a bunch of star ratings to see how they were distributed. Before we do anything let's import matplotlib as well as pandas: [source, python] ---- import random import pandas as pd import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') ---- Next we'll create an array of randomly chosen star ratings between 1 and 5: [source, python] ---- stars = pd.Series([random.randint(1, 5) for _ in range(0, 100)]) ---- We want to plot a histogram showing the proportion for each rating. The following code will plot a chart and store it in an SVG file: [source, python] ---- _, ax1 = plt.subplots() ax1.hist(stars, 5) plt.tight_layout() plt.savefig("/tmp/hist.svg") plt.close() ---- This is what the chart looks like: image::{{<siteurl>}}/uploads/2018/09/hist.svg[] This is ok, but the labels on the x axis are a bit weird - the value for each rating doesn't align with the corresponding bar. I came across https://stackoverflow.com/questions/18393887/how-to-create-a-bar-chart-histogram-with-bar-per-discrete-value[this StackOverflow post^], which shows how to solve this problem by using a bar chart instead. I ended up with this code: [source, python] ---- _, ax2 = plt.subplots() stars_histogram = stars.value_counts().sort_index() stars_histogram /= float(stars_histogram.sum()) stars_histogram *= 100 stars_histogram.plot(kind="bar", width=1.0) plt.tight_layout() plt.savefig("/tmp/bar.svg") plt.close() ---- This is what the chart looks like now: image::{{<siteurl>}}/uploads/2018/09/bar.svg[] Much better!

Learn how to create a matplotlib histogram for star ratings.

matplotlib-histogram-bar-chart-ratings-full-values

https://markhneedham.com/blog/2018/09/24/matplotlib-histogram-bar-chart-ratings-full-values

2018-01-18 23:35:25

Strava: Calculating the similarity of two runs

I go running several times a week and wanted to compare my runs against each other to see how similar they are. I record my runs with the https://www.strava.com/[Strava] app and it has an https://strava.github.io/api[API] that returns lat/long coordinates for each run in the https://strava.github.io/api/#polylines[Google encoded polyline algorithm format]. We can use the https://pypi.python.org/pypi/polyline/[polyline] library to decode these values into a list of lat/long tuples. For example: [source,python] ---- import polyline polyline.decode('u{~vFvyys@fS]') [(40.63179, -8.65708), (40.62855, -8.65693)] ---- Once we've got the route defined as a set of coordinates we need to compare them. My Googling led me to an algorithm called https://en.wikipedia.org/wiki/Dynamic_time_warping[Dynamic Time Warping] ____ DTW is a method that calculates an optimal match between two given sequences (e.g. time series) with certain restrictions. The sequences are "warped" non-linearly in the time dimension to determine a measure of their similarity independent of certain non-linear variations in the time dimension. ____ The https://pypi.python.org/pypi/fastdtw[fastdtw] library implements an approximation of this library and returns a value indicating the distance between sets of points. We can see how to apply fastdtw and polyline against Strava data in the following example: [source,python] ---- import os import polyline import requests from fastdtw import fastdtw token = os.environ["TOKEN"] headers = {'Authorization': "Bearer {0}".format(token)} def find_points(activity_id): r = requests.get("https://www.strava.com/api/v3/activities/{0}".format(activity_id), headers=headers) response = r.json() line = response["map"]["polyline"] return polyline.decode(line) ---- Now let's try it out on two runs, https://www.strava.com/activities/1361109741[1361109741] and https://www.strava.com/activities/1346460542[1346460542]: [source,python] ---- from scipy.spatial.distance import euclidean activity1_id = 1361109741 activity2_id = 1346460542 distance, path = fastdtw(find_points(activity1_id), find_points(activity2_id), dist=euclidean) >>> print(distance) 2.91985018100644 ---- These two runs are both near my house so the value is small. Let's change the second route to be https://www.strava.com/activities/1246017379[from my trip to New York]: [source,python] ---- activity1_id = 1361109741 activity2_id = 1246017379 distance, path = fastdtw(find_points(activity1_id), find_points(activity2_id), dist=euclidean) >>> print(distance) 29383.492965394034 ---- Much bigger! I'm not really interested in the actual value returned but I am interested in the relative values. I'm building a little application to generate routes that I should run and I want it to come up with a routes that are different to recent ones that I've run. This score can now form part of the criteria.

Learn how to compare runs from the Strava API using the Dynamic Time Warping algorithm.

strava-calculating-similarity-two-runs

https://markhneedham.com/blog/2018/01/18/strava-calculating-similarity-two-runs

2018-01-29 06:51:10

Tensorflow: Kaggle Spooky Authors Bag of Words Model

I've been playing around with some Tensorflow tutorials recently and wanted to see if I could create a submission for https://www.kaggle.com/c/spooky-author-identification[Kaggle's Spooky Author Identification competition] that I've written about recently. My model is based on one from the https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/learn/text_classification.py[text classification tutorial]. The tutorial shows how to create custom Estimators which we can learn more about in https://developers.googleblog.com/2017/12/creating-custom-estimators-in-tensorflow.html[a post on the Google Developers blog]. == Imports Let's get started. First, our imports: [source,python] ---- from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import pandas as pd import tensorflow as tf from sklearn import preprocessing from sklearn.model_selection import train_test_split ---- We've obviously got Tensorflow, but also scikit-learn which we'll use to split our data into a training and test sets as well as convert the author names into numeric values. == Model building functions Next we'll create a function to create a bag of words model. This function calls another one that creates different +++<cite>+++EstimatorSpec+++</cite>+++s depending on the context it's called from. [source,python] ---- EMBEDDING_SIZE = 50 MAX_LABEL = 3 WORDS_FEATURE = 'words' # Name of the input words feature. def bag_of_words_model(features, labels, mode): bow_column = tf.feature_column.categorical_column_with_identity(WORDS_FEATURE, num_buckets=n_words) bow_embedding_column = tf.feature_column.embedding_column(bow_column, dimension=EMBEDDING_SIZE) bow = tf.feature_column.input_layer(features, feature_columns=[bow_embedding_column]) logits = tf.layers.dense(bow, MAX_LABEL, activation=None) return create_estimator_spec(logits=logits, labels=labels, mode=mode) def create_estimator_spec(logits, labels, mode): predicted_classes = tf.argmax(logits, 1) if mode == tf.estimator.ModeKeys.PREDICT: return tf.estimator.EstimatorSpec( mode=mode, predictions={ 'class': predicted_classes, 'prob': tf.nn.softmax(logits), 'log_loss': tf.nn.softmax(logits), }) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) if mode == tf.estimator.ModeKeys.TRAIN: optimizer = tf.train.AdamOptimizer(learning_rate=0.01) train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step()) return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op) eval_metric_ops = { 'accuracy': tf.metrics.accuracy(labels=labels, predictions=predicted_classes) } return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops) ---- == Loading data Now we're ready to load our data. [source,python] ---- Y_COLUMN = "author" TEXT_COLUMN = "text" le = preprocessing.LabelEncoder() train_df = pd.read_csv("train.csv") X = pd.Series(train_df[TEXT_COLUMN]) y = le.fit_transform(train_df[Y_COLUMN].copy()) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42) ---- The only interesting thing here is the +++<cite>+++LabelEncoder+++</cite>+++. We'll keep that around as we'll use it later as well. == Transform documents At the moment our training and test dataframes contain text, but Tensorflow works with vectors so we need to convert our data into that format. We can use the +++<cite>+++http://tflearn.org/data_utils/#vocabulary-processor[VocabularyProcessor]+++</cite>+++ to do this: [source,python] ---- MAX_DOCUMENT_LENGTH = 100 vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor(MAX_DOCUMENT_LENGTH) X_transform_train = vocab_processor.fit_transform(X_train) X_transform_test = vocab_processor.transform(X_test) X_train = np.array(list(X_transform_train)) X_test = np.array(list(X_transform_test)) n_words = len(vocab_processor.vocabulary_) print('Total words: %d' % n_words) ---- == Training our model Finally we're ready to train our model! We'll call the Bag of Words model we created at the beginning and build a train input function where we pass in the training arrays that we just created: [source,python] ---- model_fn = bag_of_words_model classifier = tf.estimator.Estimator(model_fn=model_fn) train_input_fn = tf.estimator.inputs.numpy_input_fn( x={WORDS_FEATURE: X_train}, y=y_train, batch_size=len(X_train), num_epochs=None, shuffle=True) classifier.train(input_fn=train_input_fn, steps=100) ---- == Evaluating our model Let's see how our model fares. We'll call the +++<cite>+++evaluate+++</cite>+++ function with our test data: [source,python] ---- test_input_fn = tf.estimator.inputs.numpy_input_fn( x={WORDS_FEATURE: X_test}, y=y_test, num_epochs=1, shuffle=False) scores = classifier.evaluate(input_fn=test_input_fn) print('Accuracy: {0:f}, Loss {1:f}'.format(scores['accuracy'], scores["loss"])) ---- [source,text] ---- INFO:tensorflow:Saving checkpoints for 1 into /var/folders/k5/ssmkw9vd2yb3h5wnqlxnqbkw0000gn/T/tmpb6v4rrrn/model.ckpt. INFO:tensorflow:loss = 1.0888131, step = 1 INFO:tensorflow:Saving checkpoints for 100 into /var/folders/k5/ssmkw9vd2yb3h5wnqlxnqbkw0000gn/T/tmpb6v4rrrn/model.ckpt. INFO:tensorflow:Loss for final step: 0.18394235. INFO:tensorflow:Starting evaluation at 2018-01-28-22:41:34 INFO:tensorflow:Restoring parameters from /var/folders/k5/ssmkw9vd2yb3h5wnqlxnqbkw0000gn/T/tmpb6v4rrrn/model.ckpt-100 INFO:tensorflow:Finished evaluation at 2018-01-28-22:41:34 INFO:tensorflow:Saving dict for global step 100: accuracy = 0.8246673, global_step = 100, loss = 0.44942895 Accuracy: 0.824667, Loss 0.449429 ---- Not too bad! I managed to get a log loss score of ~ 0.36 with a scikit-learn ensemble model but it is better than some of my first attempts. == Generating predictions I wanted to see how it'd do against Kaggle's test dataset so I generated a CSV file with predictions: [source,python] ---- test_df = pd.read_csv("test.csv") X_test = pd.Series(test_df[TEXT_COLUMN]) X_test = np.array(list(vocab_processor.transform(X_test))) test_input_fn = tf.estimator.inputs.numpy_input_fn( x={WORDS_FEATURE: X_test}, num_epochs=1, shuffle=False) predictions = classifier.predict(test_input_fn) y_predicted_classes = np.array(list(p['prob'] for p in predictions)) output = pd.DataFrame(y_predicted_classes, columns=le.classes_) output["id"] = test_df["id"] output.to_csv("output.csv", index=False, float_format='%.6f') ---- Here we go: image::{{<siteurl>}}/uploads/2018/01/2018-01-29_06-44-30.png[2018 01 29 06 44 30,456] The score is roughly the same as we saw with the test split of the training set. If you want to see all the code in one place I've https://github.com/mneedham/spooky-author-identification/blob/master/tf_test.py[put it on my Spooky Authors GitHub repository].

In this mini tutorial you can learn how to create a Tensorflow Bag of Words model for Kaggle'e Spooky Authors halloween competition.

tensorflow-kaggle-spooky-authors-bag-words-model

https://markhneedham.com/blog/2018/01/29/tensorflow-kaggle-spooky-authors-bag-words-model

2018-01-23 21:11:49

Asciidoc to Asciidoc: Exploding includes

One of my favourite features in http://asciidoctor.org/docs/asciidoc-syntax-quick-reference/#include-files[AsciiDoc] is the ability to include other files, but when using lots of includes is that it becomes difficult to read the whole document unless you convert it to one of the supported backends. [source,bash] ---- $ asciidoctor --help Usage: asciidoctor [OPTION]... FILE... Translate the AsciiDoc source FILE or FILE(s) into the backend output format (e.g., HTML 5, DocBook 4.5, etc.) By default, the output is written to a file with the basename of the source file and the appropriate extension. Example: asciidoctor -b html5 source.asciidoc -b, --backend BACKEND set output format backend: [html5, xhtml5, docbook5, docbook45, manpage] (default: html5) additional backends are supported via extensions (e.g., pdf, latex) ---- I don't want to have to convert my code to one of these formats each time - I want to convert asciidoc to asciidoc! For example, given the following files: +++<cite>+++mydoc.adoc+++</cite>+++ [source,text] ---- = My Blog example == Heading 1 Some awesome text == Heading 2 \include::blog_include.adoc[] ---- .blog_include.adoc [source,text] ---- Some included text ---- I want to generate another asciidoc file where the contents of the include file are exploded and displayed inline. After a lot of searching I came across https://github.com/asciidoctor/asciidoctor-extensions-lab/blob/master/scripts/asciidoc-coalescer.rb[an excellent script] written by Dan Allen and put it in a file called +++<cite>+++adoc.rb+++</cite>+++. We can then call it like this: [source,bash] ---- $ ruby adoc.rb mydoc.adoc = My Blog example == Heading 1 Some awesome text == Heading 2 Some included text ---- Problem solved! In my case I actually wanted to explode HTTP includes so I needed to pass the +++<cite>+++-a allow-uri-read+++</cite>+++ flag to the script: [source,bash] ---- $ ruby adoc.rb mydoc.adoc -a allow-uri-read ---- And now I can generate asciidoc files until my heart's content. </p>

asciidoc-asciidoc-exploding-includes

https://markhneedham.com/blog/2018/01/23/asciidoc-asciidoc-exploding-includes

2018-06-03 20:11:21

Neo4j 3.4: Gotchas when working with Durations

Continuing with my explorations of Strava data in Neo4j I wanted to share some things I learnt while trying to work out my pace for certain distances. Before we get into the pace calculations let's first understand how the duration function works. If we run the following query we might expect to get back the same value that we put in... [source, cypher] ---- RETURN duration({seconds: 413.77}).seconds AS seconds ---- [source, text] ---- ╒═════════╕ │"seconds"│ ╞═════════╡ │413 │ └─────────┘ ---- ...but as you can see the value gets rounded down to the nearest number, losing us some accuracy. The rest of the value is available under the `millisecondsOfSecond` property, so we could retrieve the whole value by executing this query: [source, cypher] ---- WITH duration({seconds: 413.77}) AS duration RETURN duration.seconds AS s, duration.millisecondsOfSecond AS ms ---- [source, text] ---- ╒═══╤════╕ │"s"│"ms"│ ╞═══╪════╡ │413│769 │ └───┴────┘ ---- That's now split into two different values but I want to get a single value in seconds which we can do by returning the value in milliseconds and dividing by 1,000: [source, cypher] ---- RETURN duration({seconds: 413.77}).milliseconds / 1000.0 AS seconds ---- [source, text] ---- ╒═════════╕ │"seconds"│ ╞═════════╡ │413.769 │ └─────────┘ ---- == Calculating pace The actual problem I'm solving is to work out the pace I was running at for different distances. For example, we could represent my most recent predicted 5km like this: [source, cypher] ---- RETURN duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance ---- [source, cypher] ---- ╒═════════════╤══════════╕ │"elapsedTime"│"distance"│ ╞═════════════╪══════════╡ │"P0M0DT1284S"│5000.0 │ └─────────────┴──────────┘ ---- If we want to work out my pace per mile and per kilometre we can write the following query: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance RETURN duration({seconds: elapsedTime.seconds / distance * 1609.34}) AS pacePerMile, duration({seconds: elapsedTime.seconds / distance * 1000}) AS pacePerKm ---- [source, text] ---- ╒══════════════════════╤══════════════════════╕ │"pacePerMile" │"pacePerKm" │ ╞══════════════════════╪══════════════════════╡ │"P0M0DT413.278511999S"│"P0M0DT256.799999999S"│ └──────────────────────┴──────────────────────┘ ---- Let's use `apoc.date.format` to format that a bit more nicely: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance WITH duration({seconds: elapsedTime.seconds / distance * 1609.34}) AS pacePerMile, duration({seconds: elapsedTime.seconds / distance * 1000}) AS pacePerKm RETURN apoc.date.format(pacePerMile.milliseconds, "ms", "mm:ss") AS pacePerMile, apoc.date.format(pacePerKm.milliseconds, "ms", "mm:ss") AS pacePerKm ---- [source, text] ---- ╒═════════════╤═══════════╕ │"pacePerMile"│"pacePerKm"│ ╞═════════════╪═══════════╡ │"06:53" │"04:16" │ └─────────────┴───────────┘ ---- So far so good. We have a bit of duplication on lines 3 and 4 which we can remove by calculating the `pacePerMetre` and then multiplying that in the next step. The following query should do the trick: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance WITH duration({seconds: elapsedTime.seconds / distance}) AS pacePerMetre RETURN apoc.date.format(toInteger(pacePerMetre.milliseconds * 1609.34), "ms", "mm:ss") AS pacePerMile, apoc.date.format(pacePerMetre.milliseconds * 1000, "ms", "mm:ss") AS pacePerKm ---- Let's run that: [source, text] ---- ╒═════════════╤═══════════╕ │"pacePerMile"│"pacePerKm"│ ╞═════════════╪═══════════╡ │"06:51" │"04:16" │ └─────────────┴───────────┘ ---- The `pacePerKm` still looks good but the `pacePerMile` is now 2 seconds less than it was before. The rounding has struck again but let's break it down and see exactly what's happened. The following query shows us how the rounding has resulted in completely different end values: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance WITH duration({seconds: elapsedTime.seconds / distance * 1609.34}) AS pacePerMile, duration({seconds: elapsedTime.seconds / distance}) AS pacePerMetre RETURN pacePerMile.milliseconds AS millis1, pacePerMetre.milliseconds * 1609.34 AS millis2 ---- [source, text] ---- ╒═════════╤═════════╕ │"millis1"│"millis2"│ ╞═════════╪═════════╡ │413278 │411991.04│ └─────────┴─────────┘ ---- To solve our problem we'll need to return the `pacePerMetre` in microseconds and then convert it into `pacePerMile`. Let's first tweak the query above so that we get the same millisecond values: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance WITH duration({seconds: elapsedTime.seconds / distance * 1609.34}) AS pacePerMile, duration({seconds: elapsedTime.seconds / distance}) AS pacePerMetre RETURN pacePerMile.milliseconds AS millis1, pacePerMetre.microseconds * 1.60934 AS millis2 ---- [source, text] ---- ╒═════════╤════════════╕ │"millis1"│"millis2" │ ╞═════════╪════════════╡ │413278 │413276.90266│ └─────────┴────────────┘ ---- Now the 2nd value is actually more accurate but since we're only measuring down to the second it doesn't matter. We can use the same approach to get an accurate `pacePerMile` value. The following query does the trick, and we'll even add in `metresPerSecond` for good measure: [source, cypher] ---- WITH duration({minutes: 21, seconds: 24}) AS elapsedTime, toFloat(5000) AS distance WITH duration({seconds: elapsedTime.seconds / distance}) AS pacePerMetre RETURN apoc.date.format(toInteger(pacePerMetre.microseconds * 1.60934), "ms", "mm:ss") AS pacePerMile, apoc.date.format(pacePerMetre.microseconds, "ms", "mm:ss") AS pacePerKm, 1.0 / (pacePerMetre.microseconds / 1000.0 / 1000.0) AS metresPerSecond ---- And if we run that: [source, text] ---- ╒═════════════╤═══════════╤══════════════════╕ │"pacePerMile"│"pacePerKm"│"metresPerSecond" │ ╞═════════════╪═══════════╪══════════════════╡ │"06:53" │"04:16" │3.8940961608105953│ └─────────────┴───────────┴──────────────────┘ ---- Sweet! That's all I've got for now but let me know in the comments if you've had a chance to play around with the temporal data type and what your experience has been like.

Learn how to work around some rounding gotchas when working with Neo4j's new Duration data type.

neo4j-3.4-gotchas-working-with-durations

https://markhneedham.com/blog/2018/06/03/neo4j-3.4-gotchas-working-with-durations

2018-06-03 04:08:21

Neo4j 3.4: Formatting instances of the Duration and Datetime date types

In my https://markhneedham.com/blog/2018/06/02/neo4j-3.4-comparing-durations/[last blog post^] I showed how to compare instances of Neo4j's https://neo4j.com/docs/developer-manual/current/cypher/syntax/temporal/#cypher-temporal-durations[Duration data type^], and in the middle of the post I realised that I needed to use the https://neo4j-contrib.github.io/neo4j-apoc-procedures/[APOC library^] to return the value in the format I wanted. This was the solution I ended up with: [source, cypher] ---- WITH duration({seconds: 100}) AS duration RETURN apoc.text.lpad(toString(duration.minutes), 2, "0") + ":" + apoc.text.lpad(toString(duration.secondsOfMinute), 2, "0") ---- If we run that query this is the output: [source, text] ---- ╒═══════╕ │"value"│ ╞═══════╡ │"01:40"│ └───────┘ ---- It works but it's not very nice so I wanted to see if I could come up with something better. == `apoc.text.format` My first attempt used the `apoc.text.format` function, which allows us to https://github.com/neo4j-contrib/neo4j-apoc-procedures/issues/269[format Strings in sprintf format^]. This is how we can format the duration using that function: [source, cypher] ---- WITH duration({seconds: 100}) AS duration RETURN apoc.text.format("%02d:%02d", [duration.minutes, duration.secondsOfMinute]) AS value ---- This is better than our first version but what if we want to include the number of hours as well? We'd have to do this: [source, cypher] ---- WITH duration({minutes: 100, seconds: 30}) AS duration RETURN apoc.text.format("%02d:%02d:%02d", [duration.hours, duration.minutesOfHour, duration.secondsOfMinute]) AS value ---- If we execute that query we'll see this output: [source, text] ---- ╒══════════╕ │"value" │ ╞══════════╡ │"01:40:30"│ └──────────┘ ---- Not bad. At this point I remembered that APOC has lots of https://neo4j-contrib.github.io/neo4j-apoc-procedures/#_date_and_time_conversions[date formatting functions^] and I wondered if I could use one of them to make life even easier. == `apoc.date.format` Yes we can! If we can convert our duration into milliseconds we can use `apoc.date.format` to solve the problem. The following code does the trick: [source, cypher] ---- WITH duration({minutes: 100, seconds: 30}) AS duration RETURN apoc.date.format(duration.milliseconds, 'ms', 'HH:mm:ss') AS value ---- == Formatting dates We can use the same approach to format dates as well. We can extract the timestamp of a Datetime from the `epochSeconds` property. The following query formats the current Datetime: [source, cypher] ---- RETURN apoc.date.format(datetime().epochSeconds, 's', 'MMM d yyyy') AS value ---- [source, text] ---- ╒════════════╕ │"value" │ ╞════════════╡ │"Jun 3 2018"│ └────────────┘ ---- If we want to extract the timestamp in milliseconds we can do that as well: [source, cypher] ---- RETURN apoc.date.format(datetime().epochMillis, 'ms', 'MMM d yyyy') AS value ----

Learn how to format the Duration and Datetime types introduced in Neo4j 3.4

neo4j-3.4-formatting-instances-durations-dates

https://markhneedham.com/blog/2018/06/03/neo4j-3.4-formatting-instances-durations-dates

2018-06-05 05:30:21

Neo4j APOC: Importing data from Strava's paginated JSON API

Over the weekend I've been playing around with loading data from the http://developers.strava.com/[Strava API^] into Neo4j and I started with the following Python script which creates a node with a `Run` label for each of my activities. If you want to follow along on your own data you'll need to get an API key via the https://www.strava.com/settings/api['My API Application'^] section of the website. Once you've got that put it in the `TOKEN` environment variable and you should be good to go. [source, python] ---- import os from neo4j.v1 import GraphDatabase password = os.environ["NEO4J_PASSWORD"] driver = GraphDatabase.driver("bolt://localhost", auth=("neo4j", password)) with driver.session() as session: page = 1 while True: result = session.run("""\ WITH "https://www.strava.com/api/v3/athlete/activities?page=" + $page AS uri CALL apoc.load.jsonParams(uri, {Authorization: $stravaToken}, null) YIELD value MERGE (run:Run {id: value.id}) SET run.distance = toFloat(value.distance), run.startDate = datetime(value.start_date_local), run.elapsedTime = duration({seconds: value.elapsed_time}) RETURN count(*) AS count """, {"page": page, "stravaToken": "Bearer {0}".format(os.environ["TOKEN"])}) runs_imported = result.peek()["count"] print("Runs imported:", runs_imported) if runs_imported == 0: break else: page += 1 ---- The Strava API is a bit unusual in that it doesn't return any meta data indicating whether there are more pages to come - you get the data and only the data! We'll receive an empty array once we reach the end so we have to check for that condition and exit our loop when its met. Most of the word is being done by https://neo4j-contrib.github.io/neo4j-apoc-procedures/#_further_functions[APOC^]'s `apoc.load.jsonParams` procedure - we're only handling the pagination stuff in Python. Much as I love a good Python script, I was curious whether I could write the whole import script using just Cypher and get rid of the Python code completely. image::{{<siteurl>}}/uploads/2018/06/apoc-all-the-things.jpg[] == Attempt 1: Using an `Import` meta data node Let's get started! Before we do anything we'll create a parameter containing our Strava token: [source, cypher] ---- :params {stravaToken: "Bearer <insert-strava-token>"} ---- My first solution for handling this pagination is to create a separate meta data node which can keep track of the page we're up to. We should then be able to increment a `page` property on that node after every call to the Strava API. We'll wrap our call to `apoc.load.jsonParams` inside one of APOC's https://neo4j-contrib.github.io/neo4j-apoc-procedures/#_further_functions[periodic commit procedures^]. First let's create our meta data node: [source, cypher] ---- CREATE (:Import {page: 1}) ---- Now we need to work out which of the periodic commit procedures is the best fit. There are several to pick from: * `apoc.periodic.commit` - runs the given kernelTransaction in separate transactions until it returns 0 * `apoc.periodic.rock_n_roll_while` - run the action kernelTransaction in batches over the iterator kernelTransaction’s results in a separate thread. * `apoc.periodic.rock_n_roll` - run the action kernelTransaction in batches over the iterator kernelTransaction’s results in a separate thread. * `apoc.periodic.iterate` - run the second kernelTransaction for each item returned by the first kernelTransaction. After playing around with a solution in my head and then sketching out a toy example in the Neo4j browser (as well as doubting that this was even possible), I figured out that `apoc.periodic.commit` would be best suited. We can wrap our call to `apoc.load.jsonParams` in the following call to `apoc.periodic.commit`: [source, cypher] ---- call apoc.periodic.commit(" MATCH (import:Import) WITH 'https://www.strava.com/api/v3/athlete/activities?page=' + import.page AS uri, import.page AS initialPage, import CALL apoc.load.jsonParams(uri, {Authorization: $stravaToken}, null) YIELD value MERGE (run:Run {id: value.id}) SET run.distance = toFloat(value.distance), run.startDate = datetime(value.start_date_local), run.elapsedTime = duration({seconds: value.elapsed_time}) WITH initialPage, import, CASE WHEN count(*) < 30 THEN 0 ELSE count(*) END AS count FOREACH(ignoreMe in CASE WHEN count = 0 THEN [] ELSE [1] END | MERGE (import) SET import.page = initialPage+1 ) RETURN count ", {stravaToken: $stravaToken}) ---- This script will read the `page` property from our `Import` node and call the Strava API starting at that page via `apoc.load.jsonParams`. We create a node with the label `Run` for each activity and then we check if any rows were actually returned. The default activities per page is 30 so if we receive less than that back then we know we're reached the end of the stream and can return a count of `0`. We then use the https://markhneedham.com/blog/2014/06/17/neo4j-load-csv-handling-conditionals/[FOREACH hack^] to increment the `page` property on the `Import` node before returning the count. Finally we return the count and once the value returned is 0 the Cypher statement will complete. This works but it's a bit annoying to have to create the `Import` node to store our page number. We also can't easily reuse the code to pick up any new runs. We'd have to set the page back to `1` and then it would go through everything again which is a bit of a waste. == Attempt 2: The `after` parameter and timestamps While trying to come up with a cleaner way to paginate I realised that the Strava API allows you to pass in an `after` parameter. The `after` parameter indicates a minimum timestamp for the activities that should be returned. We can use this to simplify our Cypher statement! The `Run` nodes that we're creating contain a `startDate` which we can convert into a timestamp and pass to the API. If we haven't loaded any runs yet we can use the https://neo4j.com/docs/developer-manual/current/cypher/functions/scalar/#functions-coalesce[coalesce function^] to start from 0. We now end up with a much simpler script: [source, cypher] ---- call apoc.periodic.commit(" OPTIONAL MATCH (run:Run) WITH run ORDER BY run.startDate DESC LIMIT 1 WITH coalesce(run.startDate.epochSeconds, 0) AS after WITH 'https://www.strava.com/api/v3/athlete/activities?after=' + after AS uri CALL apoc.load.jsonParams(uri, {Authorization: $stravaToken}, null) YIELD value MERGE (run:Run {id: value.id}) SET run.distance = toFloat(value.distance), run.startDate = datetime(value.start_date_local), run.elapsedTime = duration({seconds: value.elapsed_time}) RETURN CASE WHEN count(*) < 30 THEN 0 ELSE count(*) END AS count ", {stravaToken: $stravaToken}) ---- We no longer need to create a meta data node, and we can easily execute this to pick up new activities. Thank you APOC!

Learn how to paginate through JSON APIs and load the data into Neo4j using only APOC's Load JSON procedure.

neo4j-apoc-loading-data-strava-paginated-json-api

https://markhneedham.com/blog/2018/06/05/neo4j-apoc-loading-data-strava-paginated-json-api

2018-06-02 03:24:21

Neo4j 3.4: Comparing durations

Neo4j 3.4 saw the https://neo4j.com/blog/neo4j-graph-database-3-4-ga-release/[introduction of the temporal date type^], which my colleague https://twitter.com/adamcowley[Adam Cowley^] covered in his https://www.adamcowley.co.uk/neo4j/temporal-native-dates/[excellent blog post^], and in this post I want to share my experience using durations from my https://www.strava.com/[Strava^] runs. I'll show how to load the whole Strava dataset in another blog post but for now we'll just manually create some durations based on the elapsed time in seconds that Strava provides. We can run the following query to convert duration in seconds into the duration type: [source, cypher] ---- WITH [2882, 2666, 2802, 3001, 3253, 2615, 2780, 2820, 2583, 2253] AS elapsedTimes UNWIND range(0, size(elapsedTimes) - 1) AS index RETURN elapsedTimes[index] AS timeInSeconds, duration("PT" + elapsedTimes[index] + "S") AS d1, duration({seconds: elapsedTimes[index]}) AS d2 ---- [source, text] ---- ╒═══════════════╤═════════════╤═════════════╕ │"timeInSeconds"│"d1" │"d2" │ ╞═══════════════╪═════════════╪═════════════╡ │2882 │"P0M0DT2882S"│"P0M0DT2882S"│ ├───────────────┼─────────────┼─────────────┤ │2666 │"P0M0DT2666S"│"P0M0DT2666S"│ ├───────────────┼─────────────┼─────────────┤ │2802 │"P0M0DT2802S"│"P0M0DT2802S"│ ├───────────────┼─────────────┼─────────────┤ │3001 │"P0M0DT3001S"│"P0M0DT3001S"│ ├───────────────┼─────────────┼─────────────┤ │3253 │"P0M0DT3253S"│"P0M0DT3253S"│ ├───────────────┼─────────────┼─────────────┤ │2615 │"P0M0DT2615S"│"P0M0DT2615S"│ ├───────────────┼─────────────┼─────────────┤ │2780 │"P0M0DT2780S"│"P0M0DT2780S"│ ├───────────────┼─────────────┼─────────────┤ │2820 │"P0M0DT2820S"│"P0M0DT2820S"│ ├───────────────┼─────────────┼─────────────┤ │2583 │"P0M0DT2583S"│"P0M0DT2583S"│ ├───────────────┼─────────────┼─────────────┤ │2253 │"P0M0DT2253S"│"P0M0DT2253S"│ └───────────────┴─────────────┴─────────────┘ ---- So far so good. == Creating nodes with `Duration` property Let's create a node with a `Run` label to represent each of these: [source, cypher] ---- WITH [2882, 2666, 2802, 3001, 3253, 2615, 2780, 2820, 2583, 2253] AS elapsedTimes UNWIND range(0, size(elapsedTimes) - 1) AS index CREATE (:Run {id: index, elapsedTime: duration({seconds: elapsedTimes[index]}) }) ---- [source, cypher] ---- Added 10 labels, created 10 nodes, set 20 properties, completed after 17 ms. ---- Great. Now we're ready to write some queries. == How do I display those durations in a more friendly format? In case we're not used to expressing durations only using seconds we can https://neo4j.com/docs/developer-manual/current/cypher/syntax/temporal/#cypher-temporal-accessing-components-durations[extract individual time units^] from the duration with the following query: [source, cypher] ---- MATCH (r:Run) RETURN r.id, r.elapsedTime.minutes AS mins, r.elapsedTime.secondsOfMinute AS secs ORDER BY r.elapsedTime DESC LIMIT 5 ---- [source, cypher] ---- ╒══════╤══════╤══════╕ │"r.id"│"mins"│"secs"│ ╞══════╪══════╪══════╡ │4 │54 │13 │ ├──────┼──────┼──────┤ │3 │50 │1 │ ├──────┼──────┼──────┤ │0 │48 │2 │ ├──────┼──────┼──────┤ │7 │47 │0 │ ├──────┼──────┼──────┤ │2 │46 │42 │ └──────┴──────┴──────┘ ---- Note that I used `secondsOfMinutes` and not `seconds`. If you use `seconds` it will give you the total number of seconds rather than the seconds of the minute: [source, cypher] ---- MATCH (r:Run) RETURN r.elapsedTime.seconds AS secs ORDER BY r.elapsedTime DESC LIMIT 5 ---- [source, text] ---- ╒══════╕ │"secs"│ ╞══════╡ │3253 │ ├──────┤ │3001 │ ├──────┤ │2882 │ ├──────┤ │2820 │ ├──────┤ │2802 │ └──────┘ ---- == How do I pad the minutes and seconds? Although the output is nicer than displaying the full duration, I'd quite like to have each duration displayed as `MM:SS` and https://neo4j-contrib.github.io/neo4j-apoc-procedures/#_text_functions[APOC^] comes to the rescue, and in particular the `apoc.text.lpad` function. The following query does exactly what I want: [source, cypher] ---- MATCH (r:Run) RETURN r.id, apoc.text.lpad(toString(r.elapsedTime.minutes), 2, "0") + ":" + apoc.text.lpad(toString(r.elapsedTime.secondsOfMinute), 2, "0") AS time ORDER BY r.elapsedTime DESC LIMIT 5 ---- [source, text] ---- ╒══════╤═══════╕ │"r.id"│"time" │ ╞══════╪═══════╡ │4 │"54:13"│ ├──────┼───────┤ │3 │"50:01"│ ├──────┼───────┤ │0 │"48:02"│ ├──────┼───────┤ │7 │"47:00"│ ├──────┼───────┤ │2 │"46:42"│ └──────┴───────┘ ---- == How many times did I run less than 45 minutes? What if I want to filter my runs to only find the shorter ones? [source, cypher] ---- MATCH (r:Run) WHERE r.elapsedTime < duration("PT45M") RETURN r.id, r.elapsedTime.minutes AS mins, r.elapsedTime.secondsOfMinute AS secs ORDER BY r.elapsedTime DESC ---- But that results in this error: [source, text] ---- Neo.ClientError.Statement.SyntaxError: Type mismatch: expected Float, Integer, Point, String, Date, Time, LocalTime, LocalDateTime or DateTime but was Duration (line 2, column 23 (offset: 44)) "WHERE r.elapsedTime < duration("PT45M")" ^ ---- If we want to compare durations we need to do that comparison by adding those durations to dates. We don't really care about dates for our query so we'll just use the current time to work around this issue. We can get that by calling the `localtime()` function. The following query will find all the runs of less than 45 minutes: [source, cypher] ---- MATCH (r:Run) WHERE localtime() + r.elapsedTime < localtime() + duration("PT45M") RETURN r.id, r.elapsedTime.minutes AS mins, r.elapsedTime.secondsOfMinute AS secs ORDER BY r.elapsedTime DESC ---- [source, text] ---- ╒══════╤══════╤══════╕ │"r.id"│"mins"│"secs"│ ╞══════╪══════╪══════╡ │1 │44 │26 │ ├──────┼──────┼──────┤ │5 │43 │35 │ ├──────┼──────┼──────┤ │8 │43 │3 │ ├──────┼──────┼──────┤ │9 │37 │33 │ └──────┴──────┴──────┘ ---- == How much shorter was this run than my longest run? We'll finish up with one final query, which was actually the real one I wanted to know the answer to! [source, cypher] ---- MATCH (r:Run) WITH MAX(r.elapsedTime) AS longestRun MATCH (r:Run) WITH r, longestRun - r.elapsedTime AS difference WHERE localtime() + difference > localtime() + duration("PT0S") RETURN r.id, r.elapsedTime.minutes AS mins, r.elapsedTime.secondsOfMinute AS secs, difference.minutes AS minutesShorter, difference.secondsOfMinute AS secondsShorter ORDER BY difference LIMIT 5 ---- On line 5 we filter out the longest run from the result set by making sure the difference is greater than 0 seconds. [source, text] ---- ╒══════╤══════╤══════╤════════════════╤════════════════╕ │"r.id"│"mins"│"secs"│"minutesShorter"│"secondsShorter"│ ╞══════╪══════╪══════╪════════════════╪════════════════╡ │3 │50 │1 │4 │12 │ ├──────┼──────┼──────┼────────────────┼────────────────┤ │0 │48 │2 │6 │11 │ ├──────┼──────┼──────┼────────────────┼────────────────┤ │7 │47 │0 │7 │13 │ ├──────┼──────┼──────┼────────────────┼────────────────┤ │2 │46 │42 │7 │31 │ ├──────┼──────┼──────┼────────────────┼────────────────┤ │6 │46 │20 │7 │53 │ └──────┴──────┴──────┴────────────────┴────────────────┘ ---- I hope that helps anyone playing around with the new `Duration` type. All that thinking about running has made me want to go for a run!

Learn how to work with the new Duration type that was introduced in Neo4j 3.4

neo4j-3.4-comparing-durations

https://markhneedham.com/blog/2018/06/02/neo4j-3.4-comparing-durations

2018-06-15 13:45:21

Neo4j: Querying the Strava Graph using Py2neo

Last week Nigel https://medium.com/neo4j/py2neo-v4-2bedc8afef2[released v4 of Py2neo^] and given I was just getting ready to write some queries against https://markhneedham.com/blog/2018/06/12/neo4j-building-strava-graph/[my Strava activity graph^] I thought I'd give it a try. If you want to learn how to create your own Strava graph you should read my previous post, but just to recap, this is the graph model that we created: image::{{<siteurl>}}/uploads/2018/06/strava-graph.svg[] Let's get to it! == tl;dr the code in this post is available as a https://github.com/mneedham/strava/blob/master/Strava.ipynb[Jupyter notebook^] so if you want the code and nothing but the code head over there! == Importing libraries Importing and creating a `Graph` object in Py2neo is as simple as executing the following lines of code: [source, python] ---- from py2neo import Graph graph = Graph("bolt://localhost:7687", auth=("neo4j", "neo")) ---- == Find the most recent activities We'll start with a simple query where we find the most recent activities that I've done. [source, python] ---- recent_runs_df = graph.run("""\ MATCH (r:Run) WITH r { .id, .startDate, .name, .movingTime, .distance, pace: duration({seconds: r.movingTime.seconds / r.distance * 1000}) } RETURN r.name, apoc.date.format(r.startDate.epochSeconds, 's', 'MMM d yyyy') AS dateOfRun, r.distance, apoc.date.format(r.movingTime.milliseconds, 'ms', 'HH:mm:ss') AS time, apoc.date.format(r.pace.milliseconds, "ms", "mm:ss") AS pacePerKm, r.startDate AS startDate """).to_data_frame() recent_runs_df \ .sort_values(by = ["startDate"], ascending=False) \ .drop(["startDate"], axis=1) \ .head(10) ---- This query converts the Cypher output into a DataFrame with the `to_data_frame` function. There are other formats that we can use instead but I want to post process the results using Pandas so this format works best for me. If we run that query we'll get the following output: ++++ <table class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>dateOfRun</th> <th>pacePerKm</th> <th>r.distance</th> <th>r.name</th> <th>time</th> </tr> </thead> <tbody> <tr> <th>605</th> <td>Jun 13 2018</td> <td>04:33</td> <td>10780.2</td> <td>Morning Run</td> <td>00:49:11</td> </tr> <tr> <th>604</th> <td>Jun 11 2018</td> <td>04:34</td> <td>10035.8</td> <td>Morning Run</td> <td>00:45:53</td> </tr> <tr> <th>603</th> <td>Jun 9 2018</td> <td>04:23</td> <td>11043.2</td> <td>Morning Run</td> <td>00:48:29</td> </tr> <tr> <th>602</th> <td>Jun 8 2018</td> <td>04:36</td> <td>11281.2</td> <td>Morning Run</td> <td>00:51:57</td> </tr> <tr> <th>586</th> <td>Jun 6 2018</td> <td>04:28</td> <td>10884.9</td> <td>Morning Run</td> <td>00:48:38</td> </tr> <tr> <th>585</th> <td>Jun 4 2018</td> <td>04:24</td> <td>10030.5</td> <td>Morning Run</td> <td>00:44:14</td> </tr> <tr> <th>584</th> <td>Jun 2 2018</td> <td>04:25</td> <td>13039.8</td> <td>Morning Run</td> <td>00:57:41</td> </tr> <tr> <th>601</th> <td>Jun 1 2018</td> <td>04:29</td> <td>10701.7</td> <td>Morning Run</td> <td>00:48:02</td> </tr> <tr> <th>600</th> <td>May 30 2018</td> <td>04:41</td> <td>9828.4</td> <td>Morning Run</td> <td>00:46:06</td> </tr> <tr> <th>599</th> <td>May 28 2018</td> <td>04:34</td> <td>10193.0</td> <td>Morning Run</td> <td>00:46:42</td> </tr> </tbody> </table> <style> table { border-collapse: collapse; } table, th, td { border: 1px solid black; padding: 5px; } </style> ++++ We could also do the sorting of the data directly in Cypher, but I wanted to have all the activities available in the DataFrame so that we could play around with it directly in Pandas without having to re-run the query each time. == Find the longest activities For example, we could find the activities ordered by distance: [source, python] ---- recent_runs_df \ .sort_values(by = ["r.distance"], ascending=False) \ .drop(["startDate"], axis=1) \ .head(10) ---- If we run that query we'll get the following output: ++++ <table class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>dateOfRun</th> <th>pacePerKm</th> <th>r.distance</th> <th>r.name</th> <th>time</th> </tr> </thead> <tbody> <tr> <th>594</th> <td>May 19 2018</td> <td>04:30</td> <td>13635.2</td> <td>Morning Run</td> <td>01:01:27</td> </tr> <tr> <th>584</th> <td>Jun 2 2018</td> <td>04:25</td> <td>13039.8</td> <td>Morning Run</td> <td>00:57:41</td> </tr> <tr> <th>590</th> <td>May 12 2018</td> <td>04:40</td> <td>12963.9</td> <td>Morning Run</td> <td>01:00:33</td> </tr> <tr> <th>597</th> <td>May 25 2018</td> <td>04:37</td> <td>11690.0</td> <td>Morning Run</td> <td>00:54:02</td> </tr> <tr> <th>572</th> <td>May 5 2018</td> <td>04:31</td> <td>11674.4</td> <td>Morning Run</td> <td>00:52:48</td> </tr> <tr> <th>531</th> <td>Mar 17 2018</td> <td>04:37</td> <td>11299.0</td> <td>Afternoon Run</td> <td>00:52:19</td> </tr> <tr> <th>602</th> <td>Jun 8 2018</td> <td>04:36</td> <td>11281.2</td> <td>Morning Run</td> <td>00:51:57</td> </tr> <tr> <th>548</th> <td>Jan 27 2018</td> <td>04:37</td> <td>11064.7</td> <td>Afternoon Run</td> <td>00:51:05</td> </tr> <tr> <th>603</th> <td>Jun 9 2018</td> <td>04:23</td> <td>11043.2</td> <td>Morning Run</td> <td>00:48:29</td> </tr> <tr> <th>586</th> <td>Jun 6 2018</td> <td>04:28</td> <td>10884.9</td> <td>Morning Run</td> <td>00:48:38</td> </tr> </tbody> </table> ++++ We can also visualise the distances over time using matplotlib: [source, python] ---- %matplotlib inline recent_runs_df.plot(x="startDate", y="r.distance") ---- ++++ <br /> <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz AAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBo dHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXmAHFW1/z+9zL4kk2Sy71tlYU1C AgqEfVdEFNEniiCiIgriQ98DBRV9uDyeIigCIi4gPwRRQUAQBEJYAmEJWaiQHbIxW2bfevn90V3d VdVV1VU13TM90+fzz3RX3aq6t7vnW6fOPfecQDweRxAEQSgugkPdAUEQBGHwEfEXBEEoQkT8BUEQ ihARf0EQhCJExF8QBKEICQ91B9zS0NDuOyyprq6SlpauXHZnSBgp44CRMxYZR2ExUsYBuRtLfX1N wGp7UVj+4XBoqLuQE0bKOGDkjEXGUViMlHFA/sfiyvJXFGUF8CNVVY/TbfsUcLmqqkcl318CXApE gBtUVX1EUZRxwL1ABbAH+Jyqql1WbXM4JkEQBCELWS1/RVGuBu4EynXbDgcuBgLJ9xOBrwIfBE4F /kdRlDLgO8C9qqoeA7wOXOrQVhAEQRgk3Fj+W4GPAn8AUBRlLPBD4ArgjmSb5cBqVVV7gV5FUbYA hwBHJ9sCPJZ8vdWm7StOnairqxzQY1B9fY3vYwuJkTIOGDljkXEUFiNlHJDfsWQVf1VVH1QUZSaA oigh4DfA14FuXbNaoFX3vh0YZdputU2/3ZGBTHzU19fQ0NDu+/hCYaSMA0bOWGQchcVIGQfkbix2 NxCv0T5LgXnAr0i4gRYpivIz4GlAf4Ua4ADQlnzdbbHN3FYQBEEYJDyJv6qqa4DFAMmngftUVb0i 6cf/gaIo5UAZsBBYD6wGzgDuBk4HVgFrbNoKgiAIg0ROQj1VVd0H3ExC3J8GrlFVtQe4AThfUZTV wFHALQ5tBUEQhEEiMFxSOg9kkddI8QOOlHHAyBmLjKOwGK7jaO/q4/E1uzh1+XRqK0uBnPr8i3eR 11Dz4Q+fCsAf/nA3Gzfae7gefPD/DVaXBEEoIP701Ds89tIu7n1y86BdU8R/ELngggtZtOgg2/2/ +91dg9gbQRAKhQPtvYm/HX2Dds1hk9snG/c/vYVX3n7fcl8oFCAa9e41OmLBeM47Ya5jm0cffZh/ /OPvxGIxLr74UpYtW040GuXHP/4B27dvY8qUqfT1Jb7QH/zgek488RQmT57C//zPdwmFwsRiMa67 7gYef/wftLW18tOf3siXvvQVbrzxBjo62mlsbOCjHz2Pc875GBdccAEzZsxh27atdHV18P3v/4iJ Eydx9913smrVs0SjUT7ykXP5yEfO5YEH7uPJJ/9JIBDgxBNP4eMfP9/z+AVBGLmMGPEfSmpqarjx xptS75977t/09fVx++13s2/fPp555ilD+1deeZmFCxfz5S9/jTfffJ3Ozg4++9mLefDB+/nGN76F qr7NSSedwsqVJ9DY2MBXvvIFzjnnYwAsXLiYr33tKn7961t58sl/smLFkbz88gvcfvvdxGIxbrvt FrZt28pTTz3JL395JwBXXnkZK1YcyfTpMwftMxEEobAZMeJ/3glzba30fE8CTZ8+w/D+3Xd3sXDh YgAmTpzI+PETDPvPOuts7rnnd1x11eVUVVVz6aWXGfaPGTOG+++/l2ef/TeVlVVEIpHUvvnzFQAm TJhAU1MTu3btZOHCxYRCIUKhEJdffiVPPfUk+/fv42tf+xIA7e3tvPvuuyL+giCkEJ9/DggEjB/j zJmz2bBhHQCNjQ00NDQY9j///LMceujh/Pznv+L440/knnt+B4AWeXXffX/koIMO4Tvf+T4nnHAS +oisQMA4cT9jxkw2b1aJxWJEIhGuuOLLTJ8+g5kzZ/OLX/yaW265nTPOOIs5c+blfNyCIOSYQYy+ HDGWfyHwy1/+nOOOO5FjjlnJK6+8zCWXfJaJEycxevRoQ7sFCxZxww3X8bvf/YZYLMbll38dgJkz Z/G9732bs846m//7vx/z1FNPUF1dTSgUSs0bmJk3T2HFiqP40pcuJhaLcc45H2PevPksW3YEX/7y xfT19bNw4WLq6+vzPn5BEIYPEuc/jBgp44CRMxYZR2ExXMfx43tf4+1dB5g/bTTf+o8lgMT5C4Ig CHlAxF8QBGEQ2d3QwQ//sJb9zRaZigfREyPiLwiCMIjc9ejbbNndyp+eeof2rj4efHYrHd39g94P mfAVBEEYAmLxOPc8uZk1m3SLUwOW7vm8IJa/IAjCIJLS9zi0JNM6DAUi/oIgCIOITvszEZ+/IAjC yERbqDnUYfYi/oIgCINJ0vSPx9NPAel94vMXBEEYkQyevDsj4i8IgjCIpHz+Vm4f8fkLgiCMUAbR teOEiL8gCMIgEkxqf2yI06qJ+AuCIAwFVi4emfAVBEEYmaRCPa12is9fEARhZBOHIfX/i/gLgiAM IgHHJb6Dh6vEboqirAB+pKrqcYqiHAb8AogCvcBnVFXdryjKJcClQAS4QVXVRxRFGQfcC1QAe4DP qaraZdU25yMTBEEoQIwrfAPmnYPWj6yWv6IoVwN3AuXJTT8HLldV9TjgL8A3FUWZCHwV+CBwKvA/ iqKUAd8B7lVV9RjgdeBSh7aCIAgjnuGU22cr8FHd+/NVVX0j+ToM9ADLgdWqqvaqqtoKbAEOAY4G Hk+2fQw4yaGtIAjCyEeX3mEoyer2UVX1QUVRZure7wVQFOUDwFeAY0lY8K26w9qBUUCtbrvVNv12 R+rqKgmHQ9ma2VJfX+P72EJipIwDRs5YZByFRaGPo7ysBIBQOEhJiVHTSkrDhv7ncyy+irkoivIJ 4BrgTFVVGxRFaQP0vawBDgDa9m6Lbea2jrS0WJQ8c8lwLepsZqSMA0bOWGQchcVwGEdfXwSA/v5o huulvz+a6n8OC7hbbvcs/oqifJrEZO1xqqo2JzevAX6gKEo5UAYsBNYDq4EzgLuB04FVDm0FQRBG PKkpXausngXm80+hKEoIuJmEtf4XRVGeURTlu6qq7ktuXwU8DVyjqmoPcANwvqIoq4GjgFsc2gqC IIx40ou8htbp78ryV1V1B3Bk8u0YmzZ3AHeYtu0HTnPTVhAEYSTR3RthrdrAikUTKAlb2NkW2r/5 vVaefOVdTj5iWt77J4u8BEEQ8sAfnlC569FNPPrSTsP2QJbEbn966p089yyBiL8gCEIe2L43MVm7 t6nTsD1QIEt8RfwFQRDygFasJWBatVsY0i/iLwiCkB+S6p6RsUGn/nbZHAajuLuIvyAIQh6IaZY/ 3i3/6CBUehHxFwRBAHY3dtLW1Zez88VtLH9jYjdr+iOxnPXDDhF/QRCKnlgszrfvfJkrbn4+h2fV fP7GrQFdbh87/d+6u5UPXfU3Nu1otm6QA0T8BUEoevLhZomlLH9rx77TFf/6/HYAfv9PNce9SiPi LwiCkIfYm7TP34gbt09ZMuFbR3d/zvulIeIvCELR48bw7+ju5/l1e4nGXPrjbSz/gGm/FaXJFcGd PRF31/KBr6yegiAII4mYC/X/9d/Ws2FHC/2RKMcvmZq1vWbZB4Mm8dd8/sRtQz27e/Mn+hpi+QuC UPS4CavfsqcNgP0t3a7OmfL5Z+zR3D72x7bn0d2jIeIvCELR4yrDps9pAbton8bWHnr6opbHtHeJ +AuCIOQdN24fDbc11m3TO+je7thnXawlnxO9GiL+gpBHXt64n627W7M3FIYUL5GebjMv2Ll9zCt+ s/Hgs1s9tXeLiL8g5JFf/30DP/jD2qHuhmDBzn3ttHb0EovHufIX7hd3Hejo5e/Pb6ev39plk8ba 8veo/fzjxZ20dvR6O8gFEu0jCHliMJJzCf7o64/y3btfIRCAX319padj12x6H4BQKMCZR820bRez S+/g6WoJ3nmvlWULxvs40h6x/AUhT4j0Fy7aRGs87v97OtDhnAco7fM3bfdxrUUz63wc5YyIvyDk CbH880c8HueBZ7ay+d0Dvo7Xp3NwO9mbERGU7TC79A4efxajq0upLC/xdpALRPyFAbH53QO88U4j kWjMhQ+0uBDtzx/vNXTy6Es7ufGe13wdH4mmV+nm6yZt5/bxWrjdLjfQQBGfvzAgtH++UdWltHb0 cde3ThjiHhUOYvnnj77IwAwNvfjnK3d+3Cafv9efRTBP4i+Wv5ATWpP+z/++/SXUXS1D3JvCYBDq cRQvA/xs9fny/X5PXi341HEeD8uT9ov4C7llX3MXt/1tw1B3ozAQ8c8bfh6qGg9009OXyJnTr7P8 vSzw8oJ23sybhLfrmXMD5QoRfyH35MlSGW7ExO2TN7xa3b39Ua6+7UWuueNlACIRHz5/f/O9xE1J QMXtIwgjHNH+/OH1s+1NBiO0tCcWSxncPv79Pq4wGwFer5Yvy9/VhK+iKCuAH6mqepyiKHOBu0mM YT1wmaqqMUVRrgPOBCLAFaqqrvHSNsfjEoYQMfwT+PUJC7nH/Js0uH3c3kl8RmyaT+81EGDIfP6K olwN3AmUJzfdBFyrquoxJD6OsxVFWQKsBFYA5wO3+mgrDDPsilrkKzRtuCGWf/7wKqBm415v+buO 9vH5fWZY/sPI7bMV+Kju/VLg2eTrx4CTgKOBJ1RVjauqugsIK4pS77GtMMyIRETdnJBQz8LB7NrJ RbSPWxU3/w7cXq6iLFHK8aSl2QvH+CGr20dV1QcVRZmp2xRQVVXrfzswCqgFmnRttO1e2jY49aOu rpJwOJStu7bU19f4PraQKKRx2CWbCgUDrvpZSGMZCHbjKGnvzdqmkBgOfdTY29qTem3ut9U44jrt qK+vobwiLUGjR1dmPR7I8L+UV5Qa2sZicfY0djClvtrw9FtWXmJoV1rqTscOnVfPlZ9ckpfVveBv kZf+Wb8GOAC0JV+bt3tp60hLS5ePriaor6+hocE6b/ZwotDG0dzWY7k9Fo9n7WehjcUvTuPQ3xwL fazD7fto1umBvt9242g40G1o33IgfXxTU4exrd3nYLLgu7v7DG3/8tw2HnlhB1/48CKOXDQxtb2r y9iu12Vd3u7eCJ3tPXS2W/+fucXuZuYn2ud1RVGOS74+HVgFrAZOVRQlqCjKdCCoqmqjx7bCMEM/ aaZHPP4JxOmTP7xG6GS4ffxM+Gbh5Y37AFi3pcmw3ez2cXu9SeOqc9IvO/xY/lcBdyiKUgpsAh5Q VTWqKMoq4EUSN5TLfLQVhhl6v6mQibj884fXlAx68W9p76WzO6Lb5+4c2a4YDiVs6YjJKPI6p7Bi 0QTmTK7lnBPn097qrl6wH1yJv6qqO4Ajk683k4jWMbe5HrjetM11W2H4YS/+A7P9O7r7aevsY/K4 qgGdZ6iRCd/8MRDL/6pbVzueKx6Pu4pYM3+9afE3nS/j/NbnKw0H6YvEiMXinLRsGuWlYfLpiJNF XoJv8mX5f+PW1Vx758vD/slCVvjmD8/i7/BdmPe5/96M7cKhxA0jEnO2/O2MgqqKxMTuYP3uRfwF 39j9SAcaltyXPK/58XnYIdqfN7y6fZzam28krt1AplOGkpZ/1Gz5Y35vTVV5whHTP8CMpW4R8Rd8 M9wt83wjn07+GOiEr2FfxiIsf3ftcDINQyQaMyyAzHQrWR9/0KyxAEybMDght5LPX/CNnWUuC3wT DHeff1dPP739Mepqyoa6Kxl4nvDNg9vH3Erv89f7/TPSO9jY/uccO4tZk2s5dM5YV9cfKCL+gm/E p+3McP94vvKzVQAFWaDHLrWIHY6Wv0u3T7bvUxP/7XvbeHnjft1x7tKBloRDHJHjIu1OiNtH8I3d P4O5cpH/8w9v9Rzu/S9kcur2MadcdjtZk+HzT//u737s7fT5B5jYLV+I+Au+ybflP9wrYRXI//iI xPOErxe3j88fXknIWk7d5PYpCQ++FIv4C76x/SfJkc+/UCyk9dua+MmfXk9VgXJLofR/JJJLy998 I/FrdIRs8u5npnQ2vq+tLOHWK4/1d9EBIOIv+Cbfln+hSOdN97/Jpp0tvLLpfU/HifbnDydL3gqn KQJz4ILbm7bZPRSysfyzRROVhEOp+YLBRMRf8I29zz+/5x8qvHZnpEyID+UTzOZ3D9DR3Z+x3avl 7+QmiphClt2e+/XNjVz8o6fZ35xIEhcOWf/ys/0Ohio6TsRf8I3tjzpHv2ZxmxQGQ/U17G3q5MZ7 XuP7v3slY59Xn7/TbymS4faxa2vc3tUbIR6HZ9/YY7FXd1QWt9LsybW2fcsnIv6Cb8w/ao2Ravl7 Zbj3X8PrE0x/JMbv/6mya//AMtM0JVOGNxzITGmcU8s/w+3j6dRUJlfm2v0/ZGw2XeCwueO8XTBH iPgLvrGd7x1hE75+GTluH2/tX9ywj2de380Nv187wAvb7xpIVk8zj76009jW44C1nDx2x2WL9ilz Wdwl14j4C77J+4TvMNfO4d7/NN4G0tOXyE0z0NxMTle1E3M7g8Hpt9ra0efq3HZoIZ52h2XG+RsN pNISEX9hmGH3mJuz8w9z9XS9WGiI2dvUyeZdLYZterEcqvUWTl+/leXfH4lx/rWPcv+/t7hq7+e6 1n1J3OTs/h8yLf+4oSh7mYi/MNzItygMD+m0Z7jcu66542Wu+vlzhm1RQ24ajwPRtf/NIxvZvrfN Z8/cp2SARFnRrp4Ij7+8y1V723ObxtvbF+W1zQ2236d2Y7F3+2S+N1j+Q7DACyS3jzAA7H7sbgph uGHYW/7DuP/63DkDGcbq9ftYvX4f/3HyfA6bO46xo8pdHbdm0346LUI8U/2z6JRTrLwXF6W56a0P vcX67c227bUkbnaXyIzzh0RYRGL7UFn+Iv6Cb+zETaJ9Egzn/kcGYvlbcM+Tm3n0pZ3872UfzNp2 x742bvvbBsc2Vpa8k5vNi9vHfG4n4YdEoXVwP+ELcYIF4PMX8Rd8k/f0Drk5zZAx3Cx/ffnCqKHA eW7O39Le66qdeQLWir5+YwH2YCBg+Xvs6uln5752T/NTXgMZ/vb8dhZMH237/2DeHItj+B8pLRG3 jzDMyLvPf5iJp5nh1v1oLJ4uRTgAy38whq1Z25DsXyBgad3f/MA6Nr/X6ilHvp/v7cUN+zOOWzSz jq272zJvPHFj5tvSsEz4CsMMO0snV26f4Z/VM7euk3yjn+TNlc/fDXubOg2lC91crqsnPR+gdVUv /m2dfaxVG9j8XisAu97vcN2fmI/vramth7WbGwzbZk2qJRQMZIZ6EjdM+Nqlhcg3YvkLvsl3KGOh CabX/uij3E1P+gVJQvATVuiALH8PzXc3dvLtO19m4Yw6/vOThydPkP24Lp3lr4m13hi54fev0tia XhnsJSOr/jxu5wo2WMwLRKMJkc+o4WuK9slVgIRXxPIXfGOfKVGc/pB7y39fcxc3P7CO5jZjuoNI NMamHc22i6qaWnu46f432NPY6Xj+SDROLB4nEo0ZzpXPr2F3Q8Ii37Qzvc7AjVFhEP+kQOuFWi/8 AD297ouid/Wkz62fW3CLFsMficYI6OYiItEY6q4WYrF4zgoeDQQRf8E39qGe+T3/UOHZDaVrn4uh /OYfG3ljSyP3PW1cxPTICzv4yX1v8MgLOyyPe/C5razf1swdD290PH80Fue636zhCz95xiCk+fwa rKxeN9fTC3TcwvLPOKeHPjXpbq56d5RbtAncSCxOMBhIjeehVdv40b2vs7ux03NK6nwgbh/BN/nw +Rv9rQM4UR7wXEAkx+Lfn7RCzSmI3951AEikP7ZCu7Z+ktSKaDTG7uTTwYAWeQ2QbJeLxmKpFBKQ /py95vvROH3FdB7TLQxrNoi/d8u/JBykpy+atPzTn99rmxtTbXr7ovznJw+3LQAzGPgSf0VRSoDf ATOBKHAJEAHuJnGTXQ9cpqpqTFGU64Azk/uvUFV1jaIoc63aDmgkwqCTD03wW0JPY9ueNiaNraSi LPd2jde+FcqErzah2J8l145ePCNRYyilF7zMBZk/lzWb9tPW6RzquVY1Tqxa+fzdctjccZz1gZkG 8ddb/n0O4n/+ifO476l3MrbPnzqatZsbmFBXwYZAINW/vn7jU8TCGXWe+5tL/Lp9zgDCqqp+APge 8APgJuBaVVWPIWH8na0oyhJgJbACOB+4NXl8Rlv/QxCGCvt8/v7PqRcDr6LzXkMHN/z+VX50z2v+ O+CA9xzyutc57osXtJWv5jmBvv6owa0RsZnoHKz71tY9rdz2tw3c+69MQdXz1tYmw/vO7n5i8bgv V8pXP3ZIhqGgv/k4Wf7LF4633P65MxZw4ekLOOWIaQQD6c/PLP5DjV/zaDMQVhQlCNQC/cCRwLPJ /Y8BpwAq8ISqqnFgl6IoYUVR6oGlFm0f8tkXYYjIh09eP4ns9fQNLd2At7A+LwzEAh5ay18Tf2Mf vvHLFwxuB/3CLr3oxeJx3mvoYOKYyryWG2xpc7cITHuCWTijjk07W7jmjpc5ePZYTlo2NSf90N8E ncTf7rOoLC/h2EMnA4k5De277x0h4t9BwuXzNjAOOAs4NinyAO3AKBI3Bv1tWtsesGjrSF1dJeEB LIaor6/xfWwhUUjjKC8rsdxeUhJy1U+rNvr47dGjKzyNt3Z/WvTz8TlVVJRantfuWjX70v0ZO7aa ynLrz8st2u+/rCxsuGZJMj1ASUnYsi+1NYl8OtFYPLW/oaU7ozxiTW1F6nWprq/v7Gnnroc3cOqR M/jKxw/L2s/qqjLbfeb+1e5OJ32rrrbP+6M/LhBMiG6N7jpvbWviI8fPzdq3bP0BCAYDqe17WjIL yWhMGG/9vevPGQ4H6Y/EqK+vybj5+v0fyRV+xf9K4J+qqv6XoijTgKeBUt3+GuAA0JZ8bd4es9jm SEtLl8+uJj7AhoaBVRUqBAptHJ1d1r7ZSH8saz/txtKpE//mli4aKt0LZltrd+p1Pj6n9vaejPM6 fSetrenfbENDR6rik180F01vb8Rwzf5kDHt/f8SyL/19/anjtf1mvzlAU1M6FLSxOf361Y37APj3 2nf5xHFzsvazo9Pegjf3r60t/Z0daLX/H9cf16H97uJGq9yPRmjnPfOoGfzjxURRlx7d5/t+k/1T 5IEW69BZfV/jsUTorNX34vd/xCt2NxC/z3AtQGvydTNQAryuKMpxyW2nA6uA1cCpiqIEFUWZDgRV VW20aSsMM/Lh84/FrF0lLe29bHmv1eqQnFzXDZ7dPgaff17jJR13a+4JfX+s1gToV/X26qJpPHus fA7V7eeruWLMCdG8TvgeNHtM6vW5K+dw65XHUlkWNk58O7h9QsHs8plw+3jq1qDh1xT5P+AuRVFW kbD4/xt4FbhDUZRSYBPwgKqq0WSbF0ncaC5LHn+Vue0AxiAMEfmo4WsXHnnVrasBuOWKY+0t6Bz9 k/VHYjS19TBxTKVhu+cJX/3rfApAlpOXWPimoxYr9PS+br1/WrsJ52NhUtRmktmJ/kiMcCiY4XP3 8v3cdtXKjOMrysKEQgFDmGufQ5x/0EWYZiAw8Ai2fOFL/FVV7QDOs9i10qLt9cD1pm2brdoKw4t8 1PC1s/w1evujBvH/66ptPPvmHn78xQ/4v6iJX/xlHeu3NfO9i5YzdXx1um+eLf/cTvj6/lgtDoxG M/ujt3KtxN9tB7yMVN+PbCLZH4ny3btfZU9jJ5VlYapMRoDd8RVl4Yw1DnZplEPBgOHG6BTq6YbE Iq/CFH9Z4Sv4xulHvbep05fFYxTM7O3/vnoHrR19NOr8/QNl/bZEnpad+9sN5/W+yCvdvqcvamlt NxzozhrXnhWbu20kGmOt+r7BhaNhZSXrBV//Op+Gq5dykdv2tKVSVJSEg1SZJtDvfyazfCNAbVWp 5XYrQsGg4bPpz5Le4bTl0x33B0i4fQrxBiArfAXf2FnC2/e2c80dL3PKEdM4/8R5ns4ZzWL52xEM BHLu8//NPzYZ3tvnMrJG3/1v3vYi40dXcOMXjzK0+eZtLwJw17dOMGx/cf0+KsrDHDZ3nLeL6njk hR38ffUOy33ZxL/P0u3jDi/fm6FuQBb11/e5JBzMcP/Z1QGoqShhv8v+hEIBevt0Ia82C+MuPnMh AOedMJfH12SWjdQIBkjmSyo88RfLX/DMnsZOrv7VC6g26QQ0Vr+11/O5DekdPBwXGIRl8p6fZEzN 3z9gfDrRPwlcdOPTvKtbn3DHIxu5+YF1TqfT7bDeY5fuAYyiq6FPYmZIn5Act1t3npfPST/PkO24 mEn8zZa/HRPGVLBg+mjOOWYW4PwkkHD7pK9zwKYAzQcPnpR67VSMJZDM7eM0dzBUiOUveOahVdsy siZa4WcRmNHn7/64wUiR4nU82dp3mzJN/vu19/jMaQuynlcvwm2dfamc9Wac/NVWlr8+7bGhUlb6 yln7Bt7cRAaff5bPS7+/JBSkusKdfFWVl3DxmYsAWLF4IjUV9jeNUDBIR3c/b21r4uDZY9m2t81w Q6gfXc4lZy02HDO6uoz3W6zdjsFkbh8/2UHzjVj+gmecwt/0eHWTgDnaJ1MMbF0Kg/BUPZD0Dlb0 mBOtaSUUs3xw+vP+8QnVtp1TOoGIpdvHZsJ3ADmNnIjF4zz47FbDeycMbp8S95Z/eWl6cnf86ArH vE/ajfX/7n+T/kiMXfvbmTq+OpUfaakynrlTjWtSv37eocyfar1ONZDM7VNoqR1AxF/wgV3eeDN+ Jrn0QmOlOXYCkatUE+812C/qGUi0jxVdJvHXhMeLlehUF9fpPFZuH/3EsHHC15vP3+3ntG5Lk0HQ HVMyx+OGp4SSUJAqBwtej5ckf/o+rFXfJxKNM3tyLU6jH19XyZfOOdhyXzCguX2Mn/cvrjjGdZ/y hYi/4Jl+l5NXXsVyd0MHr72jX3lqZflbH5sL7W/r6uM7v1lju99zVs8s+83hh5q82OWTsZIfpy71 OviZPUX7JLvj3ufvrp15/K9arDrWiMeNRkdJOMToandRPHrLPxv63+ztyfoHsyfVMrY2kUqi0uZG YpeaOZCc8DVb/m6fWvKJ+PwFz7jNce7V7fNtk/B6tfwHugipo6vfcX+uLf9uUwimVtjEbnLQ6mxO 17Cy/OPxOAGbYud6gcookO5TGJXTAAAgAElEQVSBbJ9TPB5n9Vv7ONBhfGrZuc8+lUEsHjck7CsJ B12XP/Ri+es/l/lTR1FdWcrh88Yxf9ponnjlXU5dPs3yOLs6vNoK30JL6gYi/oIP8un2yXa83Slj 8YGnUMimJd7z+Tvvz7D8fbh9nK5h5WeOxuKETatYNfQRPs26DJteg5yyzQm9vbOFux7d5NjGzPst 3Tyuy7lfEk44LT510rysKaA9Wf7JwR61eAKXfCg9sVtZXsJ/nDzf9ji7VA/aA0Ehir+4fQTPuBb/ gV7IyvK3USKvk5JWZLMkrQTTCaubV+OBdDZNs/hrtV+37k5H71idQ99NpxuslXWvjcFqUllfR1dP Ks7fhaW9r7mLf619z3b/tj1ttHc7P2FZsWNfm+G9Jv4nLbO2xPX0R9x/b9pYgx6XqYccLH/AcqHd UCPiL3jGT2k7P1jpuZ3YuXE1/H319gwR0ZMtmmft5gZPq3GtTnf1bS/y1Z8n8hiawwMDgcQN4beP ve26T56t8qToWy06srNO3bi74vE4W95r5dW333dsd8PvX3WVEM3MnY8YnxQ08XdC88NPHleZpWUa 7fN2k7dHj93NQjtNTwGKv7h9BM9kKweYK6yE3k7s4nEcHzW2723nr6u289dV2zNW06bO7UJJ32/p 9pQuwIm3thkrUj21djf/XPOuYZuWxEzPQLKFOln+dri5wWza2cJP73vD1fns/ONesEpWZ+bSDy9m 5qQaxo2qyNpWQxurV/G3Q1t8+Pt/2ofkDhVi+QuecRvnP1C8THDG4nFHkcpWvBzcCaKddfzU2vd4 2+Q2cbKY4/E4+5uNlr91muVsTzSOu23P52XNghYW6uQJ0XLuuCEX1cDcWP7lpSFPwg9pAyBX4q9/ IigrDVFVHmbCGPdPIvlELH/Bls6efsuQtKG1/O3F36v/O6ONg0//kDljWbe1yfLxvbc/yj1PbgaM OXqchLk/EnPlTsnmYvM6qa7dYNzMX5x99Cz+9vz21PdtlsO+/ij90RhV5SW2WTKtGEjWVw0vbh8v pMTfRye///kVlJlSPejP8qNLj6K6oiTvdSfcIpa/YMlLG/Zx+c9W8dybezL2RTxMoA0EK11zivN3 ElM3Vr3TDeKQOWMB6O3PfIKwexpwEma3PmCrxVh6XfLq8/di+WsCa37Sa2nvZXdjJ/99x0t8/ZbV xONxSl2IsYafBXnXXXgEJy1N1+i1Ev8LT1/AD7/8wdR7P9a7VgTez41jyriqjCcNrQ9ja8uorSol GAz4urHkA7H8BUu0pGyr3tyTKkat4cXabGrtYewo+9qsTmSz/PX7Y7G4o6Xtxp9vJbQa2hNQr0UY pt3Sfaf+9LgM/bNKw2C8hleff8zw1wlNo1KTw8kNWmGdVB+jmfMSTvT0Wo99/OiKjOR3nz9rIYfO HUdVeQkzJtakIolKdfW8j1o8kRc37GPRjDoWzklnQfXzhBofgOVvhRbt43ZNwmAilr9giePEl4ff 8X/+6gXffbD0+ev+n83pnwfi9olEY45typJuDX3InuZCsbohgPNkbEZeH7t+5dzt497y1xbNRWzc Php9EefPTuPweQlh3qFbzHX+CXO59jPL+OLZizPSXUNC5K1cj3rL//NnLeSWK45h3Gij1e0nmZrf aB87NM0vQO0X8ResiTpZQIPj9clq+RszQjpb2k6W/73/2swXfvIMzQ55csqSC4U0F8/Dq7fzhZ88 w56GDn+Wfxa3z6xJtUA6NNMOezeY9Q4vbh/tq8/Wtq8/5mrtx0GzEjVz1+uinKorS5g9uZblCydY HmPnftFHDAUCASp1N4hELh4YW+v9iVP7ffmIRrUkWMCWv7h9BEvS/wQD/9FqKQW8H2d9Lg29MMbj 8Sw+f/t9/3o14UrYsts6NfKY2rIMy/+hVdsBWPv2+4yySS3sZJVnW/GprUrVx+NrpzOEenpc96DN fbhz+5i+M5uvsD8ac7WCddGsMZSWBA1pGrLluLGr0+C0VuCqTxzG7sZOZkysydonM9rHlmu/fCGK v1j+giWOIW8ef8deUyGn+pAlzt+cC96v+GvYCen3LlqeYflrBALWQr5rfzsPPrvN9lrZQk9T4m/h 9jFkwrQZll00jye3j4X2W1n4O/e188cnNjueKxwKMH50BYtnjjFszyb+diLsNCFbURZm7hTrFMvZ OOWIxIrhg2aN9XW8Ge1TLjzpF8tfsEETf8t/Mo9aHovFwX0koON1DG4fU+GXgU742h1fWV6SSr9s dtcEME74rlUbqB9dzk/+9LrjtTqypDjQkpFFYjE27mhOJjJL7LOb9AZo7ezjb89v5+RlU7FCs/yz TSRDpvDG45lpqAHWbMxeJPG0FTMIBAIZUTpOVbASfbDeni9L+hMnzOX0I2cwKkcL+bQfVQEa/iL+ gjVW8c7RWMxX6mQrKzMej7NuaxPzpo6yzbqYbZFXxFT/daBx/k7Hl5cm+mjl39ffEG596K2s14F0 BtHScNCy4lba8o9z84NvAjBtfDWQcNls3dPKrIm1Gd/HfU+9w8sb99suukqt8HUR528WrFg8TleP +1BXPSVJH73ZmLBLkZzqg43658onn3G9QCB3wk/+3Ei5QMRfsMTK5/+NX75AW0dfwtz1cBOwEt4X 1u3lZ39OiNp3LlzGzIm1tn0wbNPp5FO6BGLZLH934m+/T/P5Z4RoBgK+MjZ2JkW0oixMXyQzX5B2 Q7QKV3x71wF+8Pu1nH/ivIwbVntX4lx2tWc1t0+2CdpgIJBhXUej/sU/nLT49b76mRNrMiJ0rPph RSH60K2IFbDlLz5/wZJ0tE96W2tHX0Lz/bh9TOzYm06wduM9r1kfmGXC94lX0nlwsvn83bh9nI4P hxKLc6yEzuppINv/+r9fT9y47NINVyerVOnnBsyrfTfuaLb3+dtECWnb7WoGaJZ5MJgpWNF43LJy mCvxT4q+3pg4xSY3vlV/zBSiJe1EId6sRPwFS3KZ4MrS7aNTdrt47Gyhngumjza0dbb809d4451G bn5gXYb165RKIRAIUFYaykjNazfhmw3NAi/LIv76gietnUbhXbe1yXbuwCprJ6S/C/1nrl+gpT3h BAOZK1FjsTh7mzLdSW7i6VOWvy5E0012T3MfJo1N5MWpH+1v4eBgo/0mC1D7/bt9FEX5L+DDQCnw S+BZ4G4S9tp64DJVVWOKolwHnAlEgCtUVV2jKMpcq7YDGIeQY2JJsfSzzN2MpRXq4unByqp94Jmt HD6vPmN/LG68Mdz8wDqWLxrPkYsmJvqgE8ObH1wHJIqKHDQ7HdWhuVjCoSArFo5n9fp9hmuXlQQz xZ+Bpbgut8mJU1OZEP/WjrRLqNtmZawVdm4dbbve8i8rCaa2l5WG6OqNEAhm1kWLRGPssRB/V5a/ 5vPXqaAb631MsnyixjUXLGVvUxeTxlZlPbYQSNc/Ljz192X5K4pyHPAB4IPASmAacBNwraqqx5D4 nzhbUZQlyf0rgPOBW5OnyGg7gDEIeUDTa6t/UK9zvtaWf3Y0y1//BLC3qStlDesFzmz5v7Glkdv/ vpH9zV2Ate/cbB33Jy3Yy889mJWHTcloX1YathS6gYi/XUI0LQSy1WP9AO3b6rTwzUPiu4jH46mx mvuguaGsfP7xuHWpRasIIDNaCmaj5W8viBefuZDrP3cEY0wLtSrLS5jjM4xzKBiJlv+pwFvAQ0At 8J/AJSSsf4DHgFMAFXhCVdU4sEtRlLCiKPXAUou2DzldsK6uknDYT7xggvp67ws+CpFBG0fyx1pZ WTrga44aVZn1HFb7q6rLqK+vyfDXjxlTxdhRFYYbSFV1Of0Wd5SKqsQ5SpLROqFgun5tdU2Z8brJ /9CxdVXU6oqDa22qKkpo6+zNOCZcYvFv5HJS3O43PTk5Ad7pMg0EQCgUpDRLycKKilJG11URB8aP qSQej3PF+YdzTTINR3VlKTR1EQ4FqLVYIbu3qYvxYyo5dcUMqsrD3PbQW4anoa9/agmBQID/vWet 4bgxY6qor6+hpjp9zro6+9/F5Im1LE0+tXmlkP7XS5I31tLSkK9+5XMsfsV/HDADOAuYBfwdCCZF HqAdGEXixqCvWKFtD1i0daSlpctnVxMfYEODfXHo4cJgjkNbXNTXF3F9zcnjqmjt6M2wOhubOig3 PWOa/flW12hv76WhoT3DhdHc3EmsL0K37jptrd20W1jJba3dNJSFaE8+LQR14t/U3GW4bmfSf97e 3k11aaLDZSWhVJtwIOF6+cFvXjL2s6Mn47puH4+6uq0t++6kf7/RVO3Lib6+iG1cvEbLgW727Eus ZJ4ytpLLzz3EsH/mhBreefcAyvQ6OqzGBYypLuX4QydlFKMBmFBbRr1FBE9XR+K77OlJz1G0t3fb /rY62nt8/dYL7X+9tzcx3kgk5rlfuRqL3Q3Er/g3AW+rqtoHqIqi9JBw/WjUAAeAtuRr8/aYxTah gPCT4Grp/HpeWL8vQ/ytYsrdrBewcvvoj9W7W+yifbRxaDeQUDCAJj/dfcZ+9if94KFgkNqqUr71 H0sMQqZZ1S/pFjXFojH6rcaXdXTJa9pMzGqhnt7cPtmvGonGUhO0Vi6nU5dPY/600SyeVcfr7zSm todDgZSbTOuTVYy+XXbPcDjxOwrrfk8hB19IrhKrDTWpFb4FOBy/0T7PA6cpihJQFGUyUAU8lZwL ADgdWAWsBk5VFCWoKMp0Ek8HjcDrFm2FAsJPIetAwPgjnzMl4bqwEiU32Sj/39NbEjl7TC517VjD Ii+brJ6ar19rqx+POcWCtthK80vPnzaaupr0hKPV5Gw0Fh9QZTO7idmyVG6f3JZbjERjqcleq5z4 VRUlLFXqKS8NG77L6RPSNpwyLRFlNWtyLRPqjFa+9tkdfcgkw2et+fz1ou4k8MMtlNOOQl7k5Uv8 VVV9BHgdWAM8DFwGXAV8V1GUF0lEAD2gqupaEsL+IvBgsh1WbQcyCCH3OGb1tCEQCBgEQ/uHd7Oa 1O5m0NMXzbh5aHMAess/Ucwl83hNmK1yFZmjZ7QYdruJSKuwzGgs7jlvvD5E1W6yOJgMLfVC3IX6 9+ss/zKL+QZ9URb9d6+feD3vhLmp/R9dOcdwvBbPf9EZC7nj6uPS2y0mfJ3Ev/Ck0h/xVLRP4eE7 1FNV1astNq+0aHc9cL1p22artkLhEDO5XOzEWT+BGsAY0hZK/sP3RqJ090YMaRzMp3N6EDBfOxqP 8/fV2w1RJnaWf6psoYUwdvdGLI/RYuzNlFlY/pFozHO0T4lOdEdXl7Kv2Xo+6+BZY3hVbXB9Xldu n0g8bfnr8up8+vQF7NrTaojw0b+elKw7O6qqNJXqAuCwueM4bcV0Hn95F2AUd/3xKfHXxfY7in8h qqUP0tE+hTcgSe8gWKJZylZphPWEw0GiyWgPs9tHs/z/9743APj1N1amhM98OjvhSqRqNm57c0sT f02mVE61s6nkpfmpY6l/wvS+7t5Ixk3h+MOnZIQXalhZ4rFY3JNrBsyFSBbx9Gu7efSlnaltWtGT ZQvGZxV/ffWr9xo6ea/BuZC63vLXW/mfOEnJmFzUy9UZR82gtbOX01bMyBjLecfPZW9jJ29ubUp9 52ZCFrl9nEI9C1Es/ZCy/AtwOLLCV7BE87NromyXG8fwz25Sf33BDUiItkbmJK71+WNxUHcZ4wF6 +zLDH2Nx6xQOmjBr+/Rt+iKZRUiOWmwfXmht+cezWv5TxhkXJGk+c0i4Uz52nNF1okXguEkw9p0L j8jaRk8kEktNbGcruq4X4LKSEBeevpCJyScAM1/92CHccfVxtta8JvR6wXdyKRaij9wP2i+jEG9m Iv6CJWa3j11uHL3ABwPGXEDmyA99pkmz1tsVrIrF45mZMi3+kVa9uYeHX9iRsb3fJP56oY5EYhkL vbSVtVZYTfje96Rqm0FT48rzDk29njOllqMOche/XutC/CvKsgi46f2W3a20dSbinSqyzCl40atA IOCYrsFS/IvC7SOWvzBMyWb5OxXuNu9zmhi1dftYXFdf/1YTE311KD13PLyRx1/elTq/Pn1yJBaj uc0Yy+40HrsFVNkyho6pLU/lrZ83ZTRlFjnslyr1GdvcWP7ZLMp0AfHE+33NXdz16CYgEa3jxEBW LpsJphLGuXP7FOQMqQ9SPv+h7YYlIv4+aW7r4dW33x/qbuQdTdfsxFkvluZkYGa3T1Nr4jPr7Yvy zGvvGvbZnd9KV/UTvdlcFwD3/3tLKtWxnvXbmrn+t68YtoUtwh817PLwmLFyD2m5aEZXl1reYC46 Y2HGNrs6BxpfPHux4/4p9VUcPDtROUs/SQuJGP3p451Xj3b2OBec8YL2VOA22mekuH3Sln/hjUcm fH1y3V1r6OyJcP3njjDEQI80NMvbzro1/KYDGEwcs8i9tHE/L23cz7hR5YaEZWDvVrKaC9DnlHez XgBgT5O7FeIlIft/UitRt+KQOWN5JWkYaGGdXz33EFa/tZfjl0xNukgCqULjkHmjhIRgnLxsGlXl Yf76vHGC+/glU1JFz7/woUWs3dzA2uTk8OjqUv73sg8CcPvDG4GEe0i/rmHFoglZF1J1Zqk25oaP HjubtWpD6ilG7xpyWuRVWT4ypCkV51+Ai9ZGxic8BGirWNs8rMAcjqQsfxtx3qsT1YA5d6HN772x NTNtgJ3nxCqLZJfOIh1bW87uLD53ICMbpx1Obh+3cffzp42mvDTEzIk1HHd4IkFcXU0ZZ31gZqrN bd9YabBuQzbX/eRJ8wDYtLMF9d0DnLtyNpCuNQtw5OKJHLl4Irc/vIGXNuwnFEwnZUtl69TduBbO qOMjx8zKOg5tzkG/LsErZ31gpmHc2Xz+N156JDv2tTOhznpiebjhp/LdYCHiX0T09UdduUn0xFM+ f2v/b11NWWpxVDBozATppXC73c3lpv/3ZsY2ze1z5lEzmDyuijuS1m0ucHL7uLX8Q8EAn7Nw4xjb GK+Tzc3x1Y8dwvNv7eW4wyYb1gkYiGeee/bkWtaqDRw8e2zqRn3e8XOpqcw+n/DBgycRCARYMj9z PsIv2cR/fF0l40eI8EO6bkUhurFE/EcI+5u7KCsNMbq6zHL/8+v2ctejm/jaxw7h0LnjXJ/3tc0N RGOxDHE+dfk0ptYnasr+5h+JCcSKspDB2HdTPUvDrfsGoCu5MvcDB02k2aZcYTbsauc6/ZO6tfxz UQPBTEVZmJOXOVe+0oqy6/3qJy+bxpRx1SycUZeqfFbh0qUSDgU59tDJPntsjdton5FCIad0lgnf EcJ/3f4SX79lte3+x9ckVmA+/9ZeT+fti8T45m0v0muq1hQOBfngwZMMZQirykuMlr+LtA4ablan anQn3T7lpWHfFpXXJyBwb/n7FbULTlW47JyDfB0LicLu5uuHQ0EOmTPWsLAsW4hnPtGLv92CsJGE F6NmsBHLv0gYSI6R5rZe/m6acNREV+8jryoPG4THzlVkhYeHhJTlX1YSyprC2I7SkiC4z5YMOM8H VJSFUxOqXp549Bx/eGYBGS9obrZsTx7Zoojyif73MZT9GCy0X0Ihun1G/q03C9v2tPFE0ioerrhJ LzDQHCO73jcu/dcERu9mqiovMbgcvPj8zfH8JyyxF0JtvKUlQd/j8dI3DS3nz6KZdfzsq0cbz6f7 DqJDZO25FX+nm1i+sZvYHqmcuHQqkHBRFhoj/9Zrw4sb9vH6O42pWP0l8+sZZ1GEIhvN7b30R2KW 6XEHCzeLcbzkFbd6VB1bW07DgXSUTiApMHW6GquV5WFDvna7VABWmN0+2SylAAmR8+NiCYChjKFb SsJBfnXVSkrCQXpMGUH1K4X9Wv4DZXxdBRu2w5Rx1Zb7x9aWpybnh4oei9QcI5njDpvCioUTCvIp p/B6lGd6+6Lc8pd1bNjRYthuNfnnhrsfe5tn39jDtz+7LBfd84WbvmshqW4sZSv/uznCRMsPU6PL gJmw/NM3wWMOmcyzb+7JiOm3wpwiQS/qAUCZPpq3dTl+SsLBjBTSbgkGA66Kjluh+f311732M8u4 4fevpt77earIBeceO4dxo8pZaTNJe+MXj7RNozFY1CajjOZkWV08kihE4YcidPu8uHFfhvCDu8pL sXicDouFL9v3tuWgZ95Zqzbw+R/9m537jNdv7+rj8Zd3pQTuiVfeTfmj3WilleVqFkvNgtTfTEpL ggaXQzgUYPmCCa7Goq8alThv+vXtVx/H0YdMMuzXnrT8+FL1aaj9Ul4a4thDJ/P1Ty0xLNaCobP8 K8vDnL5iBpXl1vmJQsHgkD6hQqIozLWfWcZV5x82pP0QilD8u3tsHjuz+Gnj8Tjf/e0rXHXralfL 3l9Yv5erf/WCYUFSNh56bhtrVfcpI+5+bBOxeDwVwqfxm39s4v5/b+GxZJrgVW/uSe3TtLKlvZfW DmsXgJUwmhdJ6d0HnzhhLqetmJ5auZq+lnthNt9UDQuggsEMizU8EPF3WMXrlkAgwIWnL+D4pYnw y6s+kRYzL5FLxcjsybUZ6SaEwaf4xN/G55jt/7WhtYd33++gPxJz5ca485FNNLb28ObWzCLXVnR0 9/PwCzu49aH1rtrrMbt93k0mOWtuSwq0xbLbq25dzZU2oaFuLP/JujTFpy6fznnHJ6o76ScTzfn9 nTDPW5h9+eZ5CC1M0JfbJw+RF4tnjWH6hISvvc5mrYUgFBLFJ/491r5evbUbi8W591+b2fJeq+64 9E3DaoL17Z0tHLCxpLPx1Nr3+OrP/ZcxNk9emksW6pMuuJkftbT8TeL/cVMOeg27Sk5mRlUbV5hG TRFL5mOrTamWB+r2yQdXnncYnz1NSeXcEYRCpvjE38byX61b/LRpZwv/evU9fvjHtenjdEmxtDJ4 en78p9e55o6XffXpnic3G957XRhi7o855C8j+VoWLC1/k9vHLsWAsViH0zWM7/uj5mgf4/5D545j 2vh0FIsm/uPrKlg8s47DPKxazle44aiqUlYeNqUoVq4Kw5/iE/9ea/H/19r3UrndrSz7Hp342UXX 2J3bK10ez2Pub4blr9OigIP6r9vayJtbGrNa/k6Wsz6vjJPlb/aLmy1/s0UfDAQMycw08S8tCXHV +Ydz2orpqX2a+8WOYCCReVMQipmiE/8eh+yOmsBZLZrSPzH0eQgTdGMDmsV01ZveUjDoxT8Wi6cW GbV29PLHJ1RDCmQnL8nP/ryOnz+wztLy198QnAu46N0+9tcyP92Yi7EELG4wQYfUAHp307c/u4yf XW5chGU4dyDAVz56cEZmS7vC7YIwEim6KXezhWmFVTinvnpULiscQcKKjepuSqvX701Zsr19UUNC sV3726kqL2HsqHSRcX1/vnzTs6knE6vi34FAdrdSthWqVrnnNVxb/lnCIa0eLvRPA2a3k/6JJhQM OpZADAYDhENB6kelF/Vd85ml1PtY5CcIw5Wis/ydNEezbq3Ev1vv9vGxOtQJvSUdCgZobuslHo/z 8OrtfOmmZ9mhi+O//rev8J+/esFwvN4NlW3BVyBgjHH/mylnD2QXZiefeSjk1udvf42JYyotJ3IN lr8pXl1778Z6125K+vPNmTwqtQBJEIqBIhR/e9HR3D168de2ZZvwHQh6ITt49li6eyN09kR4aFVC mN/ckggXNT9xaENxk9tHI4Ax26aV+GdbAOVU7cptnH8sDhecMp+FM+oM20dVlfKN8w+zPNZo+Rt/ utPGV3P5Rw/m+xcvd+x74jyZfRWEYqPoxN9J2CKRxD59+TrttT6XixfL303cjt5/Pb4u4XrYq6tg pYlUbw7yogQCASJZ1vgPxPI3x/nbsWjWGI5fMpXPn7XIsP3kI6Yxprbc2u2ju6xVOuDD59czykWM fbqouYi/ULwMyOevKMp4YC1wMhAB7iahd+uBy1RVjSmKch1wZnL/FaqqrlEUZa5V24H0xS1OVnJ/ JEp/JGqo96pNAusnfPs9WP5uctprk5v6gtyb303nsdFcKebJal/aFcjep2wrVE89wr6oSDbLv6Is xCdPnM8JK2bQ192XERapWfeWE74Olr8V3/zU4bz+TiMbdjSzuyF9Mw2I5S8I/i1/RVFKgF+Tzop+ E3CtqqrHkPAunK0oyhJgJbACOB+41a6t3354JeLgE++Pxvn5A+sMuXo0H7qbUE8rNu5sztqmrz/K uFHlLF84gQVJN8jmd9MLzLRJ1FxkRIxGY2zckdmnJl1dXaebw/cvXs7xS6ba7jcs8rLY/7nTF3L0 IZNSFrpZf7X32Xz+pSXZf7rK9DrOP3FeRnir9l7i8YViZiCW/0+B24D/Sr5fCjybfP0YcAqgAk+o qhoHdimKElYUpd6m7UNOF6urqyRsV7vUBfX1NQA4Gb2VVWVsNCV9q6oup76+xhABE3Ko6FRfX2OI DHppw37OPXE+C2aMsT2mPxKjdlTiOvUkXCdvbUunhRhVm9i35b3008DzG/anish74bk39/KcKZR0 zJgqLrrx6dT76ppy82Ep5s4a5zipOqo2HTEzfnwtFRWJSdSKshD3//AsQ9v6+hoqTJPrNcmx1taW G9oB1DWnq69MGFed2p6NEtONorQkRH19DWN053N7LisGcmwhIeMoPPI5Fl/iryjKhUCDqqr/VBRF E/9AUuQB2oFRQC2gT26jbbdq60hLS1e2JrbU19fQ0JAoRtLnYD03NXdmbHu/oZ26ijBtutQNbW09 Ge003t7SkBGNo25rZGxlCZ09/Wzd3cohc4yrUXv6IoSCgVQfS8JBg3uqrb2HhoZ2wyrbux7eYNsH r+ze22p439BojLnXpyzubOumu8N+/D3d6bxHDQ3tdCffx+Kkxgfp78S8MK6rs4+GhnY6O3sN5wFo b0uLdTAeN5zPiajpSS0ajdHQ0G44n9tzmdH/toYzMo7CI1djsbuB+HX7XAScrCjKM8BhwO+B8br9 NcABoC352rw9ZrFtULWnfeUAAA5NSURBVDCnEdBjNR/QF4nRcKCb7XvTX4K5nq0es/BD2s3wsz+/ yc/+vI4NO5r5xYPreGrte0RjMSLROKU6H7Y5Dj+Scj3lpxCGOYrI7NbSpyzO5iox+9GXLUj8LM7+ 4Cyr5hnttfNnc/vUVLpfkGWee9DeittHKGZ8Wf6qqh6rvU7eAL4I/ERRlONUVX0GOB34N7AF+LGi KD8FpgJBVVUbFUV53aLtoOC0QKvfSvz7o1x31xrDNs9pHJIas3V3Yi7hra1NvP5OI6+/08iTrybS MeujZMzzrf0W8w655OnX3jO8twplHVVVSntX9vTU+kVeAHOnjOK2q1baFkw3C7DTJLa+rZeYfPM5 tZuBua+CUEzkcoXvVcAdiqKUApuAB1RVjSqKsgp4kcRTxmV2bXPYjwxa2nq47P+e45MnznOM9rGa DO6LxDJE100+fz1mPdutq1r1fkvC9aAXNrPl/9fnt1NVUUL92Crywd9X7zC8typx+JMvf8DVuaxy 5dsJP2SKv1OWTv0+b5a/+TzW1xaEYmLA4q+q6nG6tyst9l8PXG/attmqbb5Y9cZuunsj3PXoJsd2 /dEY4VDC337OsbN56LltGXl8SkuCliuAnTBb8jssKn/phc0qzP6vq7ZxwRmLMnfkAasnoHwV/bZK 4AbWKSgMlr9D+oZMzE8XFtlOBaHIKIrnXrs0zmZ6eqNEojEWzaxjUrL4uNn/XVEa9hxlY3ajWB0f crD8IVEgPBeLvNwwkNxFjQe6szdyQPPEZFsd4aUSlFnknXITCUKxMOLFv7Onnz8+9rartg+/sANI WOpaHLlZCCvKwoYVwG5wsy5Av6hJW2Slz1/f2x/lt49s9HRdSPjcvaL196PHzubmrx3j6diDZidS JWuVvbzi5PaZObGGc1fO5n8uPdLTOTt0cxXzpo7i9CNnAGL5C8XNiBf/NZvsa+LaCc2+5i5Kk2sK +vqjVJUnrMzrP3cEFWUhz8W/7Szp6z93ROq10fJP/J0x0X+Mb3VFCdPHV3vyjWus2bg/cY7KEs9p jmdNquXWK4815Nf3gpMfPhAIcOZRM5lQV+npnHOSN8AvfGgR//XppRw8W3L5C8KIT+nsZN2FQwH6 IplC/umT56cWBvX1x+jujTJ3yiimT6jxVXjaLv//9AlpcbfSvDIfi9pCwQBf/8RhKNNGEwjA3S6f evRoE9LTx/u7+VSU+f9ZpW7IOayB/okT5nLsoZNQphuTyEmddaGYGfGWf7eDf94qQdkXz17M4fPr U8Lb0d1PLB5PCZofYeuPxPjLc9sc2+gtXs3a9mO1H7FgPAtn1BEMBggEAtT4TFO8dH69Ib5/sMiD 9lNbVZoh/IJQ7Ix48W/t7LPdV1GWaVmPTuacKU8WUGlKrubV2taaBFlbxJStD48k5xPs0LugvnH+ YRy1eAInOyRQM6P1z/ykY+6vHeZcOdlKIeYLPwXZ/SI+f6GYGfFunwO6tAxmZk8eRXPb+wQDgdQk q2Ztj64pIxgI8E4yn462qOjU5dN5a1szsybXcumHFxEMBPhLXQX/eHGn7XXe3NKYej15XBXHHz6F eVONE7F6n//0CTVc8qFEhs+jD57E829lL+tYWVZCd280Qzz1riXn48P09advlLMmDb7VD7qJ70Hw yUwaW0VZaYiTl7m/yQrCSGHEi/+ksVVMHlfFnsbMvD2nLJvGlHFVLFPq2dfcxZtbm5iQDPEMh4KM qS2jMZntcvK4xAKrCWMqMxY8nbtyjkH8F86o4z9Ons+1d74MpEM7lyr1XHLWIstFT1YpjAEuOnMh W/e0srfJPrfRJR9axAPPbE2cxyT+c6dmRvtMG1/Nu+93cP6J87jvqXcAqCwv4UBHn+Nxg0Eqzn8Q rlVWEuJXXx+05SaCUFCMeLfP2UfP4rZvnWjYtnR+PcsXjmf25FrOPnoWU+qrWaqM56IzFhos53G6 Orma+LvhlCOmMXlcFTeaQhLHj66wXe0acvBBOBnBc6eM4qjFE1NPElPHG9014VCQ71y4jO/pKlx9 9dxD+NlXj+YDB01MbSsvNfbLz8R2LpCMC4IwOIx4yx8yreFTlk9j3tTRWY8bN6oCLefchDrn4t4n LpnKU8kcOZoLaXxdJZ8+ZT5/fGIzgKEQuxmnEEenguvaBPRnT1vAkvn1LJlfn9Fm5kSjC6e6soSy kpChYtdg+tqdSK/wHeKOCMIIpyjtLLex66Nr0pEyNVnSCXzq5Hmp13pRPUFX+KTcQ44bPdrNZEp9 NaOrjf3QJnorysIsXzjBVRqGsmQ/9NfUX34obwSFchMShJFOUYq/2/DHUVXperDZRCkQCLA0aXWb XS8a5Q5hok7n16xgZUYdY0cZC62McSi84oYLT1/ARWcs5ILTFqS2VZYP3QOhaL8gDA5F4fbRc+7K 2e4t/2pvMfJf+shBtHb2UVdjXUS81KHurBvLPxgIpG4E4+sqWDC9jrOPts6Tb8UpR0zL8O0fe+jk 1OsViybw8sb9VA5gkdZA0T4HJ1eXIAgDp+jEf85k91EsJR5X2AaDAVvhz3qsg8Wr6WAgkBbFCXWV XHj6AvuDLDj/xHmO+7VKYVUVQyj+SdP/qIMmsvqtfXzkGPc3N0EQ3FN04u8lNfGsSYkY+dOW+8tT Y8YpJ5C5opUebQ4hGAwQS6YJyod75GPHzaG1s4+LzvB2U8klmuVfVV7CdbrcR4Ig5JbiE/+we9Ws qSzlrm+dMOBrjhtVTmNrD6Mc3Ehuon30i9HyMTE6eVwV3/7sspyf1wsy4SsIg0Pxif8QBJL/9wVL 2bSzhYNm2WeTdPb5p9ukbgQjtAqVaL8gDA5FF+0Tdph0zRejq8s4avFExzbO0T4JwU/4/Em9Hino 50lG6k1NEAqN4hP/AhUX80I0PXrLP5a6ERTmOPygXwk9ksYlCIVM0Ym/VRrnQidm8PmTfD2EHcox +qiqkTQuQShkhp8SFiH6Cd94LH8TvoWAuH0EYXAoGvHXSjFa5fAvdLTwzpHq9tEzUm9qglBoFI34 3/jFo/j+xcuHLFtlVhxWtH76lPkAHLdkqu4pYFB6NeiI+AvC4FCgSph7qspLqCr3XhaxEDj20Mkc fcgkJoyvTfn8R6zlP1LvaoJQYPgSf0VRSoC7gJlAGXADsBG4m0QdjvXAZaqqxhRFuQ44E4gAV6iq ukZRlLlWbQc0khGOZhGnJn9H6DObaL8gDA5+JeTTQJOqqscApwG3ADcB1ya3BYCzFUVZAqwEVgDn A7cmj89o638IxcVIn/AdqU80glBo+BX/PwPfTr4OkLDqlwLPJrc9BpwEHA08oapqXFXVXUBYUZR6 m7aCC8TtIwhCLvDl9lFVtQNAUZQa4AHgWuCnqqpqs5btwCigFmjSHaptD1i0daSurpKwxyybeurr 3RUyHyqqqss99bGqsrTgx5QNq/7X19e4TrldKAz370FDxlF45HMsvid8FUWZBjwE/FJV1XsVRfmx bncNifqHbcnX5u0xi22OtLTYFzDPRn19DQ0N7b6PHww6O3qy9rG+viaVGbSnp7/gx+SE3XfS3NRB 9xDWE/DKcPhtuUHGUXjkaix2NxBfbh9FUSYATwDfVFX1ruTm1xVFOS75+nRgFbAaOFVRlKCiKNOB oKqqjTZtBRdohVac6gEPZ8TtIwiDg18T67+BOuDbiqJovv+vATcrilIKbAIeUFU1qijKKuBFEjea y5JtrwLu0Lf1O4Bi42sfP4RHX9zJ6StyU2Og0BDpF4TBwa/P/2skxN7MSou21wPXm7ZttmorZGdq fTVf+PDioe5GzqkfXU7DgR5CIZF/QRgMho9zVRjR/OCSI+npixIaqQsYBKHAEPEvEIZjttFcEg4F qa4o7s9AEAYT+W8bYv77gqUsmV/P0QdPGuquCIJQRIjlP8TMnTKKr3z04KHuhiAIRYZY/oIgCEWI iL8gCEIRIuIvCIJQhIj4C4IgFCEi/oIgCEWIiL8gCEIRIuIvCIJQhIj4C4IgFCGBeDyevZUgCIIw ohDLXxAEoQgR8RcEQShCRPwFQRCKEBF/QRCEIkTEXxAEoQgR8RcEQShCRPwFQRCKEBF/QRCEIkTE XxAEoQgR8RcEQShCRPwFQRCKECngLhQ1iqJ8F/iXqqqr/ByjKMrdwAlAMwljKgD8VFXV32U5x4eA eaqq3uS784IwAMTyF4qdlUBogMd8R1XVw1RVPQQ4G/ihoignZTnHUqDW43UFIWeI5S8UDYqiTAXu AaqAGPAIsAy4U1GUc4AxwA+ASqAOuFpV1T8nrfuxwFzgRtMxBlRV3aYoys+BLwP/UhRlpfmcwAbg i8k+7QT+DNwKHETipvIjVVX/lI/PQBA0xPIXiomLgUdUVV1GQoS7gFeBz6uq+hZwefL1kmTb7+iO bVJVdWHSnaM/xor1wILk64xzqqq6EbgNuE1V1d8C1wJrVVVdChwLXKMoyuzcDVsQMhHLXygm/gX8 RVGUw4F/ALcAZ+n2fxo4S1GUjwNHAtW6fS97uE4c6HZxTo2TgEpFUS5Kvq8CFgPbPFxTEDwhlr9Q NKiquhpYBPwT+ATwsKnJKmA5sJaEqyag29eNew4BNro4p0YI+HRy3uAwEjeJxz1cTxA8I+IvFA2K ovwYuCDpuvkKsASIAGFFUcYA80m4ZR4FTsF+IjiCzVOzoijzgMuAX2U5p/4cTwNfSh4/CVgHTB/A UAUhK1LGUSgaFEWZBtwL1ABR4EckRPaLwGeAc4GPAG3AiySeDqaTmIx9RlXVu5Pn+YbumC+QDvWM kxD1H6uq+udk2/+1OedS4HfATcm/vwQOI3FzuDFbqKggDBQRf0EQhCJE3D6CIAhFiIi/IAhCESLi LwiCUISI+AuCIBQhIv6CIAhFiIi/IAhCESLiLwiCUIT8f885B+9SWNjXAAAAAElFTkSuQmCC " > ++++ == Estimated runs In our graph we also have estimated attempts at different distances. When you submit an activity Strava generates predicted best times for a range of distances less than the total distance for that activity. For example if you submit an activity of 6,000 metres, Strava will generated estimated times for 5k, 2 miles, 1 mile, 1k, and 400m. We can write the following query to find my best 10k attempts: [source, python] ---- estimated_effort_query = """\ MATCH (distance:Distance {name: {distance}})<-[:DISTANCE]-(effort), (effort)<-[:DISTANCE_EFFORT]-(run) WITH run { .id, .startDate, .distance, pace: duration({ seconds: run.elapsedTime.seconds / run.distance * 1000})}, effort { .elapsedTime, pace: duration({ seconds: effort.elapsedTime.seconds / distance.distance * 1000 })} RETURN apoc.date.format(run.startDate.epochSeconds, 's', 'MMM d yyyy') AS dateOfRun, apoc.date.format(effort.elapsedTime.milliseconds, 'ms', 'mm:ss') AS time, apoc.date.format(effort.pace.milliseconds, "ms", "mm:ss") AS pacePerKm, apoc.math.round(toFloat(effort.pace.seconds) / 60, 2) AS pacePerKmFloat, apoc.date.format(run.pace.milliseconds, "ms", "mm:ss") AS overallPacePerKm, run.distance AS totalDistance, run.startDate AS startDate ORDER BY effort.elapsedTime LIMIT {limit} """ df_10k = graph \ .run(estimated_effort_query, {"distance": "10k", "limit": 1000}) \ .to_data_frame() df_10k \ .drop(["startDate", "pacePerKmFloat"], axis=1) \ .head(10) ---- ++++ <br /> <table class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>dateOfRun</th> <th>overallPacePerKm</th> <th>pacePerKm</th> <th>time</th> <th>totalDistance</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>Jun 9 2018</td> <td>04:24</td> <td>04:24</td> <td>44:05</td> <td>11043.2</td> </tr> <tr> <th>1</th> <td>Jun 2 2018</td> <td>04:25</td> <td>04:25</td> <td>44:12</td> <td>13039.8</td> </tr> <tr> <th>2</th> <td>Jun 4 2018</td> <td>04:27</td> <td>04:27</td> <td>44:35</td> <td>10030.5</td> </tr> <tr> <th>3</th> <td>Jun 6 2018</td> <td>04:28</td> <td>04:28</td> <td>44:49</td> <td>10884.9</td> </tr> <tr> <th>4</th> <td>Jun 1 2018</td> <td>04:29</td> <td>04:29</td> <td>44:59</td> <td>10701.7</td> </tr> <tr> <th>5</th> <td>May 19 2018</td> <td>04:31</td> <td>04:30</td> <td>45:02</td> <td>13635.2</td> </tr> <tr> <th>6</th> <td>May 5 2018</td> <td>04:33</td> <td>04:32</td> <td>45:26</td> <td>11674.4</td> </tr> <tr> <th>7</th> <td>May 21 2018</td> <td>04:33</td> <td>04:34</td> <td>45:41</td> <td>10147.0</td> </tr> <tr> <th>8</th> <td>Jun 13 2018</td> <td>04:34</td> <td>04:34</td> <td>45:48</td> <td>10780.2</td> </tr> <tr> <th>9</th> <td>May 16 2018</td> <td>04:34</td> <td>04:34</td> <td>45:49</td> <td>10148.8</td> </tr> </tbody> </table> ++++ We can also create a matplotlib plot to see my 10k runs over time: [source, python] ---- %matplotlib inline df_10k.sort_values(by=["startDate"]).plot(x="startDate", y="pacePerKmFloat") ---- ++++ <br /> <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXIAAAD8CAYAAABq6S8VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz AAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBo dHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd81dX9x/HXHVk3udk3ISEJIyQn QNhhOBgiUkXrqButFa3b6q/t76e1tlpbta2rrbUO3LMqiq0DnIAKMhNGIOSEsEN2yN7j/v5IggEh ubm5yb03fJ6PRx8N+a7PCfK+35zv+Z5jsNvtCCGE8F5GdxcghBCibyTIhRDCy0mQCyGEl5MgF0II LydBLoQQXs480BcsKal2ephMWJiF8vI6V5bjMQZr26Rd3mewts3b22WzWQ0n2uZVd+Rms8ndJfSb wdo2aZf3GaxtG6ztAi8LciGEED8kQS6EEF5OglwIIbycBLkQQng5CXIhhPByEuRCCOHlJMiFEMLL eU2Ql1U28MrHO2hsanV3KUII4VEG/M1OZ2XtO8z7K3MJDjAzc3ysu8sRQrjJQw/9gZycbKzWYAwG A21tbfz6179h5MjEHo8tKMjn/vt/y+LFrwCwdesW/vznB/jTn/5KUlJyj8fPmTOD1NTxR/48fPhI rrrqmqPO6ajCwkJyc3M4/fRZvTrueLwmyIcNsQKw62ClBLkQJ7lbbrmDGTNOBWDt2jW88MKzPPzw o706R0bGJp544q888sjfSUgY5tAxwcEhPPXU4qO+V1CQ36vrfn/9jezfv+/kCvI4WxAWfzM5eRXu LkUIr/Puilw2Zhc7tK/JZKC1tecpkaamRHHZ3FHd7rNs2Ud8++0q6urqqKioYNGin2O321m6dAkt LS0YDAYefvgxQkJC+NvfHmHnzh00N7dw/fU3MnPmHJ599im2bt1MW1sbl19+FXPnzvvBNaqrqwgI CADgvffe5osvPsNgMHDmmfO59NIreOihP1BZWUl9fQ2/+MWvAdi4cT3/+MdjPPbYPxkyZAjQfqdv NpspLCygubmZM8+cz5o131BUVMhf/vIEQ4fG9fgz2bhxHYsXP4Ofnx/BwSHcc899WCwWHn30YYqL iygrK+W002Zx/fU38cYbr9DQ0MC4ceM5/fTZPZ67O14T5EajgdHDw0nPLqayppGQID93lySEcEB9 fT1/+9u/qKgo54YbfsZ5513Ao4/+A39/fx555CE2bFiLn58/lZUVPP/8a1RVVfHOO29iNvtQUHCI Z555kcbGRm66aRFTp04H4JlnnuSNN17BZDIRGRnJLbfcyd69e/jqqy94+ukXAPjlL29j+vQZAEyZ ksbtt9/Mtm2a/Pw8Fi9+msbGJpqaGo6qdciQGO6++3c8+ujDFBQc4rHHnuTFF59jzZpvuOyyhVRV VXL77Tce2f/2239JSEgIAHa7nUceeZinn34Bmy2Kd9/9N6+++iIXX3wZY8eO4ze/+T2NjY385CcL uPHGW7n66ms77sj7FuLgRUEOMHZkBOnZxeTkVTI1Jcrd5QjhNS6bO6rHu+dONpuVkpJql1174sTJ GI1GwsMjjvRrP/jg/VgsFvbv30dq6niKivYzdmx733NwcDA33HALb775KlpnHwnOlpYWCgvbuzG6 dq102rp1M0VFhdx55y0AVFdXc/DgQYCjuk58ff14/PEnyczcxu9/fw+LF7+Mn58/AMnJKQAEBVkZ Nmw4AFarlcbGpo7aTty1UlFRgcUSiM0W1dHuSTz33NMEBwezc+cOMjI2ERgYSFNTswt+qkfzmlEr AGNGRACQc1C6V4TwFlpnA3D4cBm1tTV88MESHnjgYe6++3f4+flht9sZPnw42dlZANTU1PCrX93O sGHDmTQpjaeeWsyTTz7L3Lnzuu3eSEgYxvDhI/nnP5/jqacWs2DBeSQmJgFgMHwfdZGRNoKDQzjt tJlMmDCRJ5545Mg2g+GEM8X2KDQ0lLq6WkpLSwHYsiWD+PgEli37mKAgK/ff/yBXXHE1jY0N2O12 DAYDdnub09fryqvuyJMTQjGbjOySIBfCaxw+XMadd97SEdB3s2zZR9x88yJMJjNWq5XS0hIWLPgx mzZt4JZbrqe1tZVFi25gxoxT2bw5nVtv/Tn19XXMmnUGFkvgCa+TlJRMWtpUbr31epqamhk9eiw2 m63b2m677X+44YZrWL784z6302AwcNdd93Lvvf+H0WjAag3mt7/9A4cPl/HAA79jx45MfHx8iIuL p7S0hMTEUbz22kskJ6cwb96P+nZtu93pdR6c0peFJWw2K7/+2yp25VXyz/+ZhcXfqz6HuuXqX2c9 hbTL+7iybcuWfcT+/fu45ZZfuOR8feHtf2eDZmEJgKT4UOxA7qFKd5cihBAewetuaZPjQ/lk7X52 5VUwPjHC3eUIIbqxYMGP3V3CScHr7shHDQ3BYJAHnkII0cnrgjzAz0x8VBB7C6pobpF5V4QQwuuC HCA5LpSWVjt7C7z3wYUQQriKQ33kSqkMoKrjj3u11ou6bDsHuB8wAOnAbVrrfh0KkxwfypfpeeQc rCA5PrQ/LyWEEB6vxyBXSvkDBq31nONsswKPAnO01qVKqbuASKDE1YV2ldQR3jLvihBCOHZHPgGw KKU+79j/t1rrdR3bTgUygceVUiOBF7TW3YZ4WJgFs9nkdME2mxWbDWIjA9mTX0V4RBAmo/NvY3kS m83q7hL6hbTL+wzWtg3WdjkS5HXAY8ALQBKwXCmltNYttN99nwFMBGqAb5VSa7XWOSc6WXl5ndPF dh3QPzI2mNXbCti8o+DIFLfezNtfVjgRaZf3Gaxt8/Z2dfch5MjDzhzgDa21vSOgy4CYjm1lwEat daHWugb4hvZQ73fJcdK9IoQQ4FiQXwc8DqCUigWCgYKObRlAqlIqUillBmYAWf1R6LGS49unjpR5 V4QQJztHgvxFIFQptRp4h/Zgv0Mpdb7Wuhi4B/gMWA8s1Vpv77dqu7CFBhAS5EtOXiUDPV+MEEJ4 kh77yLXWTcDCY779XZftbwNvu7iuHhkMBpLjQtmYXUxxeT3R4ZaBLkEIITyCV74Q1KlzDLm8ri+E OJkNjiCXB55CiJOYVwf5UFsgFj8zuw7KlLZCiJOXVwe50WBgVFwIxRX1VNQ0urscIYRwC68OcpB+ ciGE8P4g73gxSLpXhBAnK68P8uExVnzMRnngKYQ4aXl9kJtNRkbGBJNXXENdQ7O7yxFCiAHn9UEO siCzEOLkNiiCvHPelRzpJxdCnIQGRZAnxnYsyCz95EKIk9CgCPIAPzMJ0Vb2yYLMQoiT0KAIcvh+ QeY9+VU97yyEEIPI4Anyzn7yvN71k2/eVcLnGw/KVLhCCK/lyFJvXiHpyItBjveTf73lEK9+qgFQ 8aGDYsk4IcTJZ9DckQcH+jIk3ELuoUra2nq+u16Rkcern2rMpvYfweptBT0cIYQQnmnQBDm0d680 NLVysLim2/2+2HiQNz7PIdjiw++umUJwoC/rsgppbmkboEqFEMJ1BlWQd3avdDeB1qfrD/Dvr3YR EuTL3VdNJiHayqljh1Db0MLW3NKBKlUIIVxmUAV5TwtNfLJ2H++uzCXM6sdvFk4mJiIQgNPGDQFg daZ0rwghvM+gCvLIEH/CrH7sOljxg1EoH67ey/tf7yEi2I+7F046ao3PobYgRsRY2b7nsMxrLoTw OoMqyA0GA0lxIVTVNVNUXg+A3W5n6Td7+M/qvUSG+HP3wslEhf1woebTxsXQZrezbkfRQJcthBB9 MqiCHI5eaMJut/Peqt18/N0+okID+M1Vk4kMDTjucdNGR2M2GVidWSBjyoUQXsWhceRKqQyg85XJ vVrrRcdsNwKfAP/VWj/r2hJ7J7nLA8/80lo+33iQ6HALd105iTCr3wmPCwrwYVKSjY3ZxewrrGZE TPBAlSyEEH3SY5ArpfwBg9Z6Tje7PQiEuaqovoi1BRLob2btjkLsdoiJaA/xkKATh3in08bFsDG7 mNWZBRLkQgiv4UjXygTAopT6XCm1Qik1o+tGpdQlQBvwaX8U2FtGg4FRQ0Ow2yHOFsjdCyc7FOIA Y0eEERLky/odRTL5lhDCazjStVIHPAa8ACQBy5VSSmvdopRKBRYClwD3OXLBsDALZrPJ2Xqx2Xp+ jf7yH6UQufEAi84b63CId5o3NYH3V+ayu6iWmROHOlumUxxpmzeSdnmfwdq2wdouR4I8B8jVWtuB HKVUGRADHASuAYYCK4DhQJNSap/W+oR35+XldU4Xa7NZKSmp7nG/IcF+XHVmEk31TZTUN/XqGpMS I3h/ZS7L1+wlZejAda842jZvI+3yPoO1bd7eru4+hBwJ8uuAccCtSqlYIBgoANBa39W5k1LqD0Bh dyHuDWIjAxkZG8z2vWWUVzd2+4BUCCE8gSN95C8CoUqp1cA7tAf7HUqp8/u1Mjc6bVwMdjus3VHo 7lKEEKJHPd6Ra62baO8H7+q74+z3BxfV5HbTR0fx7y93sSazgHOmJ2AwGNxdkhBCnNCgeyHIFSz+ PkxOjqSgrE5WHBJCeDwJ8hM4fVwMAGtkIi0hhIeTID+BMcPDCbP6sX5nMU3NMqZcCOG5JMhPwGg0 cGrqEOobW8jYVeLucoQQ4oQkyLtx2pHuFRm9IoTwXBLk3RgSbmHU0BCy9h7mcFWDu8sRQojjkiDv wWnjhmAHvtsud+VCCM8kQd6DqSnR+JqNrJF5yoUQHkqCvAcWfzOTlY2i8np2H5Ix5UIIzyNB7oDO h56rM/PdXIkQQvyQBLkDRieEER7sx4adxTTKmHIhhIeRIHdA+5jyGBqaWsnIkTHlQgjPIkHuoNPG DQFg9TZ5ZV8I4VkkyB0UHWYhzhbE7kOVtMnoFSGEB5Eg74WYCAtNLW1U1vRu1SEhhOhPEuS9EBUW AEBxH5arE0IIV5Mg74Wo0PYgLyqvd3MlQgjxPQnyXvj+jlyCXAjhOSTIeyEqzAJAcYUEuRDCc0iQ 90JokC++ZqP0kQshPIoEeS8YDAaiwgIoLq+XCbSEEB5DgryXosIsNDS1Ul3X7O5ShBACkCDvNXng KYTwNGZHdlJKZQCdc7ju1Vov6rLtl8AVHX9cprV+wLUlepbOIC8qr2NUXIibqxFCCAeCXCnlDxi0 1nOOs20kcBUwHWgDViulPtBab3N1oZ6icyy53JELITyFI3fkEwCLUurzjv1/q7Ve17HtIHC21roV QCnlA3S7uGVYmAWz2eR0wTab1eljXWG0qb32yvpml9fi7rb1F2mX9xmsbRus7XIkyOuAx4AXgCRg uVJKaa1btNbNQKlSygA8CmzWWud0d7LyPgzds9mslJRUO328K9jb7JhNBg4WVrm0Fk9oW3+Qdnmf wdo2b29Xdx9CjgR5DpCrtbYDOUqpMiCG9rvxzq6Xl4Bq4NY+V+vhjEYDttAA6VoRQngMR0atXAc8 DqCUigWCgYKOPxuA/wJbtdY3dXaxDHZRoQHUNrRQUy9DEIUQ7ufIHfmLwCtKqdWAnfZgv0MplQuY gNmAn1LqnI7979Far+2Xaj1E+6v6ZZRU1BMU4OPucoQQJ7keg1xr3QQsPObb33X52t+lFXmBrkMQ R8QEu7kaIcTJTl4IckK0vBQkhPAgEuROsEmQCyE8iAS5EyKC/TEaDBLkQgiPIEHuBLPJSGSIv0xn K4TwCBLkTooKC6Cqrpn6xhZ3lyKEOMlJkDupc+RKiawWJIRwMwlyJx1Z9k36yYUQbiZB7qSuY8mF EMKdJMidJGPJhRCeQoLcSZEhARiQIBdCuJ8EuZN8zEbCg/0oloedQgg3kyDvg6gwC+XVjTQ2nxST PgohPJQEeR/IEEQhhCeQIO+DI0Eu/eRCCDeSIO+DqND2seRFEuRCCDeSIO+DI0MQpWtFCOFGEuR9 YAvtHEsuLwUJIdxHgrwP/HxNhAb5ylhyIYRbSZD3UVRoAGVVDTS3tLm7FCHESUqCvI+iwizY7VBa KXflQgj3kCDvoyiZc0UI4WYS5H0kQS6EcDezIzsppTKAqo4/7tVaL+qy7QbgJqAFeFBr/bHLq/Rg 0Z3zkssQRCGEm/QY5Eopf8CgtZ5znG1DgDuANMAfWK2U+kJr3ejqQj3V90MQJciFEO7hyB35BMCi lPq8Y//faq3XdWybBqzpCO5GpVQuMB7Y2C/VeiCLvxmrxUfGkgsh3MaRIK8DHgNeAJKA5UoppbVu AYKByi77VgMh3Z0sLMyC2Wxyslyw2axOH9tfhtqC2HWwgvDwQEwm5x87eGLbXEHa5X0Ga9sGa7sc CfIcIFdrbQdylFJlQAxwkPZ+864/GStQ0d3Jyvtw52qzWSkpqXb6+P4SFuRLa5ud7D2lRHV0tfSW p7atr6Rd3mewts3b29Xdh5Ajt4/XAY8DKKViab8LL+jYtgGYqZTyV0qFAKOB7X2q1gt9vxCzdK8I IQaeI0H+IhCqlFoNvEN7sN+hlDpfa10IPAl8C6wA7tVaN/RbtR5KhiAKIdypx64VrXUTsPCYb3/X ZfvzwPMursurSJALIdxJXghygSNjySXIhRBuIEHuAoH+Zix+ZnkpSAjhFhLkLmAwGIgKC6C4vJ42 u93d5QghTjIS5C4SFRZAS2sbFdUnzUutQggPIUHuIp0PPGX9TiHEQJMgd5HOhZhlLLkQYqBJkLuI DEEUQriLBLmLREuQCyHcRILcRYIDffHzMUkfuRBiwEmQu0jnEMSSinrsMgRRCDGAJMhdKCosgMbm Vqpqm9xdihDiJCJB7kIyBFEI4Q4S5C4kc64IIdxBgtyFjqzfWSFjyYUQA0eC3IVkCKIQwh0kyF0o 1OqH2WSUPnIhxICSIHchY5dZEGUIohBioEiQu1hUaAD1jS3UNrS4uxQhxElCgtzFvh+CKA88hRAD Q4LcxeSBpxBioEmQu1iUjCUXQgwwCXIXsx25I5euFSHEwDA7spNSKgpIB87SWmd3+f5VwK+BVuAl rfUz/VKlF4kI9sNkNMgduRBiwPR4R66U8gGeA46XTI8B84DTgF8rpcJcW573MRmNRIb4y1hyIcSA caRr5THgWSD/ONu2ASGAP2AAZPA07f3kNfXN1DU0u7sUIcRJoNuuFaXUtUCJ1vozpdQ9x9llO+1d LrXAUq11RU8XDAuzYDabnKkVAJvN6vSxA2VYbDCZe8poxtirer2hbc6Qdnmfwdq2wdqunvrIrwPs Sql5wETgNaXU+VrrQqXUeOBcYARQA7yhlLpUa72kuxOW9+EhoM1mpaSk2unjB4rVv/3HqveWEuLv 2IeWt7Stt6Rd3mewts3b29Xdh1C3Qa61ntX5tVJqFXCz1rqw41uVtPeb12utW5VSxcBJ30cOMpZc CDGwHBq10pVSaiEQpLVerJR6DlitlGoCdgOvuLg+ryRjyYUQA8nhINdaz+n4MrvL956l/UGo6CIy xB+jwcC+wirsdjsGg8HdJQkhBjF5IagfmE1GJidHkldSS9b+cneXI4QY5CTI+8m5pwwH4JPv9rm1 DiHE4CdB3k+GDbGSOjKc7AMV5B6qdHc5QohBTIK8H53XcVe+bO1+9xYihBjUJMj7UXJ8KElxIWzJ LeVgcc2AX7+mvtnlKxW1trVR3yiLZgjhSSTI+1lnX/mydQN3V97a1sZbX+Zwxz++5Y+vbuLbbfk0 Nbf26ZyVtU189N0+7npmLb96ag2HSgb+g0kIcXy9HkcuemfcyHASooLYsLOIC2eOILpjjHl/qWto 4bkPd5C5p4yQQF8OFFXz8rJs3l2Ry8wJsZwxaSi20ACHzmW329mdX8WKjDw27iymtc2Or4+RpuY2 Xl6ezW+vnoLRKEMrhXA3CfJ+ZjAYOPfU4Tzzn+0sX3eAa89J6bdrlVTU84/3tpFfWkvqyHBuPj+V +sYWVm05xDdb8/l0/QE+W3+A8YkRnDkljjEjwjEeZ4x7U3Mr67OKWJFxiP1F7a80x0RYmDs5jlNT h/Dqp9ls2FnMl+l5zJ8a32/tEUI4RoJ8AExJthEdbmFNZgEXnD6CMKufy6+Rc7CCp5ZmUlPfzLy0 OC6fOwqT0YjF38zFsxM5/7QRbMou5quMPLbuLmPr7jKiwgKYOzmO08cNweLvQ3FFPasyDvHttnxq G1owGGByso0zJw8lZVjYkRebFp6VTNa+cpZ+s5uJSZFEOXiHL4ToHwZXPwzrSUlJtdMX9OZJb77d ls/Ly7KZPzWeK85M+sH2vrRtTWYBr36aTVsbXD0/mTmThna7/96C9u6S9VnFtLS24etjZFi0ldy8 SuyA1eLD7ImxzJk4lPBg/+OeY92OQhZ/lMXoYWH87xUTT/j2qjf/nXVnsLYLBm/bvL1dNpv1hP2Y ckc+QE4ZO4T/rt7Lqi2HOPeUYVgtvn0+Z5vdztKv97Bs3X4sfmZuvSiVMcPDezxuREww1587hsvO GMXqbQWs3HyIXXmVJMYGM3dKHGkqCh9z98/Bp4+JZl1WEdt2l/HttgJmTYjtc3uEEM6RIB8gZpOR s6cl8NaXu/hyUx4XzRrZp/M1NrXy/MdZZOSUEB0WwB2XjCcmIrBX57BafDlnxjB+NC2B6vpmQgId /3AxGAxc8yPF715Yzzsrchk3MqJfuoyEED2T4YcDaOaEWKwWH75Kz+vTWOzDVQ38+c10MnJKSEkI 5d5r0nod4l0ZjYZehXin8GB/LjtjFPWNLbz+mXb5mHUhhGMkyAeQn4+J+VPjqWtsYdXmQ06dY29B FX96bRMHimqYNSGWX10+kaAAHxdX6rhZE2NR8aFsyS1lY3ax2+oQ4mQmQT7AzpgUR4Cfic82HuzV Szp2u50VGXn85c0MqmqbuOLMJH52tsJscu9fodFg4NoFKfiYjbz5RQ7VdU1uredkkLXvMA+8spE/ vLxB1oUVgAT5gLP4m5k7OY6q2iZWZxY4dExlTSN/X7KNNz7Pwdds5M5LxjN/arzHzHMeHWbhopkj qa5r5u2vdrm7nEErv7SWvy/ZymNvb2F/YTUHimp4/qMs2qRL66QnQe4GZ6XF42s2snzdAVpa27rd N12X8PsXN5C5p4zUEeH88frpjE+MHKBKHXfW1DhGxFhZu6OIbbtL3V3OoFJV28Trn2nue3ED23aX kZIQyu9/lsbY4WFs3V3Gh6v3urtE4WYS5G4QHOjLrAmxlFU1sD6r6Lj71De28NInO/nXB5k0Nrdy 1VnJ/PKyCR47MsRkNLLonNGYjAZe/VTLxFou0NzSyrJ1+7ln8VpWbj6ELSyAX/xkHP935SRGxARz 0wWpRIb48+GafWzZJR+eJzMJcjc5e3oCJqOBZev2/+BX4115Fdz/0gZWZxYwLNrK/ddO5cwpcR7T lXIicVFBnHvKMMqrG3lv1W53l+O17HY767IK+e3i9by3ajdGg4GF85L40/XTmJRsO/LfQVCAD7f/ ZBy+ZiPPf7yDwsN1bq5cuIsEuZuEB/tzSuoQCsrq2JxTAkBLaxtLv9nNX97MoKyqgXNPGca910wh NtL5oYUD7dxThjM0MpCVmw+hD8gyd72Vm1fJQ6+ns/jDLCprG/nRtHj+cvMpzEuLP+6D7YRoKz87 J4X6xlb++f42+U3oJCVB7kYLZgzDAHy8dj8Hi6p56PV0Pv5uPxHB/vzmqslcPDvR7aNSesvHbOTa BSkYgJeXZ9PYx+lzTxYtrW289mk2D7+Rzp78KtJSonjwhhlcPjeJQP/uh5eeMnYI89LiKCir46Vl O2U8/0nIu1JikBkSbiEtJYr9hdXc8fhK9hdWc/q4GB64bhpJcaHuLs9pibEhnDU1nuLyet76NNvl 5885WEFBWa1Lz9nc0kZGTgmNTQP/wVNT38wT72xh1ZZ84mxB3HP1ZG69MLVXk5FddsYoVHwo6bpk QOe+d6ea+mYy95S5uwyH2O12tu0uo7y6sV/OL0HuZueeMgyDAQL8fLjtolSuO3c0AX7eP3PCRTNH Ygv154Ovc9nuwn9sW3JL+cubGdz/0gaWr99PW1vf7z7zSmp48LVNPLU0k1c/c/0HT3cKymp58LVN ZB+oYEqyjXt/OsWpD3GzycgtF6YSZvVj6dd7XPoz91QvL9vJ397d6vFr4lbWNPKP97bx9yVb+XT9 gX65hkNBrpSKUkodVEqlHPP9qUqpb5VSq5VS7ymljj9VnjihhGgrf1g0jWfunssUFeXuclzGz9fE zRekYjIaee7DHRRX1Pf5nIWH63j+ox34mI1Y/H1YsnI3j/57M6WVzp27zW7n8w0H+OMrmzhYXENQ gA/rdhQNWN/+jn2HefC1dIrL6zn3lGHcclEqfr4mp88XHOjLbReNw2QyuOxn7qnySmrY3DFSZ5MH v1GckdM+fHjb7jLGjghnwSnD+uU6PQa5UsoHeA6oP+b7BuB5YJHW+nTgU6B/qhzk4qOCCAnyzGGF fTEiJphbLx5PbUMLT72f2adui/rGFp5amkl9YyvXnp3Cn66fxuRkG/pg+wiftdsLe9U3fLiqgcff 3sLbK3IJ8DPxi4vHceel4wF484scWtu6H9/fVysz8vjbO1tpbmnl5+eN5uLZicdd5KO3RsYGc/V8 5ZKfuSfr7D4yGCBdF3vcc4HO4cNPLW0fPrxwXhK/vGyCU3MaOcKRO/LHgGeB/GO+nwyUAb9USn0N hGuttYvrE17urOnDmDNpKHklNbzyabZT/+DsdjsvLdtJfmkt89LiOCV1CFaLL7ddlMqiBSm02eH5 j7N49r87qKnv+ZX19VlF3PfiBnbuL2dCYgR/vH46k5JsJMaGMHN8DHkltazMcG4unJ60trXx5hc5 vP55DoEBZv7vykmcmhrj0mvMmhDb55+5JyuuqGd9VhFxtkCmj4mmrKqRfYWeM8941+HDCdFB3Hft VOalxbvkg/pEuu2MVUpdC5RorT9TSt1zzOZI4FTgdiAX+FgptUlrvaK7c4aFWTCbnf/10WazOn2s pxusbbvjiskUHq5jfVYRqaNsXDg7sVfHL/kqh3RdQmpiBLddNumokTw/OTOYUyfG8cRbGWzMLmZP QRX/c8UkJib/sJuqpr6ZZ9/fxteb8/DzNXHbJRP40YxhR43Pv+niCWTsKuW/q/dy9ukjCbOeuLew t39ftfXNPPL6JjJ0MQlDrNzkX7okAAAQg0lEQVR3/Qyiw/tnDde+/sw9+b/Fd7/eg90OV8xPwc/X xLodRWQdqGDa+O4XVIH+bVdLaxv//lzz3lc52IFLz0ziyvkpPc7t7wrdrhCklPoGsHf8byKQA5yv tS7s6C9forUe17HvLwEfrfUj3V3wZF0hqCeDtW2d7SqvbuSPr2ykuq6ZX18xkdHDwhw6fvveMv72 7lZCg/y479qpJ/zVtLWtjWXrDvDh6r20ttmZlxbHJbMT8fVpv2nYub+cFz/J4nBVIyNjg7nhvDEn DNGv0vN484scTh8Xw3Xnju62XY4qrqjnH0u2UlBWx/jECG46f2y/P9R29mfuyf8tllc3cvez3xFu 9eehG6fT2mrnzidXExLky59vnNHtS3OOtqu0sp7Cw3VEhQYQEeKPydhzEBeU1bL4oyz2F1YTEezP DT8eQ3K8a0eeOb1CkNZ6VufXSqlVwM1a68KOb+0BgpRSo7TWucBM4MW+lysGozCrH7delMojb23m mf9s5/5rpxIR0v2z8eKKep777w5MRgO3XTSu2/5Fk9HIj08dTuqIcJ7/KIsvN+WRta+cRQtSSM8u 4bMNBzAYDFxw+gjOO3VYt/8450yK5Zut+azOLGDWxFhGDQ1xut1w9HqqZ6XFc/ncURiN/f+WbpjV j1suTOXRf2/muf9u54/XTye4n/poB8rnGw/Q0mrnnBkJmIxGTEYYnxjBxuxi8kpqiY8K6tP529rs PPLWZkorGwAwGQ1EhPgTFRZAdKgFW1hA+9dhAUSGBGA2GViRcYglK3NpamnjtNQhLDwrecBHnvX6 akqphUCQ1nqxUup64K2OB5/faa0/cXmFYtBIigtl4bwkXv88h399kMk9V0/G5wTdbI3NrfxraSa1 DS1ce04KI2ODHbrGiJhg7l80lSUrc1mRcYiHXksHICosgBt+PIbE2J5D2WQ0cvX8ZP78RgZvfp7D 73+W5nTwrs8q4oWPswC45mzFnIk9//rvSsnxoVw8O5F3V+by0rKd3HnJeI+f6uFEauqbWbU5n9Ag 36OeK0xRNjZmF7Mpu7jPQb5972FKKxsYNTQEW2gAxRV1lJTXs33PYbZz+Kh9DUCQxYfqumYC/c38 /LwxpKW4Z+SZw0GutZ7T8WV2l++tAKa5uCYxiM2ZNJS9BdWszizgtc801y0Y/YNgsdvtvLo8m4PF NcyZGNvr9UD9fExcPV8xYVQkb3+1i5SEMC49IxF/X8fvW5LiQjll7BDW7ijk6635nNHDgtbHsyaz gJeW7cTf18ztF6Uy2oH1VPvD/Gnx7NhbxrbdZazIOMSZU+LcUkdffbnpII3NrVw0c8RR/c7jEyPw MRtJzynp8xKK32xtH9Nx5bwkRsR8f/NQ39hCcXk9xRX1FJfXUVReT0nHnyclRXL1fOXWCe28/80T 4VUMBgM//VEyeSU1rMksZERMMHMnHx0sX2zKY11WEYlDg7lyXrLT1xo3MoJxIyOcPv6yMxLZvKuE pV/vZmpKVK9WYvpmaz6vLs/G4m/m11dMZPgQx36j6A9Gg4Hrzh3D/S9t4J0VuaiEUOJsfbtzHWj1 jS18lZ5HUIAPsyYe/cHu72smdUQ4m3eVUlBW6/SyhxU1jWzZVUpCVBDDhxz9UDTAz8ywIVaGDfHM h8DyZqcYcD5mE7f/ZBxWiw///nIXu/Iqjmzbub+cd1fkEhLoy60XjhuQJ/4nEhLkx4Wnj6C2oYX3 v3Z8NseVmw/xyvJsAgN8+L8rJ7k1xDuFWf1YtCCFltY2nvtwB80t3jW+/Ost+dQ2tDAvLe64v1ml dbxMt0mXOH2NNZkFtNntzJ4Y63XdTxLkwi3Cg/255YJU7HZ4+oPtlFc3UlbZwLP/3Y7BwJHXzd1t 7pQ4hkYG8s2WfPYWVPW4/5ebDvL6ZxqrxYe7rpxEQrTn3MFNSrIxZ9JQDpXUsmSl90wz3NzSymcb DuDnazpht9CEURGYjAbStXNvebbZ7Xy9JR9fHyPTxwzpS7luIUEu3CZlWBiXnZFIZW0TT/8nk399 kEl1XTNXzkty+dAtZ5lNRhaelYyd9jc+u1tW7bMNB3jry12EBPpy18LJxPXxwVt/uHzuKGIiLHyZ nse23d4xH8vqzEIqa5uYO2noCWeCtPj7MGZ4OAeKapyammDnvnJKKxuYlhKNxd/7epwlyIVbnTU1 nhljotl9qIp9hdWcNm6IUw8W+9PoYWFMGx3Fnvwq1mw7/jqry9bt550VuYQG+XLXwkkM9dA55P18 TNx0/ljMJgMvfZJFZa1nL5bd2tbG8nX7MZuMzJ8a3+2+U5QNwKm78q87HnLOnti7B+ueQoJcuJXB YOBn56SQHB/K6GFh/HS+8sj+ycvOGIWfj4n3vt5N7TEr13+0Zi/vrdpNeLAfd1812emHbQMlIdrK xbMTqapr5mUPn798Q1YxpZUNzJwQ0+N8RJOSIjEaDKT3sp+8sraJzTklDLUFOjzM1dNIkAu38/Mx cffCSfzvFROPvInpacKD/fnxacOprmvmP9+0L3Zst9v5z7d7+ODbvUSG+HP3wslEh/XPK/eudtbU eMaOCGfb7jK+Ss9zdznH1Wa388m6/RgNBs6ZltDj/laLLyohlD35VRyuanD4Ot9lFtDaZmf2BO97 yNlJglx4BIPB4PH/iOZPjSc63MKKzXnsza9k6Td7+HDNPmyh7SFu68VCEO5mNBi4/tzRBAX48O7K 3eQV17i7pB/YsquU/NJaZoyNJtLBn21aZ/dKjmN35Xa7na+35uNjNnJKqvc95OwkQS6Eg8wmI1ed lYTdDvc+s4ZP1u4nOiyA31w1pcfpBjxRaFCXIYkf7aDJg5bls9vtfLJ2Hwbal0R01ORkGwYg3cE5 yrMPVFBcXk+aiupxST1PJkEuRC+kjohgSrKN6rpmYiIs3H3VZI8YJumsSUk2zugckrjKc4YkZu0v Z29BNZOTbb1afDwkyI9RcSHsyquksqbnZdW+3tI+XbG3PuTsJEEuRC/99GzFNQtGc/fCyYQOggVB Lps7itjIQL5Kz2Nrbqm7ywHgk+/2ATi1os4UFYUdyNjVfVuq65rIyCkhJsJCUlzfJkZzNwlyIXop 2OLLpWcme/1Mgp2OGpK4bCflvXhQ2B9yD1WSfaCCsSPCj5rvxFFTkh0bhvjd9kJaWr37IWcnCXIh BPFRQVwyZxTVdc388aX1VDjQLdFflq1tX8btPCfXt4wI8WdETDDZ+ytOuGKUveNNTrPJwKnjXLtC kztIkAshAJiXFsfp42LIPVjBn17dxP4BXj6tvLqRlRl5bMktZdTQkD693ZumbLTZ7WzedfzRK7vy Kik8XEea6t1kaJ7K+95FFUL0C6PBwKIFKSQmhPHaJ1n8+c10bvzxWCZ3dFW4WnNLG7l5FWTuPcz2 PWXkldQeqeOCmSP61N0xRdlYsmo36bqEmeN/+CCz8yFnb6dI9lQS5EKIIwwGA5fMTcLqZ2LxRzv4 19JMLp6TyDnTE1zSj1xUXte+SMOeMnYeKKepuQ0AH7OR1BHhpI6MYEJiRJ/XMo0KsxAfFcSOvYep a2g5av6UmvpmNmaXEB0WgErwjDl9+kqCXAjxA5OTbdxz1RSefH8b763aTUFpLdec7dxCwvsLq1m9 rYDMPWVHTWgVE2EhdUQE40aGkxwf6vK3eqcoGweLa9i6u5RTxn7/ss/aHYW0tLYxe+JQr3/I2UmC XAhxXMOGWPn9z9L45/vbWLO9kOKK+o555HserdPc0sYmXcyKjDx2H2qf/jfAz8SUZBtjR4aTOiKc yJD+fRM2TUXxn2/3kq5LjgS53W7nmy35mIwGTh3nvW9yHkuCXAhxQqFBfty9cDIvfrKTjdnF/OnV Tdx56YQTzu54uKqBVVsO8c2WfKrqmjHQvhTb3MlDGTM8HLNp4MZXxEYGEhNhIXNPGQ1NLQDszq/i UGktU1OiCHbgA8lbSJALIbrl62Pi5gvGEhNh4cM1+3j49U3cfEHqkWX07HY72QcqWJGex+ZdpbTZ 7QT6m/nRtHjOmDSUKDdOJDZFRfHxd/vI3HOY+KFhg+ZNzmNJkAshemQwGLhw5khiIgJ58ZOd/H3J Vi4/YxRms5EVGYfIL20fcZIQFcSZU+KYNiYaPw+YyTJN2fj4u32k62JmpSWwcWcxUaEBpAwLc3dp LiVBLoRw2PQx0USG+vPP9zN5e0UuACajgRljopk7OY7EocEe9QAxPioIW6g/W3eX8eWG/TS1tDFz QgxGD6rRFRwKcqVUFJAOnKW1zj7O9sXAYa31b1xcnxDCwyTGhvD7a9JYsiqX2MhAZk8cSoiHTldg MBhIU1EsX3+A15dnYzIaOH0QvMl5rB6fPCilfIDngOMuhKeUugkY5+K6hBAeLCLEn5svSOX800Z4 bIh3mqKiAGhqbmViUmSPKw15I0ceIT8GPAvkH7tBKXUqMJ32oBdCCI8zIsZKeHB7eM8eJG9yHqvb rhWl1LVAidb6M6XUPcdsiwHuBy4CLnP0gmFhFsxm5x+C2GxWp4/1dIO1bdIu7zPY2rbovLFs31PG 7KnDMBoHV/84gKG7hVeVUt8A9o7/TQRygPO11oVKqTuAnwHVwBDAAtyntX6luwuWlFQ7vdKrzWal pGRgJ/IZKIO1bdIu7zNY2+bt7bLZrCf8BOr2jlxrPavza6XUKuBmrXVhx7YngSc7tl0LpPQU4kII IVyv169ZKaUWKqVu7I9ihBBC9J7D48i11nM6vvzB8EO5ExdCCPeRhSWEEMLLSZALIYSXkyAXQggv J0EuhBBeToJcCCG8XLcvBAkhhPB8ckcuhBBeToJcCCG8nAS5EEJ4OQlyIYTwchLkQgjh5STIhRDC y0mQCyGEl5MgF0IILydBLoQQXk6CXAghvJwEuRBCeDmHVwgSwpMppR4AvtRaf+vMMUqpV4C5wGHa b3AMwGNa61d7OMePgSSt9RNOFy9EH8kduRgsZgOmPh5zn9Z6otZ6PHAB8LBSal4P55gCBPfyukK4 lNyRC6+jlIoD3gQCgTbgYyANeEEpdREQDjwEWIAw4C6t9ZKOu+4IYBTwl2OOOYrWeo9S6h/ArcCX SqnZx54T2AHc3FHTfmAJ8C8glfYPiL9qrf/dHz8DIbqSO3Lhja4HPtZap9EeqHXAJuDnWutM4Bcd X0/u2Pe+LseWaa1Hd3SZdD3meLYDKR1f/+CcWuss4FngWa31y8DvgHSt9RRgFnCvUmqk65otxPHJ HbnwRl8CS5VSk4BPgKeA87psvxo4Tyl1KTADCOqybX0vrmMH6h04Z6d5gEUpdV3HnwOBscCeXlxT iF6TO3LhdbTWa4AxwGfA5cBHx+zyLTANSKe9O8TQZVs9jhsPZDlwzk4m4OqOfvaJtAf+p724nhBO kSAXXkcp9Qjw047ukduByUALYFZKhQPJtHd9LAPmc+KHoC2c4LdSpVQScBvwTA/n7HqOFcAtHcfH ANuAhD40VQiHyFJvwusopeKBtwAr0Ar8lfbAvBm4BrgYuBCoAtbSfteeQPuDyFVa61c6zvO/XY65 ke+HH9ppD+hHtNZLOvZ9/ATnnAK8CjzR8f9PAxNpD/q/9DR8UQhXkCAXQggvJ10rQgjh5STIhRDC y0mQCyGEl5MgF0IILydBLoQQXk6CXAghvJwEuRBCeLn/ByWevb3MNGQCAAAAAElFTkSuQmCC " > ++++ == Combining estimated runs What if we want to combine my efforts for multiple distances in a single row? The pandas `merge` function comes in handy here. For example we could write the following code to create a DataFrame that combines my 10k and 5k runs: [source, python] ---- import pandas as pd cols = ["run.id", "dateOfRun_x", "time_x", "pacePerKm_x", "time_y", "pacePerKm_y"] df_5k = graph \ .run(estimated_effort_query, {"distance": "5k", "limit": 1000}) \ .to_data_frame() df_10k = graph \ .run(estimated_effort_query, {"distance": "10k", "limit": 1000}) \ .to_data_frame() pd.merge(df_5k, df_10k, on="run.id")[cols].head(10) ---- ++++ <br /> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>run.id</th> <th>dateOfRun_x</th> <th>time_x</th> <th>pacePerKm_x</th> <th>time_y</th> <th>pacePerKm_y</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>1611168962</td> <td>Jun 2 2018</td> <td>21:24</td> <td>04:16</td> <td>44:12</td> <td>04:25</td> </tr> <tr> <th>1</th> <td>1626636004</td> <td>Jun 9 2018</td> <td>21:34</td> <td>04:18</td> <td>44:05</td> <td>04:24</td> </tr> <tr> <th>2</th> <td>1620188065</td> <td>Jun 6 2018</td> <td>22:00</td> <td>04:24</td> <td>44:49</td> <td>04:28</td> </tr> <tr> <th>3</th> <td>1616050069</td> <td>Jun 4 2018</td> <td>22:01</td> <td>04:24</td> <td>44:35</td> <td>04:27</td> </tr> <tr> <th>4</th> <td>1581401227</td> <td>May 19 2018</td> <td>22:15</td> <td>04:27</td> <td>45:02</td> <td>04:30</td> </tr> <tr> <th>5</th> <td>1609355524</td> <td>Jun 1 2018</td> <td>22:16</td> <td>04:27</td> <td>44:59</td> <td>04:29</td> </tr> <tr> <th>6</th> <td>1635264102</td> <td>Jun 13 2018</td> <td>22:20</td> <td>04:28</td> <td>45:48</td> <td>04:34</td> </tr> <tr> <th>7</th> <td>1585759604</td> <td>May 21 2018</td> <td>22:27</td> <td>04:29</td> <td>45:41</td> <td>04:34</td> </tr> <tr> <th>8</th> <td>1566256778</td> <td>May 12 2018</td> <td>22:30</td> <td>04:30</td> <td>46:11</td> <td>04:37</td> </tr> <tr> <th>9</th> <td>1624450599</td> <td>Jun 8 2018</td> <td>22:30</td> <td>04:30</td> <td>46:11</td> <td>04:37</td> </tr> </tbody> </table> ++++ That's all for now. Hopefully that's given you some ideas of how you can use the new version of Py2neo to query your graph data. I only covered some examples in this blog post. If you want to see the full set you can look at the https://github.com/mneedham/strava/blob/master/Strava.ipynb[accompanying Jupyter notebook^].

Learn how to query a Strava activity graph using Py2neo v4.

neo4j-querying-strava-graph-py2neo

https://markhneedham.com/blog/2018/06/15/neo4j-querying-strava-graph-py2neo

2018-06-12 05:30:21

Neo4j: Building a graph of Strava activities

In my https://markhneedham.com/blog/2018/06/05/neo4j-apoc-loading-data-strava-paginated-json-api/[last post^] I showed how to import activities from Strava's API into Neo4j using only the APOC library, but that was only part of the graph so I thought I'd share the rest of what I've done. == The Graph Model In the previous post I showed how to import nodes with `Run` label, but there are some other pieces of data that I wanted to import as well. `Segments` are member created portions of a road where users can compete for time. A run can have `SegmentEfforts` on `Segments` where a segment effort will indicate how long it took to complete that segment. Each run also has 'best efforts' where Strava indicates a predicted time for different distances (e.g. 1km, 1 mile, 2 miles, 5km etc) In the graph model we'll create `DistanceEffort` nodes for each run and a `Distance` node to represent each distance. This is what our graph should look like. This diagram was created using http://www.apcjones.com/arrows/#[Alistair Jones' Arrows tool^] in case you want to create your own. image::{{<siteurl>}}/uploads/2018/06/strava-graph.svg[] == Create constraints Before we import any data we'll set up some constraints so we don't end up with duplicate nodes. When we create a constraint on a `(label, property)` pair an index is also created so it'll help speed up the import process as well. [source, cypher] ---- CREATE CONSTRAINT ON (d:Distance) ASSERT d.name is UNIQUE; CREATE CONSTRAINT ON (r:Run) ASSERT r.id is UNIQUE; CREATE CONSTRAINT ON (d:DistanceEffort) ASSERT d.id is UNIQUE; CREATE CONSTRAINT ON (s:SegmentEffort) ASSERT s.id is UNIQUE; CREATE CONSTRAINT ON (s:Segment) ASSERT s.id is UNIQUE; ---- == Importing data First we'll create a parameter that contains our Strava token for interacting with their API. You can generate a token via the https://www.strava.com/settings/api['Create and Manage Your App'^] page. [source, cypher] ---- :param stravaToken => "Bearer <strava-token>"; ---- Now we're ready to import some data! The data we want to import comes from several different API endpoints, but we'll start with the `Run` nodes. We can get these from the http://developers.strava.com/docs/reference/#api-Activities-getLoggedInAthleteActivities[List Athlete Activities^] part of the API. This is a sample of what the response from that endpoint looks like: [source, json] ---- [ { "name": "Morning Run", "distance": 3465.8, "moving_time": 1375, "elapsed_time": 1420, "total_elevation_gain": 0, "type": "Run", "id": 214959724, "start_date": "2014-11-03T06:15:07Z", "start_date_local": "2014-11-03T06:15:07Z", "timezone": "(GMT+00:00) Europe/London", "utc_offset": 0, "average_speed": 2.521, "max_speed": 6.9, "has_heartrate": false, "elev_high": 10, "elev_low": 6, }, ] ---- We will use the `apoc.load.jsonParams` procedure from the https://neo4j-contrib.github.io/neo4j-apoc-procedures/[APOC^] library to help us import this data. My colleague Jennifer Reif has https://medium.com/neo4j/explore-new-worlds-adding-plugins-to-neo4j-26e6a8e5d37e[written a blog post^] explaining how to install APOC and other plugins so check that out if you haven't used APOC yet. If we want to load the first 30 activities we could write the following query: [source, cypher] ---- WITH 'https://www.strava.com/api/v3/athlete/activities' AS uri CALL apoc.load.jsonParams(uri, {Authorization: $stravaToken}, null) YIELD value MERGE (run:Run {id: value.id}) SET run.distance = toFloat(value.distance), run.startDate = datetime(value.start_date_local), run.elapsedTime = duration({seconds: value.elapsed_time}), run.movingTime = duration({seconds: value.moving_time}), run.name = value.name, run.totalElevationGain = toInteger(value.total_elevation_gain), run.elevationHigh = toFloat(value.elev_high), run.elevationLow = toFloat(value.elev_low), run.averageSpeed = toFloat(value.average_speed), run.maximumSpeed = toFloat(value.max_speed) ---- We store the date using the new DateTime data type introduced in Neo4j 3.4 and the moving and elapsed times using the Duration data type. We could increase the number of activities from 30 to a maximum of 200 by setting the `per_page` parameter, but I have more activities than that so we're going to need to do some pagination. Luckily this API endpoint lets us pass in an `after` parameter which defines `An epoch timestamp to use for filtering activities that have taken place after a certain time`. We'll use this to help us paginate through the API and get all our activities since there are more of those than will be returned by one API call. As I explained in https://markhneedham.com/blog/2018/06/05/neo4j-apoc-loading-data-strava-paginated-json-api/[my previous post^], it took me a while to figure out how to handle the pagination using only APOC, but I eventually realised that the `apoc.periodic.commit` procedure would do the trick. The following query will import all our runs: [source, cypher] ---- CALL apoc.periodic.commit(" OPTIONAL MATCH (run:Run) WITH run ORDER BY run.startDate DESC LIMIT 1 WITH coalesce(run.startDate.epochSeconds, 0) AS after WITH 'https://www.strava.com/api/v3/athlete/activities?after=' + after AS uri CALL apoc.load.jsonParams(uri, {Authorization: $stravaToken}, null) YIELD value MERGE (run:Run {id: value.id}) SET run.distance = toFloat(value.distance), run.startDate = datetime(value.start_date_local), run.elapsedTime = duration({seconds: value.elapsed_time}), run.movingTime = duration({seconds: value.moving_time}), run.name = value.name, run.totalElevationGain = toInteger(value.total_elevation_gain), run.elevationHigh = toFloat(value.elev_high), run.elevationLow = toFloat(value.elev_low), run.averageSpeed = toFloat(value.average_speed), run.maximumSpeed = toFloat(value.max_speed) RETURN CASE WHEN count(*) < 30 THEN 0 ELSE count(*) END AS count ", {stravaToken: $stravaToken}); ---- Now we need to import the distance and segment efforts for each run. This data is available via the http://developers.strava.com/docs/reference/#api-Activities-getActivityById[Get Activity^] endpoint, and we can use the `apoc.periodic.iterate` procedure to help iterate through all our runs. This is a sample of what the response from that endpoint looks like: [source, json] ---- { "name": "Morning Run", "distance": 10884.9, "moving_time": 2918, "elapsed_time": 2918, "total_elevation_gain": 107, "type": "Run", "workout_type": 0, "id": 1620188065, "start_date": "2018-06-06T04:18:47Z", "start_date_local": "2018-06-06T05:18:47Z", "timezone": "(GMT+00:00) Europe/London", "utc_offset": 3600, "calories": 862.6, "segment_efforts": [ { "id": 40571736882, "resource_state": 2, "name": "Stanley to Bridge", "elapsed_time": 82, "moving_time": 82, "start_date": "2018-06-06T04:19:04Z", "start_date_local": "2018-06-06T05:19:04Z", "distance": 322, "segment": { "id": 17875143, "resource_state": 2, "name": "Stanley to Bridge", "activity_type": "Run", "distance": 322, "average_grade": 0, "maximum_grade": 2.9, "elevation_high": 71, "elevation_low": 69, "climb_category": 0, }, }, ], "best_efforts": [ { "id": 3497998232, "resource_state": 2, "name": "400m", "elapsed_time": 92, "moving_time": 93, "start_date": "2018-06-06T05:02:29Z", "start_date_local": "2018-06-06T06:02:29Z", "distance": 400, "start_index": 2494, "end_index": 2586, "pr_rank": null, "achievements": [] }, { "id": 3497998233, "resource_state": 2, "name": "1/2 mile", "elapsed_time": 190, "moving_time": 191, "start_date": "2018-06-06T05:01:23Z", "start_date_local": "2018-06-06T06:01:23Z", "distance": 805, "start_index": 2431, "end_index": 2618, "pr_rank": 1, }, ], } ---- The following query imports this data into our graph: [source, cypher] ---- CALL apoc.periodic.iterate( "MATCH (run:Run) RETURN run", "WITH run, 'https://www.strava.com/api/v3/activities/' + run.id + '?include_all_efforts=true' AS uri CALL apoc.load.jsonParams(uri,{Authorization:$stravaToken},null) YIELD value WITH run, value UNWIND value.best_efforts AS bestEffort MERGE (distance:Distance {name: bestEffort.name}) ON CREATE SET distance.distance = toFloat(bestEffort.distance) MERGE (effort:DistanceEffort {id: bestEffort.id}) ON CREATE SET effort.elapsedTime = duration({seconds: bestEffort.elapsed_time}), effort.movingTime = duration({seconds: bestEffort.moving_time}) MERGE (effort)-[:DISTANCE]->(distance) MERGE (run)-[:DISTANCE_EFFORT]->(effort) WITH run, value, count(*) AS count UNWIND value.segment_efforts AS segmentEffort MERGE (segment:Segment {id: segmentEffort.segment.id}) ON CREATE SET segment.name = segmentEffort.segment.name, segment.distance = toFloat(segmentEffort.segment.distance) MERGE (effort:SegmentEffort {id: segmentEffort.id}) ON CREATE SET effort.elapsedTime = duration({seconds: segmentEffort.elapsed_time}), effort.movingTime = duration({seconds: segmentEffort.moving_time}) MERGE (effort)-[:SEGMENT]->(segment) MERGE (run)-[:SEGMENT_EFFORT]->(effort)", {batchSize: 10, parallel:false, params: {stravaToken: $stravaToken}}); ---- We already have our `Run` nodes created so we iterate through those and call the API endpoint one time for each run. We then use the `UNWIND` clause to process the arrays contained in the JSON response for `best_efforts` and `segment_efforts` and connect those to the `Run` node. That's the main structure of the graph, but I also wanted to import some more detail about the segments which was available from the http://developers.strava.com/docs/reference/#api-Segments-getSegmentById[Get Segment^] endpoint. [source, cypher] ---- CALL apoc.periodic.iterate( "MATCH (segment:Segment) RETURN segment", "WITH segment, 'https://www.strava.com/api/v3/segments/' + segment.id AS uri CALL apoc.load.jsonParams(uri,{Authorization:$stravaToken},null) YIELD value WITH segment, value SET segment.averageGrade = toFloat(value.average_grade), segment.maximumGrade = toFloat(value.maximum_grade), segment.totalElevationGain = toFloat(value.total_elevation_gain), segment.elevationHigh = toFloat(value.elevation_high), segment.elevationLow = toFloat(value.elevation_low) ", {batchSize: 10, parallel:false, params: {stravaToken: $stravaToken}}); ---- == What have we imported? Now that we've got the data imported let's write a few queries to check how much data we've imported. == How many runs are there? [source, cypher] ---- MATCH (:Run) RETURN count(*) ---- [source, text] ---- ╒══════════╕ │"count(*)"│ ╞══════════╡ │604 │ └──────────┘ ---- == How many segments? [source, cypher] ---- MATCH (:Segment) RETURN count(*) ---- [source, text] ---- ╒══════════╕ │"count(*)"│ ╞══════════╡ │382 │ └──────────┘ ---- == How many efforts on those segments? [source, cypher] ---- MATCH (:SegmentEffort) RETURN count(*) ---- [source, text] ---- ╒══════════╕ │"count(*)"│ ╞══════════╡ │2913 │ └──────────┘ ---- == Which segment has the most efforts? [source, cypher] ---- MATCH (segment:Segment) RETURN segment.name AS segment, size((segment)<-[:SEGMENT]-()) AS efforts ORDER BY efforts DESC LIMIT 5 ---- [source, text] ---- ╒══════════════════════╤═════════╕ │"segment" │"efforts"│ ╞══════════════════════╪═════════╡ │"Lap of the track" │348 │ ├──────────────────────┼─────────┤ │"York to Vet" │201 │ ├──────────────────────┼─────────┤ │"Stanley to Bridge" │158 │ ├──────────────────────┼─────────┤ │"Bridge Road (down)" │83 │ ├──────────────────────┼─────────┤ │"Overton to Beresford"│67 │ └──────────────────────┴─────────┘ ---- These are just a few exploratory queries we can do on this dataset. In my next post I'll show how to query some more complex patterns.

Learn how to paginate through JSON APIs and load the data into Neo4j using only APOC's Load JSON procedure.

neo4j-building-strava-graph

https://markhneedham.com/blog/2018/06/12/neo4j-building-strava-graph

2018-12-21 16:57:00

Pandas: Create matplotlib plot with x-axis label not index

I've been using matplotlib a bit recently, and wanted to share a lesson I learnt about choosing the label of the x-axis. Let's first import the libraries we'll use in this post: [source, python] ---- import pandas as pd import matplotlib.pyplot as plt ---- And now we'll create a DataFrame of values that we want to chart: [source,python] ---- df = pd.DataFrame({ "name": ["Mark", "Arya", "Praveena"], "age": [34, 1, 31] }) df ---- This is what our DataFrame looks like: [source, text] ---- name age 0 Mark 34 1 Arya 31 2 Praveena 1 ---- [source, python] ---- df.plot.bar() plt.tight_layout() plt.show() ---- If we run that code we'll see this chart: image::{{<siteurl>}}/uploads/2018/12/start.svg[] The chart itself looks fine, but the labels of the values on the x-axis are a bit weird. They're 1, 2, and 3, whereas we want them to use the values in the `name` column of our DataFrame. I was a bit confused at first, but eventually realised that they were the index values of our rows. We can see that by executing the following code: [source, python] ---- >>> df.index.values array([0, 1, 2]) ---- There are a couple of ways that we can fix our chart. The first is to use the `name` column as our index, an approach I learnt from https://www.dataquest.io/blog/adding-axis-labels-to-plots-with-pandas-and-matplotlib/[Josh Devlin's blog post]. We can reset the index by running the following code: [source, python] ---- df.set_index("name",drop=True,inplace=True) ---- Let's check the index values: [source, python] ---- >>> df.index.values array(['Mark', 'Arya', 'Praveena'], dtype=object) ---- Ah, much better! Now we can plot our chart again: [source, pythong] ---- df.plot.bar() plt.tight_layout() plt.show() ---- If we run that code we'll see this chart: image::{{<siteurl>}}/uploads/2018/12/next.svg[] That's much better! We can also achieve the same outcome by specifying the `x` parameter when we call the `bar` function: [source, python] ---- df = pd.DataFrame({ "name": ["Mark", "Arya", "Praveena"], "age": [34, 1, 31] }) df.plot.bar(x="name") plt.tight_layout() plt.show() ----

Learn how to set the x-axis label of a matplotxlib plot

pandas-plot-x-axis-index

https://markhneedham.com/blog/2018/12/21/pandas-plot-x-axis-index

2018-12-09 10:25:00

PySpark: Creating DataFrame with one column - TypeError: Can not infer schema for type: <type 'int'>

I've been playing with PySpark recently, and wanted to create a DataFrame containing only one column. I tried to do this by writing the following code: [source, python] ---- spark.createDataFrame([(1)], ["count"]) ---- If we run that code we'll get the following error message: [source, bash] ---- Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/home/markhneedham/projects/graph-algorithms/spark-2.4.0-bin-hadoop2.7/python/pyspark/sql/session.py", line 748, in createDataFrame rdd, schema = self._createFromLocal(map(prepare, data), schema) File "/home/markhneedham/projects/graph-algorithms/spark-2.4.0-bin-hadoop2.7/python/pyspark/sql/session.py", line 416, in _createFromLocal struct = self._inferSchemaFromList(data, names=schema) File "/home/markhneedham/projects/graph-algorithms/spark-2.4.0-bin-hadoop2.7/python/pyspark/sql/session.py", line 348, in _inferSchemaFromList schema = reduce(_merge_type, (_infer_schema(row, names) for row in data)) File "/home/markhneedham/projects/graph-algorithms/spark-2.4.0-bin-hadoop2.7/python/pyspark/sql/session.py", line 348, in <genexpr> schema = reduce(_merge_type, (_infer_schema(row, names) for row in data)) File "/home/markhneedham/projects/graph-algorithms/spark-2.4.0-bin-hadoop2.7/python/pyspark/sql/types.py", line 1062, in _infer_schema raise TypeError("Can not infer schema for type: %s" % type(row)) TypeError: Can not infer schema for type: <type 'int'> ---- The problem we have is that `createDataFrame` http://sqlblog.com/blogs/jamie_thomson/archive/2016/12/12/creating-a-spark-dataframe-containing-only-one-column.aspx[expects a tuple of values^], and we've given it an integer. Luckily we can fix this reasonably easily by passing in a single item tuple: [source, python] ---- spark.createDataFrame([(1,)], ["count"]) ---- If we run that code we'll get the expected DataFrame: [options="header"] |======= |count |1 |=======

Learn how to create a PySpark DataFrame with one column.

pyspark-creating-dataframe-one-column

https://markhneedham.com/blog/2018/12/09/pyspark-creating-dataframe-one-column

2018-12-24 21:09:00

Neo4j: Pruning transaction logs more aggressively

One thing that new users of Neo4j when playing around with it locally is how much space the transaction logs can take up, especially when we're creating and deleting lots of data while we get started. We can see this by running the following query a few times: [source, cypher] ---- UNWIND range(0, 1000) AS id CREATE (:Foo {id: id}); MATCH (f:Foo) DELETE f ---- This query creates a bunch of data before immediately deleting it. We can now run the following command to see the state of the database: [source, cypher] ---- :sysinfo ---- We'll see this table: image::{{<siteurl>}}/uploads/2018/12/Selection_091.png[] Most of the space is taken up by `Logical Log`, which is the aggregate size of Neo4j's transaction logs. These are the files in our `data/databases/graph.db` field that have the `neostore.transaction.db` prefix: [source, bash] ---- $ ls -alh data/databases/graph.db/neostore.transaction.db* -rw-rw-r-- 1 markhneedham markhneedham 1.3M Dec 22 19:17 data/databases/graph.db/neostore.transaction.db.30 -rw-rw-r-- 1 markhneedham markhneedham 1.3M Dec 22 19:17 data/databases/graph.db/neostore.transaction.db.31 -rw-rw-r-- 1 markhneedham markhneedham 145M Dec 24 21:31 data/databases/graph.db/neostore.transaction.db.32 ---- Our latest log file is more than 100MB, and we might wonder why we need to keep around all those logs! We can run the following procedures to see the default config for checkpointing and transaction log pruning, which work together to control how many logs are kept around: [source, cypher] ---- CALL dbms.listConfig("dbms.checkpoint.interval") YIELD name, description, value RETURN name, description, value UNION CALL dbms.listConfig("dbms.tx_log") YIELD name, description, value RETURN name, description, value ---- If we run that procedure we'll see this output: image::{{<siteurl>}}/uploads/2018/12/Selection_090.png[] In summary: * Checkpointing is done every 900 seconds (15 minutes) * Checkpointing is done every 100,000 transactions * Transaction logs are kept for 7 days * Transaction log files are rotated when they reach 262,144,000 bytes (250MB) These defaults are not a bad place to start for a production system, but we probably don't need to keep around so many logs when we're playing around with Neo4j locally. Chris Gioran has https://neo4j.com/developer/kb/checkpointing-and-log-pruning-interactions/[written an excellent article^] explaining these config options in more detail. From the article I came up with the following config, which I think makes more sense when working locally: [source, text] ---- dbms.checkpoint.interval.time=30s dbms.checkpoint.interval.tx=1 dbms.tx_log.rotation.retention_policy=false dbms.tx_log.rotation.size=1M ---- So now: * Checkpointing is done every 30 seconds * Checkpointing is done every 1 transactions * Minimal transaction logs are kept around * Transaction log files are rotated when they reach 1MB If we run our first query again a few times while tailing `logs/debug.log` we'll see the following output: [source, bash] ---- 2018-12-24 21:43:20.132+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 56 checkpoint started... 2018-12-24 21:43:20.589+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 56 checkpoint completed in 457ms 2018-12-24 21:43:20.592+0000 INFO [o.n.k.i.t.l.p.LogPruningImpl] Pruned log versions 30-31, last checkpoint was made in version 33 2018-12-24 21:43:30.593+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 57 checkpoint started... 2018-12-24 21:43:30.716+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 57 checkpoint completed in 122ms 2018-12-24 21:43:30.736+0000 INFO [o.n.k.i.t.l.p.LogPruningImpl] Pruned log versions 32-32, last checkpoint was made in version 34 2018-12-24 21:43:40.737+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 65 checkpoint started... 2018-12-24 21:43:40.982+0000 INFO [o.n.k.i.t.l.c.CheckPointerImpl] Checkpoint triggered by scheduler for tx count threshold @ txId: 65 checkpoint completed in 245ms 2018-12-24 21:43:40.995+0000 INFO [o.n.k.i.t.l.p.LogPruningImpl] Pruned log versions 33-40, last checkpoint was made in version 42 ---- We can see that logs are now being pruned much more aggressively, and if we run `:sysinfo` again we'll see that the size of logical logs is now much less: image::{{<siteurl>}}/uploads/2018/12/Selection_092.png[] That's much better!

Learn how to prune Neo4j transaction log files more aggressively.

neo4j-prune-transaction-logs-more-aggressively

https://markhneedham.com/blog/2018/12/24/neo4j-prune-transaction-logs-more-aggressively

2018-12-25 21:09:00

Python: Pandas - DataFrame plotting ignoring figure

In my continued use of matplotlib I wanted to change the size of the chart I was plotting and struggled a bit to start with. We'll use the same DataFrame as before: [source,python] ---- df = pd.DataFrame({ "name": ["Mark", "Arya", "Praveena"], "age": [34, 1, 31] }) df ---- In my last blog post I showed how we can create a bar chart by executing the following code: [source,python] ---- df.plot.bar(x="name") plt.tight_layout() plt.show() plt.close() ---- But how do we make it bigger? We can control this https://stackoverflow.com/questions/332289/how-do-you-change-the-size-of-figures-drawn-with-matplotlib[by using^] the https://matplotlib.org/api/_as_gen/matplotlib.pyplot.figure.html#matplotlib.pyplot.figure[`figure`^] function. I gave this a try: [source,python] ---- plt.figure(figsize=(20,10)) df.plot.bar(x="name") plt.tight_layout() plt.show() plt.close() ---- If we run that we'll see this output: image::{{<siteurl>}}/uploads/2018/12/Selection_093.png[] Hmmmm...we now have two figures, and the bigger one is completely blank! That's not quite what we expected. I came across a https://stackoverflow.com/questions/42215252/inconsistency-when-setting-figure-size-using-pandas-plot-method/42216385#42216385[really thorough StackOverflow post^] which explained a variety of ways to solve the problem. The first way is to specify the `figsize` parameter when we call the `bar` function: [source,python] ---- df.plot.bar(x="name", figsize=(20,10)) plt.tight_layout() plt.show() plt.close() ---- If we execute that code we'll now have our big chart: image::{{<siteurl>}}/uploads/2018/12/big.svg[] There are another couple of ways we can achieve this as well. The `plot` function takes in a `ax` parameter, to which we can pass an existing Axes. The `gca` function on our plot returns the current Axes instance or creates a new one: [source,python] ---- plt.figure(figsize=(20,10)) df.plot.bar(x="name", ax=plt.gca()) plt.tight_layout() plt.show() plt.close() ---- Or rather than using the `gca` function on `plt`, we can capture the axes from the `figure` function and pass it in directly: [source,python] ---- fig = plt.figure(figsize=(20,10)) df.plot.bar(x="name", ax=fig.gca()) plt.tight_layout() plt.show() plt.close() ----

Learn how to plot a Pandas DataFrame onto a custom sized chart.

python-pandas-dataframe-plot-figure

https://markhneedham.com/blog/2018/12/25/python-pandas-dataframe-plot-figure

2011-03-04 02:49:59

TWU: Session Design - Measurable goals

We've been spending our time recently preparing the sessions for the next ThoughtWorks University batch and one thing http://www.learninggeneralist.com/[Sumeet] has encouraged us to do is ensure that we have a *measurable goal for each session*. In our case that means that we need to design our sessions with the intention of the grads being able to do something rather than understand something after the session. It's very difficult to measure whether someone understands something and from what I've noticed having a goal of someone understanding something can encourage you to put in more than is strictly necessary. Sumeet pointed us to Cathy Moore's http://blog.cathy-moore.com/2008/05/be-an-elearning-action-hero/[action mapping] which talks about the need to create some sort of action from the learning opportunity that we're providing. She also talks about the need to avoid http://www.markhneedham.com/blog/2010/10/31/distributed-agile-context/[brain dumping] and I've noticed that I have a tendency to do this if my goal is for someone to 'understand topic x'. I've found it quite difficult to work out how much information and context we should be providing but our current thinking is that providing just enough to allow the grads to work on http://www.sukrupa.org/[their project] while encouraging them to seek out more information when they need it will be the most effective approach. On a somewhat related note, after a recommendation by my colleague http://jimbarritt.com/non-random/[Jim Barritt] I've been reading through Gerald Weinburg's 'http://www.amazon.com/Becoming-a-Technical-Leader-ebook/dp/B004J4VV3I/ref=sr_1_2?ie=UTF8&m=AG56TWVU5XWC2&s=books&qid=1299125329&sr=8-2[Becoming a Technical Leader]' and I quite like Weinburg's advice around this: ____ When I write a book or an essay or a novel, or give a workshop, I measure my success by one simple test: _When I'm finished with them, do they care less about the subject?_ If the answer if yes, I've failed. ____ I'm not sure how measurable this one is but it certainly encourages you not to make the session boring!

twu-session-design-measurable-goals

https://markhneedham.com/blog/2011/03/04/twu-session-design-measurable-goals

2011-03-20 18:36:42

Retrospectives: Mini Group Discussions

One of the approaches that I like the best in retrospectives is when the facilitator splits the team into smaller groups during the brainstorming part of the retrospective. I decided to try this out in a retrospective we ran after one week of ThoughtWorks University, using http://www.thekua.com/rant/2006/03/the-retrospective-starfish/[The Retrospective Starfish] to provide a framework in which people could frame their thoughts. Usually what I've seen happen in these mini groups is that everyone will write down their own ideas on stickies and then discuss them as a group but still put up all the stickies even if the group didn't agree with everything. http://twitter.com/frankmt[Frankie] observed that in this retrospective that hadn't really happened and the mini groups had been reaching a consensus on their ideas before one or two people went and put them up on the wall. I think this partly came down to my failure to explain the intent of the exercise clearly i.e. *it is a brainstorming exercise rather than an analytical one*. An interesting side effect was that when people came and looked at the wall to see what the other groups had come up with they noticed quite a few things that they agreed with but hadn't come up with in their group. I think next time I'll try and explain the exercise a bit more clearly to help keep people in the mindset of coming up with ideas. It's difficult to say if any important points were missed by people analysing so early but there was certainly less duplication of ideas than normal!

retrospectives-mini-group-discussions

https://markhneedham.com/blog/2011/03/20/retrospectives-mini-group-discussions

2011-03-20 18:08:35

Confirmation Bias and Loss of Autonomy

I've mentioned confirmation bias http://www.markhneedham.com/blog/2010/07/22/the-prepared-mind-vs-having-context-when-learning-new-ideas/[in] http://www.markhneedham.com/blog/2009/08/12/zen-mind-beginners-mind-book-review/[a few] http://www.markhneedham.com/blog/2009/12/24/debug-it-book-review/[of my previous blog posts] but I hadn't realised quite how widespread it can be in organisations until quite recently. _Confirmation bias_ ____ [A] tendency for people to favor information that confirms their preconceptions or hypotheses regardless of whether the information is true. As a result, people gather evidence and recall information from memory selectively, and interpret it in a biased way. The biases appear in particular for emotionally significant issues and for established beliefs. ____ I've noticed that it is particularly prevalent in organisations when people feel that they are being told what to do i.e. people feel they don't have autonomy. http://www.youtube.com/watch?v=u6XAPnuFjJc[Dan Pink] talks about autonomy as being one of the 3 things that lead to better performance and personal satisfaction. _Autonomy_ ____ immunity from arbitrary exercise of authority ____ One example could be if an organisation were to force a certain way of working on their employees without getting their input on it beforehand. It's highly likely the employees will start looking for reasons why the new way of working is worse than what they have. Even if the management can very logically explain why it's better they're unlikely to make much headway because *people will only see information which confirms their view that the old way is better*. http://twitter.com/zaynilee[Zaynab] pointed out that a useful technique to avoid confirmation bias is to look at what you were trying to achieve in old way and see how you would do that with the new way. That way you lose nothing! I think this approach only really works once the http://stevenmsmith.com/ar-satir-change-model/[emotions of the change] have calmed down a bit though. Equally the management may be prone to confirmation bias since they have bought into the fact that the new way is better and may dismiss potentially valid feedback because it doesn't fit with their belief system of how things should be. I feel like confirmation bias is quite a natural human reaction to a situation like this so it's useful to be aware of it if you're having something forced onto you but also if you're in a position of instigating some sort of organisational change.

confirmation-bias-and-loss-of-autonomy

https://markhneedham.com/blog/2011/03/20/confirmation-bias-and-loss-of-autonomy

2011-03-29 18:32:14

ThoughtWorks University: Pulling the 'pearls'

I recently wrote about the http://www.markhneedham.com/blog/2011/03/29/thoughtworks-university-coding-dojo-style/[coding dojo style week that we ran at ThoughtWorks University last week] and I briefly mentioned that we used break out sessions to cover topics ('the pearls') that people didn't totally understand. To describe that in more detail what we did to start with was write the name of each of the 90/180 minute sessions on a card and put it on the wall under a 'To Do' heading:+++<div align="center">+++image::{{<siteurl>}}/uploads/2011/03/twu-topics-todo.jpg[Twu topics todo,271] image::{{<siteurl>}}/uploads/2011/03/twu-topics-done.jpg[Twu topics done,271]+++</div>+++ There were about 10 of those topics and our goal was to cut each of those topics down to a 20 minute introduction that one of the trainers could give when it seemed like a good time. For example we did a brief introduction to 'Build and Deployment' when we first talked about continuous integration and we went through the application architecture just before we started coding our first story. Our goal with this approach was to *encourage a pull based approach to learning over a push based one* where we just presented on different topics without giving the grads a chance to properly see if they understood the topic. The reason that we did such short presentations is that we didn't feel you can learn that much from a presenation so we wanted to give just enough information that the grads would be able to go and explore the topic more on their own. To push this further we asked the grads to add any other topics they wanted us to talk about to the board so that we could cover those when we got the chance. While we were doing these introductory presentations http://twitter.com/frankmt[Frankie] and http://twitter.com/jimbarritt[Jim] came up with the idea of asking the grads to rate themselves 1-5 on their current understanding of the topic and to also give a time limit for the presentation. We repeated the rating afterwards to see if the introduction had actually been useful and then spent time discussing the topic further if necessary. This approach worked pretty well for helping avoid the http://www.markhneedham.com/blog/2011/03/23/twu-brain-dumping/[brain dumping] that I wrote about last week and the rating system has helped give us an idea of which topics are considered more difficult by the group. Hopefully within the next few weeks we'll start to see the grads running their own sessions which will http://www.markhneedham.com/blog/2009/04/21/learning-through-teaching/[take their learning even further].

thoughtworks-university-pulling-the-pearls

https://markhneedham.com/blog/2011/03/29/thoughtworks-university-pulling-the-pearls

2011-03-29 17:25:20

The working long hours culture

One of the aspects of software development that I've thankfully seen relatively infrequently over the last few years is that of some people in teams working long hours on a consistent basis. I have seen it happen on a few occasions and I think it can have a detrimental effect on a team rather than the good which is presumably intended. The biggest disadvantage is that it makes other people in the team feel guilty that they aren't working long hours and they may feel peer pressured into matching the hours of their colleagues. In a conversation with http://www.learninggeneralist.com[Sumeet] about work/life balance he pointed out that if you really enjoy what you do for work then you don't necessarily see a clear distinction between the two and it wouldn't be a big deal to work for 10+ hours a day. While I understand this point of view I think in a team environment it's very easy to start believing that you're more important to a team because you put in more hours. It's then very easy to stop valuing the contributions of your colleagues or considering their opinions less important since they *only* worked a standard work day. *Someone isn't necessarily not committed to something because they don't spend their whole life doing it*. Another aspect to this which is easy to overlook is that the people working these long hours might not actually be working in a particularly effective way. If I spend most of the day getting distracted/procrastinating and end up 'working' for 12 hours then I may actually end up being just as productive as someone who works only 8 hours but is much more focused during that time. Even if we assume that someone is productive for 12 hours a day it still isn't necessarily great because they'll end up being the only one who knows the code that they write when everyone else has gone home. When I was in Pune one of the other teams in the office had a mandated finish time of 6.30 and it actually seemed to help people remain focused during their time in the office because they knew they wouldn't be able to work after that time. I'm not necessarily a fan of setting rules of what people can/should be allowed to do but in that case it seemed to work reasonably well.

the-working-long-hours-culture

https://markhneedham.com/blog/2011/03/29/the-working-long-hours-culture

2011-03-29 17:15:48

ThoughtWorks University: Coding Dojo Style

One of the things that link:[Sumeet] has been encouraging at ThoughtWorks University is the idea that the 'trainers' should be in http://www.learninggeneralist.com/2010/05/changing-our-trainer-mindsets.html[a coaching role rather than a training one]. As a result of this suggestion one of the things we've done is to change http://www.learninggeneralist.com/2010/08/thoughtworks-university-story-of-our.html[the style of the second week] so that it wasn't full of sessions/workshops but instead involved working on code as a group. http://twitter.com/jimbarritt[Jim] came up with the idea of the 'exploded story' whereby we spent the whole of last week as a group working on one story for http://www.sukrupa.org[Sukrupa] while spending quite a bit of time exploring the different activities that playing a story end to end would involve. We did this by making use of two types of coding dojos: * *Randori* - two people at the keyboard and the rest of the group watching and contributing ideas about what could be done next. * *Kake* - one computer per pair but everyone is working on the same problem == Randori We began last week with a http://codingdojo.org/cgi-bin/wiki.pl?RandoriKata[Randori dojo] where initially two of the trainers paired while implementing a story to add improved search functionality to the sukrupa admin application. image::{{<siteurl>}}/uploads/2011/03/twu-code.jpg[Twu code,258] We rotated one of the pair every 5 minutes, initially making sure that there was always a trainer at the keyboard but we quickly changed that so that it was mostly the grads driving the implementation. The cool thing about using the randori dojo like this was that we were able to code as a group and people were able to get a rough feel for the strengths of their colleagues and see any areas they might be able to improve on. We were also easily able to see where people were struggling so that we could break out and do a quick session on a topic if necessary. One disadvantage of this style is that it does put people under a bit of pressure because everyone is seeing the code they're writing so I'm not sure that it necessarily provides the best learning environment. We did the randori dojo for a few mornings while doing a kake dojo in the afternoon before deciding as a group that it would be more beneficial to do a http://www.dtsato.com/blog/2008/10/29/uberdojo-sao-paulo-coding-dojo/[kake dojo] for the whole day. == Kake image::{{<siteurl>}}/uploads/2011/03/twu-dojo.jpg[Twu dojo] We initially ran the kake dojo with 10 minute iterations after which we would discuss how everyone was doing and whether there were any learnings to share. We pair rotated every other iteration and eventually increased the iteration time to 30 minutes so that we'd have more time to solve some of the more difficult problems. It was getting really irritating being interrupted every 10 minutes at times! A few times a day we went around the room to each machine and the pair was able to describe the code they'd written and the approach they'd taken. We'd then choose as a group which code we wanted to push to the github repository as a baseline and then continue working from there. I quite enjoyed working in this style and it worked fairly well until we got towards the end of the story and the code that each pair was writing was pretty much identical. At that stage we switched back to a 30 minute randori dojo before the week was complete!

thoughtworks-university-coding-dojo-style

https://markhneedham.com/blog/2011/03/29/thoughtworks-university-coding-dojo-style

2011-03-17 06:52:37

Pair Presenting

Over the last year or so I've had some opportunities to pair with a few different people on sessions/presentations that we've been giving. I much prefer doing this than presenting something by myself mainly because it's much more fun and seems to encourage more participation than when I do something alone. I feel that it's probably easier to pair present if you both have similar opinions on the subject matter and are comfortable with a similar style of delivery. For example http://twitter.com/#!/frankmt[Frankie] and I have run a couple of sessions at ThoughtWorks University and beforehand we've created a rough outline of how we expect the session to play out. Once we've started though both of us are quite comfortable with changing it while we're going if that will make the session better whereas others might prefer more to the pre planned structure. Having another person there can allow you to approach a topic in a way that is quite difficult to do alone. About a year ago I did a talk about http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming[Functional Programming in C#] with http://twitter.com/#!/Mikewagg[Mike Wagg] and we were able to play different roles to demonstrate certain points. He played the guy who's predominantly in favour of OO programming but is interested in learning about functional programming while I played the guy who loves functional programming and wants to use it everywhere. It seemed to work reasonably well. A variation on this which http://www.learninggeneralist.com/[Sumeet] and I tried is to have one person leading the session and the other recording any questions that need to be answered later on or create a mindmap of what's being covered in the session. One of the dangers of pair presenting is that you can end up just having a conversation with the other person rather than talking to the audience but I think this is something that can be overcome with practice. Preparation also becomes more difficult because you need to do at least some of it together so you both know what's going to happen in the session. I think that's outweighed by the other benefits I see from pairing though.

pair-presenting

https://markhneedham.com/blog/2011/03/17/pair-presenting

2011-03-09 14:42:41

TWU: Session Preparation - Limited WIP

I've spent a fair percentage of the last couple of weeks preparing sessions for ThoughtWorks University and one thing http://twitter.com/#!/frankmt[Frankie] has been trying to encourage is only preparing one at a time i.e. limited work in progress Normally I'd be completely in favour of that approach but it doesn't seem to work at all for me with this type of work. There seem to be a few parts to creating a session, including: * Plan out how you want the structure of the session to be * Write up any presentation aspects of it The first can pretty much be stream lined so that you're doing one of them at a time but I find the latter to be a much more creative process and I don't do that work in a linear way at all. I've noticed over the last couple of years that I prepare presentations in a very stop/start way. I really struggle to create them in one go. I'll create a rough outline and then add to it randomly after that. It seems to work reasonably well and I'll come up with ideas that improve the presentation at random different times when I'm not even working on the presentation. Presumably this is because I'm thinking about the presentation subconsciously which is one way of being creative (to a degree). I'm curious as to whether I could get a similar effect by stimulating creativity by using http://www.pomodorotechnique.com/[time as a constraint]. Something to try out at least...

twu-session-preparation-limited-wip

https://markhneedham.com/blog/2011/03/09/twu-session-preparation-limited-wip

2011-03-30 20:34:32

ThoughtWorks University: The use of games

When I attended ThoughtWorks University in August 2006 we spent quite a bit of time playing games which had been designed to help us to achieve various learning objectives. At the time I didn't think much about it but now being on the other side as a trainer I've started to doubt whether these types of sessions are as useful as I originally thought. I recently came across http://www.learninggeneralist.com/2010/08/think-workscapes-not-training.html[a blog post Sumeet wrote last year where he talks about effective e-learning environments] and I think his point still applies here: ____ The really effective elearning is where people actually practice real-world tasks, but we have little time for that post our fascination with card games and flashy animations. ____ == The Agile Lego Game I was pondering this a couple of weeks ago when we ran the http://agile2009.agilealliance.org/node/476/[agile lego game]. Interestingly the feedback that we got from the participants of this session was that they really enjoyed the games part of the sessions. My current thinking is that the feedback may have been more indicative of the fun that people had rather than the learning gained. The problem I see is that people do know it's a somewhat contrived situation and may therefore have difficulty relating it to a real life problem that they face later on. For example in the agile lego game</a> I acted as a customer with the instructions to be very picky/particular about what I actually wanted so that the team would communicate with me more frequently. The idea was to try and simulate a real life customer and to allow the participants to see the value of collaborating with the customer frequently. I found this part of the role really difficult as I knew how much I would hate to be on the other side facing someone acting like that. On the other hand we did encounter the same types of problems that can happen on real projects: * Making assumptions about what the customer wanted * Not speaking to the customer and just building something * Miscalculating how long it would take to build something and spending ages doing it * 'Committing' to way more points than could ever be done Despite seeing people learn those lessons and not committing the same mistakes in the next iteration I have noticed these same mistakes happening now that people are working on a real project. From what I've seen *it's not until they make these mistakes in a real environment that the learning really sinks in*. Having said that I wouldn't completely write off the use of games in learning environments. They certainly provide a really good way to get people to interact as a group as well as proving them a good opportunity to know each other better. The real learning happens when you're in a real environment though!

thoughtworks-university-the-use-of-games

https://markhneedham.com/blog/2011/03/30/thoughtworks-university-the-use-of-games

2011-03-30 19:17:57

ThoughtWorks University: A double loop learning example

One of the most interesting things that I've been reading about recently is the idea of single and double loop learning which were defined by Chris Argyris and Donald Schon in their book 'http://en.wikipedia.org/wiki/Organizational_learning#CITEREFArgyrisSch.C3.B6n1978[Organizational Learning: A theory of action perspective]' in 1978. image::{{<siteurl>}}/uploads/2011/03/single-double-loop.jpg[Single double loop,477] I quite like the definitions that Mark Smith gives for these types of learning in http://www.infed.org/thinkers/argyris.htm[his article about Chris Argyris]: *Single Loop Learning* ____ Single-loop learning seems to be present when goals, values, frameworks and, to a significant extent, strategies are taken for granted. The emphasis is on '`techniques and making techniques more efficient`' (Usher and Bryant: 1989: 87) Any reflection is directed toward making the strategy more effective. ____ *Double Loop Learning* ____ Double-loop learning, in contrast, '`involves questioning the role of the framing and learning systems which underlie actual goals and strategies ____ I've found in a lot of 'agile' teams that I've worked on we do single loop learning pretty well but often struggle when it comes to double loop learning. For example while working in Pune I would often hear people justify the use of an "agile practice" with the phrase "we do it because it's agile" without necessarily reflecting on the benefit the practice was supposed to be providing. I was therefore quite pleased to see my colleague http://twitter.com/cepitchford[Claire] employing some double loop learning while questioning the value of the wrap up that we do at the end of each day of ThoughtWorks University. The wrap up is a 15 minute stand up where people share what they're learned during the day that might be useful for other people to know as well. Claire raised the point that it doesn't necessarily work well as a learning device because it's quite difficult to switch so quickly from working on the project to having to reflect on what you've learned. When we discussed the usefulness of the session as a group a couple of people pointed out that it works quite nicely as an end of day activity and helped create some closure on what they'd been working on. http://twitter.com/jimbarritt[Jim] also encouraged the group to stick with it for a bit longer as his experience from the previous university was that the wrap up sessions tended to get better as people got more used to the format. We decided to stick with it for the moment and it's been interesting to notice that the quality of the discussion does seem to have improved as the days have gone by. Despite that I thought it was really good that the group took the chance to reflect on whether something which had been pushed on them was actually useful rather than just going with it for 6 weeks and not getting much out of it.

thoughtworks-university-a-double-loop-learning-example

https://markhneedham.com/blog/2011/03/30/thoughtworks-university-a-double-loop-learning-example

2011-03-06 04:19:01

Coding: Reflection vs Action mode

It recently struck me while preparing some ThoughtWorks University sessions that there appear to be two modes that I spend my time switching between while coding: * *Action mode* - we're focused on getting things done, making things happen * *Reflective mode* - we're a bit more detached and looking at things from a higher level I spent the majority of 2008 and 2009 in reflective mode on the systems I was working on which can be seen by scanning through a lot of the blog posts that I wrote during that time. I'm sure would have been times when I was action mode but I was far more interested in how something was being built and whether that could be done more successfully. In 2010/2011 I became much more interested in building stuff and spent more time thinking about that rather than how to refactor code or design it in a more functional way for example. I'm now coming to the conclusion that both of these mentalities are useful at different times and I need to be more aware of when I've been spending too long in one or the other. == Examples of the two modes When http://www.markhneedham.com/blog/category/pair-programming/[pairing programming] these modes describe the role of the driver/navigator reasonably well. While driving we're head down focusing on building the required functionality whereas the navigator focuses more on quality of what's being written, whether we can do that better, whether we're going to cause ourselves big problems down the line and so on. When we're learning something new we'll mostly be in action mode to start with - we want to see something working so that we get some feedback that we're getting somewhere. After a while when we're a bit more comfortable with the language/tool/technique we'll probably step back and reflect on how it's going. I think you can be in these two mindsets in non coding situations too. For example I've recently become much more vocal in trying to get teams to use approaches that I've seen work before whereas previously I was happier to sit back and watch how things panned out and learn from that. == Are the modes this clear cut? While writing this post I've started to wonder whether the way we use these two modes are actually this clearcut and whether I'm only aware of the 'obvious' switches between the two when in fact there are many more switches. I'll keep observing...

coding-reflection-vs-action-mode

https://markhneedham.com/blog/2011/03/06/coding-reflection-vs-action-mode

2011-03-06 08:37:11

Kano Model: Some ThoughtWorks examples

My colleague Jason Yip http://twitter.com/jchyip/status/43144563472343040[recently linked] to the http://en.wikipedia.org/wiki/Kano_model[Kano Model] and although it's a theory about product development the definition of what counts as a product seems like it can be quite broad. The best explanation of the model that I've come across so far is http://www.agile-ux.com/tag/kano-model/[a post by Jean Claude Grosjean] which http://twitter.com/#!/frankmt[Frankie] linked me to. Grosjean describes the three types of requirements like so: == Must Have ("Basic needs") These are not always expressed but they are obvious to the customer and must be met...[they] are *not a source of satisfaction but can cause major disappointment*. == Performance needs ("Linear") The need is expressed and customer satisfaction is *proportional to the level of performance (and quality) of what is implemented*. == Delighters ("Exciters") These requirements are not necessarily expressed. Sometimes they're unconscious. This is the happy surprise that can make a difference but if they are not there then there won't be any dissatisfaction or frustration because they're not expected. *Exciters are the key to innovation*. image::{{<siteurl>}}/uploads/2011/03/kano.jpg[Kano,257] To work out which category a requirement fits in Grosjean suggests we ask the following two questions: * *Functional question*: "How would you feel if the product had feature X ?" * *Dysfunctional question*: "How would you feel if the product didn't have feature X ?" I was thinking about this idea with respect to scenarios inside an organisation. I'm http://en.wikipedia.org/wiki/Anaphylaxis[anaphylactic allergic] to dairy products, eggs, nuts and seafood so my general expectation if I go to any event arranged by ThoughtWorks is that I'll have to work out for myself what I'll be able to eat. However, when I first started working at ThoughtWorks UK in 2006 we had an office manager called Vicki Mott who didn't leave me to fend for myself. She would call me up or email me before every event she organised, check what I was allowed to eat and then make sure there was something I could eat at the venue. I never expected anyone to do that so it was certainly a delighter for me. In this case the 'product' is more a 'service' being provided by another member of an organisation but I feel that the same theory applies. http://www.uie.com/articles/kano_model[Jared Spool] explains that what were previously exciters will move to performance needs and then eventually basic needs as time goes on: ____ One of the predictions that the Kano Model makes is that once customers become accustomed to excitement generator features, those features are not as delightful. The features initially become part of the performance payoff and then eventually migrate to basic expectations. ____ An interesting example that I can think of which seems to fit this is the way some aspects of travel are dealt with in ThoughtWorks Australia. In Australia if you are travelling anywhere for ThoughWorks then there will be a driver to drop you to and pick you up from the airport. When I first saw this it was a delighter for me because I'd never seen anything like it but now it's become expected which leads to disappointment because we don't tend to do that in the other countries. Of course it's still important that other basic/performance needs are met otherwise the delighters aren't able to have the same impact but I hadn't previously thought that much about viewing a service as a product.

kano-model-some-thoughtworks-examples

https://markhneedham.com/blog/2011/03/06/kano-model-some-thoughtworks-examples

2011-03-24 21:58:31

Java: Faking System.in

We ran a http://www.markhneedham.com/blog/2011/03/22/thoughtworks-university-a-refactoring-dojo/[refactoring dojo] a couple of days ago at ThoughtWorks University and in preparation I wrote some system level tests around https://github.com/mneedham/biblioteca/blob/master/src/main/Program.java[the coding problem] that we were going to use during the session. It's a command line application which is called through the main method of 'Program' and since there's no dependency injection we need to be able to set System.in and System.out in order to do any testing. My initial thinking was that it should be possible to fake System.in with the following code: [source,java] ---- String input = "1\n9\n"; System.setIn(new ByteArrayInputStream(input.getBytes())); ---- This works fine when I just want to simulate one value being passed to System.in but it doesn't work so well if I want to simulate passing more than one value because we had a BufferedReader being created each time we loop. [source,java] ---- ... while(true) { ... InputStreamReader inputStream = new InputStreamReader(System.in); BufferedReader reader = new BufferedReader(inputStream); ... } ---- This means that the second time System.in gets read it is empty. http://jimbarritt.com/non-random/[Jim] and I paired on the problem for a bit and came to the conclusion that we'd need to 'stub' the 'read' method of 'InputStream' if we wanted to be able to control exactly what was being returned by System.in. We eventually ended up with the following https://github.com/mneedham/biblioteca/blob/master/src/test/StubbedInputStream.java[StubbedInputStream]: [source,java] ---- class StubbedInputStream extends InputStream { private Queue<String> input; public StubbedInputStream(Queue<String> input) { this.input = input; } @Override public int read(byte[] bytes, int i, int i1) throws IOException { if(input.isEmpty()) { return -1; } int byteLocation = 0; for(byte b : input.remove().getBytes()) { bytes[byteLocation] = b; byteLocation++; } bytes[byteLocation] = "\n".getBytes()[0]; return byteLocation + 1; } public static InputStreamBuilder stubInputStream() { return new InputStreamBuilder(); } ... } ---- Which can be constructed using the https://github.com/mneedham/biblioteca/blob/master/src/test/InputStreamBuilder.java[following DSL]: [source,java] ---- System.setIn(stubInputStream().toReturn("1").then("9").atSomePoint()); ---- The code we wrote is on https://github.com/mneedham/biblioteca/tree/master/src[github] - I'm not sure that it covers every possible scenario that you might come up with but it does pass the tests that I've managed to come up with!

java-faking-system-in

https://markhneedham.com/blog/2011/03/24/java-faking-system-in

2011-03-23 18:45:59

ThoughtWorks University: Brain dumping

One of the things that I'm learning while working at ThoughtWorks University is to bite my tongue a bit to allow people to learn in their own way. I noticed this particularly yesterday in a refactoring session we were doing. For about 10-15 minutes in the middle of the session we'd managed to get the code into a state where it didn't compile and we couldn't run the tests. The 'natural' inclination in that situation for me would be to step in and impart some 'wisdom' about the importance of taking small steps while refactoring. Instead we kept on going for another 10 minutes or so until one of the guys pointed out that the code hadn't compiled and nor had our system test been run for quite a while. With some prodding from http://twitter.com/frankmt[Frankie] the pair at the keyboard made some temporary changes to the application so that it'd compile and then completed the rest of the refactoring in a more incremental fashion. Of course the other side of the coin is to ensure that I do actually give some input when it's useful. The key here seems to be to ensure only to give enough input for the situation. I've learnt quite a lot about some topics and with the amount of stories I've picked up and the analogies/metaphors I've picked up *it can easily become a brain dump if you're not careful*. From my own experience this style of receiving information isn't particularly easy to digest, especially if you don't have any context to link the stories to. The other danger with telling stories is that one story can often trigger another trainer to tell their own story and before you know it 30 minutes has gone by and the original point has long been lost!

twu-brain-dumping

https://markhneedham.com/blog/2011/03/23/twu-brain-dumping

2011-03-15 01:11:37

TWU: Fishbowl

As part of a session on http://www.thoughtworks.com/values-and-culture[ThoughtWorks values] at ThoughtWorks Univesity we held a http://en.wikipedia.org/wiki/Fishbowl_(conversation)[fishbowl] to discuss the trade offs we often have to make between the values when confronted with real life situations. ____ A fishbowl conversation is a form of dialog that can be used when discussing topics within large groups. Four to five chairs are arranged in an inner circle. This is the fishbowl. The remaining chairs are arranged outside the fishbowl. A few participants are selected to fill the fishbowl, while the rest of the group sit on the chairs outside the fishbowl. One chair is left empty Any member of the audience can, at any time, occupy the empty chair and join the fishbowl. When this happens, an existing member of the fishbowl must voluntarily leave the fishbowl and free a chair. The discussion continues with participants frequently entering and leaving the fishbowl. ____ image:http://lisacrispin.com/wordpress/wp-content/uploads/2010/06/FishbowlBetter-300x225.jpg[] We tried a slight variation on this in that we had the people not currently in the fishbowl stand around the outside of fishbowl rather than sitting down in an attempt to encourage participation. The overall feedback that we got from the session was that it was enjoyable to take part in although it was clear that people weren't rotating into and out from the fishbowl as frequently as I've seen before. The tone of the discussion was also relatively agreeable and there weren't any big disagreements between people where they got really fired up in defending their view. http://www.learninggeneralist.com/[Sumeet] pointed out afterwards that the *fishbowl is often more effective in facilitating discussion around a topic which people are really passionate about* and have strong opinions on. Since we had only introduced the ThoughtWorks values about 20 minutes earlier this wouldn't fit into that category. Interestingly although the trainers had strong opinions on certain topics it was difficult to create a discussion because the grads mostly didn't have examples to disagree with those points so the discussion became more theoretical/hypothetical. I do like this format though so we'll have to try it again with some other topics or perhaps the same one in a few weeks time to see how it works out.

twu-fishbowl

https://markhneedham.com/blog/2011/03/15/twu-fishbowl

2011-03-13 13:39:54

Use of language: Intuitive

http://www.learninggeneralist.com/[Sumeet] and I were recently discussing the difference between the use of Google Groups for internal communication compared to the http://www.jivesoftware.com/[Jive platform] which we're now moving to and I suggested that I found the former more intuitive to use. Sumeet suggested that the word 'intuitive' is quite overloaded and later pointed me to http://docs.moodle.org/en/Usability[an article on the Moodle website] which advocates the same thing: ____ Intuitive is a word you should avoid in discussions of usability as its meaning is often confused. It is generally accepted that a large part of usability is based on familiarity and experience. Using 'intuitive' as a short-hand for something that is familiar often gives the impression that if something is 'intuitive' then it is so regardless of prior learning or experience and therefore equally true for everyone. ____ While the article is technically correct, from my experience it's very difficult to get people to change the language that they use and to tell them to not use certain words is likely to provoke a defensive reaction. I've found it more useful to look beneath the language used to work out exactly what is meant by the word since that's what you're really interested in. In my case the use of the word 'intuitive' means that the way Google Groups works is *exactly the same as other mailing lists that I've used previously*. Therefore when we moved to using Google Groups internally about 15 months ago it was really easy for me to understand how to use it. The steps are pretty much: * Search for mailing list I'm interested in * Subscribe to mailing list * Messages on that mailing list come to my inbox * Job done! With Jive the 'algorithm' has to be a bit different because you're initially met with a new feed which contains absolutely everything that people have posted. It's conceptually the same as being met with the twitter stream for every single person using twitter. The only difference I can really see between twitter and Jive is that twitter doesn't default to having every single item on your stream, you have to build it up yourself. That was pretty similar to the metaphor being used by the Facebook news feed which I was already familiar with and could therefore get the hang of very quickly. On the other hand I've found it more difficult to work out how to reduce the noise on Jive so that it would only contain information I'm interested in. It would probably be possible to find some documentation that would explain what I need to do but I like it better when I can work out how to use something myself without external help. Maybe it'll just take me a bit longer to work out how to use Jive and then it'll be as intuitive to me as Google Groups and twitter are. For further reading, Jared Spool has an interesting article where he goes into much more detail than I have about http://www.uie.com/articles/design_intuitive/[what makes a design seem to be intuitive].

use-of-language-intuitive

https://markhneedham.com/blog/2011/03/13/use-of-language-intuitive

2011-03-13 12:03:13

Everything I know everyone else knows

For as long as I can remember I've had the belief that, at least as far as software is concerned, *everything I know how to do everyone else also knows how to do*. I carried that assumption for quite a while and only realised relatively recently how harmful it can be. The most observable outcome I noticed is that I either didn't give my opinion in group situations or just didn't take part in them because I assumed that what I wanted to say would eventually be contributed by someone else anyway. The danger of doing that is that sometimes people didn't come up with a solution I'd seen work before and I'd be extremely frustrated because it seemed like the others were making what I considered bad decisions deliberately. I think this belief evolved from the fact that for several years I was nearly always the least experienced person on the teams that I worked on and it was often true that my colleagues knew way more about almost everything than I did. As time has gone on I've seen more situations and gained some ideas on approaches which work and I haven't been the least experienced in the teams I've been working on so the belief doesn't necessarily hold anymore. I'm not sure if this is a common stage to go through on the software journey so it'd be interesting to hear about your experience. I'm now moving more towards an approach where I give my opinions in situations where I have some knowledge while also accepting the fact that there will be other situations where others know much more than me. In those situations I can legitimately keep quiet and learn from my colleagues experiences.

everything-i-know-everyone-else-knows

https://markhneedham.com/blog/2011/03/13/everything-i-know-everyone-else-knows

2011-03-22 19:10:09

ThoughtWorks University: A refactoring dojo

I facilitated a refactoring session today at ThoughtWorks University where we spent the morning refactoring our way through one of the problems the grads had to work on as part of the pre coursework. The previous version of this session has been more structured, whereby one of the trainers worked solo at the keyboard and took suggestions from the group about which refactoring to cover next. There are a certain number of refactorings that the session aims to introduce and the trainer would have practiced beforehand so they could make these fairly flawlessly. I'm not really a fan of that style of session so we refactored code which the grads were quite familiar with and I was unfamiliar with. We ended up doing 3x45 minute stints in the style of a http://codingdojo.org/cgi-bin/wiki.pl?RandoriKata[randori coding dojo] and we had one person keeping a list of the potential refactorings on the whiteboard. The 3 stints went like this: . Me always at the keyboard, people pairing with me and http://twitter.com/frankmt[Frankie] facilitating/controlling the whiteboard. . Two grads pairing and me facilitating the session . Two grads pairing and one grad facilitating the session. We're slowly trying to encourage the idea of the grads owning the way they learn so this was a step on the way to that. These were some of the learnings from covering a topic in this way: * Frankie noticed that I was dominating the keyboard in round 1 so we decided that the grads could pair with each other for the remainder. We'd already gone through a lot of the main refactorings in that 1st round so it made sense to make this change. * We switched the order of people before the 3rd round after some feedback so that people would have the opportunity to pair with different people than they had in the 2nd round. * In the first round I was a bit too focused on teaching keyboard shortcuts to the people I was pairing with. Frankie pointed out that it's more useful to *learn the refactoring first* and then once you have that concept then teach the shortcuts. By the 3rd round the grads were teaching each other the shortcuts which I thought was pretty cool. * We didn't get to cover as many different refactorings as we would have in a more structured session but we'll get to those in the next few weeks when we're coding on the project so I don't think it'll be too much of a problem. * Since this was a problem everyone had worked on previously several of the people had already done some of the refactorings in their own solution. Therefore parts of the session weren't a big learning experience for those people. That's been a bit of a theme so far - *working out how to cater for all skill/experience levels seems a difficult problem to solve!* Overall I was quite impressed with how much we managed to refactor the code in the amount of time we coded for. The only thing I'm a bit unsure about with the randori style is that it leaves a lot of people observing for big chunks of time. The http://www.dtsato.com/blog/2008/10/29/uberdojo-sao-paulo-coding-dojo/[Kake/UberDojo] format is one that might be more suitable but that would mean splitting up the group which wasn't something we'd considered.

thoughtworks-university-a-refactoring-dojo

https://markhneedham.com/blog/2011/03/22/thoughtworks-university-a-refactoring-dojo

2011-04-03 17:11:46

ThoughtWorks University: The coaching/training conflict

As I http://www.markhneedham.com/blog/2011/03/29/thoughtworks-university-coding-dojo-style/[mentioned in an earlier post] Sumeet has been encouraging us to act more as coaches rather than trainers during ThoughtWorks University but it's not quite as easy as it seems. I've noticed that there are a few things that contribute to this difficulty. == Assessment The biggest obstacle is that by the end of TWU the trainers are required to send a review about each of the grads to the respective Resource Managers describing each person's current level of skill in various categories. Although we're trying hard to be helpful when conveying this message it's difficult for the grads to get beyond the feeling that they're being tested which to some extent is true. I find the idea of assessing people while I'm working with them quite difficult so for me it's more a point of working out the best way to help each person improve their skills. On the other hand the advantage of being in a mode where you're explicitly looking for ways for them to improve is that you are able to give much more detailed feedback than you might be able to if you were on a 'normal team'. == Switching roles One of the things that a couple of the trainers were doing was acting as a proxy customer as well as playing their normal role. This is an approach that has been used on previous TWU's and the intention was to give the grads an idea of the different types of customers that they might encounter. The feedback from the grads was that it can be quite confusing because you're never quite sure which role the trainer is going to be playing when you go to speak to them. As a result we've decided to drop this idea and let the http://www.sukrupa.org/[Sukrupa] guys completely play the role of customer while the trainers just play their normal role. == Drifting outside the group A more subtle thing which can signify a difference between trainers/grads is the tendency for trainers to drift outside of group situations physically. For example in the http://www.markhneedham.com/blog/2011/03/30/thoughtworks-university-a-double-loop-learning-example/[wrap up that we do at the end of the day] if the trainers don't participate in that then it signifies a difference between them and the grads i.e. they're not really part of the group. I think we've got better at this as time has gone on and it's actually much more fun to take part in everything than to just be an observer. It's very difficult to completely get rid of the role of being a trainer but at least having an awareness of the situations where we make it more difficult for ourselves can help us get closer to achieving that.

thoughtworks-university-the-coachingtraining-conflict

https://markhneedham.com/blog/2011/04/03/thoughtworks-university-the-coachingtraining-conflict

2011-04-27 12:33:56

ThoughtWorks University: v2.0 vs v1.0

Since we finished the most recent ThoughtWorks University session last week a few people have been asking me how the experience was and I've found myself comparing this experience to my own as an attendee in August 2006. Back then ThoughtWorks University was much different. We had 5 weeks of workshop style sessions and then spent the last week working on an internal application. This time we spent 1 week doing the workshop style sessions, 1 week working together on a story and then 4 weeks working on the application. == Knowing what you don't know My general feeling is that although http://www.learninggeneralist.com/2010/08/thoughtworks-university-story-of-our.html[TWU v2.0] is better designed for helping people to learn, an advantage of the previous approach was that there was more opportunity to see the gaps in your skill-set. From what I remember there was much more trainer input and at times it was amazing to see http://www.markhneedham.com/blog/2006/09/02/watching-a-master-at-work/[how good someone could be at programming] once they'd got years of practice behind them. Although this still happened, albeit less frequently, there was often feedback that people didn't know what they didn't know and were therefore unsure what they needed to learn. They will still be able learn about those gaps on the projects they work on but I didn't feel this group had the sense of how much there still is to learn as I did 4 1/2 years ago. == The 'trainer' role The role of the ThoughtWorks University trainers has changed from being an actual trainer to being http://www.markhneedham.com/blog/2011/04/03/thoughtworks-university-the-coachingtraining-conflict/[more of an enablement coach] whose primary goal is to facilitate people learning. I think this makes the 'trainer' a more passive participant as your job is no longer to 'teach' people things but rather to let them learn themselves. At times this meant sitting back to allow people to explore and learn from their mistakes and although I think this is a valuable approach it can get quite boring! == Realism vs Creating Learning Opportunities One of the nice things about the new style is that the challenges and problems that people encountered were actually real and not contrived. On the other hand this meant that we couldn't specifically target things that we wanted people to learn in such a structured way. For example, I remember doing several sessions on object design and design patterns and although we weren't experts in either of those by the end of TWU it helped us to see some areas that we could go and read/learn more about. I think people probably came across similar types of situations in this TWU but in their pairs rather than as a group so it was more difficult to point out the learning area.

thoughtworks-university-v2-0-vs-v1-0

https://markhneedham.com/blog/2011/04/27/thoughtworks-university-v2-0-vs-v1-0

2011-04-17 11:27:31

Tech Leading: Initial Thoughts

As I mentioned in an earlier post I've been playing the role of tech lead on the project that we've been doing at ThoughtWorks University so I thought it'd be interesting to note down some of my observations so far. Out of the tech leads that I've had I liked the style of http://intwoplacesatonce.com/[Dave Cameron] the best. He viewed himself more as a technical facilitator rather than as a person who should make every single decision about how a system got built which meant that others also got a chance to take some responsibility. == Varying the style I wanted to apply this style with everyone on the team such that I would facilitate a conversation with the pair about the story that they were working on but they would decide how they went about it. This worked reasonably well for some of the people but I quickly noticed that others were ending up quite lost if we only had a brief conversation. They needed a bit of a structure around what they were going to work on so in those cases we http://www.thekua.com/atwork/2007/07/onboarding-strategy-tiny-tasks/[tiny tasked] out the implementation together. == A fresh view When I worked with https://twitter.com/#!/christianralph[Christian] as my tech lead I noticed that when we were stuck on something he would often come round and ask a question which guided us to a solution which had been completely evading us. I don't yet do that as well as him but I have found that having a fresh and higher level view of a problem means that you can see things which the pair may now be missing because they're so stuck in the implementation. That's happened several times and is always immensely frustrating for the pair involved! == Knowing what's on the wall I've got quite used to only having to know what story I was working on and not really needing to know that much about what the rest of the team are working on. That approach doesn't work quite as well in the tech lead role where you need to be the one who has an idea of what's going on with everything that's in play. This is the thing I've struggled the most with and there have been occasions where stories have been in play way too long where I could have intervened and help the pair work out how to finish them. Other people that I've spoken to have suggested that one way of ensuring you know what's going on is to browse every checkin that's made to the repository each day. I did try this a couple of weeks ago but it's really time consuming and I think you can get information about a story quicker by just talking to the people working on it.

tech-leading-initial-thoughts

https://markhneedham.com/blog/2011/04/17/tech-leading-initial-thoughts

2011-04-17 12:05:12

The sunk cost fallacy

I recently came across David McRaney's post about http://youarenotsosmart.com/2011/03/25/the-sunk-cost-fallacy/[the sunk cost fallacy with reference to Farmville], a fallacy that is very applicable to software. David starts off with the following statements which describe the fallacy pretty well: ____ *The Misconception*: You make rational decisions based on the future value of objects, investments and experiences. *The Truth*: Your decisions are tainted by the emotional investments you accumulate, and the more you invest in something the harder it becomes to abandon it. ____ I think this is very true in a lot of IT organisations in particular when they've made a big investment on some sort of middleware, usually an http://en.wikipedia.org/wiki/Enterprise_service_bus[ESB]. These can often cost hundreds of thousands if not millions of £'s so the person who authorised the purchase is likely to push very hard for it to be used because if it's not then their decision looks very foolish. The problem is that in a lot of cases using an ESB doesn't simplify the system being built - it makes it much more complicated. ESB's are typically difficult to test against, difficult to setup on a continuous integration server and generally make the life of people who have to use them hell. The sunk cost fallacy applies here because the organisation feels the pain of the initial purchase and doesn't want to write that off even if it would make life easier for them from now onwards. I even have my own smaller example from something I've been working on over the weekend. I wanted to try moving this blog from Wordpress to https://github.com/mojombo/jekyll[Jekyll] and I came across https://github.com/imathis/octopress[octopress] which simplifies the process by providing ready made style sheets and layouts. I've got it mostly working but I couldn't work out how to create pages which showed the posts in certain categories or for a specific month. From what I can tell you can get that functionality by implementing a plugin but unfortunately plugins were only added to Jekyll from version 0.6 and octopress relies on henrik-jekyll version 0.5. I've spent about a day and a half getting the blog to its current state so I'm pretty reluctant to write off that time and scrap the octopress idea. Unfortunately that may not be possible if I want to get all the functionality of wordpress. I'm not sure exactly when we should take the sunk cost and when we should write it off but being aware of it is at least a step in the right direction.

the-sunk-cost-fallacy

https://markhneedham.com/blog/2011/04/17/the-sunk-cost-fallacy

2011-04-07 19:18:04

Unix: Getting the sound from 'say' as a wav file

I spent a bit of time yesterday afternoon working out how to get the output from the Unix command 'say' to be played whenever our build breaks. We're using http://ccnet.sourceforge.net/CCNET/CCTray.html[cctray] on a Windows box for that purpose which means that we need to have the file in the 'wav' format. Unfortunately 'say' doesn't seem to be able to output a file in that format: [source,text] ---- > say "WARNING! Drainage has occurred, please fix it. Drainage has occurred, please fix it." --output-file drain.wav Opening output file failed: fmt? ---- So I first converted it into a 'wmv': [source,text] ---- > say "WARNING! Drainage has occurred, please fix it. Drainage has occurred, please fix it." --output-file drain.wmv ---- And then converted it into a 'wav' via http://media.io/[media.io]. Sadly media.io doesn't seem to have an API so I can't fully automate it. If anyone knows a service that does have an API let me know!

unix-getting-the-sound-from-say-as-a-wav-file

https://markhneedham.com/blog/2011/04/07/unix-getting-the-sound-from-say-as-a-wav-file

2011-04-09 10:54:59

HTML encoding/escaping with StringTemplate and Spring MVC

Last week my colleague T.C. and I had to work out how to HTML encode the values entered by the user when redisplaying those onto the page to prevent a cross site scripting attack on the website. I wrote a blog post a couple of years ago http://www.markhneedham.com/blog/2009/02/12/aspnet-mvc-preventing-xss-attacks/[describing how to do this in ASP.NET MVC] and the general idea is that we need to have a custom renderer which HTML encodes any strings that pass through it. In our case this means that we needed to write a custom renderer for String Template and hook that into Spring MVC. We already had a view class +++<cite>+++StringTemplateView+++</cite>+++ so we needed to add to that class and add our custom renderer. The viewResolver was defined like so: [source,java] ---- @Bean public ViewResolver viewResolver() { InternalResourceViewResolver viewResolver = new InternalResourceViewResolver(); viewResolver.setPrefix("/WEB-INF/templates/"); viewResolver.setViewClass(StringTemplateView.class); viewResolver.setSuffix(".st"); return viewResolver; } ---- And after some guidance from http://twitter.com/jimbarritt[Jim] we changed +++<cite>+++StringTemplateView+++</cite>+++ to look like this: [source,java] ---- public class StringTemplateView extends InternalResourceView { @Override protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception { String templateRootDir = format("%s/WEB-INF/templates", getServletContext().getRealPath("/")); StringTemplateGroup group = new StringTemplateGroup("view", templateRootDir); StringTemplate template = group.getInstanceOf(getBeanName()); AttributeRenderer htmlEncodedRenderer = new HtmlEncodedRenderer(); template.registerRenderer(String.class, htmlEncodedRenderer); ... } private class HtmlEncodedRenderer implements AttributeRenderer { @Override public String toString(Object o) { return HtmlUtils.htmlEscape(o.toString()); } @Override public String toString(Object o, String formatName) { return HtmlUtils.htmlEscape(o.toString()); } } } ---- At the moment we want to HTML encode everything that we render through StringTemplate but if that changes then we could http://www.antlr.org/wiki/display/ST/Object+rendering[make use of the formatName parameter] which we're currently ignoring. In retrospect this looks pretty simple to do but my Googling skills were pretty much failing me at the time so I thought it'd be good to document.

html-encodingescaping-with-stringtemplate-and-spring-mvc

https://markhneedham.com/blog/2011/04/09/html-encodingescaping-with-stringtemplate-and-spring-mvc

2011-04-09 10:38:47

ThoughtWorks University: Similarities with 'Discussing the Undiscussable'

I'm currently reading the final chapter of William Noonan's http://www.amazon.com/gp/product/0787986321/ref=as_li_ss_tl?ie=UTF8&tag=marneesblo-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0787986321[Discussing the Undiscussable] titled 'Helping Those Who Teach, Learn' and a couple of the ideas that he describes seem quite applicable to what we're doing at ThoughtWorks University. == Modelling the skills When teaching the http://blog.benjaminm.net/2011/02/16/argyriscasestudylearningmodelii/[Mutual Learning Model] Noonan suggests that the practitioner needs to be able to produce actions consistent with the model in real time situations rather than just being able to do convincing presentations on the subject. I think this is the same with teaching/facilitating the learning of ThoughtWorks University and it seems to centre around the http://www.markhneedham.com/blog/2011/02/23/espoused-theory-theory-in-action-hypocrisy/[espoused theory and theory in action]. The espoused theory describes our theory of what we think we do in a situation whereas the theory in action describes what we actually do. I was a bit worried about doing a presentation/session on a topic where I would present my espoused theory about a topic and then more than likely not meet that theory in practice. Over the course of the last month or so it's become more clear to me that it's not a big problem to make mistakes, even when you're supposed to be the one who knows what they're doing, as long as you're open about your mistakes == Leading questions Noonan talks about the use of leading questions when opening a topic to the group, something which I think is quite prevalent in sessions and workshops: ____ There are potential downsides to the approach of using questions to get to the predetermined correct answer. If the class doesn't answer correctly, the teacher keeps asking questions like, "No, that is not it exactly. What other things can you think of?" The students or participants hit a point of frustration where there is finally a collective call to "just tell us the answer." ____ The intention is to try and make the session interactive but I'm not convinced that it helps learning and it often seems that if someone does actually get to the 'correct answer' that it's because of guessing rather than real understanding. http://twitter.com/frankmt[Frankie] and I unfortunately ended up using an approach similar to this when facilitating a session on the ThoughtWorks delivery model. We wanted the group to come up with the different components of a software delivery project rather than have us do a presentation on it which would have been immensely boring. They got 90% of these without the need for any intervention but we did end up asking leading questions to draw out the last 10%. Rather than doing this, Noonan suggests the following approach: ____ The remedy is for the leader to follow the basic rule of thumb that if you have a view, state it and balance it with inquiry to see if people agree or have different views. ____ In this case that would have meant that we would have kept the facilitated discussion but then helped fill in the missing components before discussing those with the group.

thoughtworks-university-similarities-with-discussing-the-undiscussable

https://markhneedham.com/blog/2011/04/09/thoughtworks-university-similarities-with-discussing-the-undiscussable

2011-04-06 01:34:00

ThoughtWorks University: Letting people explore

I've been acting as the tech lead on the project that we're working on at ThoughtWorks University and as a result I sometimes find myself being dragged away from my pair to help someone else. An interesting thing which I've noticed on more than one occasion is that when I've come back from helping - maybe 15 or 20 minutes later - my pair has actually got much further than I expected them to. I think there are probably more than one factors that lead to this but one which I think is quite applicable is that *having me there is stopping the grads from exploring the problem*. In general if I see someone moving around the editor or browser without there seeming to be any logical path I'll start asking questions to try and 'guide' them to where I believe we need to go. On other projects that I've worked on this has worked reasonably well because we both have a similar understanding of the problem, the tools and so on. In this case I think that shared understanding is much less and my approach is much more harmful. I've been reading John Medina's http://www.amazon.com/Brain-Rules-Principles-Surviving-Thriving/dp/0979777747/ref=sr_1_1?ie=UTF8&qid=1302114250&sr=8-1[Brain Rules] over the last couple of days and Rule #12 seems to agree with what I've observed: Rule #12: We are powerful and natural explorers ____ We are natural explorers, even if the habit sometimes stings us. The tendency is so strong, it is capable of turning us into lifelong learners. ____ I particularly liked the following section... ____ [Humans] Make a sensory observation, form a hypothesis about what is going on, design an experiment capable of testing the hypothesis, and then draw conclusions from the findings. ____ ..which seems to describe the process that I'm sometimes restricting by asking 'guiding' questions. http://twitter.com/jimbarritt[Jim] suggested that one way to get around this problem could be to split up as a pair when we're in this explorative mode but what I've been trying at the moment is keeping more silent and trying to understand what discovery is going on. I'm still getting it wrong sometimes but I'm starting to pick up more where they're really stuck and need some help and where I should just keep quiet and allow them to work out what to do themselves.

thoughtworks-university-letting-people-explore

https://markhneedham.com/blog/2011/04/06/thoughtworks-university-letting-people-explore

2011-04-24 14:11:36

The ladder of inference

In http://www.discussingtheundiscussable.com/[Discussing the Undiscussable] William Noonan describes *the ladder of inference*, a tool which can be used to help us achieve double loop learning with respect to our interactions with other people. ____ Ladder of Inference helps people identify what information or facts are used as the basis for their reasoning process. It also helps people understand how they interpret that information and how they apply their interpretation to the issue or problem at hand. Essentially, the Ladder of Inference is a metaphorical tool designed to help people understand and describe their use of inductive reasoning. Given what we see, what conclusions do we draw? ____ image::{{<siteurl>}}/uploads/2011/04/ladder-of-inference.jpg[Ladder of inference,326] The book mainly describes the ways that we end up climbing the inference ladder ourselves but I've been thinking recently that it's quite interesting to know that in all likelihood that's how other people are thinking about the things that we do. One of the main examples of people climbing the ladder of inference in an 'agile' context is when somebody comes late to the standup in the morning. The other members of the team often jump up the ladder and come to the conclusion that the late person is lazy/doesn't care about the project or their time and is generally a bad person, all before finding out why they were late! The ladder climbing gets even worse if the person is a serial offender and even though it's unfair to that person, it's unlikely that you're going to be able to get all the other people in the team to change their way of thinking. It therefore makes sense to be aware that people may be making these inferences about our behaviour and perhaps adjust the way we act accordingly.

the-ladder-of-inference

https://markhneedham.com/blog/2011/04/24/the-ladder-of-inference