From 03663537a74f66c115b17b0067463c19b9b3aafb Mon Sep 17 00:00:00 2001 From: Cesare Concordia Date: Tue, 14 Dec 2021 08:23:34 +0100 Subject: [PATCH] Eliminare 'Values_Check_Tools_and_Services.ipynb' --- Values_Check_Tools_and_Services.ipynb | 1557 ------------------------- 1 file changed, 1557 deletions(-) delete mode 100644 Values_Check_Tools_and_Services.ipynb diff --git a/Values_Check_Tools_and_Services.ipynb b/Values_Check_Tools_and_Services.ipynb deleted file mode 100644 index 815a5d0..0000000 --- a/Values_Check_Tools_and_Services.ipynb +++ /dev/null @@ -1,1557 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Draft: check properties for Tools and Services in the MarketPlace Dataset \n", - "\n", - "This notebook checks values in the MarketPlace datsaset for Tools and Services. \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### External libraries and function to download descriptions from the MarketPlace dataset using the API\n", - "The following two cells are used to import the external libraries used in this Notebook and to define a function; in the final release of this Notebook this function will be (possibly) optimized and provided as an external library." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def getMPDescriptions (url, pages):\n", - " mdx = pd.Series(range(1, pages+1))\n", - " df_desc = pd.DataFrame()\n", - " for var in mdx:\n", - " turl = url+str(var)+\"&perpage=20\"\n", - " df_desc_par=pd.read_json(turl, orient='columns')\n", - " df_desc=df_desc.append(df_desc_par, ignore_index=True)\n", - " \n", - " return (df_desc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Get the the descriptions of Tools and Services\n", - "The MarketPlace API are used to download the descriptions of Tools and Services" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "RangeIndex(start=0, stop=1606, step=1)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_tool_all = pd.DataFrame()\n", - "df_tool_all =getMPDescriptions (\"https://sshoc-marketplace-api.acdh-dev.oeaw.ac.at/api/tools-services?page=\", 81)\n", - "df_tool_all.index" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### A quick look at data" - ] - }, - { - "cell_type": "code", - "execution_count": 163, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "id 1606\n", - "category 1606\n", - "label 1606\n", - "version 0\n", - "persistentId 1606\n", - "description 1606\n", - "licenses 1606\n", - "contributors 1606\n", - "properties 1606\n", - "externalIds 1606\n", - "accessibleAt 1606\n", - "sourceItemId 1606\n", - "relatedItems 1606\n", - "lastInfoUpdate 1606\n", - "status 1606\n", - "olderVersions 1606\n", - "newerVersions 1606\n", - "source.id 1606\n", - "source.label 1606\n", - "source.url 1606\n", - "source.urlTemplate 1606\n", - "informationContributor.id 1606\n", - "informationContributor.username 1606\n", - "informationContributor.displayName 1606\n", - "informationContributor.enabled 1606\n", - "informationContributor.registrationDate 1606\n", - "informationContributor.role 1606\n", - "informationContributor.email 1606\n", - "dtype: int64" - ] - }, - "execution_count": 163, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_tool_flat = pd.json_normalize(df_tool_all['tools'])\n", - "#df_tool_work=df_tool_flat[['id', 'category', 'label', 'licenses', 'contributors', 'accessibleAt', 'sourceItemId']]\n", - "df_tool_flat.count()" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [], - "source": [ - "df_tool_flat_opt=pd.json_normalize(df_tool_all['tools'])\n", - "df_tool_flat_opt = df_tool_flat_opt.replace('No description provided.', np.nan)\n", - "df_tool_flat_opt.licenses = df_tool_flat_opt.licenses.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.externalIds = df_tool_flat_opt.externalIds.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.contributors = df_tool_flat_opt.contributors.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.accessibleAt = df_tool_flat_opt.accessibleAt.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.relatedItems = df_tool_flat_opt.relatedItems.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.olderVersions = df_tool_flat_opt.olderVersions.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.newerVersions = df_tool_flat_opt.newerVersions.apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_tool_flat_opt.properties = df_tool_flat_opt.properties.apply(lambda y: np.nan if len(y)==0 else y)" - ] - }, - { - "cell_type": "code", - "execution_count": 194, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Property Number of missing values\n" - ] - }, - { - "data": { - "text/plain": [ - "id 0\n", - "category 0\n", - "label 0\n", - "version 1606\n", - "persistentId 0\n", - "description 174\n", - "licenses 1605\n", - "contributors 366\n", - "properties 199\n", - "externalIds 1606\n", - "accessibleAt 507\n", - "sourceItemId 0\n", - "relatedItems 1478\n", - "lastInfoUpdate 0\n", - "status 0\n", - "olderVersions 2\n", - "newerVersions 1606\n", - "source.id 0\n", - "source.label 0\n", - "source.url 0\n", - "source.urlTemplate 0\n", - "informationContributor.id 0\n", - "informationContributor.username 0\n", - "informationContributor.displayName 0\n", - "informationContributor.enabled 0\n", - "informationContributor.registrationDate 0\n", - "informationContributor.role 0\n", - "informationContributor.email 0\n", - "dtype: int64" - ] - }, - "execution_count": 194, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print('{:<35}Number of missing values'.format(\"Property\"), end='\\n')\n", - "df_tool_flat_opt.isnull().sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Checking description values" - ] - }, - { - "cell_type": "code", - "execution_count": 115, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(12, 6))\n", - "ax.hist(df_tool_flat_opt['description'].str.len(), bins=100)\n", - "ax.set_title('Description Length')\n", - "ax.set_xlabel('Characters in description')\n", - "ax.set_ylabel('Frequency');" - ] - }, - { - "cell_type": "code", - "execution_count": 195, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " There are 174 Tools and Services with empty descriptions\n", - "\n" - ] - } - ], - "source": [ - "print (f\"\\n There are {df_tool_flat_opt['description'].isna().sum()} Tools and Services with empty descriptions\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 185, - "metadata": {}, - "outputs": [], - "source": [ - "#Print the Tools and Services with empty descriptions in a CSV file \n", - "df_tool_flat_opt_e=df_tool_flat_opt[df_tool_flat_opt['description'].isna()]\n", - "df_tool_flat_opt_e[['id', 'label', 'description']].sort_values('label').to_csv(path_or_buf='ts_emptydescription.csv')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Count all Tools and Services where the description is shorter than an old school tweet (clearly the minimum amount of characters required to express any meaningful information in these years...:)." - ] - }, - { - "cell_type": "code", - "execution_count": 190, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " There are 217 Tools and Services where the description has less than 140 characters\n", - "\n" - ] - } - ], - "source": [ - "df_tool_flat_d = df_tool_flat_opt[(df_tool_flat_opt['description'].notnull()) & (df_tool_flat_opt['description'].str.len()<140)]\n", - "print (f'\\n There are {df_tool_flat_d[\"description\"].count()} Tools and Services where the description has less than 140 characters\\n')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following table shows some Tools and Services with short description. The list is currently saved on a file, this could be changed if we decided that this is a significant curation feature." - ] - }, - { - "cell_type": "code", - "execution_count": 191, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
id label description
7629934ARRASARRAS is a historically important tool for analyzing and concording text. It notably provided inspiration for the TACT system.\n", - "
1530370Acronym Finder - Beta (TAPoRware)This tool locates acronyms and matches them with the corresponding full name from a user-specified input text.\n", - "
2730353AelfredAelfred is a bare-bones Java XML parser. It has not been updated since 2002, and is dependent on JDK 1.4, which is very outdated.\n", - "
4929219AnnotateItAnnotateIt lets users annotate anything anywhere on the web.\n", - "
5629224AnnotumAnnotum is an open-source, open-process, open-access scholarly authoring and publishing platform based on WordPress.\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 191, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_tool_flat_d[['id', 'label', 'description']].sort_values('label').head().style.set_properties(subset=['description'], **{'width': '600px'})" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "metadata": {}, - "outputs": [], - "source": [ - "df_tool_flat_d[['id', 'label', 'description']].sort_values('label').to_csv(path_or_buf='ts_shortdescription.csv')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Checking values on Contributors" - ] - }, - { - "cell_type": "code", - "execution_count": 198, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " There are 366 Tools and Services with no contributors\n", - "\n" - ] - } - ], - "source": [ - "print (f\"\\n There are {df_tool_flat_opt['contributors'].isna().sum()} Tools and Services with no contributors\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 203, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Int64Index: 1372 entries, 0 to 1355\n", - "Data columns (total 9 columns):\n", - " # Column Non-Null Count Dtype \n", - "--- ------ -------------- ----- \n", - " 0 actor.id 1372 non-null int64 \n", - " 1 actor.name 1372 non-null object\n", - " 2 actor.externalIds 1372 non-null object\n", - " 3 actor.website 566 non-null object\n", - " 4 actor.email 293 non-null object\n", - " 5 actor.affiliations 1372 non-null object\n", - " 6 role.code 1372 non-null object\n", - " 7 role.label 1372 non-null object\n", - " 8 tool_label 1372 non-null object\n", - "dtypes: int64(1), object(8)\n", - "memory usage: 107.2+ KB\n" - ] - } - ], - "source": [ - "df_prop_data_co = pd.json_normalize(data=df_tool_all['tools'], record_path='contributors', meta_prefix='tool_', meta=['label'])\n", - "df_prop_data_co.sort_values('tool_label').info()" - ] - }, - { - "cell_type": "code", - "execution_count": 204, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
actor.idactor.nameactor.externalIdsactor.websiteactor.emailactor.affiliationsrole.coderole.labeltool_label
0483Ian Pearce, Devin Gaffney[]NoneNone[]contributorContributor140kit
1213Dassault Systemes[]NoneNone[]contributorContributor3DVIA Virtools
24514D[]http://www.4d.com/None[]contributorContributor4th Dimension
361780legs[]NoneNone[]contributorContributor80legs
4256Nathan Smith[]http://sonspring.com/None[]contributorContributor960 Grid System
\n", - "
" - ], - "text/plain": [ - " actor.id actor.name actor.externalIds \\\n", - "0 483 Ian Pearce, Devin Gaffney [] \n", - "1 213 Dassault Systemes [] \n", - "2 451 4D [] \n", - "3 617 80legs [] \n", - "4 256 Nathan Smith [] \n", - "\n", - " actor.website actor.email actor.affiliations role.code \\\n", - "0 None None [] contributor \n", - "1 None None [] contributor \n", - "2 http://www.4d.com/ None [] contributor \n", - "3 None None [] contributor \n", - "4 http://sonspring.com/ None [] contributor \n", - "\n", - " role.label tool_label \n", - "0 Contributor 140kit \n", - "1 Contributor 3DVIA Virtools \n", - "2 Contributor 4th Dimension \n", - "3 Contributor 80legs \n", - "4 Contributor 960 Grid System " - ] - }, - "execution_count": 204, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_prop_data_co.sort_values('tool_label').head()" - ] - }, - { - "cell_type": "code", - "execution_count": 207, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Property Number of missing values\n" - ] - }, - { - "data": { - "text/plain": [ - "actor.id 0\n", - "actor.name 0\n", - "actor.externalIds 1372\n", - "actor.website 806\n", - "actor.email 1079\n", - "actor.affiliations 1372\n", - "role.code 0\n", - "role.label 0\n", - "tool_label 0\n", - "dtype: int64" - ] - }, - "execution_count": 207, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_prop_data_contrib = pd.json_normalize(data=df_tool_all['tools'], record_path='contributors', meta_prefix='tool_', meta=['label'])\n", - "df_prop_data_contrib['actor.externalIds'] = df_prop_data_contrib['actor.externalIds'].apply(lambda y: np.nan if len(y)==0 else y)\n", - "df_prop_data_contrib['actor.affiliations'] = df_prop_data_contrib['actor.affiliations'].apply(lambda y: np.nan if len(y)==0 else y)\n", - "print('{:<15}Number of missing values'.format(\"Property\"), end='\\n')\n", - "df_prop_data_contrib.isnull().sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Check the validity of URLs in the *actor.website* property using the HTTP Result Status\n", - "The code below explicitly execute an http call for every URL, waits for the [Result Status Code](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes) of the call and then registers the code. \n", - "Depending on connections and server answer times it may take several minutes to process all URLs. \n", - "In the final release of this Notebook this code will be (possibly) optimized and provided as an external library." - ] - }, - { - "cell_type": "code", - "execution_count": 213, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
urlstatus
0http://www.4d.com/200
1http://sonspring.com/200
2https://www.abbyy.com/200
3http://geoffreyrockwell.com/200
4https://www.adobe.com/200
\n", - "
" - ], - "text/plain": [ - " url status\n", - "0 http://www.4d.com/ 200\n", - "1 http://sonspring.com/ 200\n", - "2 https://www.abbyy.com/ 200\n", - "3 http://geoffreyrockwell.com/ 200\n", - "4 https://www.adobe.com/ 200" - ] - }, - "execution_count": 213, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_tool_work_urls=df_prop_data_contrib[df_prop_data_contrib['actor.website'].str.len()>0]\n", - "df_urls=df_tool_work_urls['actor.website'].values\n", - "df_tool_work_aa_http_status = pd.DataFrame (columns = ['url','status'])\n", - "import requests\n", - "import re\n", - "regex = re.compile(\n", - " r'^(?:http|ftp)s?://' # http:// or https://\n", - " r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\\.)+(?:[A-Z]{2,6}\\.?|[A-Z0-9-]{2,}\\.?)|' #domain...\n", - " r'localhost|' #localhost...\n", - " r'\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})' # ...or ip\n", - " r'(?::\\d+)?' # optional port\n", - " r'(?:/?|[/?]\\S+)$', re.IGNORECASE)\n", - "for var in df_urls:\n", - " if ( var != \"\" and var!=None and re.match(regex, var)):\n", - " try:\n", - " r =requests.get(var,timeout=8)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(r.status_code)}, ignore_index=True)\n", - " except requests.exceptions.ConnectionError:\n", - " # print(var)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(503)}, ignore_index=True)\n", - " except requests.exceptions.ConnectTimeout:\n", - " # print(var)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(408)}, ignore_index=True)\n", - " except requests.exceptions.ReadTimeout:\n", - " # print(var)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(408)}, ignore_index=True)\n", - " except requests.exceptions.RequestException:\n", - " # print(var)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(500)}, ignore_index=True)\n", - " except TypeError:\n", - " # print(var)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(400)}, ignore_index=True)\n", - " else:\n", - " # print(var ,0)\n", - " df_tool_work_aa_http_status = df_tool_work_aa_http_status.append({'url': var, 'status': int(400)}, ignore_index=True)\n", - "df_tool_work_aa_http_status.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 214, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Status Frequency\n" - ] - }, - { - "data": { - "text/plain": [ - "200 462\n", - "503 54\n", - "404 28\n", - "403 8\n", - "406 5\n", - "500 3\n", - "408 3\n", - "502 2\n", - "400 1\n", - "Name: status, dtype: int64" - ] - }, - "execution_count": 214, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_http_status_sub=df_tool_work_aa_http_status[df_tool_work_aa_http_status['status'] != 1]\n", - "df_db_st = df_http_status_sub['status'].value_counts()\n", - "print('{:<8}Frequency'.format(\"Status\"))\n", - "df_db_st.head(10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first column in the table above shows the HTTP Status codes obtained when trying to connect on *accessibleAt* URLs, the second column the total number of URLs returning the status.\n", - "Notice that while 404 means that the resource is not found, other status codes may indicate temporary problems. \n", - "The image below summarizes of the above result." - ] - }, - { - "cell_type": "code", - "execution_count": 215, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA38AAAGSCAYAAABT8nj6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvZElEQVR4nO3deZhkdX3v8fcHUHAJCqLIpoPKGAGNGkCNS0BkC15QrxrUKCpK3BLUG1n0JoIGQ4yi5roEUJS4BtEoioojCoiyCKhRQAYURBaBEQw7AvO9f5zToWi6Z7pmqk7N9Hm/nqef7vrVqVPf+vbpmvrM7yypKiRJkiRJ89saky5AkiRJkjR+hj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJ6p0kByepJCfOcN9xSU7usJbt21q27uo5h5HkcUm+n+Tmts4Fsyx3aXt/JflDkouS/HOSB3Rc8lQ9n0py9sDt7ZIcPMTj10jymiQ/THJDktuS/DzJ25I8cAT1vS/JpSu7njk8z8FJloz7eeZq2N/DqiLJgnbbfu5KrmeltktJWlmGP0l9tnOSbSddxCruX4AHA3sATwOuWsayn2uXeQ7w78BbgA+Nub652g5451wWTLIG8B/Ah4HTgRcDfwF8EngD8O4x1TgOHwd2mXQRA+b8e5in3g28cuB23/shqWNrTboASZqQ64DLgXcAz5tsKeOTZJ2qum0lVvHHwPFVddIclr2qqs5ofz41ySbAK5PsW1VLV6KGrr0R+N/AzlX1nYHx7yb5CPD0yZQ1vKq6nGY7n5eS3K+qbp10HXNVVb+cdA2S+s2ZP0l9VcB7gD2SPH62hWbbba7dBexNA7cvbXflOzDJVUn+O8n70/iLJOcluTHJV5KsN8NTbZzk6+3ulZcled0Mz/mMJKckuSXJ75IcleSPBu5/ZVvXdklOTnIr8LZlvLYnJjmpXd/1ST6bZMP2vgVJCng08JZ2vSfPtq5Z/BRYG3jowHOun+SIJFe3u1L+MMlTptW1T9uvW5MsaV/zVu19M+4m277e42Z5na8E/l/7c83htbwF+M9pwQ+AqrptMAgn2bz9nd7Q/n6/luQx057/wUk+1/5ur0ryjlnqfESSLyS5rv2dnJjksdOWOSjJxW3vrk7yrSQPn+2FTN9+B/q3fZIvJrkpya+SvGEZ/Zh67CuSnNbWd32S7yXZZoblntXed1P7d3Bykict7/eQ5NlJzhx4bR/NwC62A7XvkuT4JDfRzM4ybR2VZOOBsdOT3JXkwQNjP0ty6MDt5fa+tW6ST7e/62uS3GPWLsmmSY5t77s1yS+TvHvg/v/Z7XMO/dg6yQntc93Y/r5m/V1L0lwY/iT12ReBxTSzf6OwF81uXK8C3gu8FTicZlevvwdeB/w58E8zPPYTwH8BLwC+CXwsA8cXJXk6cBLwW+CFwJu5e1fE6T4PfL29/+szFZrkocDJwP2BlwJ/09a2KMl9aXbvfFr7fFO7cy43IEzzCOBGYEn7nGsD3wF2ogmlzwOuBb4z9aE2ybOAfwM+A+wGvBr4IfCgIZ970AnA+9ufn8YyXkuSzYDNgW8tb6Xt6zkJeBzwWprd+TYHTkmy/sCin6R5LW8G9gV2ptlWBte1PnAa8Fia7eTFwANoenO/dplXAG+n2aZ2AV4PXNwuN6yjaML582m2g48k2W45j1lAszvvi2i2mctpZngfNfA6tqfpyR3A3sBfAt8HNmEZv4ckW9L0fAnNrOs72+eYKdB/oq19j/bnQae3z/3Mdr33B/4U+APtjG3b663auubU+wH/AtxC8zd4FPDOJG8cuP/fgc1ofs+7AYfS/AfITJbVj8cAPwDWAV5Os21tBXwtSWZZnyQtX1X55ZdffvXqCzgYWNL+/ErgLmBhe/s44OSZlp22jgLeNHD7UpoP4msOjJ0F3AlsPjD2XuDqgdvbt+s6ctr6FwFnDNz+PvC9acs8u33s1gOvpYD95tCDw4DfA+sOjG3XPv4l017X++awvktpPsiuRRModwWuBw4YWGYfmg/hWwyMrQX8EviX9vbfAecs43mm+rX1tPGTgeMGbn8KOHvg9puaf/KW+zqe2q5/lzks+7r29/uogbFN29d4UHt7q3Z9fzmwzANpdju+dGDs3cDvgPUHxtYD/ht4Y3v7w8CXVnRbn9a/dw2M3YcmhB82xHrXaH93vwD+YWD8dOBsILM8bsbfA/AF4CLu+ffz4rbWp02r/QPLqe104MMDfyNL2vUf1o7tQfM3v+4QvV/QPve3pz3XUcAVwBrt7ZuA/7WM2ua0XQKfBi4E7jswtkVb9+7DbAN++eWXX4NfzvxJ6rvPAJcBB41gXSdX1V0Dty+m+YB/ybSxh7aza4P+c9rtLwN/mmTNdvbiacCxSdaa+qKZrbiDZmZj0AlzqHU7mg+yN0wNVNVZNCHuGXN4/Eze2tZzM83s5feq6p8H7n8OcA5wycBrADgFmNp98CfAk5J8oN19cHqfulJzWGY74Nyq+tX/PKg5xu4H3N3DqRMKHT+wzE004X7Qc9qxGwZ6cyNNvwZ78xdJDkmza++aw72ke/j2QD130ASvTZf1gDRnfv3PJFfThJA7aGbLFrb3PwB4CnBMVc2lf4O2o9nVdvDv50s04Xr69ri87fv7tDN/wLPa26dMG/vpwLY/l95PmenvdGPu7t1PgH9Kswv2I5ZT57I8p32upQM1XULz93mvXW0laa4Mf5J6rarupJmN+6skj1zJ1f1+2u0/zDIWYHqouWaG22sBG9DMQqwJfJTmA/fU1+00szabTXvs1XOodaNZlrsaWH+G8bn4DE3Y2Z5mV8fnJ3n9wP0b0Mys3THt61W0r6Ga4+xeRfMB/WRgSXvsV1eXjLii/T6XD+5z6eHDgRvr3iclmf773oBmF8npvdmBu3+/R9Ps9vli4Ezg6iTvXsEQ+Ptpt/9As4vhjNIcW/rttpa30gSpbWl2v5x63Ho02/ayzgg7m3v1sg2Cv+Pe2+Pytu9Tga3bY/yeSRP+vg9sk2SdgbEpc+n9lJn+Tqfqp13P2cAHgF8n+UmSHZdT70w2AA6YoaZHzVCTJM2ZZ/uUpOZD9f+l+bA13W1MC2qZ+YQtK+thM9y+k2aXtXVoZqIOBr4xw2OvnHZ7LrMuV83wnAAb0sx4rIirq2rqGmantGH6XUn+vapuptnV8WyaY9Wmu33qh6o6BjimPS7xBTQfpG8ADqT5fcC9w/P6tMcWroyq+k2SX9EcU/fx5Sx+Fc1undNtSPNaoTlm8o9y77NSTu/9dTSzgzNdRuLGtralNL34QHts4stojim7guY4yXF6Gs3s1k5V9YupwSSDx2JeDyzl7iA0jHttj22ofQh393LK8rbvH9CE0O1p/rPhAOA8ml0ydwSeTHPs3pTl9n7ATH+nU/VTVVfQnOF2DZrZzIOB45M8oqp+t5y6B11HM/M30za4yly3UdLqx5k/Sb1XVbcD76M5ucj0D66X03x432RgbOcxlPH8GW6fU1V3tcHpDOCxVXX2DF/Tw99cnAnsknueLXRbmmObTlvB1zDdQTQzGPu0t08CHgNcNsNr+Nn0B1fVtVV1BM0szZbt8NRlCx43UPdmNLsfLssf2mVnnd0a8EHgBUl2mH5HknWSPLu9eSbNrrmbD9y/CfBn3N3DH7Xf9xhY5oE0J70ZdBJNkDxvht5cOL2OqvpNVR1GsxvxltPvH4OpE5/8T0hP8mc028tUTTfT9OQVyzgpyWy/hzNpZooHZzFfQPOf1ENtj1V1PfBzmrO23gX8uN0N9TRg/xnWOUzvp/+dvoAm+N3jchpVtbSay54cQnMM7Gx7FczWj5OArWneA6bXdOlyWiBJs3LmT5IaR9DsUvdnNMcHTfkWcCtwdJL305zN8V6XYRiB3dpTz59C84FyJ2DPgfv3B05KspTmpDQ30uyauDvwjqpaPOTzHU4zA3dikn+mOQnJYcDPaI61WmlVdVaSRTSXivgIzZkQXwecnOR9wK9oZna2A35bVR9IcgjNLN7JNDMcT6I5C+mB7TovT/Ij4N1JbqH5T8y3c+/ZoemmZqv2S/Jd4IaZQlXrIzS7nX6jrXsRzYf0P6E5QcfXgO/SnLzjAOCbSf6BJmgc3NZ9RFvveUmOpzl767o0QeFtNGeMHHQ48Fc01xL8fzSzeRu2r/20qvp8kiPa13kGzclIdqA5CchMM9ajdgbNzNlRSd5LMwt4MHfvJjvlQJozun4zyZE0x38+jeYkJ19n9t/DPwI/Br6S5GPt+v8ZOLGqTp+tqHZ2+ZfAq6vq3wfuOpXmeo0nDhxH+H2aGb+Lquq3A8sut/cDy27V/h6+RLON7ENzgqWl7SzoiTTb+WKas3z+H5rZ3wtmeQmz9eNgmhNGnZDkaJptahOa94VPVdXJs/VEkpbFmT9JAqrqFppd6qaPT516flPgKzQfEl86hhJeQ7M72leA59KcZXDwJCGn0XzYfCjNmQC/RhMIf8PcjvG7h6q6liY83EZzaYiP0Hw43qmq/rAyL2Saf6SZHXpxNReb34EmTB1CcwzZh2gCzFnt8j+imcn6N5oP0q+n+SD8oYF1vpTmJD2foblW47tozoy4LFMf/PejmWU6YrYF290r/5Lm8hfPoPmg/02aD/qfbuuZmjF+Ds0H+E8AxwC/BravqsEw+sr2tX6wXe4kmrNPDj7nEppdFH9Bsx1+m+ZY1AfRXAIEmrNYPovmeMpv0MxCvbaqvrKc177Squpqmks8PBz4Ks1lK15HM/M4uNypNAHl/jS/n/+gCVFTM2Mz/h6q6jyaSyM8jOYkKv9Is12+cDmlheZ42OmfZ6aO6Tt1hrF7zCTOsfdT9gfWpdkm/ppmV9Gpaw3eRvOfJ/vR7EZ6DE3I33mGYz4Ha5qpH4vbmm4BjqTZ/g6hmXm9eMY1SdIcZPgTckmSJEmSVjfO/EmSJElSDxj+JEmSJKkHDH+SJEmS1AOGP0mSJEnqAcOfJEmSJPXAvLrO3wYbbFALFiyYdBkr5Pbbb2fttdeedBm9Ys+7Z8+7Z8+7Z8+7Z8+7Z8+7Z8+7t7r2/JxzzllSVQ+d6b55Ff4WLFjA2WefPekyVsjixYtZuHDhpMvoFXvePXvePXvePXvePXvePXvePXvevdW150l+Pdt97vYpSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA2tNuoDVyYIDTxjbunfaZCmLjr5oLOu+9LDdx7JeSZIkSasPZ/4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6oPPwl2TNJD9O8vX29vpJFiW5qP2+3sCyByW5OMmFSXbpulZJkiRJmi8mMfO3H3DBwO0DgZOqagvgpPY2SbYE9gK2AnYFPppkzY5rlSRJkqR5odPwl2RTYHfg4wPDewLHtD8fAzxvYPwLVXV7VV0CXAxs11GpkiRJkjSvdD3z90Fgf2DpwNiGVXUVQPv9Ye34JsBvBpa7vB2TJEmSJA1pra6eKMlzgWuq6pwk28/lITOM1Qzr3RfYF2DjjTdm8eLFK1PmMu20ydLlL7SCHrNucc9MPDrj7MnqbMmSJZMuoXfseffseffseffseffseffseffmY887C3/A04E9kvwFsA6wbpLPAFcn2aiqrkqyEXBNu/zlwGYDj98UuHL6SqvqSOBIgG222aYWLlw4thew6OiLxrZuWMqiK8YzEXvUGHuyuhvn9qKZ2fPu2fPu2fPu2fPu2fPu2fPuzbeed7bbZ1UdVFWbVtUCmhO5fLeq/go4Hti7XWxv4Kvtz8cDeyVZO8nmwBbAWV3VK0mSJEnzSZczf7M5DDg2yT7AZcCLAKrqvCTHAucDdwJvrKq7JlemJEmSJK2+JhL+qupk4OT2598BO86y3KHAoZ0VJkmSJEnz1CSu8ydJkiRJ6pjhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST3QWfhLsk6Ss5L8NMl5SQ5px9dPsijJRe339QYec1CSi5NcmGSXrmqVJEmSpPmmy5m/24FnV9WfAE8Edk3yVOBA4KSq2gI4qb1Nki2BvYCtgF2BjyZZs8N6JUmSJGne6Cz8VeOm9uZ92q8C9gSOacePAZ7X/rwn8IWqur2qLgEuBrbrql5JkiRJmk/W6vLJ2pm7c4DHAB+pqjOTbFhVVwFU1VVJHtYuvglwxsDDL2/Hpq9zX2BfgI033pjFixePrf6dNlk6tnU/Zt0CxrP+cfZkdbZkyZJJl9A79rx79rx79rx79rx79rx79rx787HnnYa/qroLeGKSBwP/mWTrZSyemVYxwzqPBI4E2GabbWrhwoWjKHVGi46+aGzrhqUsumI8E7FHjbEnq7txbi+amT3vnj3vnj3vnj3vnj3vnj3v3nzr+UTO9llVvwdOpjmW7+okGwG0369pF7sc2GzgYZsCV3ZXpSRJkiTNH12e7fOh7YwfSe4HPAf4BXA8sHe72N7AV9ufjwf2SrJ2ks2BLYCzuqpXkiRJkuaTLnf73Ag4pj3ubw3g2Kr6epLTgWOT7ANcBrwIoKrOS3IscD5wJ/DGdrdRSZIkSdKQOgt/VfVfwJNmGP8dsOMsjzkUOHTMpUmSJEnSvDfUbp9JfpLkTYMXYpckSZIkrfqGPebvBGB/4Mokn08y44ydJEmSJGnVMlT4q6p3AI8EXgCsCZyQ5NIk/5DkEeMoUJIkSZK08oY+22c1vllVLwY2Bo4A3g78KsmJSXYddZGSJEmSpJWzwpd6SPJU4DDgQJrr7x0C/BI4LskHR1KdJEmSJGkkhjrbZ5KHAa8AXgU8muZafC+sqkUDyxzXjr95dGVKkiRJklbGsJd6uBy4GPgEcExVLZlhmbOBH61sYZIkSZKk0Rk2/O1YVd9f1gJVdQOww4qXJEmSJEkatWGP+bsuyROmDyZ5QpItR1STJEmSJGnEhg1/RwJbzzC+ZXufJEmSJGkVNGz4ewJw1gzjPwIev/LlSJIkSZLGYdjwdxfwoBnG1wOy8uVIkiRJksZh2PB3CvCOJGtODSRZC3gHcOooC5MkSZIkjc6wZ/vcHzgNuDjJae3YM4AHAs8aZWGSJEmSpNEZauavqi6kOe7vc8D6wEOAzwJ/UlUXjL48SZIkSdIoDDvzR1VdRbObpyRJkiRpNTF0+Etyf+CJwMOYNnNYVV8eTVmSJEmSpFEaKvwleQ7weZrdPacrYM0ZxiVJkiRJEzbs2T4/BJwAbFpVa0z7MvhJkiRJ0ipq2N0+FwB7VNWVY6hFkiRJkjQmw878/QB47DgKkSRJkiSNz7Azf/8GvC/JxsDPgDsG76yqc0dVmCRJkiRpdIYNf8e134+c4T5P+CJJkiRJq6hhw9/mY6lCkiRJkjRWQ4W/qvr1uAqRJEmSJI3PsCd8IcluSb6e5Pwkm7Vjr0my4+jLkyRJkiSNwlDhL8nLgGOBi2h2Ab1Pe9eawP6jLU2SJEmSNCrDzvztD7y2qt4C3DkwfgbwxFEVJUmSJEkarWHD3xbA6TOM3wSsu/LlSJIkSZLGYdjwdyWwcIbxZwG/XPlyJEmSJEnjMGz4OxL41yRPb29vlmRv4L3Ax0ZamSRJkiRpZIa91MN7kzwIWASsA3wPuB14X1V9ZAz1SZIkSZJGYNiLvFNV70hyKLAlzczh+VV108grkyRJkiSNzNDhD6CqbgHOHnEtkiRJkqQxGSr8JTl+WfdX1R4rV44kSZIkaRyGnfn73bTb9wH+BNgM+PJIKpIkSZIkjdywJ3x51UzjSd4P3DiSiiRJkiRJIzfspR5mcwTwhhGtS5IkSZI0YqMKf48d0XokSZIkSWMw7Alf/nX6ELARsBtw9KiKkiRJkiSN1rAnfHn8tNtLgWuBt2D4kyRJkqRV1rAnfNlhXIVIkiRJksZnVMf8SZIkSZJWYcMe8/c9oOaybFU9e4UqkiRJkiSN3LDH/F0AvAz4LXBmO7Yd8HDgc8BdoytNkiRJkjQqw4a/24FjgP2q6n9mAJN8EEhV7TfC2iRJkiRJIzLsMX+vAD48GPxaHwVePpqSJEmSJEmjNmz4C/e+3AOzjEmSJEmSVhHD7vZ5NPDxJFsAZ7RjTwX2Bz45ysIkSZIkSaMzbPjbH7gG2A94Tzt2FXAY8P4R1iVJkiRJGqFhL/K+FHgv8N4k67ZjN4yjMEmSJEnS6KzQRd6TbAPsRntphyQPSDLsLKIkSZIkqSPDXuR9Q+B4YFuai71vAfwKOBy4jWZ3UEmSJEnSKmbYmb8P0Fzg/SHALQPjXwR2HlVRkiRJkqTRGnZXzR2BHavq+iSD478EHjGyqiRJkiRJIzXszN/9gD/MMP5Qmt0+JUmSJEmroGHD36nAKwduV5I1gQOAk0ZVlCRJkiRptFbkOn+nJNkWWJvm2n5bAQ8Cnj7i2iRJkiRJIzLUzF9VnQ88Hvgh8G1gHZqTvTypqn65rMcm2SzJ95JckOS8JPu14+snWZTkovb7egOPOSjJxUkuTLLLsC9OkiRJktSY88xfkvsApwGvqKp3rsBz3Qn8n6o6N8kfAeckWUSzG+lJVXVYkgOBA4EDkmwJ7EUzs7gx8J0kC6vqrhV4bkmSJEnqtTnP/FXVHcDmNNf3G1pVXVVV57Y/3whcAGwC7Akc0y52DPC89uc9gS9U1e1VdQlwMbDdijy3JEmSJPXdsMf8HQO8FnjbyjxpkgXAk4AzgQ2r6ipoAmKSh7WLbQKcMfCwy9ux6evaF9gXYOONN2bx4sUrU9oy7bTJ0rGt+zHrFjCe9Y+zJ6uzJUuWTLqE3rHn3bPn3bPn3bPn3bPn3bPn3ZuPPR82/D0AeFmSnYBzgJsH76yqv13eCpI8EPgS8OaqumHa9QLvsegMY/eadayqI4EjAbbZZptauHDh8kpYYYuOvmhs64alLLpi2JOvzs1RY+zJ6m6c24tmZs+7Z8+7Z8+7Z8+7Z8+7Z8+7N996Pqfwl+QJwHnA44Bz2+FHTVtsubuDtscNfgn4bFV9uR2+OslG7azfRsA17fjlwGYDD98UuHIu9UqSJEmS7mmuM38/Bjaqqh0AkpwAvGZqd825SDPF9wnggqo6fOCu44G9gcPa718dGP9cksNpTviyBXDWXJ9PkiRJknS3uYa/6btgPhO435DP9XTg5cDPkvykHXs7Teg7Nsk+wGXAiwCq6rwkxwLn05wp9I2e6VOSJEmSVsywx/xNmfVAvdlU1WnLeNyOszzmUODQYZ9LkiRJknRPcz3DSHHvY/pW6JIPkiRJkqTuDbPb52eS3N7eXgc4KsktgwtV1R6jLE6SJEmSNBpzDX/HTLv9mVEXIkmSJEkanzmFv6p61bgLkSRJkiSNz3iuKi5JkiRJWqUY/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknqgs/CX5Ogk1yT5+cDY+kkWJbmo/b7ewH0HJbk4yYVJdumqTkmSJEmaj7qc+fsUsOu0sQOBk6pqC+Ck9jZJtgT2ArZqH/PRJGt2V6okSZIkzS+dhb+qOhW4btrwnsAx7c/HAM8bGP9CVd1eVZcAFwPbdVGnJEmSJM1Ha034+TesqqsAquqqJA9rxzcBzhhY7vJ27F6S7AvsC7DxxhuzePHisRW70yZLx7bux6xbwHjWP86erM6WLFky6RJ6x553z553z553z553z553z553bz72fNLhbzaZYaxmWrCqjgSOBNhmm21q4cKFYytq0dEXjW3dsJRFV4xnIvaoMfZkdTfO7UUzs+fds+fds+fds+fds+fds+fdm289n/TZPq9OshFA+/2advxyYLOB5TYFruy4NkmSJEmaNyYd/o4H9m5/3hv46sD4XknWTrI5sAVw1gTqkyRJkqR5obPdPpN8Htge2CDJ5cA7gcOAY5PsA1wGvAigqs5LcixwPnAn8MaququrWiVJkiRpvuks/FXVS2a5a8dZlj8UOHR8FUmSJElSf0x6t09JkiRJUgcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQfWmnQB0rIsOPCEsa17p02Wsujoi8ay7ksP230s65UkSZJWlDN/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDhj9JkiRJ6gHDnyRJkiT1gOFPkiRJknrA8CdJkiRJPWD4kyRJkqQeMPxJkiRJUg8Y/iRJkiSpBwx/kiRJktQDa026AEmrlgUHnjC2de+0yVIWHX3RWNZ96WG7j2W9kiRJ84Uzf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6YK1JFyBJfbfgwBPGtu6dNlnKoqMvGsu6Lz1s97GsV5IkjYczf5IkSZLUA6v8zF+SXYEPAWsCH6+qwyZckiRpNedsqySpj1bpmb8kawIfAXYDtgRekmTLyVYlSZIkSaufVX3mbzvg4qr6FUCSLwB7AudPtCpJkjQUZ1u7Z8+7Z8+1qlvVw98mwG8Gbl8OPGVCtUiSJElahRi4h5OqmsgTz0WSFwG7VNVr2tsvB7arqr8ZWGZfYN/25mOBCzsvdDQ2AJZMuoiesefds+fds+fds+fds+fds+fds+fdW117/siqeuhMd6zqM3+XA5sN3N4UuHJwgao6Ejiyy6LGIcnZVbXNpOvoE3vePXvePXvePXvePXvePXvePXvevfnY81X6hC/Aj4Atkmye5L7AXsDxE65JkiRJklY7q/TMX1XdmeRNwIk0l3o4uqrOm3BZkiRJkrTaWaXDH0BVfQP4xqTr6MBqv+vqasied8+ed8+ed8+ed8+ed8+ed8+ed2/e9XyVPuGLJEmSJGk0VvVj/iRJkiRJI2D4kyRJkqQeMPxJkiRJUg+s8id8ma+SBNgO2AQomusXnlUehDk2SdYAqKql7aVDtgYurarrJltZPyR5Q1V9dNJ1zGdu491qe3zH1Pt2kh2AJwPnV9U3J1rcPOe/od1K8gjghqr6fZIFwDbAL6rq55OtbP5Lcp+qumPa2AZVtTpeeHyV1pf3FU/4MgFJdgY+ClwEXNEObwo8BnhDVX17UrXNV0meBxwBLAVeB7wduBlYCLy+qr42uermnyRvnT4EHAS8B6CqDu+8qHnObbx7SX4KbF9V1yd5G/B8mrNT/zlwdlUdNNEC5yn/De1WkgOBvwZuB94H/B3wA+CpwCd8Px+P9j+TPg2sDfwY2LeqLm3vO7eqnjzB8uadPr2vGP4mIMkFwG5Tf8QD45sD36iqx02ksHksyY+B3YD7AT8Ftq2qC5M8EvhSVW0z0QLnmSQ30nwIPo8m+AG8GfggQFUdMpHC5jG38e4l+XlVbd3+fDbwzKq6NclawLlV9YTJVjg/+W9ot5KcRzPTd3/gUuBRVXVtkgcAZ079DWi0kvwIeGVVnZfkhcA/AS+vqjOS/LiqnjThEueVPr2vuNvnZKwFXD7D+BXAfTqupTeq6rcASS6rqgvbsV9P7SqnkdoKOBx4AHBIVd2SZG9D33i5jXfuhiRbt7u+LQHWAW6leY+35+Pjv6Hduqv9T40/0GzfvwOoqpubveQ0JvetqvMAquq4Npx8uZ2JdeZm9HrzvmL4m4yjgR8l+QLwm3ZsM2Av4BMTq2qeS7JGVS0FXj0wtiZw38lVNT9V1WXAC5PsCSxK8oFJ19QHbuOdex3w2Xb3z2uAs5OcAjyBdhdnjYX/hnbr3CSfo/nPvJOAY5J8C3g2cP5EK5vf7kjy8Kn/1GtnAHcEvg48erKlzUu9eV9xt88JSbIlsAfNQaWh+d+G46vKN9IxSLIt8LOqum3a+ALgGVX1mYkU1gPtrkEHA0+pqmdNuJx5y218MtpwvTPNsZVT/3N8YlX9fpJ1zXf+G9qddjfmF9HMNh0HPAV4CXAZ8JGqunmC5c1bSZ4DXFtVP502/mDgjVV16EQKm8f68r5i+JMkSZKkHvCYhAlI8qAkhyX5RZLftV8XtGMPnnR985E979a0fl9nv8fPbbx79nwy7Hu3fD+fDLfzbvWp34a/yTgWuJ7mFOEPqaqHADsAvwe+OMnC5rHZen499nwcBvu9vv3uhNt49+z5ZPhvaLdmez//PfZ7nHx/6VZv3lfc7XMCklxYVY8d9j6tOHveLfvdPXvePXs+Gfa9W/Z7Mux7t/rUb2f+JuPXSfZPsuHUQJINkxzA3WcY0mjZ827Z7+7Z8+7Z88mw792y35Nh37vVm34b/ibjL4GHAKckuT7JdcDJwPrAiydZ2Dxmz7s1vd/X0/T7IdjvcbHn3bPnk+H7ebfczifD7bxbvdnO3e1zQpL8MbApcEZV3TQwvmtVfWtylfVDkmcC29GcGv/bk66nD5J8uqpePuk6+sSed8+ed8/38+65nXfP7bx783U7N/xNQJK/Bd4IXAA8Edivqr7a3nduVT15guXNS0nOqqrt2p9fQ9P/r9Bcn+trVXXYBMubd5IcP8Pws4HvAlTVHt1WNP/Z8+7Z88nw/bxbbueT4XberT5t52tNuoCeei3wp1V1U5oLMB+XZEFVfYjmopIavfsM/PzXwM5VdW2S9wFnAL6JjtamwPnAx2kuDBxgW+D9kyxqnrPn3bPnk+H7ebfczifD7bxbvdnOPeZvMtac2tWzqi4Ftgd2S3I4hr9xWSPJekkeQjPjfS1AVd0M3DnZ0ualbYBzgHcA/11VJwO3VtUpVXXKRCubv+x59+z5ZPh+3i2388lwO+9Wb7ZzZ/4m47dJnlhVPwFoZwCfCxwNPH6ilc1fD6L5ow5QSR5eVb9N8kAM3CNXVUuBDyT5Yvv9any/GSt73j17PjG+n3fI7Xxi3M471KftfF6+qNXAK5j2vzZVdSfwiiRHTKak+a2qFsxy11Lg+R2W0itVdTnwoiS7AzdMup4+sOfds+fd8v18MtzOu+V2Phl92M494YskSZIk9YDH/EmSJElSDxj+JEmSJKkHDH+SJA0pycFJfj7pOgYleWESj+WQJM3K8CdJWm0k+VSSar/uTHJZko8lWW8VqOvrc1z2j5K8O8n5SW5NcnWSk5O8JIn/LkuSxsazfUqSVjffAV5O82/YljSXyXkw8JIJ1jQnSR4MnAasB/xf4CzgD8AzgL8HTgcunVB5kqR5zv9hlCStbm6vqt9W1eVV9W3gP4CdBxdI8qp2Zu22JIuTvGVwVi3JX7fjtyW5NsmJSdZq77vXLN6ydvNMcjCwN7D7wKzk9rPU/h5gc+ApVfXJqjqvqi6qqk8CTwZ+265zvSTHJLm+nR38TpKtpj3vK5L8Osktbb0bzlDb/0pyTvs6L0lyaJL7ztpZSdK85syfJGm1leRRwK7AHQNjrwXeBfwNzUWStwaOapf5cJJtgI/QBLbTaGYNn70SZbwPeBywPs2MJMB1M9S6BrAX8Nn2WlL3UFW3Ddz8FPBYYE/geuBQ4FtJFlbVrUme0i7z98AXgR1oguXg8+0CfBbYDzgVeATwb8DawN+t2EuVJK3ODH+SpNXNrkluAtYE1mnH3jpw/98D+1fVce3tS5IcBrwB+DBNCLoZOL6qbgR+Dfx0RYupqpuS3Eo7I7mMRTeg2d3zgmWtL8kWwB7An1fVqe3Yy4HLgJcBH6cJdCdV1aHtwxYn2RbYZ2BV7wD+pZ1VBPhlkgOAzyR5W3mhX0nqHcOfJGl1cyqwL3A/4LXAo4F/BUjyUGAz4IgkHxt4zFpA2p8X0QS+S5KcCHwb+HIbBMcpy18EaGYRl9Ic/wdAVf13kp/RHOM4tczXpj3udO4Z/v4U2K4NfFPWoOnbw4Gr5l66JGk+MPxJklY3t1TVxe3Pf5vkezSzfQdz97HsrwN+ONODq+rGJE8GngXsBBwEvCfJtlV1JU3wmh7U7jOCuq+l2YXzcctZblkhseawzJQ1gENodgudqRZJUs94whdJ0uruEOCAJBtX1dXAFcCjq+ri6V9TD6iqO6vqu1V1EPAE4AHAc9u7rwU2mvYcT1xODX+g2Q11VlW1lObkNC9Lsun0+5Osk2Qd4Hyaf5+fNnDfusDj2/tovz912iqm3z4X+OOZ+lBVdy7n9UiS5iHDnyRptVZVJwPn0Vw6AZoZwP3bM3w+NsnW7ZkxDwJI8twk+yV5UpJHAi8F/oi7j8X7LvCkJK9O8pgk+wNPX04ZlwJbt8+3QZLZZgrfTnPs3pntGUm3ap/j5TQnp3l4VV0EfJVm19VnJnk88BngBuBz7Xr+FXhOkoOSbNGe5Ob5057rXcBLk7yr7cEftxeCf+9yXoskaZ4y/EmS5oPDgX2SPLKqPg68mubMmz8Fvk9zjOAl7bK/B55Hc73AX9Cc+fI1VfV9gKo6kWY28VCaQLYA+Ohynv8omvB4Ns3M4Yxhsaqup5mh+xRwQLv+H9Icq/dummAI8CqaawAe336/P7BrVd3arueM9jGvB/4LeAFN6B18rhOB3WnOBHpW+3XgwHNIknomnuxLkiRJkuY/Z/4kSZIkqQcMf5IkSZLUA4Y/SZIkSeoBw58kSZIk9YDhT5IkSZJ6wPAnSZIkST1g+JMkSZKkHjD8SZIkSVIPGP4kSZIkqQf+P8JgNhYGpxuAAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "df_db_st.plot(kind='bar', figsize=(15,6), x='Status', y='Frequency',)\n", - "plt.grid(alpha=0.6)\n", - "ax.yaxis.set_label_text(\"\")\n", - "ax.set_title(\"Number of Result Codes in actor.website\", fontsize=15)\n", - "ax.set_xlabel('Result Code', fontsize=14)\n", - "ax.set_ylabel('Frequency', fontsize=14);\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The list of possibly wrong URLs is saved in a Comma Separated Values (CSV) file having the following columns: *id, label, url, status*. The final release of this notebook will save this data in the curation dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 222, - "metadata": {}, - "outputs": [], - "source": [ - "df_http_status_err=df_http_status_sub[df_http_status_sub['status'] != 200]\n", - "df_list_of_tools_wrongaa=pd.merge(left=df_prop_data_contrib, right=df_http_status_err, left_on='actor.website', right_on='url')\n", - "df_list_of_tools_wrongaa.head()\n", - "df_list_of_tools_wrongaa[['actor.id', 'tool_label', 'actor.website', 'status']].sort_values('tool_label').to_csv(path_or_buf='ts_wrongcontributorsurls.csv')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Checking values on Properties" - ] - }, - { - "cell_type": "code", - "execution_count": 225, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " There are 199 Tools and Services with no properties\n", - "\n" - ] - } - ], - "source": [ - "print (f\"\\n There are {df_tool_flat_opt['properties'].isna().sum()} Tools and Services with no properties\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 226, - "metadata": {}, - "outputs": [], - "source": [ - "#TODO: Print/Save the Tools and Services with empty properties " - ] - }, - { - "cell_type": "code", - "execution_count": 239, - "metadata": {}, - "outputs": [], - "source": [ - "df_prop_data_ts = pd.json_normalize(data=df_tool_all['tools'], record_path='properties', meta_prefix='ts_', meta=['label'])\n", - "#df_prop_data_ts.sort_values('ts_label').head(7)" - ] - }, - { - "cell_type": "code", - "execution_count": 255, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Property Number of missing values\n" - ] - }, - { - "data": { - "text/plain": [ - "id 0\n", - "value 3263\n", - "type.code 0\n", - "type.label 0\n", - "type.type 0\n", - "type.ord 0\n", - "type.allowedVocabularies 3128\n", - "concept.code 3128\n", - "concept.vocabulary.code 3128\n", - "concept.vocabulary.label 3128\n", - "concept.vocabulary.accessibleAt 6391\n", - "concept.label 3128\n", - "concept.notation 3128\n", - "concept.definition 3128\n", - "concept.uri 3128\n", - "concept 6391\n", - "ts_label 0\n", - "dtype: int64" - ] - }, - "execution_count": 255, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_prop_data_ts = pd.json_normalize(data=df_tool_all['tools'], record_path='properties', meta_prefix='ts_', meta=['label'])\n", - "df_prop_data_ts['type.allowedVocabularies'] = df_prop_data_ts['type.allowedVocabularies'].apply(lambda y: np.nan if len(y)==0 else y)\n", - "print('{:<25}Number of missing values'.format(\"Property\"), end='\\n')\n", - "df_prop_data_ts.isnull().sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Values in *type.code*" - ] - }, - { - "cell_type": "code", - "execution_count": 266, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Type Code Frequency\n" - ] - }, - { - "data": { - "text/plain": [ - "media 1092\n", - "activity 1080\n", - "terms-of-use 916\n", - "tool-family 156\n", - "keyword 142\n", - "language 132\n", - "thumbnail 68\n", - "version 56\n", - "authentication 51\n", - "geographical-availabilities 15\n", - "life-cycle-status 15\n", - "technical-readiness-level 15\n", - "usermanual-url 11\n", - "source-last-update 11\n", - "service-level-url 9\n", - "see-also 9\n", - "helpdesk-url 6\n", - "termsofuse-url 5\n", - "privacypolicy-url 4\n", - "methodica-link 4\n", - "accesspolicy-url 3\n", - "pages 2\n", - "volume 1\n", - "repository-url 1\n", - "wikidata-id 1\n", - "doi 1\n", - "license 1\n", - "media-caption 1\n", - "Name: type.code, dtype: int64" - ] - }, - "execution_count": 266, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_df=df_prop_data_ts.drop_duplicates(['type.code','ts_label'])\n", - "df_temp_tc_label = a_df['type.code'].value_counts()\n", - "print('{:<28}Frequency'.format(\"Type Code\"), end='\\n')\n", - "df_temp_tc_label.head(39)" - ] - }, - { - "cell_type": "code", - "execution_count": 291, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idvaluetype.codetype.labeltype.typetype.ordtype.allowedVocabulariesconcept.codeconcept.vocabulary.codeconcept.vocabulary.labelconcept.vocabulary.accessibleAtconcept.labelconcept.notationconcept.definitionconcept.uriconceptts_label
6149181262Open Sourceterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNword2vec
6148181261Freeterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNword2vec
6226181814Freeterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNwordsimilarity (Word 2 Word)
6227181815Open Sourceterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNwordsimilarity (Word 2 Word)
6271179508Open Sourceterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNxMod
6268179505Freeterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNxMod
6303178536Closed Sourceterms-of-useTerms Of Usestring42NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNyED Files
\n", - "
" - ], - "text/plain": [ - " id value type.code type.label type.type type.ord \\\n", - "6149 181262 Open Source terms-of-use Terms Of Use string 42 \n", - "6148 181261 Free terms-of-use Terms Of Use string 42 \n", - "6226 181814 Free terms-of-use Terms Of Use string 42 \n", - "6227 181815 Open Source terms-of-use Terms Of Use string 42 \n", - "6271 179508 Open Source terms-of-use Terms Of Use string 42 \n", - "6268 179505 Free terms-of-use Terms Of Use string 42 \n", - "6303 178536 Closed Source terms-of-use Terms Of Use string 42 \n", - "\n", - " type.allowedVocabularies concept.code concept.vocabulary.code \\\n", - "6149 NaN NaN NaN \n", - "6148 NaN NaN NaN \n", - "6226 NaN NaN NaN \n", - "6227 NaN NaN NaN \n", - "6271 NaN NaN NaN \n", - "6268 NaN NaN NaN \n", - "6303 NaN NaN NaN \n", - "\n", - " concept.vocabulary.label concept.vocabulary.accessibleAt concept.label \\\n", - "6149 NaN NaN NaN \n", - "6148 NaN NaN NaN \n", - "6226 NaN NaN NaN \n", - "6227 NaN NaN NaN \n", - "6271 NaN NaN NaN \n", - "6268 NaN NaN NaN \n", - "6303 NaN NaN NaN \n", - "\n", - " concept.notation concept.definition concept.uri concept \\\n", - "6149 NaN NaN NaN NaN \n", - "6148 NaN NaN NaN NaN \n", - "6226 NaN NaN NaN NaN \n", - "6227 NaN NaN NaN NaN \n", - "6271 NaN NaN NaN NaN \n", - "6268 NaN NaN NaN NaN \n", - "6303 NaN NaN NaN NaN \n", - "\n", - " ts_label \n", - "6149 word2vec \n", - "6148 word2vec \n", - "6226 wordsimilarity (Word 2 Word) \n", - "6227 wordsimilarity (Word 2 Word) \n", - "6271 xMod \n", - "6268 xMod \n", - "6303 yED Files " - ] - }, - "execution_count": 291, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_prop_data_ts[(df_prop_data_ts['type.code']=='terms-of-use')].sort_values('ts_label').tail(7)" - ] - }, - { - "cell_type": "code", - "execution_count": 267, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ts_labeltypecodes
0140kit{activity, media}
13DF Zephyr - photogrammetry software - 3d mode...{language, keyword}
23DHOP{language, keyword}
33DHOP: 3D Heritage Online Presenter{keyword}
43DReshaper \\| 3DReshaper{language}
\n", - "
" - ], - "text/plain": [ - " ts_label typecodes\n", - "0 140kit {activity, media}\n", - "1 3DF Zephyr - photogrammetry software - 3d mode... {language, keyword}\n", - "2 3DHOP {language, keyword}\n", - "3 3DHOP: 3D Heritage Online Presenter {keyword}\n", - "4 3DReshaper \\| 3DReshaper {language}" - ] - }, - "execution_count": 267, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_typecode_ts=df_prop_data_ts[['ts_label', 'type.code']]\n", - "df_typecode_ts_flat=df_typecode_ts.groupby('ts_label')['type.code'].apply(set).reset_index(name='typecodes')\n", - "df_typecode_ts_flat.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 277, - "metadata": {}, - "outputs": [], - "source": [ - "from collections import Counter, defaultdict\n", - "import itertools\n", - "cooccurrences = []\n", - "\n", - "for props in df_typecode_ts_flat['typecodes']:\n", - " prop_pairs = itertools.combinations(props, 2)\n", - " for pair in prop_pairs:\n", - " cooccurrences.append(tuple(sorted(pair)))\n", - "\n", - "# Count the frequency of each cooccurring pair.\n", - "properties_co_counter = Counter(cooccurrences)" - ] - }, - { - "cell_type": "code", - "execution_count": 281, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Top TypeCodes Cooccurrences by Frequency \n", - "\n", - "Cooccurrence Frequency\n", - "[activity, media] 1013\n", - "[media, terms-of-use] 861\n", - "[activity, terms-of-use] 828\n", - "[media, tool-family] 156\n", - "[terms-of-use, tool-family] 151\n", - "[activity, tool-family] 143\n", - "[keyword, language] 90\n", - "[thumbnail, version] 56\n", - "[authentication, thumbnail] 51\n", - "[authentication, version] 51\n" - ] - } - ], - "source": [ - "print(\"Top TypeCodes Cooccurrences by Frequency\", '\\n')\n", - "print('{:<50}{}'.format('Cooccurrence', 'Frequency'))\n", - "for k, v in properties_co_counter.most_common(10):\n", - " topics = '['+k[0] + ', ' + k[1]+']'\n", - " print(f'{topics:<50}{v}')" - ] - }, - { - "cell_type": "code", - "execution_count": 282, - "metadata": {}, - "outputs": [], - "source": [ - "property_cooccurrences = list(\n", - " itertools.chain(*[[tuple(sorted(c)) for c in itertools.combinations(d, 2)] \n", - " for d in df_typecode_ts_flat['typecodes']])\n", - ")\n", - "# Count the frequency of each cooccurring pair.\n", - "property_edge_counter = Counter(property_cooccurrences)" - ] - }, - { - "cell_type": "code", - "execution_count": 283, - "metadata": {}, - "outputs": [], - "source": [ - "property_cooccurrence_df = pd.DataFrame({\n", - " 'prop0': [dcc[0] for dcc in property_edge_counter.keys()],\n", - " 'prop1': [dcc[1] for dcc in property_edge_counter.keys()],\n", - " 'count': list(property_edge_counter.values()),\n", - "}).pivot_table(index='prop0', columns='prop1')['count']" - ] - }, - { - "cell_type": "code", - "execution_count": 285, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "fig, ax = plt.subplots(figsize=(22, 18))\n", - "sns.heatmap(property_cooccurrence_df, annot=True, linewidths=0.2, fmt='.0f', ax=ax, cbar=None, cmap='Blues', linecolor='gray')\n", - "ax.set_xticklabels(ax.get_xticklabels(), rotation=30, ha='right')\n", - "ax.set_yticklabels(ax.get_yticklabels(), rotation=0)\n", - "ax.invert_yaxis()\n", - "ax.set_xlabel(None)\n", - "ax.set_ylabel(None)\n", - "#sns.heatmap(df, linewidths=2, linecolor='yellow')\n", - "title = 'Cooccurences of TypeCode in Tools and Services\\n'\n", - "plt.title(title, loc='left', fontsize=20)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Values in *concept.vocabulary.code*" - ] - }, - { - "cell_type": "code", - "execution_count": 299, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Type Code Frequency\n" - ] - }, - { - "data": { - "text/plain": [ - "tadirah2 1080\n", - "iso-639-3 130\n", - "iso-639-3-v2 2\n", - "software-license 1\n", - "Name: concept.vocabulary.code, dtype: int64" - ] - }, - "execution_count": 299, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "acvc_df=df_prop_data_ts.drop_duplicates(['concept.vocabulary.code','ts_label'])\n", - "df_temp_cvc_label = acvc_df['concept.vocabulary.code'].value_counts()\n", - "print('{:<18}Frequency'.format(\"Type Code\"), end='\\n')\n", - "df_temp_cvc_label.head(39)" - ] - }, - { - "cell_type": "code", - "execution_count": 301, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Analyzing 358\n", - "eng 130\n", - "Discovering 115\n", - "Disseminating 109\n", - "Capturing 108\n", - "Creating 58\n", - "Sharing 32\n", - "Visual Analysis 29\n", - "Annotating 28\n", - "Web Development 27\n", - "Organizing 25\n", - "Editing 19\n", - "Data Cleansing 18\n", - "Collaborating 16\n", - "Storing 15\n", - "Gathering 14\n", - "Publishing 13\n", - "Parsing 12\n", - "Content Analysis 8\n", - "Named Entity Recognition 8\n", - "Converting 6\n", - "Communicating 6\n", - "Tagging 5\n", - "Programming 5\n", - "Modeling 5\n", - "Writing 5\n", - "Imaging 4\n", - "Translating 4\n", - "Enriching 3\n", - "Spatial Analysis 3\n", - "Recording 3\n", - "Network Analysis 3\n", - "Identifying 3\n", - "Transcribing 2\n", - "Interpreting 2\n", - "Archiving 2\n", - "Englisch 2\n", - "Designing 2\n", - "Structural Analysis 2\n", - "Name: concept.label, dtype: int64" - ] - }, - "execution_count": 301, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_temp_cvc_concept = acvc_df['concept.label'].value_counts()\n", - "df_temp_cvc_concept.head(39)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}