From 2fc434a1a0b755b474d0ee9f50a5349a6f81b509 Mon Sep 17 00:00:00 2001 From: nparavicini7 Date: Tue, 8 Jul 2025 00:14:04 -0700 Subject: [PATCH 1/7] added item graph guide and sample --- .../itemgraph_and_remap_data.ipynb | 981 +++++++++++++ .../org_wide_dependency_graph.ipynb | 1264 +++++++++++++++++ 2 files changed, 2245 insertions(+) create mode 100644 guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb create mode 100644 samples/03_org_administrators/org_wide_dependency_graph.ipynb diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb new file mode 100644 index 0000000000..354c370e21 --- /dev/null +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -0,0 +1,981 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5a2b9ec3-226a-451d-8991-28f97107bb3d", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from arcgis.gis import GIS\n", + "from arcgis.apps.itemgraph import ItemGraph, create_dependency_graph\n", + "gis = GIS(profile=\"your_online_profile\")" + ] + }, + { + "cell_type": "markdown", + "id": "9c6bf122-1555-4798-adbe-706ad2dd89dc", + "metadata": {}, + "source": [ + "# Working with Item Dependencies and Data Sources\n", + "\n", + "Versions 2.4.0 and 2.4.1 of the ArcGIS API for Python introduced some very handy functionality for content management workflows: the `arcgis.apps.itemgraph` module and the `item.remap_data()` function. This functionality was added with a set of goals in mind: to give users the ability to understand what their org items need to exist, understand how the org items relate to one another, and easily fix org items with faulty components.\n", + "\n", + "The `itemgraph` module helps us accomplish these first two goals. The classes and functions in this module allow a user to create a directional graph documenting the relationships between different items in an org- start with a root item, and you'll be able to see all of the items it needs to exist, all of the items that those items then need to exist, and so on. \n", + "\n", + "`remap_data()` helps us accomplish the third goal. Say you have a complex application- once you know an item's dependencies, you can easily change or fix one. Additionally, if you have knowledge of the structure of your app, you can use this function to fix other components of it as well.\n", + "\n", + "Using these two things in conjunction with one another is a powerful combination, and we'll go over a basic but important workflow that leverages both of them.\n", + "\n", + "## The `arcgis.apps.itemgraph` Module\n", + "\n", + "### What is a Dependency?\n", + "\n", + "We'll start by examining 2 classes and a function that center around a core concept: creating a dependency graph that allows users to examine how items relate to eachother in their ArcGIS Online or Enterprise organizations. As mentioned above, these graphs inform us what items are required for other items to exist, and encompass the full range of dependency types for items. \n", + "\n", + "Before we dive a bit deeper into it, let's briefly go over a handful of the ways an item can be part of another item. There are tons of different item types in the ArcGIS universe, and the ways they all store and use data vary greatly; some are based on JSON structures, some are based on hosted services, and others on a variety of common (or uncommon) file types. Items can use other items in a wide range of ways, such as:\n", + "- source files for published layers (e.g., File GDB -> Feature Layer)\n", + "- visual components in a web-based app (e.g., a Web Map found in a StoryMap)\n", + "- attachments to other items (e.g., a Microsoft Word template in a Survey123 application)\n", + "\n", + "### Class Breakdown\n", + "\n", + "[The documentation for the module can be found here](https://developers.arcgis.com/python/latest/api-reference/arcgis.apps.itemgraph.html).\n", + "\n", + "Let's break down the 4 things we see in the doc:\n", + "#### - `ItemGraph`:\n", + " \n", + "The `ItemGraph` is the main structure that a user will be working with. It is built on top of [NetworkX's DiGraph class](https://networkx.org/documentation/stable/reference/classes/digraph.html), meaning it also gets access to all of NetworkX's DiGraph and Graph functionality. An `ItemGraph` is populated with instances of `ItemNode`, and can be created from scratch via `create_dependency_graph()` or from a priorly saved `ItemGraph` via `load_from_file`.\n", + "\n", + "#### - `ItemNode`:\n", + "\n", + " An `ItemNode` is an object that pertains to an indexed item/dependency. The node's `.id` property is an item's id, or a service's url. In the case of nodes with a valid `Item` object in the org tied to the item id, that `Item` object will be stored as the node's `.item` property. The `ItemNode` class has functions on it that allow a user to see an item's dependencies stored in the graph going in either direction, initial-level or recursive.\n", + "\n", + "#### - `create_dependency_graph()`:\n", + "\n", + " This is the main function that a user will use to construct an `ItemGraph`. Users feed in a list of `Item` objects or item id/url strings, and the function will recursively dissect any items or dependent items found and add everything to one `ItemGraph` returned back to a user. Users have the option to include items referenced from outside organizations in their graph, but these outside org items will not be explored for further dependencies. Additionally, for certain items that have reverse dependencies documented through their `related_items()` function, users have the option to include those in the graph as well.\n", + "\n", + "#### - `load_from_file()`:\n", + "\n", + "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved GML file format via `ItemGraph.write_to_file()`. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this guide(add link) for an advanced workflow demonstrating it.\n", + "\n", + "Now that we know the basics of the code, let's jump into it. We'll use `create_dependency_graph()` to create an `ItemGraph`, then examine `ItemNode` instances in the graph to learn what our org items contain, are contained by, require to exist, and are required by to exist. We'll start with a Survey123 item." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "63b63e9f-1912-49db-acfe-6ee0e7151107", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# first, grab a survey to see everything that is required for it to exist\n", + "survey_id = \"02d0702e1ef0468083f780791670c969\"\n", + "survey = gis.content.get(survey_id)\n", + "graph = create_dependency_graph(gis, [survey])\n", + "graph" + ] + }, + { + "cell_type": "markdown", + "id": "da409930-f779-44b8-982b-305f146ef6d9", + "metadata": {}, + "source": [ + "Calling `ItemGraph.all_items()` lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "08877035-6d84-40cc-b9eb-b32665d7efef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph.all_items(\"item\")" + ] + }, + { + "cell_type": "markdown", + "id": "4fa16c48-193c-4326-b3c1-3694e6a18f9d", + "metadata": {}, + "source": [ + "Let's grab and inspect an `ItemNode` instance by calling `ItemGraph.get_node()`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "80cdc270-5c10-4a33-bcd7-e54615f3b747", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ItemNode(id: 02d0702e1ef0468083f780791670c969, item: San Diego Parrot Sightings)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# now, let's grab a node and examine the structure\n", + "survey_node = graph.get_node(survey_id)\n", + "survey_node" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7073ad79-a286-41d0-bb35-6cedd74cf838", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " San Diego Parrot Sightings\n", + " \n", + "
Use this form to report sightings of parrots in San Diego.
Form by nparavicini_geosaurus\n", + "
Last Modified: March 13, 2024\n", + "
0 comments, 48 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# we can see the item attached to the node if we want\n", + "survey_node.item" + ] + }, + { + "cell_type": "markdown", + "id": "0d09ee89-4786-405c-a976-f7ee1c0238d4", + "metadata": {}, + "source": [ + "Now we'll examine dependencies of specific nodes." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ebf32e28-2a90-4c02-8fb5-c68e84649d9f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: a7192e06cfb446e1bab59849285e1038, item: San Diego Parrot Sightings_results),\n", + " ItemNode(id: d818128edbab44099238bc44e4bf2df0, item: summary_individual_temp),\n", + " ItemNode(id: 447ef32f6431488c9f9d7552f7d20ce0, item: individual_temp),\n", + " ItemNode(id: 588f0e0acc514c11bc7c898fed9fc651, item: Topographic),\n", + " ItemNode(id: 6a5d407b62954806ac31558c6774656f, item: summary_temp),\n", + " ItemNode(id: 9fccd6b78482414994eb2c19f90a44c8, item: San Diego Parrot Sightings_form)]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# contains() = items immediately used/referenced by the survey item\n", + "survey_node.contains()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "12740dd6-0b81-427c-a92e-1b0297b052d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 6a5d407b62954806ac31558c6774656f, item: summary_temp),\n", + " ItemNode(id: 588f0e0acc514c11bc7c898fed9fc651, item: Topographic),\n", + " ItemNode(id: a7192e06cfb446e1bab59849285e1038, item: San Diego Parrot Sightings_results),\n", + " ItemNode(id: 41dd3cca32914cc7ae8fd3a727f44e17, item: San Diego Parrot Sightings),\n", + " ItemNode(id: 447ef32f6431488c9f9d7552f7d20ce0, item: individual_temp),\n", + " ItemNode(id: 9fccd6b78482414994eb2c19f90a44c8, item: San Diego Parrot Sightings_form),\n", + " ItemNode(id: d818128edbab44099238bc44e4bf2df0, item: summary_individual_temp)]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# requires() = every item needed for the survey to exist\n", + "survey_node.requires()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a77d0662-0331-4b99-84b9-bfbe84ac2524", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " San Diego Parrot Sightings\n", + " \n", + "
Use this form to report sightings of parrots in San Diego.
Feature Layer Collection by nparavicini_geosaurus\n", + "
Last Modified: March 06, 2024\n", + "
0 comments, 57 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# conversely, we can grab a dependent item and see what items immediately contain it and need it to exist\n", + "result_form = graph.get_item(\"41dd3cca32914cc7ae8fd3a727f44e17\")\n", + "result_form.item" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5e5be5d7-a45e-4c6b-907f-67a7609764a9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: a7192e06cfb446e1bab59849285e1038, item: San Diego Parrot Sightings_results),\n", + " ItemNode(id: 9fccd6b78482414994eb2c19f90a44c8, item: San Diego Parrot Sightings_form)]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# contained_by() = items in the graph that immediately use/reference this feature layer item\n", + "result_form.contained_by()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "04def57a-c26e-4c96-9a68-3bce19e963de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 9fccd6b78482414994eb2c19f90a44c8, item: San Diego Parrot Sightings_form),\n", + " ItemNode(id: a7192e06cfb446e1bab59849285e1038, item: San Diego Parrot Sightings_results),\n", + " ItemNode(id: 02d0702e1ef0468083f780791670c969, item: San Diego Parrot Sightings)]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# required_by() = every item in the graph that needs this feature layer item to exist\n", + "result_form.required_by()" + ] + }, + { + "cell_type": "markdown", + "id": "fd1761f6-ef27-4201-b11d-a43bf1414c81", + "metadata": {}, + "source": [ + "An important thing to remember is that `create_dependency_graph()` finds relationships from the top down, so `contained_by()` and `required_by()` will only show items that have been analyzed along the way from our root node(s)- they're not a full picture of _every_ item in the organization that may contain or require a specific item, just the ones contained under the umbrella of our original items. However, `contains()` and `requires()` do indeed show every item in an org that are contained or required by a given item.\n", + "\n", + "To get the full, org-wide picture with `contained_by()` or `required_by()`, a graph would need to be made with every item in the organization. See this sample(insert link) for a guide on how to create and manage that type of graph." + ] + }, + { + "cell_type": "markdown", + "id": "fe80e250-bf3c-4999-a19e-e49beda7444e", + "metadata": {}, + "source": [ + "### The `Item.remap_data()` Function\n", + "\n", + "[The documentation for this function can be found here.](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)\n", + "\n", + "We've covered functionality that can identify items contained within other items- now let's take a look at functionality that can automate replacement of those items, or fix other parts of an application's structure. `remap_data()` is a powerful tool for working with your JSON-based applications in the ArcGIS system. At its core, it allows you to swap out data sources within your apps. Say you have multiple layers in a webmap you want to swap out, or a map present in a StoryMap- all you have to do is construct a replacement dictionary mapping your old item ID's to your new ones, and it will replace them, both in the draft and published versions of your app.\n", + "\n", + "When the `force` parameter is set to `False` (the default), some validation occurs under the hood. The function ensures that both items exist in the GIS organization, and that they're of the same type, so nothing gets messed up in the application. However, setting `Force` to `True` gives you more power, at the risk of altering the underlying structure without validation. You can use it to replace item ID's that no longer exist in the organization, change the name of something throughout the app, fix a typo, etc. It uses a regular expression to identify and replace instances of strings, so it will pick things up wherever they are in the structure.\n", + "\n", + "Let's look at a basic example of it in action. We'll examine the JSON of an application we're working with to note the effects." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "39361085-7850-49c8-9da5-f4d66251d640", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'operationalLayers': [{'id': '197e871ef5d-layer-2',\n", + " 'title': 'USA_Major_Cities',\n", + " 'url': 'https://services7.arcgis.com/JEwYeAy2cc8qOe3o/arcgis/rest/services/USA_Major_Cities_94522/FeatureServer/0',\n", + " 'itemId': 'ad8ead0c99044b94aef1d5a364e6629c',\n", + " 'layerType': 'ArcGISFeatureLayer',\n", + " 'popupInfo': {'popupElements': [{'type': 'fields'},\n", + " {'type': 'attachments', 'displayType': 'auto'}],\n", + " 'showAttachments': True,\n", + " 'fieldInfos': [{'fieldName': 'FID',\n", + " 'isEditable': False,\n", + " 'label': 'FID',\n", + " 'visible': False},\n", + " {'fieldName': 'NAME',\n", + " 'isEditable': True,\n", + " 'label': 'NAME',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_10_14',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_10_14',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_15_19',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_15_19',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_20_24',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_20_24',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_25_34',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_25_34',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_35_44',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_35_44',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_45_54',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_45_54',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_5_9',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_5_9',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_55_64',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_55_64',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_65_74',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_65_74',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_75_84',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_75_84',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_85_UP',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_85_UP',\n", + " 'visible': True},\n", + " {'fieldName': 'AGE_UNDER5',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AGE_UNDER5',\n", + " 'visible': True},\n", + " {'fieldName': 'AMERI_ES',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'AMERI_ES',\n", + " 'visible': True},\n", + " {'fieldName': 'ASIAN',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'ASIAN',\n", + " 'visible': True},\n", + " {'fieldName': 'AVE_FAM_SZ',\n", + " 'format': {'digitSeparator': True, 'places': 2},\n", + " 'isEditable': True,\n", + " 'label': 'AVE_FAM_SZ',\n", + " 'visible': True},\n", + " {'fieldName': 'AVE_HH_SZ',\n", + " 'format': {'digitSeparator': True, 'places': 2},\n", + " 'isEditable': True,\n", + " 'label': 'AVE_HH_SZ',\n", + " 'visible': True},\n", + " {'fieldName': 'BLACK',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'BLACK',\n", + " 'visible': True},\n", + " {'fieldName': 'CAPITAL',\n", + " 'isEditable': True,\n", + " 'label': 'CAPITAL',\n", + " 'visible': True},\n", + " {'fieldName': 'CLASS',\n", + " 'isEditable': True,\n", + " 'label': 'CLASS',\n", + " 'visible': True},\n", + " {'fieldName': 'FAMILIES',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'FAMILIES',\n", + " 'visible': True},\n", + " {'fieldName': 'FEMALES',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'FEMALES',\n", + " 'visible': True},\n", + " {'fieldName': 'FHH_CHILD',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'FHH_CHILD',\n", + " 'visible': True},\n", + " {'fieldName': 'FID_1',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'FID_1',\n", + " 'visible': True},\n", + " {'fieldName': 'HAWN_PI',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HAWN_PI',\n", + " 'visible': True},\n", + " {'fieldName': 'HISPANIC',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HISPANIC',\n", + " 'visible': True},\n", + " {'fieldName': 'HOUSEHOLDS',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HOUSEHOLDS',\n", + " 'visible': True},\n", + " {'fieldName': 'HSE_UNITS',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HSE_UNITS',\n", + " 'visible': True},\n", + " {'fieldName': 'HSEHLD_1_F',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HSEHLD_1_F',\n", + " 'visible': True},\n", + " {'fieldName': 'HSEHLD_1_M',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'HSEHLD_1_M',\n", + " 'visible': True},\n", + " {'fieldName': 'MALES',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'MALES',\n", + " 'visible': True},\n", + " {'fieldName': 'MARHH_CHD',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'MARHH_CHD',\n", + " 'visible': True},\n", + " {'fieldName': 'MARHH_NO_C',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'MARHH_NO_C',\n", + " 'visible': True},\n", + " {'fieldName': 'MED_AGE',\n", + " 'format': {'digitSeparator': True, 'places': 2},\n", + " 'isEditable': True,\n", + " 'label': 'MED_AGE',\n", + " 'visible': True},\n", + " {'fieldName': 'MED_AGE_F',\n", + " 'format': {'digitSeparator': True, 'places': 2},\n", + " 'isEditable': True,\n", + " 'label': 'MED_AGE_F',\n", + " 'visible': True},\n", + " {'fieldName': 'MED_AGE_M',\n", + " 'format': {'digitSeparator': True, 'places': 2},\n", + " 'isEditable': True,\n", + " 'label': 'MED_AGE_M',\n", + " 'visible': True},\n", + " {'fieldName': 'MHH_CHILD',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'MHH_CHILD',\n", + " 'visible': True},\n", + " {'fieldName': 'MULT_RACE',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'MULT_RACE',\n", + " 'visible': True},\n", + " {'fieldName': 'OTHER',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'OTHER',\n", + " 'visible': True},\n", + " {'fieldName': 'OWNER_OCC',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'OWNER_OCC',\n", + " 'visible': True},\n", + " {'fieldName': 'PLACEFIPS',\n", + " 'isEditable': True,\n", + " 'label': 'PLACEFIPS',\n", + " 'visible': True},\n", + " {'fieldName': 'POP_CLASS',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'POP_CLASS',\n", + " 'visible': True},\n", + " {'fieldName': 'POP2010',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'POP2010',\n", + " 'visible': True},\n", + " {'fieldName': 'POPULATION',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'POPULATION',\n", + " 'visible': True},\n", + " {'fieldName': 'RENTER_OCC',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'RENTER_OCC',\n", + " 'visible': True},\n", + " {'fieldName': 'ST', 'isEditable': True, 'label': 'ST', 'visible': True},\n", + " {'fieldName': 'STFIPS',\n", + " 'isEditable': True,\n", + " 'label': 'STFIPS',\n", + " 'visible': True},\n", + " {'fieldName': 'VACANT',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'VACANT',\n", + " 'visible': True},\n", + " {'fieldName': 'WHITE',\n", + " 'format': {'digitSeparator': True, 'places': 0},\n", + " 'isEditable': True,\n", + " 'label': 'WHITE',\n", + " 'visible': True}],\n", + " 'title': 'USA_Major_Cities: {NAME}'}}],\n", + " 'baseMap': {'baseMapLayers': [{'id': 'World_Hillshade_3689',\n", + " 'opacity': 1,\n", + " 'title': 'World Hillshade',\n", + " 'url': 'https://services.arcgisonline.com/arcgis/rest/services/Elevation/World_Hillshade/MapServer',\n", + " 'visibility': True,\n", + " 'layerType': 'ArcGISTiledMapServiceLayer'},\n", + " {'id': 'VectorTile_6451',\n", + " 'opacity': 1,\n", + " 'title': 'World Topographic Map',\n", + " 'visibility': True,\n", + " 'layerType': 'VectorTileLayer',\n", + " 'styleUrl': 'https://cdn.arcgis.com/sharing/rest/content/items/7dc6cea0b1764a1f9af2e679f642f0f5/resources/styles/root.json'}],\n", + " 'title': 'Topographic'},\n", + " 'authoringApp': 'ArcGISMapViewer',\n", + " 'authoringAppVersion': '2025.2',\n", + " 'initialState': {'viewpoint': {'targetGeometry': {'spatialReference': {'latestWkid': 3857,\n", + " 'wkid': 102100},\n", + " 'xmin': -29758310.977920525,\n", + " 'ymin': -13360173.707963193,\n", + " 'xmax': 6559672.893375559,\n", + " 'ymax': 20335714.345038887}}},\n", + " 'spatialReference': {'latestWkid': 3857, 'wkid': 102100},\n", + " 'timeZone': 'system',\n", + " 'version': '2.34'}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basic_map = gis.content.get(\"a9ace97e3fdc415d943675d5ba75901e\")\n", + "old_json = basic_map.get_data()\n", + "old_json" + ] + }, + { + "cell_type": "markdown", + "id": "bb3391f5-d6ad-4c7f-ae84-24cb4855f7c3", + "metadata": {}, + "source": [ + "Now, let's look what happens when we run `remap_data()` to replace the layer in our map with a different one. We'll compare some of the new layer values with the old." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c529db76-a941-49a0-bc2d-8bf5d81f05da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Old: ad8ead0c99044b94aef1d5a364e6629c, New: 2113d04eade0432784e8edd336193e68\n", + "Old: USA_Major_Cities, New: CA/OR Airports\n", + "Old: https://services7.arcgis.com/JEwYeAy2cc8qOe3o/arcgis/rest/services/USA_Major_Cities_94522/FeatureServer/0, New: https://services7.arcgis.com/JEwYeAy2cc8qOe3o/arcgis/rest/services/ad363a_87e5a/FeatureServer/0\n" + ] + } + ], + "source": [ + "basic_map.remap_data({\"ad8ead0c99044b94aef1d5a364e6629c\" : \"2113d04eade0432784e8edd336193e68\"})\n", + "new_json = basic_map.get_data()\n", + "\n", + "for key in [\"itemId\", \"title\", \"url\"]:\n", + " old_value = old_json['operationalLayers'][0][key]\n", + " new_value = new_json['operationalLayers'][0][key]\n", + " print(f\"Old: {old_value}, New: {new_value}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6cca8bb8-0033-4faf-b3b1-e59b3e3fd2ea", + "metadata": {}, + "source": [ + "### Putting it Together\n", + "\n", + "Now that we've seen how these things work, let's see how we can use them to speed up what might be an otherwise tedious workflow.\n", + "\n", + "Put yourself in the shoes of an admin that has been tasked with the process of migrating items to a new portal. Before migrating, you want to ensure that all of your items (such as your complex apps) are rendering correctly and not missing any data sources, but don't want to manually click through each one and/or their drafts. How can we more efficiently find out what's missing?\n", + "\n", + "We can create a dependency graph, and then look at which item ID's within the graph don't correspond to existent or accessible items. Let's show a quick example of this by looking at a StoryMap with some broken pieces within it, and show how easy it is to detect and fix it. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a3cd6a7a-c4ab-4efb-81a3-a31f18bedde2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: fd5801d2f66b43e1a20146d8761f758b, item: Oh heavens),\n", + " ItemNode(id: faa67b0af7914a2f9f4d96c561816c6e),\n", + " ItemNode(id: 35983e54e61a40b8ac03148e197452ac, item: PLACES: Arthritis),\n", + " ItemNode(id: 3b7221d4e47740cab9235b839fa55cd7, item: PLACES: Local Data for Better Health),\n", + " ItemNode(id: 7099b3c2e979415e975d00e58afed77e, item: Map that should totally work),\n", + " ItemNode(id: baaf98d1695f47db8d5dc701c0e5f864, item: Read-Only CA/OR Airports),\n", + " ItemNode(id: 0384ujr43n53490890843t543ojf809re)]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the dependency construction will look for all item id's, but won't retrieve items from broken id's or outside org items\n", + "storymap = gis.content.get(\"fd5801d2f66b43e1a20146d8761f758b\")\n", + "graph2 = create_dependency_graph(gis, [storymap])\n", + "graph2.all_items()" + ] + }, + { + "cell_type": "markdown", + "id": "4e9b5f84-8c50-4ef0-a6a3-4391f6b9ec86", + "metadata": {}, + "source": [ + "We can see that there are certain nodes in our graph that don't have items attached to them. This means that there are dependencies that won't render anything in our apps, meaning they're broken and should be replaced. Let's isolate them." + ] + }, + { + "attachments": { + "6011ce85-3e62-475c-9d46-d7f3600af61a.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "903887ff-25a0-475c-8188-0cb013db0181", + "metadata": {}, + "source": [ + "Just to relate it visually, let's see what the two problematic webmaps in our StoryMap look like.\n", + "![Screenshot 2025-07-07 at 10.47.11 PM.png](attachment:6011ce85-3e62-475c-9d46-d7f3600af61a.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "babead65-dd21-49d4-910f-c59afda275ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "faa67b0af7914a2f9f4d96c561816c6e\n", + "0384ujr43n53490890843t543ojf809re\n" + ] + } + ], + "source": [ + "# note how some of these items don't have items attached\n", + "# that means they're inaccessible in this org or don't exist\n", + "for node in graph2.all_items():\n", + " if node.item == None:\n", + " print(node.id)" + ] + }, + { + "cell_type": "markdown", + "id": "bb18a9d2-b1b0-422f-ad69-5295cc6c4d24", + "metadata": {}, + "source": [ + "We can do a little magic with matplotlib to visualize where these items are present and figure out which apps we need to replace them in." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2e52b45c-eaa1-4f0d-8aab-113d3fe9f6dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# let's visualize how they fit into the graph to see what we need to fix\n", + "# we can do this by employing matplotlib and networkx\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "pos = nx.spring_layout(graph2) # positions for all nodes\n", + "nx.draw(graph2, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=6, font_color=\"green\")\n", + "nx.draw_networkx_labels(graph2, pos, labels=nx.get_node_attributes(graph2, 'label'))\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "bda3bfa0-4582-4093-b89f-d786ffcbdd67", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " Map that should totally work\n", + " \n", + "

Web Map by nparavicini_geosaurus\n", + "
Last Modified: March 12, 2025\n", + "
0 comments, 74 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# so we can see that one of them is from our root item, and one is from a dependent item\n", + "# let's see what that sub item is\n", + "sub_node = graph2.get_item(\"7099b3c2e979415e975d00e58afed77e\")\n", + "webmap = sub_node.item\n", + "webmap" + ] + }, + { + "cell_type": "markdown", + "id": "8d958e5a-23e1-4102-9a0b-31052b189d93", + "metadata": {}, + "source": [ + "With some suitable replacements for our broken data sources, we can call `remap_data()` on the apps that contain them." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d399f7b6-4116-4cba-8e38-2e58389bd7fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# now that we know where our two problematic id's exist, we can replace them and fix our storymap\n", + "# we can use the item class's remap_data() function to easily do this. let's identify some replacements\n", + "bad_layer_id = \"0384ujr43n53490890843t543ojf809re\"\n", + "bad_webmap_id = \"faa67b0af7914a2f9f4d96c561816c6e\"\n", + "new_layer_id = \"55c85385338d434ba1194d9b2c2a60c8\"\n", + "new_webmap_id = \"865ec0112fde477788c4f51c4a7baae6\"\n", + "# we call remap_data() on the item containing the dependencies to be swapped\n", + "storymap.remap_data({bad_webmap_id : new_webmap_id}, force = True)\n", + "webmap.remap_data({bad_layer_id : new_layer_id}, force = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "7900128c-19d2-437e-a4ea-e61fc3071f7d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: fd5801d2f66b43e1a20146d8761f758b, item: Oh heavens),\n", + " ItemNode(id: 865ec0112fde477788c4f51c4a7baae6, item: clone map different layer id),\n", + " ItemNode(id: 2113d04eade0432784e8edd336193e68, item: CA/OR Airports),\n", + " ItemNode(id: 35983e54e61a40b8ac03148e197452ac, item: PLACES: Arthritis),\n", + " ItemNode(id: 3b7221d4e47740cab9235b839fa55cd7, item: PLACES: Local Data for Better Health),\n", + " ItemNode(id: 7099b3c2e979415e975d00e58afed77e, item: Map that should totally work),\n", + " ItemNode(id: baaf98d1695f47db8d5dc701c0e5f864, item: Read-Only CA/OR Airports),\n", + " ItemNode(id: 55c85385338d434ba1194d9b2c2a60c8, item: polygons),\n", + " ItemNode(id: d3a24f71ee864118968fa24e572c6dc2, item: polygons)]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# now, we can make a new graph from the storymap and see if everything looks right\n", + "graph2_updated = create_dependency_graph(gis, [storymap])\n", + "graph2_updated.all_items()" + ] + }, + { + "attachments": { + "58a41056-8e57-4d53-a674-0e9bd42120e5.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "04919247-3da1-4a6b-89d7-955a163f14fc", + "metadata": {}, + "source": [ + "And finally, let's see what our the maps in our StoryMap look like, just to confirm what we did through automation. Tada!\n", + "![Screenshot 2025-07-07 at 10.41.46 PM.png](attachment:58a41056-8e57-4d53-a674-0e9bd42120e5.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/samples/03_org_administrators/org_wide_dependency_graph.ipynb b/samples/03_org_administrators/org_wide_dependency_graph.ipynb new file mode 100644 index 0000000000..8012f994b8 --- /dev/null +++ b/samples/03_org_administrators/org_wide_dependency_graph.ipynb @@ -0,0 +1,1264 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2b116b66-8015-4742-8115-bcb0f09a6e10", + "metadata": {}, + "source": [ + "# Working with an Organization-Wide Dependency Graph" + ] + }, + { + "cell_type": "markdown", + "id": "a8fd2570-ff4b-4cec-9269-cbf542cd66af", + "metadata": {}, + "source": [ + "Version 2.4.1 of the ArcGIS API for Python brought about some exciting new functionality for content management: the `arcgis.apps.itemgraph` module. This module, in it's most basic usage, allows you to take an item in an organization and examine the deep dependencies of it- what items it needs to exist, what items those items need to exist, and so on. This is very helpful for management of apps and smaller subsets of org items, but what if we really want to push the limits of what we can do with this module?\n", + "\n", + "With a little patience and creativity, we can create an actively-updated dependency graph that encapsulates every item in our organization. Doing so opens up all sorts of doors for us, such as:\n", + "- The ability to examine the total reverse dependencies of an item (e.g., take a feature layer- we can see every app or map in our org that requires it to exist, or that will be effected by a change to it\n", + "- Quick identification of all broken dependencies in our organization\n", + "- Sorting of org items by complexity (most vs. least dependencies)\n", + "\n", + "In this sample, we'll provide code to create and update an organization-wide graph, glean information from our graph, and then finally include a section on how to automate this process via ArcGIS Notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "19637729-09c6-4094-8fd4-c7daf9b94299", + "metadata": {}, + "source": [ + "## Part 1: Creating and Updating an Org-Wide Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3d4c3a05-240c-4906-9509-75ccaba0c625", + "metadata": {}, + "source": [ + "from arcgis.gis import GIS\n", + "from arcgis.apps.itemgraph import create_dependency_graph, load_from_file\n", + "import datetime\n", + "import networkx as nx\n", + "gis = GIS(\"home\")" + ] + }, + { + "cell_type": "markdown", + "id": "e74b49d1-0290-4634-9313-ceaf3334512e", + "metadata": {}, + "source": [ + "### Initial Run\n", + "\n", + "This builds the initial dependency graph by indexing over every single item in the organization. This only needs to be run once, and will likely take a very long time, depending on how many items are in the org. Once it's been run and the graph structure and time stamp are saved into files, this notebook that updates the dependency graph can be run. This first cell can also be executed outside of ArcGIS Notebooks, and the .gml and .txt files can be brought in from elsewhere.\n", + "\n", + "*Note: Comment out this cell after the first time running the notebook.*" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7d4665-5542-4d80-866b-c10e6081fc3b", + "metadata": {}, + "outputs": [], + "source": [ + "# only run this cell the very first time you index over your org and grab all the dependencies\n", + "# this will take a long time if the org has a ton of items\n", + "\n", + "import datetime\n", + "items = gis.content.search(\"\", max_items = 10000)\n", + "timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", + "graph = create_dependency_graph(gis, items)\n", + "graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", + " file.write(str(timestamp))" + ] + }, + { + "cell_type": "markdown", + "id": "adf0a4ab-8fc1-4152-bd96-82f88bb219d1", + "metadata": {}, + "source": [ + "Now, we have a snapshot of every item in the organization and how they relate to one another. But, what if we don't want to run this lengthy initial step every time we want to work with this graph? And what if there are items that are getting created, updated, and deleted, so the relationships in this graph might become outdated? This notebook will go over how we can use specific capabilities of the ItemGraph to examine massive graphs without re-indexing, and will include code that will update the graph through automation, meaning that scheduling this notebook to run will ensure that your organization-wide dependency graph stays up to date." + ] + }, + { + "cell_type": "markdown", + "id": "f4146031-7653-4d06-b2b6-563048535186", + "metadata": {}, + "source": [ + "### Efficiently Analyzing the Existent Graph\n", + "\n", + "When loading up an existent graph based on a .gml file, it still may take some time to retrieve every single item associated with each node in the graph, especially for organizations with thousands and thousands of items. If you want to instantly analyze the items and relationships in a .gml file with thousands of records, we can call `load_to_file()` and elect to *not* retrieve each item. This still gives us the power to view all item id's and their dependencies in the org, but without the overhead of retrieving each one from a REST endpoint first. Users can simply retrieve the associated items as needed, based on the id's.\n", + "\n", + "We'll show a quick example of this using the existent graph, and then use a graph loaded with the items to ensure we're up-to-date with the current state of organization. We'll only print the first few for the sake of keeping this page short." + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "63d6a566-4e5d-495f-b448-cf452db3f967", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3643" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fast_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, False)\n", + "len(fast_graph.all_items())" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "08e88638-8b71-4340-b912-88e0b5d71ddd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 72c2671bff1143c4bc577755bc00a7aa),\n", + " ItemNode(id: 405b512903e74ec0af5ce2083b863705),\n", + " ItemNode(id: 039e2c7e648b4a5d9d64c57b470d7397),\n", + " ItemNode(id: 64a096654b924b2998ed07a747524e96),\n", + " ItemNode(id: e12e8599965c43af9632a5c9633c2994),\n", + " ItemNode(id: 5b534fa4a26d4fd1868ea7509806b053),\n", + " ItemNode(id: 96cf6c756ee74c288a8a88788f980266),\n", + " ItemNode(id: 64480b5bfc474ab1a464fa18098c92e5),\n", + " ItemNode(id: 14d12cc813b2422db0f4b7b1b701bcc1),\n", + " ItemNode(id: 5a1a8ac568a942b792c1283b7acff602),\n", + " ItemNode(id: dc5014dff7014a23af6eff25b492bce6),\n", + " ItemNode(id: 1fcbf4e77ebc46ef9971d1194f412c3b),\n", + " ItemNode(id: fc02404cdda24f72842d34b28267d77a),\n", + " ItemNode(id: 4cc1488a3c134af9abbe0a268d50b499),\n", + " ItemNode(id: 24ca75398c494dad8b4e7104e2a640d5),\n", + " ItemNode(id: 4839158f96544bafb841c1739d84f11b),\n", + " ItemNode(id: 9b9de0ff974e4924b15bc278ad6d6676),\n", + " ItemNode(id: 87c2394212ad42bcb89de9e244d4072d),\n", + " ItemNode(id: 13697d5ab62449e78dd9c28037380592),\n", + " ItemNode(id: a93fd45749ec4773839f02623ebad01d)]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fast_graph.all_items()[:20]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8a3c2f4b-c416-4ef5-bb22-a1d24a628da8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " Latin America\n", + " \n", + "

Mobile Map Package by esri_nav\n", + "
Last Modified: October 01, 2017\n", + "
0 comments, 0 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random_node = fast_graph.all_items()[0]\n", + "gis.content.get(random_node.id)" + ] + }, + { + "cell_type": "markdown", + "id": "8d0d126a-8b82-4b52-ab64-b9fb8231a836", + "metadata": {}, + "source": [ + "As we can see, we can instantly load in this complicated graph and just grab the `Item` associated with a given node as needed. However, for this next part, we're going to need to retrieve everything in the graph, which could take a while; that's why it's meant for some scheduled automation.\n", + "\n", + "### Automation: Updating our Org-Wide Graph\n", + "\n", + "The items in our org might not be the same as the ones we had in it yesterday- that's why we want to update our graph periodically. We can use some attributes of the `ItemGraph` class and some networkx tricks to maintain an up-to-date record of everything in the org.\n", + "\n", + "We'll start by loading up our existent graph stored in the .gml file with every `Item` attached. This may take a while to do, depending on how many items must be retrieved. We retrieve the items so that later we can verify which ones still exist and which ones have been deleted." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ccf52250-3b9e-47e2-bcb2-81d82473d515", + "metadata": {}, + "outputs": [], + "source": [ + "# grab the graph created yesterday to update it\n", + "old_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, True)" + ] + }, + { + "cell_type": "markdown", + "id": "cfe9d923-1528-4e9c-9ffb-d48783bcd977", + "metadata": {}, + "source": [ + "Keeping timestamps allows us to understand when the last time we updated the graph was and maintain an accurate graph. This approach allows for the scheduling of this notebook on any timeframe- whether you run it every day, every week, every month, or something else." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c3989f2-7047-48dc-ac27-e941f8cc0f3b", + "metadata": {}, + "outputs": [], + "source": [ + "# grab our old and new timestamps\n", + "# old is the last time we updated the graph, new is current time\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"r\") as file:\n", + " old_timestamp = int(file.read())\n", + "new_timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", + "\n", + "# use these timestamps to see items that have been modified or created since last run\n", + "q = f\"modified: [{old_timestamp} TO {new_timestamp}]\"\n", + "modified_items = gis.content.search(query = q, sort_field = \"modified\", sort_order = \"desc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1dcbf4d7-02e0-471c-bd64-8e69e0462a96", + "metadata": {}, + "outputs": [], + "source": [ + "# now that we have our list of updated items, make a graph out of them\n", + "mod_graph = create_dependency_graph(gis, modified_items)" + ] + }, + { + "cell_type": "markdown", + "id": "f9a664b7-6bc8-46e5-b8e9-3972d371508e", + "metadata": {}, + "source": [ + "Now we have a graph containing only new/modified items, and all of their dependencies. We'll have to combine the new information in this graph with our existent graph, and delete the outdated information. Time for some fun graph operations!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9605f93b-b732-4379-9636-b2e9340d57b4", + "metadata": {}, + "outputs": [], + "source": [ + "# nx.compose() combines all nodes and relationships of two graphs\n", + "new_graph = nx.compose(old_graph, mod_graph)\n", + "\n", + "# find the list of items in both graphs\n", + "# these are ones that already existed but were modified, meaning dependencies might have changed\n", + "intersects = set(old_graph.all_items('id')) & set(mod_graph.all_items('id'))\n", + "\n", + "# go through these items and delete outdated forward dependencies\n", + "for itemid in list(intersects):\n", + " old_contains = set(old_graph.get_node(itemid).contains(\"id\"))\n", + " mod_contains = set(mod_graph.get_node(itemid).contains(\"id\"))\n", + " \n", + " # isolate deps that only existed in old graph\n", + " outdated = old_contains - mod_contains\n", + "\n", + " # remove these relationships from the new graph\n", + " for dep in list(outdated):\n", + " new_graph.delete_relationship(itemid, dep)" + ] + }, + { + "cell_type": "markdown", + "id": "2d76e7f6-2c07-4c45-9f3a-37112d3f26d9", + "metadata": {}, + "source": [ + "Our `new_graph` now has an accurate reflection of all item relationships in our organization- any item that got changed could have had it's forward dependencies altered, so we made sure that those got updated to reflect any changes. We didn't have to worry about changing any reverse dependencies, since every reverse dependency is still just a forward dependency for another item, so the appropriate relationship was addressed during that process.\n", + "\n", + "We have one more little housekeeping thing to do with this new graph now- due to the way that `nx.compose()` works, the individual nodes within the new graph still contain references to the old graph. We just have to make sure those nodes now use the new graph for any computation." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "730ad8cc-a7a9-4e3f-8088-015b5e59790e", + "metadata": {}, + "outputs": [], + "source": [ + "# make sure our nodes are all referencing the new updated graph\n", + "for node in new_graph.all_items():\n", + " node.graph = new_graph" + ] + }, + { + "cell_type": "markdown", + "id": "4db9c02d-b77f-42e6-bc31-250055ff1846", + "metadata": {}, + "source": [ + "Alright, awesome, now we have all newly created or recently modified items accounted for- but we still have to account for items that might have been deleted. How do we do this? \n", + "\n", + "Remember when we ran the `load_from_file()` function earlier that retrieved all of the items while rebuilding the graph? Well, any node of an item that's been deleted won't have an attached `Item` object anymore, since it wouldn't have been retrieved. Therefore, if we have a node with no associated item, we can assume the item has been deleted, and that if the node is not contained by another node, then the item is not still meant to exist. So, we can delete nodes from our graph that fit that criteria.\n", + "\n", + "One added layer of complexity: what if the node of a deleted item is contained by another node of a deleted item that just hasn't been processed yet? We can avoid this scenario by sorting our nodes in ascending order of how many items they're required by, ensuring we're prioritizing processing ones furthest up the dependency chains first (e.g., deleted item A contains B which contains C- if we analyze B or C first, we'll wrongfully keep them, but if we start with A and go down the chain, all will get deleted properly)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "96cea807-c561-4408-aa42-4153d752fc98", + "metadata": {}, + "outputs": [], + "source": [ + "nodes = new_graph.all_items()\n", + "\n", + "# define our sort function\n", + "def count_reqs(node):\n", + " return len(node.required_by(\"id\"))\n", + "\n", + "# this orders our nodes properly\n", + "sorted_nodes = sorted(nodes, key=count_reqs)\n", + "\n", + "# remove ones that don't have items and aren't dependencies of others\n", + "for node in sorted_nodes:\n", + " if not node.item and not node.contained_by():\n", + " new_graph.remove_node(node.id)" + ] + }, + { + "cell_type": "markdown", + "id": "d89a380c-1f85-4326-8372-37b74bb5aa00", + "metadata": {}, + "source": [ + "And there we have it. Now we have a properly updated graph, one that reflects today's state of every item and their dependencies. Grabbing a node for a given item from `new_graph` should give you a holistic look of all items it relates to in an org, no matter if it's an immediate or deep relationship in either direction. To summarize, we:\n", + "\n", + "- Loaded in the graph from the last time we ran the notebook\n", + "- Determined what items had been modified/created since the last time we ran the notebook\n", + "- Created a graph from those updated items, capturing their current dependencies\n", + "- Merged the old graph with the modified graph to create a new graph with all nodes/relationships from both graphs\n", + "- Got rid of relationships that no longer existed from the new graph\n", + "- Got rid of any items that had been deleted and weren't dependencies of an item from the new graph\n", + "\n", + "Now, we'll write out the state of this graph and the timestamp at which we started everything, so we can repeat this process in the future and continue to update our graph as the items in our ArcGIS organization evolve." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ef2845ff-c2cd-428d-9ff4-486ed0c8160c", + "metadata": {}, + "outputs": [], + "source": [ + "new_graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", + " file.write(str(timestamp))" + ] + }, + { + "cell_type": "markdown", + "id": "08f5ef15-cf3f-4317-bca6-794761166f70", + "metadata": {}, + "source": [ + "# Part 2: Using the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "587f19ea-923c-4001-ad87-5dde5129b99b", + "metadata": {}, + "source": [ + "Now that we have our organization-wide graph and know that it's up to date, we can use it for some useful administration and analysis. We'll take a look at the three things mentioned in the intro: examining comprehensive reverse dependencies of items, identifying broken dependencies that need fixing, and sorting our items based on their complexity." + ] + }, + { + "cell_type": "markdown", + "id": "b60c0fc9-4523-4a93-bf0a-47be12ff689a", + "metadata": {}, + "source": [ + "### Comprehensive Reverse Dependencies\n", + "\n", + "This is a very powerful perk of having every relationship in an organization included in a graph: the ability to see _every_ single item that relies on a specific item. Say you have a feature layer that is used in numerous maps and applications throughout your org: you can instantly acquire a list of every one that consumes it, either directly or indirectly. Let's take a look." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "35636665-42d0-486d-a1bc-e9aae10bed2c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " World Topographic Map\n", + " \n", + "
This vector tile layer provides a world topographic map. (World Edition)
Vector Tile Layer by esri_livingatlas\n", + "
Last Modified: April 26, 2025\n", + "
0 comments, 0 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# grab a node corresponding to a feature layer\n", + "flayer_id = \"7dc6cea0b1764a1f9af2e679f642f0f5\"\n", + "flayer_node = new_graph.get_node(flayer_id)\n", + "flayer_node.item" + ] + }, + { + "cell_type": "markdown", + "id": "51ccb876-369a-4636-9112-f0f9c39b94b0", + "metadata": {}, + "source": [ + "Calling `.contained_by()` will show all of the items that contain our vector tile layer." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "cb088e78-1ffa-4b89-ac4e-25526b372388", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "flayer_node.contained_by(\"item\")" + ] + }, + { + "cell_type": "markdown", + "id": "d6328f75-6018-4c7a-b275-2ebfded5985f", + "metadata": {}, + "source": [ + "Calling `.required_by()` will show us all of the items that depend on our layer in some way." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0af9dea-2b2b-46ca-a9ee-faff7e7c6b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "flayer_node.required_by(\"item\")" + ] + }, + { + "cell_type": "markdown", + "id": "d4df1dfe-a652-4655-a60b-694877f9f9a9", + "metadata": {}, + "source": [ + "There we have it- we instantly determined which items would be affected by deleting or changing our layer." + ] + }, + { + "cell_type": "markdown", + "id": "e1c1bdf8-834e-4e8c-b7ad-c513e3593814", + "metadata": {}, + "source": [ + "### Finding Broken Dependencies\n", + "\n", + "In this context, we're calling an item that is contained by another item, but isn't valid or accessible, a \"broken\" dependency- these sorts of items can lead to rendering or logic issues in applications such as Web Maps, StoryMaps, Experiences, Surveys, and so on. There can be a number of reasons for why these improper dependencies may exist- an item being used by an application mistakenly got deleted, there was some sort of corruption with data, the json structure of an application might have been copied from one in a different org, and so on.\n", + "\n", + "Luckily, the way the `ItemGraph` is constructed allows us to instantly find these cases where something is potentially awry. During construction of the graph, the ID of each `ItemNode` was passed into the GIS org to see if it yielded an item. Therefore, any node that doesn't have an `.item` property could potentially be a problem." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d50fcf1d-107f-4bbf-a21f-3ebcfd0c0fb2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 370b95fdf676475ca8fd184ad0931610),\n", + " ItemNode(id: 1dc6042bb3ba409c9d1eb1d7c996d6ed),\n", + " ItemNode(id: bf08d46ab087435aa4afbc62092223cb),\n", + " ItemNode(id: 123hehethiswontwork),\n", + " ItemNode(id: 2fe20a161c514e16b805a21a7e2d636b),\n", + " ItemNode(id: 15efb8c0d9e3447782789592f432fc1a),\n", + " ItemNode(id: bda2f1dc3c824c3e97f4a682554177cf),\n", + " ItemNode(id: bbf4d26d7c3340dab009c7164cc3e1e5),\n", + " ItemNode(id: d60affb34dd948a1b973da076830ad00),\n", + " ItemNode(id: 1182ef6f62a543fdba4a55c85c014431),\n", + " ItemNode(id: f32924d7b16f41d78839dba3b943b08c),\n", + " ItemNode(id: 9f91d4c34f194da793c8573b24a751a9),\n", + " ItemNode(id: 91fa101048bb4855970f7d004a4542ce),\n", + " ItemNode(id: 6e02b538bea841ed858ef9f52709b655),\n", + " ItemNode(id: 878802f78aad4ab5a83c1397c72048c5),\n", + " ItemNode(id: f1801a1b3d674de7b9de246a126eb17b),\n", + " ItemNode(id: 2),\n", + " ItemNode(id: 44c3348139a84423b4a46074a104efdf),\n", + " ItemNode(id: 74ab88e7e22d4dbd93b43a00b2d0155b),\n", + " ItemNode(id: 306cf223a2fd46d3bf6ce39225681977),\n", + " ItemNode(id: 1ee3200825ce448c91a1ec9ae4f70c28),\n", + " ItemNode(id: 72224efc9e044001934bb3be87120beb),\n", + " ItemNode(id: 90ff936dc4704a0798f61ebbb1dec357),\n", + " ItemNode(id: 0df19d2d940b47658857cc2fc9623840),\n", + " ItemNode(id: cdf23b869e7649469759cf756c1d43f0),\n", + " ItemNode(id: a5f11273b85d40adbd7cf9a162f81ef2),\n", + " ItemNode(id: 08a9b819b9e04de9a68418f2b225ec6a),\n", + " ItemNode(id: f265c79c47a3413b8b8f711909f03fe2),\n", + " ItemNode(id: 819ee7ddbf5848889effd0fa6b039a51),\n", + " ItemNode(id: 8548e23d8b1a478eaf2246e6fc3b31b9),\n", + " ItemNode(id: f97edbe48af7427f8604f20320e2de52),\n", + " ItemNode(id: b66792b3bb004fa8997fcfcef991e984),\n", + " ItemNode(id: 9204269c8e714500a565a3ddf055825d),\n", + " ItemNode(id: 28dae0b8f1c44814b281b71752453c61),\n", + " ItemNode(id: d15c117e60dd4fe299ec03a379c9caf8),\n", + " ItemNode(id: 3b6d38a456164adea4c061a2a51d89b1),\n", + " ItemNode(id: a12fcbe07c8d41f1b6981f33a10d1d0c),\n", + " ItemNode(id: ae4bea7c35824bf1ae571783142dc97d),\n", + " ItemNode(id: 8e969d9adb7f485c88a8350d317e8c9b),\n", + " ItemNode(id: 493db5d6832b44a581547a8df8c3907c),\n", + " ItemNode(id: ebe640ee5d344bea9fca7bfa4d80bb3a),\n", + " ItemNode(id: 6595a5cf08d64212a85ce9dc47700575),\n", + " ItemNode(id: 761e9fcf5efa4b368716fae9a1ffda0f),\n", + " ItemNode(id: 39f0fc3c5b424d679c2ef9ae67e71624),\n", + " ItemNode(id: 59835c8d71d94475ae04f540a8167343),\n", + " ItemNode(id: 5b2e49a83dd9427abf398aeeecc00f75),\n", + " ItemNode(id: dcf4a23abb614d7db9cda2dce90cc528),\n", + " ItemNode(id: 1d250ce2c5c0463abe0e1887597cc926),\n", + " ItemNode(id: e57b96c732cc4c34830756d53c8f3619),\n", + " ItemNode(id: 79f3399102ce4ab79bed0407b03005fc),\n", + " ItemNode(id: 872d78b038d342b98b6a3547ed8a7ac9),\n", + " ItemNode(id: 3a2d7671322e4dcbb386e4b961e28c27),\n", + " ItemNode(id: 8900b18d92ac43cfae142a5a5ad91e4a),\n", + " ItemNode(id: ba6575ad916041a89887309492473b42),\n", + " ItemNode(id: 5bbbe8978d9f43a0a7a947b5af3cdc1d),\n", + " ItemNode(id: 73196ca49b6b40c0a03206663cb10554),\n", + " ItemNode(id: 9566f596ba404a05aa8eae9221bce82a),\n", + " ItemNode(id: c2e2b6eaea3740059546951c16af5151),\n", + " ItemNode(id: 4cee55fa5973406596359e7630ab167e),\n", + " ItemNode(id: 086eb0c799794d4b99a95a39cd43dca2),\n", + " ItemNode(id: 6313031ddbe14d7ca0358c4ba8011b27),\n", + " ItemNode(id: bc68a4d142fb4801a2401a0a5a551ba1),\n", + " ItemNode(id: 07b7fe74b02c40afa1551d41f19f6d99),\n", + " ItemNode(id: 632d3de849224fcb990f6d9feae36331),\n", + " ItemNode(id: 26e87527293b43978b1fb4a24133ead1),\n", + " ItemNode(id: efff5de20fd546de94e613fbed730372),\n", + " ItemNode(id: 401d890c10d94e88948a0bd5f82e7559),\n", + " ItemNode(id: 8cf058d7e58d4f66831e8bc7ae7addbd),\n", + " ItemNode(id: fed737361fcf4815b2b62651e1cd2a57),\n", + " ItemNode(id: 46472e81856c4420aeb091e6f0fd24e8),\n", + " ItemNode(id: d1414cb87c2d41099cfcfe55aa8344e2),\n", + " ItemNode(id: c2f21b0e86de49fa9b6437cd72779488),\n", + " ItemNode(id: 77efb9bd7831430ab3788741d327e5df),\n", + " ItemNode(id: 633c43f3c0e148dea129d6ca49e7fd22),\n", + " ItemNode(id: 3dce15e4178a4a9c92cacb66f2f7f1ea),\n", + " ItemNode(id: 2a6e5de8aa4a40899e44017121c5cd89),\n", + " ItemNode(id: bccbd571d0d54e45b6a69ca0249e7132),\n", + " ItemNode(id: c8cbf786be774df7b064f149c5898fef),\n", + " ItemNode(id: 71276e9e9638459890a3072df64e31b6),\n", + " ItemNode(id: a06302053b3f4e35961584d5818bf1f2),\n", + " ItemNode(id: 5feee1e7f41a4c47b3f137457c130182),\n", + " ItemNode(id: 6e403956c5d7419b9c0628e65bed0769),\n", + " ItemNode(id: 196b5b2798204de38b6dd125823bd714),\n", + " ItemNode(id: 88ba2cd25d1c423c808fa2e1941a540b),\n", + " ItemNode(id: c1e6eb63502c4012bb631097b69aefad),\n", + " ItemNode(id: 4c56c5e083544decbd8d61f3a0bc5a67),\n", + " ItemNode(id: 905567641b10499ba6a77a0a6e4e5f13),\n", + " ItemNode(id: 861096f2cb274134bcdca7e875899d69),\n", + " ItemNode(id: 3afb37e1c7784a05b7d0b4c4c98088c1),\n", + " ItemNode(id: ae5179630d714200893cda3a6e50e460),\n", + " ItemNode(id: 2243cb05a01f43cc8d7439447ffe3bbf),\n", + " ItemNode(id: 27d2f0ad1c7545e48848b43bbd51581a),\n", + " ItemNode(id: 9dc85299a77540b0bac1507ce67e9dfa),\n", + " ItemNode(id: 16ffb93988c94d699b672d837c1e03e6),\n", + " ItemNode(id: 3668c924551b4ff2a508cd2cda897abe),\n", + " ItemNode(id: c2e075d098a6493393dc3f55876d48f4),\n", + " ItemNode(id: 53071c1408d240c1997a3779c48467b4),\n", + " ItemNode(id: 36a01f823259430197c896ff415ee493),\n", + " ItemNode(id: 21e0d7322928434d8889eba70e4c645a),\n", + " ItemNode(id: 3e5ba2fec29f4f25afd5a5dbfaadf136),\n", + " ItemNode(id: d79cd0205b03479b8019648e1dd057f4),\n", + " ItemNode(id: 8461fdc33b554ffbad1ba54afd1ff499),\n", + " ItemNode(id: 940e3b1543bf4289822790a15e66c5a4),\n", + " ItemNode(id: 15e70e3da80b42fd9b60eda8cd6e7cd4),\n", + " ItemNode(id: 4438ff8fb9174783934412c1c51f4865),\n", + " ItemNode(id: db089afa931a4a9fb1cb2afe33a6c2f6),\n", + " ItemNode(id: ba0ff62d9aaf4f628eb1a869c0bb5ee0),\n", + " ItemNode(id: d50ecf25a35a4cd9baaa1ba7035f77da),\n", + " ItemNode(id: 76e505d722f64fa6b0debd0f196c3ae1),\n", + " ItemNode(id: dfcdd3b0495d4f4cb3c3a4a401616d6e),\n", + " ItemNode(id: 03bcd4dfbeae4a91ae270a934fa27e1b),\n", + " ItemNode(id: 1c5e01156f5a4f0fae4dc61297785c1d),\n", + " ItemNode(id: 16d1d5083719466487007bf90313184f),\n", + " ItemNode(id: 2f87efbdf4ec4942ad610fe4b6bd8c36),\n", + " ItemNode(id: 97162f48110d4458820c3b66de375d67),\n", + " ItemNode(id: e98bc26706ba46c782c03c81c739a065),\n", + " ItemNode(id: 8d721aaa69aa4715911693fa4863b7cf),\n", + " ItemNode(id: 7a238f29b99f4ff1957e3a469177c56a),\n", + " ItemNode(id: ff9cafd475ff4a0abf5d8f3a34fc7646),\n", + " ItemNode(id: ae00236efed94d0b8739ef8a244cc312),\n", + " ItemNode(id: 12b7fd7eaefc4f40b2fe003604153b3c),\n", + " ItemNode(id: 1f2248e4464b4065a864cc6aab7aa780),\n", + " ItemNode(id: c13634e58a024cae9de6a15a4b3eb101),\n", + " ItemNode(id: bd6943458948460a8eb71d97baaa2ada),\n", + " ItemNode(id: 6fafb84fc46d4b9c8b25fb57dd9911a2),\n", + " ItemNode(id: c209e14b44b7420cb40ed650cfefa4f5),\n", + " ItemNode(id: 048de0545a834d8b8c31a6e0e10270d7),\n", + " ItemNode(id: 40bf682bf17c4c32a5acade2d54eafb9),\n", + " ItemNode(id: e608d5be1b4241cdbb1fbf61418513d6),\n", + " ItemNode(id: 908ceeaa2e5e4ef19e823715a35ab978),\n", + " ItemNode(id: 7d907c5ac31b4da098d47922bb31f2aa),\n", + " ItemNode(id: 5dd87bebb9864dac9c2f42604bb79b14),\n", + " ItemNode(id: 78186ce321f1433091aeb2593abbc565),\n", + " ItemNode(id: cb7a89a516e84af7b3d7e551a38afed5),\n", + " ItemNode(id: 6b63dafabf4e486183c21bede31b149e),\n", + " ItemNode(id: a962b03a45d9415ea97b96eaab7f20d6),\n", + " ItemNode(id: ac96d6152ba34373ac1c7288b2fcefe4),\n", + " ItemNode(id: d0d5d3caafed43cd9ce18b9a2609fc5f),\n", + " ItemNode(id: d9b8675be48d49078db4c55208a0d19e),\n", + " ItemNode(id: 2defd52c9e4f4759ba085f339d284cd4),\n", + " ItemNode(id: 961434231c034930801f5b3237715587),\n", + " ItemNode(id: af83304d94cd4e0da83318f76cde60c4),\n", + " ItemNode(id: 85179dd8a0fe4ea597586fed851bdeff),\n", + " ItemNode(id: d5e20e6f7a9542d5ace62983699d3212),\n", + " ItemNode(id: e3e1712a046d4feeb454e5538a6049d7),\n", + " ItemNode(id: 045ba64dd5bc4b1a94350f897de956cf),\n", + " ItemNode(id: 4fb8f3f5422d4a7696b0f8136a4b48aa),\n", + " ItemNode(id: 75113e1eb7e045229c2cb2698e43114c),\n", + " ItemNode(id: 228834a1eff64c629c80d0b638f9e43c),\n", + " ItemNode(id: 42b653e394104606987cbf4b6d1587f9),\n", + " ItemNode(id: 2c82e7cf420b4026b875ad45750c7a24),\n", + " ItemNode(id: f1894e0262e44dd6adadef875577d8aa),\n", + " ItemNode(id: 4f93f1fbebdd4f66a55b6a02f332fa20),\n", + " ItemNode(id: caa4a0e4ddcb47c9845eb92f024fcd7f),\n", + " ItemNode(id: 1a9c7b34467d41728f9472a0b6628841),\n", + " ItemNode(id: 7f4342f006a44c8780d8df79d5da5652),\n", + " ItemNode(id: a90891b098034e0d928fc4ee30dec1a3),\n", + " ItemNode(id: caa7ab7f82ab41dd9af1215c11f55a8f),\n", + " ItemNode(id: bb46d017f7af49728d5af8d8eec43c4e),\n", + " ItemNode(id: a5df7d4a77c24fc39a1115122370cd8f),\n", + " ItemNode(id: 879921e888a14e96b5f5b339af907acd),\n", + " ItemNode(id: 8dd1b1b7731c49839489e0d30146f513),\n", + " ItemNode(id: eb0499aeb1d5461f877e9b40534e225e),\n", + " ItemNode(id: 4138c0fbe6b446fbad5447ecc34c8ab8),\n", + " ItemNode(id: e2ee852f11c14d99814dd4ed42a0a16c),\n", + " ItemNode(id: e27013ac9f664054a044edd3567c763a),\n", + " ItemNode(id: ee527fed605a4088b10c49ab9c9ed096),\n", + " ItemNode(id: a7cdce7ebb404ae6b700b491f21b3243),\n", + " ItemNode(id: e0dfd02f8f61479c8e1a276c79cafcd5),\n", + " ItemNode(id: 3d0d28a295e54d25966e7945e2bf5d8e),\n", + " ItemNode(id: d8e9dfe815b44c8ab3e94a6dc1fcf201),\n", + " ItemNode(id: 3ce93787d12645f386d42d57ca57c1b4),\n", + " ItemNode(id: 9c03b76829464ee68d4e6af241cebd5e),\n", + " ItemNode(id: 5707b86b5f3f4b7c9e67ac2fd317254a),\n", + " ItemNode(id: 79719a8a27d3440d9d622041ff7b8506),\n", + " ItemNode(id: 1adc07ec24774989873cafc6c68c1536),\n", + " ItemNode(id: 1926c33e9bf34ef99b8950f1408368a3),\n", + " ItemNode(id: 892a696bf2aa4a899f5177017d998156),\n", + " ItemNode(id: 57654725661049eba50bca930ae786e8),\n", + " ItemNode(id: c85179865e0c45089e0f9bb29b7ca83e),\n", + " ItemNode(id: b9cb2d66aaa04093950683767c8eaff0),\n", + " ItemNode(id: c9b04902a93c4aeda9b92e45b303fe01),\n", + " ItemNode(id: 1c8354e6f69e4df1969befae339412c7),\n", + " ItemNode(id: ed2246c081ee49369024cfb312e34899),\n", + " ItemNode(id: 6d6bae1a02484353add60ddefaca185e),\n", + " ItemNode(id: a143d4fe84e14712bfd28e71b26ac868),\n", + " ItemNode(id: d822827df8f345d280ebf2c2be8a48a1),\n", + " ItemNode(id: 3f4789f0a58b4cdcab5b7d1a08f5f9d9),\n", + " ItemNode(id: f091f6195a194f38a47f8b329bbd9255),\n", + " ItemNode(id: 7f7c4245f03445e782e9aa4a4d06221d),\n", + " ItemNode(id: 07a05ca8a10843aba797076d40ca8f36),\n", + " ItemNode(id: https://oceans1.arcgis.com/arcgis/rest/services/USA_Drilling_Platforms/FeatureServer/0),\n", + " ItemNode(id: e26f2752e86d4a8dad52ea75501480f0),\n", + " ItemNode(id: aecf7fd35dca43fe80fc67b60fb73516),\n", + " ItemNode(id: ab924202cc404af58b41efcf99b0aafa),\n", + " ItemNode(id: 1c735ebaed8d48b5bfd6fcfcd35eb3d1),\n", + " ItemNode(id: a5846d8e82834f4398fb54e0ef0db0c5),\n", + " ItemNode(id: bbf872949f2f43a6921e716f7fbe1d72),\n", + " ItemNode(id: 1c80207bf5384974994ad4a13abf4556)]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "no_item_nodes = [node for node in new_graph.all_items() if not node.item]\n", + "no_item_nodes" + ] + }, + { + "cell_type": "markdown", + "id": "f621f913-9b8c-47e0-b7d3-619410223d9c", + "metadata": {}, + "source": [ + "As we can see, we now have a list of nodes where the ID's don't lead to a portal item. There is one anomaly here: what appears to be a service that just doesn't have an associated portal item, but still may be valid. We can add some separate logic to ensure we test any URL for valid data." + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "5d0a224d-de59-4b6f-ad86-b209c5a91340", + "metadata": {}, + "outputs": [], + "source": [ + "from arcgis.layers import Service\n", + "updated_no_item = []\n", + "for node in no_item_nodes:\n", + " if \"https://\" in node.id:\n", + " try:\n", + " serv = Service(node.id)\n", + " if not serv:\n", + " raise\n", + " except:\n", + " updated_no_item.append(node)\n", + " else:\n", + " updated_no_item.append(node)" + ] + }, + { + "cell_type": "markdown", + "id": "fd4c5d32-2f52-44d0-a59d-c5beaec43493", + "metadata": {}, + "source": [ + "Given this list of items with ID's that lead nowhere, we can grab the node for any one of them and do what we did above- see which org items contain or require them. From there, we can figure out how to fix it- one option is using the `remap_data()` function, documented [here](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "de01da8b-84f6-4f46-864d-ceb41b31e9e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents)]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "broken_node = updated_no_item[0]\n", + "broken_node.contained_by()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "c4f3a39d-9c0b-4659-8705-6b114ca3a635", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents),\n", + " ItemNode(id: d3b24b91f2c3432fbb5b7d2862f7525d, item: TestInstantApp),\n", + " ItemNode(id: 7259119a69044ae4aebd3e4cd338321f, item: AZ Vehicle App)]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "broken_node.required_by()" + ] + }, + { + "cell_type": "markdown", + "id": "014807cf-c9e1-442f-9d74-22b7a215e99a", + "metadata": {}, + "source": [ + "### Sorting Items by Degree, Type, and More\n", + "\n", + "Finally, let's put ourselves in the shoes of an organization admin that wants to learn about the items in their org: which items have the most dependencies, and which ones are needed by the most items? Which ones have the most broken dependencies? Let's take a look at how we can capitalize on some graph logic and networkx tricks to gain insights into our organization's content." + ] + }, + { + "cell_type": "markdown", + "id": "c2e3cf87-7861-4b60-ae6a-55fb62215042", + "metadata": {}, + "source": [ + "We'll start basic: just identify which nodes have the highest _degree_, or number of direct relationships (\"contains\"/\"contained by\"). Since a degree can refer to either direction relationship, we specify the _out_ degree or _in_ degree, which in an `ItemGraph` will show the amount of each node's `contains()` and `contained_by()`, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "e0de0bbf-eacd-4791-97ed-a7e948adca7b", + "metadata": {}, + "outputs": [], + "source": [ + "def sort_degrees(direction = \"out\", descending = True, result_count = 50):\n", + " node_degrees = new_graph.out_degree()\n", + " if direction == \"in\":\n", + " node_degrees = new_graph.in_degree()\n", + " nodes_sorted = sorted(node_degrees, key=lambda item: item[1], reverse=descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " graph_node = new_graph.get_node(node)\n", + " if graph_node.item:\n", + " print(f\"Title: {graph_node.item.title}, Type: {graph_node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node}, Degree: {degree}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "6975d920-3314-484e-8a6e-af5929b18d42", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", + "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", + "Title: San Diego Parrot Sightings, Type: Form, Degree: 6\n", + "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 6\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 4\n", + "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", + "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", + "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", + "Title: TestInstantApp, Type: Web Mapping Application, Degree: 3\n", + "Title: map test, Type: Web Map, Degree: 3\n", + "Title: Cycling Explorer, Type: Web Map, Degree: 3\n", + "Title: AZ and NM Cities, Type: Web Map, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", + "Title: map test, Type: Web Map, Degree: 3\n", + "Title: Group Layer Map Test, Type: Web Map, Degree: 3\n", + "Title: Map Series 884411, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 213975, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 959005, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 537579, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 845552, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 836403, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 639470, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 816182, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 398285, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 985608, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 287154, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 396347, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 684806, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 709821, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 587161, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 255073, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 553493, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 329174, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 37166, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 261798, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 395417, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 326103, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 116930, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 222445, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 432118, Type: Web Mapping Application, Degree: 3\n", + "Title: USA WebMap, Type: Web Map, Degree: 3\n", + "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 692346, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 772573, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 254278, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 19528, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 238550, Type: Web Mapping Application, Degree: 3\n" + ] + } + ], + "source": [ + "# find which items contain the most other items\n", + "sort_degrees(direction = \"out\", descending = True, result_count = 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "6c7a1bc2-b888-4cd0-8d8e-8cf5c9e30ab5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ID: bf08d46ab087435aa4afbc62092223cb, Degree: 153\n", + "ID: 123hehethiswontwork, Degree: 153\n", + "ID: 7f7c4245f03445e782e9aa4a4d06221d, Degree: 33\n", + "ID: 07a05ca8a10843aba797076d40ca8f36, Degree: 33\n", + "Title: World Topographic Map, Type: Vector Tile Service, Degree: 8\n", + "Title: Web Map 400800, Type: Web Map, Degree: 7\n", + "Title: Outline Map, Type: Web Map, Degree: 7\n", + "Title: Newspaper (WGS84), Type: Vector Tile Service, Degree: 5\n", + "Title: OpenStreetMap Streets with Relief, Type: Vector Tile Service, Degree: 5\n", + "ID: 2, Degree: 3\n", + "Title: Esri_Regional_Offices_US, Type: File Geodatabase, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 2\n", + "Title: Basic, Type: Web Mapping Application, Degree: 2\n", + "Title: AGO World Geocoder (arcgis_python), Type: Geocoding Service, Degree: 2\n", + "ID: 2fe20a161c514e16b805a21a7e2d636b, Degree: 2\n", + "ID: 15efb8c0d9e3447782789592f432fc1a, Degree: 2\n", + "ID: bda2f1dc3c824c3e97f4a682554177cf, Degree: 2\n", + "ID: d60affb34dd948a1b973da076830ad00, Degree: 2\n", + "ID: f32924d7b16f41d78839dba3b943b08c, Degree: 2\n", + "ID: 9f91d4c34f194da793c8573b24a751a9, Degree: 2\n", + "ID: 91fa101048bb4855970f7d004a4542ce, Degree: 2\n", + "ID: 6e02b538bea841ed858ef9f52709b655, Degree: 2\n", + "Title: National Weather Service Day 1, Type: WMS, Degree: 2\n", + "Title: Enhanced Contrast Dark Map (WGS84), Type: Web Map, Degree: 2\n", + "ID: 44c3348139a84423b4a46074a104efdf, Degree: 2\n", + "Title: Test Case 12305 Survey, Type: Feature Service, Degree: 2\n", + "Title: Test Case 232 A, Type: Feature Service, Degree: 2\n", + "Title: USA_Major_Cities_Data, Type: Feature Service, Degree: 2\n", + "Title: San Diego Parrot Sightings, Type: Feature Service, Degree: 2\n", + "Title: DevSummit Theme, Type: StoryMap Theme, Degree: 2\n", + "Title: ca_public_schools, Type: Feature Service, Degree: 2\n", + "ID: cdf23b869e7649469759cf756c1d43f0, Degree: 2\n", + "ID: a5f11273b85d40adbd7cf9a162f81ef2, Degree: 2\n", + "ID: 08a9b819b9e04de9a68418f2b225ec6a, Degree: 2\n", + "ID: f265c79c47a3413b8b8f711909f03fe2, Degree: 2\n", + "ID: 819ee7ddbf5848889effd0fa6b039a51, Degree: 2\n", + "ID: 8548e23d8b1a478eaf2246e6fc3b31b9, Degree: 2\n", + "ID: f97edbe48af7427f8604f20320e2de52, Degree: 2\n", + "ID: b66792b3bb004fa8997fcfcef991e984, Degree: 2\n", + "ID: 9204269c8e714500a565a3ddf055825d, Degree: 2\n", + "ID: 28dae0b8f1c44814b281b71752453c61, Degree: 2\n", + "ID: d15c117e60dd4fe299ec03a379c9caf8, Degree: 2\n", + "ID: 3b6d38a456164adea4c061a2a51d89b1, Degree: 2\n", + "ID: a12fcbe07c8d41f1b6981f33a10d1d0c, Degree: 2\n", + "ID: ae4bea7c35824bf1ae571783142dc97d, Degree: 2\n", + "ID: 8e969d9adb7f485c88a8350d317e8c9b, Degree: 2\n", + "ID: 493db5d6832b44a581547a8df8c3907c, Degree: 2\n", + "ID: ebe640ee5d344bea9fca7bfa4d80bb3a, Degree: 2\n" + ] + } + ], + "source": [ + "# find which items are contained by the most other items\n", + "sort_degrees(direction = \"in\", descending = True, result_count = 50)" + ] + }, + { + "cell_type": "markdown", + "id": "cc04967d-5a99-47ef-bb95-85ee2e09b7c6", + "metadata": {}, + "source": [ + "We can similarly define a function that will do that for the \"deep\" degrees- finding which items have the most recursive dependencies or items dependent upon them." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "49a220a2-87e7-42c9-ab0a-da043e689aba", + "metadata": {}, + "outputs": [], + "source": [ + "def sort_deep_degrees(direction = \"out\", descending = True, result_count = 50):\n", + " if direction == \"in\":\n", + " nodes_weighted = [(node, len(node.required_by())) for node in new_graph.all_items()]\n", + " else:\n", + " nodes_weighted = [(node, len(node.requires())) for node in new_graph.all_items()]\n", + " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " if node.item:\n", + " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node.id}, Degree: {degree}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "f03263b2-d5a1-4097-a36e-f77e7a8ce65f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Title: Testing Copy Content, Type: StoryMap, Degree: 159\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: DS-Page1-copy-1745540879568, Type: Hub Page, Degree: 14\n", + "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", + "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", + "Title: TestInstantApp, Type: Web Mapping Application, Degree: 8\n", + "Title: San Diego Parrot Sightings, Type: Form, Degree: 8\n", + "Title: All About Arizona and New Mexico, Type: StoryMap, Degree: 8\n", + "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 8\n", + "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 7\n", + "Title: Formerly Local, Now Global Experience, Type: Web Experience, Degree: 6\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 5\n", + "Title: AZ and NM Cities, Type: Web Map, Degree: 5\n", + "Title: Ruff Ruff, Type: StoryMap, Degree: 5\n", + "Title: Group Layer Map Test, Type: Web Map, Degree: 5\n", + "Title: LimerickStoryMap, Type: StoryMap, Degree: 5\n", + "Title: test_cat_selector, Type: Dashboard, Degree: 5\n", + "Title: Copy this story, Type: StoryMap, Degree: 4\n", + "Title: map test, Type: Web Map, Degree: 4\n", + "Title: Cycling Explorer, Type: Web Map, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", + "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", + "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", + "Title: Nothing Funny About This Test - updated PR, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test2, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test - updated PR, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test - updated PR1, Type: Web Experience, Degree: 3\n", + "Title: No Image Test, Type: Web Experience, Degree: 3\n", + "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", + "Title: No Image Test, Type: Web Experience, Degree: 3\n", + "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", + "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", + "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n" + ] + } + ], + "source": [ + "sort_deep_degrees()" + ] + }, + { + "cell_type": "markdown", + "id": "d2e9dc54-59e5-4503-8ba8-267dbe9e6e25", + "metadata": {}, + "source": [ + "Finally, we can construct a custom function that can do the two prior bits, plus sort items by type, and define the result count. This allows us to easily filter and search our org's items with additional context on the weight of their dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "07dea0a0-ab93-45f1-bfde-cb13573c393d", + "metadata": {}, + "outputs": [], + "source": [ + "def filter_nodes(direction = \"out\", deep = False, descending = True, item_type = None, result_count: int = None):\n", + " if item_type:\n", + " nodes_filtered = [node for node in new_graph.all_items() if node.item and node.item.type == item_type]\n", + " else:\n", + " nodes_filtered = new_graph.all_items()\n", + " if direction == \"in\" and deep:\n", + " nodes_weighted = [(node, len(node.required_by())) for node in nodes_filtered]\n", + " elif direction == \"out\" and deep:\n", + " nodes_weighted = [(node, len(node.requires())) for node in nodes_filtered]\n", + " elif direction == \"in\" and not deep:\n", + " nodes_weighted = [(node, len(node.contained_by())) for node in nodes_filtered]\n", + " else:\n", + " nodes_weighted = [(node, len(node.contains())) for node in nodes_filtered]\n", + " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " if node.item:\n", + " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node.id}, Degree: {degree}\")" + ] + }, + { + "cell_type": "markdown", + "id": "83550b88-950f-48b8-8c39-bb9364540e52", + "metadata": {}, + "source": [ + "## Part 3: Automating this Notebook" + ] + }, + { + "cell_type": "markdown", + "id": "b57d4e60-b053-4136-a47b-59b442080af8", + "metadata": {}, + "source": [ + "Everything we've done in this notebook is purely informative- no changes, additions, or deletions to org items were done. All we've done is update and manipulate or ItemGraph in memory and written out to file. So what does this mean? \n", + "\n", + "This means that you can download this very notebook and run it for yourself. Keeping this notebook run on a consistent timeframe will provide you with an up-to-date graph to analyze your org items. ArcGIS Notebooks, in both ArcGIS Online and ArcGIS Enteprise, provide us with an easy way to schedule automation of notebooks. Let's take a look how.\n", + "\n", + "### Scheduling a Task\n", + "\n", + "A \"task\" is a command to run a given notebook. You can create scheduled tasks that dictate when and how often to run a notebook. Each time the notebook is run according to the schedule you set, the site opens a new container and runs the notebook without user control.\n", + "\n", + "To access this function, open the \"Tasks\" pane in the notebook editor. You can schedule it to run just once in the future or on a recurring basis— from once every 15 minutes to once every 6 months.\n", + "\n", + "Once you click on the Tasks pane, you will be prompted to provide a title for the Task." + ] + }, + { + "cell_type": "markdown", + "id": "81ad1aee-9219-4490-a9bf-eda1ab7907d7", + "metadata": {}, + "source": [ + "![Image](https://github.com/user-attachments/assets/0e374e87-e08d-4789-9cb8-e6a387ac18f6)" + ] + }, + { + "cell_type": "markdown", + "id": "3ac566c6-cdca-4a13-abb0-78c0c460fec8", + "metadata": {}, + "source": [ + "You can also set other specific parameters for when and how often you would like for this notebook to run." + ] + }, + { + "cell_type": "markdown", + "id": "d36908b0-1cf0-479b-8356-9a89c0c65535", + "metadata": {}, + "source": [ + "![parameters](https://github.com/user-attachments/assets/551a68f5-976a-47ea-83c1-257c99643ffd)" + ] + }, + { + "cell_type": "markdown", + "id": "b2cdebf2-1d01-4ea5-8001-dd15a79963ad", + "metadata": {}, + "source": [ + "Once you have created this task, you can find it under the Tasks pane, and can pause, delete or edit it as necessary. " + ] + }, + { + "cell_type": "markdown", + "id": "f47c1284-c735-4688-9618-94fa954b9d5f", + "metadata": {}, + "source": [ + "![tasks](https://github.com/user-attachments/assets/975a6137-1cf7-4e6c-ae1c-85342b534d7f)" + ] + }, + { + "cell_type": "markdown", + "id": "79eb8bb0-cf28-43dd-b8c0-07fba4addfc9", + "metadata": {}, + "source": [ + "> Note: For Notebooks in ArcGIS Online, you can have a maximum of 10 active tasks across all your notebooks. If you pause some of your active tasks, you will be allowed to create more tasks until you reach 10 active tasks again. For Notebooks in ArcGIS Enterprise, the default number of maximum active tasks is set at 20. Administrators of an organization have the privilege to [change that limit](https://developers.arcgis.com/rest/enterprise-administration/portal/limits-system). " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From e266ed0d0ddc53a714ce70613098c86085540dc1 Mon Sep 17 00:00:00 2001 From: John Yaist Date: Tue, 8 Jul 2025 11:40:01 -0700 Subject: [PATCH 2/7] added some hyperlinks and markdown format updates --- .../itemgraph_and_remap_data.ipynb | 60 +- .../org_wide_dependency_graph.ipynb | 2527 +++++++++-------- 2 files changed, 1303 insertions(+), 1284 deletions(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 354c370e21..1822ec6001 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -1,5 +1,21 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "d001bd9c-9c51-465f-8f4c-3e5b70a791d5", + "metadata": {}, + "source": [ + "# Working with Item Dependencies and Data Sources" + ] + }, + { + "cell_type": "markdown", + "id": "25fe73d4-40ed-41af-adcc-8dd97479a1ce", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -19,47 +35,49 @@ "id": "9c6bf122-1555-4798-adbe-706ad2dd89dc", "metadata": {}, "source": [ - "# Working with Item Dependencies and Data Sources\n", - "\n", - "Versions 2.4.0 and 2.4.1 of the ArcGIS API for Python introduced some very handy functionality for content management workflows: the `arcgis.apps.itemgraph` module and the `item.remap_data()` function. This functionality was added with a set of goals in mind: to give users the ability to understand what their org items need to exist, understand how the org items relate to one another, and easily fix org items with faulty components.\n", + "Versions 2.4.0 and 2.4.1 of the ArcGIS API for Python introduced some very handy functionality for content management workflows: the [`arcgis.apps.itemgraph`](/python/latest/api-reference/arcgis.apps.itemgraph.html) module and the [`item.remap_data()`](/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data) function. The primary goals of this added functionality: \n", + "* provide the ability to understand what organizational items need in order to exist\n", + "* understand how organizational items relate to one another\n", + "* update organizational items with invalid components\n", "\n", - "The `itemgraph` module helps us accomplish these first two goals. The classes and functions in this module allow a user to create a directional graph documenting the relationships between different items in an org- start with a root item, and you'll be able to see all of the items it needs to exist, all of the items that those items then need to exist, and so on. \n", + "The [`itemgraph`](/python/latest/api-reference/arcgis.apps.itemgraph.html) module accomplishes these first two goals. The classes and functions in this module allow a user to create a directional graph documenting the relationships between different items in an organization- starting with a root item, you'll be able to see all of the items it needs to exist, all of the items that those items need to exist, and so on. \n", "\n", - "`remap_data()` helps us accomplish the third goal. Say you have a complex application- once you know an item's dependencies, you can easily change or fix one. Additionally, if you have knowledge of the structure of your app, you can use this function to fix other components of it as well.\n", + "The [`remap_data()`](/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data) method accomplishes the third goal. Say you have a complex application- once you know an item's dependencies, you can easily change or fix one. Additionally, if you have knowledge of the structure of your app, you can use this function to fix other components of it as well.\n", "\n", - "Using these two things in conjunction with one another is a powerful combination, and we'll go over a basic but important workflow that leverages both of them.\n", + "Using these functions and methods in conjunction is a powerful combination, and we'll go over a basic but important workflow that leverages both of them.\n", "\n", "## The `arcgis.apps.itemgraph` Module\n", "\n", "### What is a Dependency?\n", "\n", - "We'll start by examining 2 classes and a function that center around a core concept: creating a dependency graph that allows users to examine how items relate to eachother in their ArcGIS Online or Enterprise organizations. As mentioned above, these graphs inform us what items are required for other items to exist, and encompass the full range of dependency types for items. \n", + "We'll start by examining 2 classes and a function that center around a core concept: creating a dependency graph that allows users to examine how items relate to each other in their ArcGIS Online or Enterprise organizations. As mentioned above, these graphs inform us what items are required for other items to exist, and encompass the full range of dependency types for items. \n", "\n", - "Before we dive a bit deeper into it, let's briefly go over a handful of the ways an item can be part of another item. There are tons of different item types in the ArcGIS universe, and the ways they all store and use data vary greatly; some are based on JSON structures, some are based on hosted services, and others on a variety of common (or uncommon) file types. Items can use other items in a wide range of ways, such as:\n", + "Before we dive a bit deeper into it, let's briefly go over a handful of the ways an item can be part of another item. There are many different [item types](/rest/users-groups-and-items/items-and-item-types/) in the ArcGIS universe, and the ways they store and use data vary greatly; some are based on JSON structures, some are based on hosted services, and others on a variety of common (or uncommon) file types. Items can use other items in a wide range of ways, such as:\n", "- source files for published layers (e.g., File GDB -> Feature Layer)\n", "- visual components in a web-based app (e.g., a Web Map found in a StoryMap)\n", "- attachments to other items (e.g., a Microsoft Word template in a Survey123 application)\n", "\n", "### Class Breakdown\n", "\n", - "[The documentation for the module can be found here](https://developers.arcgis.com/python/latest/api-reference/arcgis.apps.itemgraph.html).\n", + "[The documentation for the module can be found here](/python/latest/api-reference/arcgis.apps.itemgraph.html).\n", "\n", "Let's break down the 4 things we see in the doc:\n", - "#### - `ItemGraph`:\n", + "\n", + "#### [`ItemGraph`](/python/latest/api-reference/arcgis.apps.itemgraph.html#itemgraph)\n", " \n", "The `ItemGraph` is the main structure that a user will be working with. It is built on top of [NetworkX's DiGraph class](https://networkx.org/documentation/stable/reference/classes/digraph.html), meaning it also gets access to all of NetworkX's DiGraph and Graph functionality. An `ItemGraph` is populated with instances of `ItemNode`, and can be created from scratch via `create_dependency_graph()` or from a priorly saved `ItemGraph` via `load_from_file`.\n", "\n", - "#### - `ItemNode`:\n", + "#### [`ItemNode`](/python/latest/api-reference/arcgis.apps.itemgraph.html#itemnode)\n", "\n", - " An `ItemNode` is an object that pertains to an indexed item/dependency. The node's `.id` property is an item's id, or a service's url. In the case of nodes with a valid `Item` object in the org tied to the item id, that `Item` object will be stored as the node's `.item` property. The `ItemNode` class has functions on it that allow a user to see an item's dependencies stored in the graph going in either direction, initial-level or recursive.\n", + "An `ItemNode` is an object that pertains to an indexed item/dependency. The node's `.id` property is an item's id, or a service's url. In the case of nodes with a valid `Item` object in the org tied to the item id, that [`Item`](/python/latest/api-reference/arcgis.gis.toc.html#item) object will be stored as the node's `.item` property. The `ItemNode` class has functions on it that allow a user to see an item's dependencies stored in the graph going in either direction, initial-level or recursive.\n", "\n", - "#### - `create_dependency_graph()`:\n", + "#### [`create_dependency_graph()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#create-dependency-graph)\n", "\n", - " This is the main function that a user will use to construct an `ItemGraph`. Users feed in a list of `Item` objects or item id/url strings, and the function will recursively dissect any items or dependent items found and add everything to one `ItemGraph` returned back to a user. Users have the option to include items referenced from outside organizations in their graph, but these outside org items will not be explored for further dependencies. Additionally, for certain items that have reverse dependencies documented through their `related_items()` function, users have the option to include those in the graph as well.\n", + "This is the main function that a user will use to construct an `ItemGraph`. Users feed in a list of `Item` objects or item id/url strings, and the function will recursively dissect any items or dependent items found and add everything to one `ItemGraph` returned back to a user. Users have the option to include items referenced from outside organizations in their graph, but these outside org items will not be explored for further dependencies. Additionally, for certain items that have reverse dependencies documented through their [`related_items()`](/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.related_items) function, users have the option to include those in the graph as well.\n", "\n", - "#### - `load_from_file()`:\n", + "#### [`load_from_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#load-from-file)\n", "\n", - "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved GML file format via `ItemGraph.write_to_file()`. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this guide(add link) for an advanced workflow demonstrating it.\n", + "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved [GML file format](https://networkx.org/documentation/stable/reference/readwrite/gml.html) via the [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) method. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this [sample](/python/lateste/samples/org-wide-dependency-graph) for an advanced workflow demonstrating it.\n", "\n", "Now that we know the basics of the code, let's jump into it. We'll use `create_dependency_graph()` to create an `ItemGraph`, then examine `ItemNode` instances in the graph to learn what our org items contain, are contained by, require to exist, and are required by to exist. We'll start with a Survey123 item." ] @@ -94,7 +112,7 @@ "id": "da409930-f779-44b8-982b-305f146ef6d9", "metadata": {}, "source": [ - "Calling `ItemGraph.all_items()` lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default)." + "Calling [`ItemGraph.all_items()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.all_items) lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default) by specifiying and `out_format` agrument:" ] }, { @@ -122,7 +140,7 @@ } ], "source": [ - "graph.all_items(\"item\")" + "graph.all_items(out_format=\"item\")" ] }, { @@ -130,7 +148,7 @@ "id": "4fa16c48-193c-4326-b3c1-3694e6a18f9d", "metadata": {}, "source": [ - "Let's grab and inspect an `ItemNode` instance by calling `ItemGraph.get_node()`." + "Let's grab and inspect an `ItemNode` instance by calling the [`ItemGraph.get_node()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.get_node) method." ] }, { @@ -352,7 +370,7 @@ "id": "fd1761f6-ef27-4201-b11d-a43bf1414c81", "metadata": {}, "source": [ - "An important thing to remember is that `create_dependency_graph()` finds relationships from the top down, so `contained_by()` and `required_by()` will only show items that have been analyzed along the way from our root node(s)- they're not a full picture of _every_ item in the organization that may contain or require a specific item, just the ones contained under the umbrella of our original items. However, `contains()` and `requires()` do indeed show every item in an org that are contained or required by a given item.\n", + "An important thing to remember is that `create_dependency_graph()` finds relationships from the top down, so [`contained_by()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.contained_by) and [`required_by()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.required_by) will only show items that have been analyzed along the way from our root node(s)- they're not a full picture of _every_ item in the organization that may contain or require a specific item, just the ones contained under the umbrella of our original item. However, [`contains()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.contains) and [`requires()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.requires) do indeed show every item in an org that are contained or required by a given item.\n", "\n", "To get the full, org-wide picture with `contained_by()` or `required_by()`, a graph would need to be made with every item in the organization. See this sample(insert link) for a guide on how to create and manage that type of graph." ] @@ -973,7 +991,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.2" } }, "nbformat": 4, diff --git a/samples/03_org_administrators/org_wide_dependency_graph.ipynb b/samples/03_org_administrators/org_wide_dependency_graph.ipynb index 8012f994b8..0c426da395 100644 --- a/samples/03_org_administrators/org_wide_dependency_graph.ipynb +++ b/samples/03_org_administrators/org_wide_dependency_graph.ipynb @@ -1,1264 +1,1265 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "2b116b66-8015-4742-8115-bcb0f09a6e10", - "metadata": {}, - "source": [ - "# Working with an Organization-Wide Dependency Graph" - ] - }, - { - "cell_type": "markdown", - "id": "a8fd2570-ff4b-4cec-9269-cbf542cd66af", - "metadata": {}, - "source": [ - "Version 2.4.1 of the ArcGIS API for Python brought about some exciting new functionality for content management: the `arcgis.apps.itemgraph` module. This module, in it's most basic usage, allows you to take an item in an organization and examine the deep dependencies of it- what items it needs to exist, what items those items need to exist, and so on. This is very helpful for management of apps and smaller subsets of org items, but what if we really want to push the limits of what we can do with this module?\n", - "\n", - "With a little patience and creativity, we can create an actively-updated dependency graph that encapsulates every item in our organization. Doing so opens up all sorts of doors for us, such as:\n", - "- The ability to examine the total reverse dependencies of an item (e.g., take a feature layer- we can see every app or map in our org that requires it to exist, or that will be effected by a change to it\n", - "- Quick identification of all broken dependencies in our organization\n", - "- Sorting of org items by complexity (most vs. least dependencies)\n", - "\n", - "In this sample, we'll provide code to create and update an organization-wide graph, glean information from our graph, and then finally include a section on how to automate this process via ArcGIS Notebooks." - ] - }, - { - "cell_type": "markdown", - "id": "19637729-09c6-4094-8fd4-c7daf9b94299", - "metadata": {}, - "source": [ - "## Part 1: Creating and Updating an Org-Wide Graph" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3d4c3a05-240c-4906-9509-75ccaba0c625", - "metadata": {}, - "source": [ - "from arcgis.gis import GIS\n", - "from arcgis.apps.itemgraph import create_dependency_graph, load_from_file\n", - "import datetime\n", - "import networkx as nx\n", - "gis = GIS(\"home\")" - ] - }, - { - "cell_type": "markdown", - "id": "e74b49d1-0290-4634-9313-ceaf3334512e", - "metadata": {}, - "source": [ - "### Initial Run\n", - "\n", - "This builds the initial dependency graph by indexing over every single item in the organization. This only needs to be run once, and will likely take a very long time, depending on how many items are in the org. Once it's been run and the graph structure and time stamp are saved into files, this notebook that updates the dependency graph can be run. This first cell can also be executed outside of ArcGIS Notebooks, and the .gml and .txt files can be brought in from elsewhere.\n", - "\n", - "*Note: Comment out this cell after the first time running the notebook.*" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0f7d4665-5542-4d80-866b-c10e6081fc3b", - "metadata": {}, - "outputs": [], - "source": [ - "# only run this cell the very first time you index over your org and grab all the dependencies\n", - "# this will take a long time if the org has a ton of items\n", - "\n", - "import datetime\n", - "items = gis.content.search(\"\", max_items = 10000)\n", - "timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", - "graph = create_dependency_graph(gis, items)\n", - "graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", - "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", - " file.write(str(timestamp))" - ] - }, - { - "cell_type": "markdown", - "id": "adf0a4ab-8fc1-4152-bd96-82f88bb219d1", - "metadata": {}, - "source": [ - "Now, we have a snapshot of every item in the organization and how they relate to one another. But, what if we don't want to run this lengthy initial step every time we want to work with this graph? And what if there are items that are getting created, updated, and deleted, so the relationships in this graph might become outdated? This notebook will go over how we can use specific capabilities of the ItemGraph to examine massive graphs without re-indexing, and will include code that will update the graph through automation, meaning that scheduling this notebook to run will ensure that your organization-wide dependency graph stays up to date." - ] - }, - { - "cell_type": "markdown", - "id": "f4146031-7653-4d06-b2b6-563048535186", - "metadata": {}, - "source": [ - "### Efficiently Analyzing the Existent Graph\n", - "\n", - "When loading up an existent graph based on a .gml file, it still may take some time to retrieve every single item associated with each node in the graph, especially for organizations with thousands and thousands of items. If you want to instantly analyze the items and relationships in a .gml file with thousands of records, we can call `load_to_file()` and elect to *not* retrieve each item. This still gives us the power to view all item id's and their dependencies in the org, but without the overhead of retrieving each one from a REST endpoint first. Users can simply retrieve the associated items as needed, based on the id's.\n", - "\n", - "We'll show a quick example of this using the existent graph, and then use a graph loaded with the items to ensure we're up-to-date with the current state of organization. We'll only print the first few for the sake of keeping this page short." - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "63d6a566-4e5d-495f-b448-cf452db3f967", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3643" - ] - }, - "execution_count": 101, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fast_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, False)\n", - "len(fast_graph.all_items())" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "08e88638-8b71-4340-b912-88e0b5d71ddd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[ItemNode(id: 72c2671bff1143c4bc577755bc00a7aa),\n", - " ItemNode(id: 405b512903e74ec0af5ce2083b863705),\n", - " ItemNode(id: 039e2c7e648b4a5d9d64c57b470d7397),\n", - " ItemNode(id: 64a096654b924b2998ed07a747524e96),\n", - " ItemNode(id: e12e8599965c43af9632a5c9633c2994),\n", - " ItemNode(id: 5b534fa4a26d4fd1868ea7509806b053),\n", - " ItemNode(id: 96cf6c756ee74c288a8a88788f980266),\n", - " ItemNode(id: 64480b5bfc474ab1a464fa18098c92e5),\n", - " ItemNode(id: 14d12cc813b2422db0f4b7b1b701bcc1),\n", - " ItemNode(id: 5a1a8ac568a942b792c1283b7acff602),\n", - " ItemNode(id: dc5014dff7014a23af6eff25b492bce6),\n", - " ItemNode(id: 1fcbf4e77ebc46ef9971d1194f412c3b),\n", - " ItemNode(id: fc02404cdda24f72842d34b28267d77a),\n", - " ItemNode(id: 4cc1488a3c134af9abbe0a268d50b499),\n", - " ItemNode(id: 24ca75398c494dad8b4e7104e2a640d5),\n", - " ItemNode(id: 4839158f96544bafb841c1739d84f11b),\n", - " ItemNode(id: 9b9de0ff974e4924b15bc278ad6d6676),\n", - " ItemNode(id: 87c2394212ad42bcb89de9e244d4072d),\n", - " ItemNode(id: 13697d5ab62449e78dd9c28037380592),\n", - " ItemNode(id: a93fd45749ec4773839f02623ebad01d)]" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fast_graph.all_items()[:20]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "8a3c2f4b-c416-4ef5-bb22-a1d24a628da8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - " \n", - " \n", - " \n", - "
\n", - "\n", - "
\n", - " Latin America\n", - " \n", - "

Mobile Map Package by esri_nav\n", - "
Last Modified: October 01, 2017\n", - "
0 comments, 0 views\n", - "
\n", - "
\n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "random_node = fast_graph.all_items()[0]\n", - "gis.content.get(random_node.id)" - ] - }, - { - "cell_type": "markdown", - "id": "8d0d126a-8b82-4b52-ab64-b9fb8231a836", - "metadata": {}, - "source": [ - "As we can see, we can instantly load in this complicated graph and just grab the `Item` associated with a given node as needed. However, for this next part, we're going to need to retrieve everything in the graph, which could take a while; that's why it's meant for some scheduled automation.\n", - "\n", - "### Automation: Updating our Org-Wide Graph\n", - "\n", - "The items in our org might not be the same as the ones we had in it yesterday- that's why we want to update our graph periodically. We can use some attributes of the `ItemGraph` class and some networkx tricks to maintain an up-to-date record of everything in the org.\n", - "\n", - "We'll start by loading up our existent graph stored in the .gml file with every `Item` attached. This may take a while to do, depending on how many items must be retrieved. We retrieve the items so that later we can verify which ones still exist and which ones have been deleted." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ccf52250-3b9e-47e2-bcb2-81d82473d515", - "metadata": {}, - "outputs": [], - "source": [ - "# grab the graph created yesterday to update it\n", - "old_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, True)" - ] - }, - { - "cell_type": "markdown", - "id": "cfe9d923-1528-4e9c-9ffb-d48783bcd977", - "metadata": {}, - "source": [ - "Keeping timestamps allows us to understand when the last time we updated the graph was and maintain an accurate graph. This approach allows for the scheduling of this notebook on any timeframe- whether you run it every day, every week, every month, or something else." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "9c3989f2-7047-48dc-ac27-e941f8cc0f3b", - "metadata": {}, - "outputs": [], - "source": [ - "# grab our old and new timestamps\n", - "# old is the last time we updated the graph, new is current time\n", - "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"r\") as file:\n", - " old_timestamp = int(file.read())\n", - "new_timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", - "\n", - "# use these timestamps to see items that have been modified or created since last run\n", - "q = f\"modified: [{old_timestamp} TO {new_timestamp}]\"\n", - "modified_items = gis.content.search(query = q, sort_field = \"modified\", sort_order = \"desc\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "1dcbf4d7-02e0-471c-bd64-8e69e0462a96", - "metadata": {}, - "outputs": [], - "source": [ - "# now that we have our list of updated items, make a graph out of them\n", - "mod_graph = create_dependency_graph(gis, modified_items)" - ] - }, - { - "cell_type": "markdown", - "id": "f9a664b7-6bc8-46e5-b8e9-3972d371508e", - "metadata": {}, - "source": [ - "Now we have a graph containing only new/modified items, and all of their dependencies. We'll have to combine the new information in this graph with our existent graph, and delete the outdated information. Time for some fun graph operations!" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9605f93b-b732-4379-9636-b2e9340d57b4", - "metadata": {}, - "outputs": [], - "source": [ - "# nx.compose() combines all nodes and relationships of two graphs\n", - "new_graph = nx.compose(old_graph, mod_graph)\n", - "\n", - "# find the list of items in both graphs\n", - "# these are ones that already existed but were modified, meaning dependencies might have changed\n", - "intersects = set(old_graph.all_items('id')) & set(mod_graph.all_items('id'))\n", - "\n", - "# go through these items and delete outdated forward dependencies\n", - "for itemid in list(intersects):\n", - " old_contains = set(old_graph.get_node(itemid).contains(\"id\"))\n", - " mod_contains = set(mod_graph.get_node(itemid).contains(\"id\"))\n", - " \n", - " # isolate deps that only existed in old graph\n", - " outdated = old_contains - mod_contains\n", - "\n", - " # remove these relationships from the new graph\n", - " for dep in list(outdated):\n", - " new_graph.delete_relationship(itemid, dep)" - ] - }, - { - "cell_type": "markdown", - "id": "2d76e7f6-2c07-4c45-9f3a-37112d3f26d9", - "metadata": {}, - "source": [ - "Our `new_graph` now has an accurate reflection of all item relationships in our organization- any item that got changed could have had it's forward dependencies altered, so we made sure that those got updated to reflect any changes. We didn't have to worry about changing any reverse dependencies, since every reverse dependency is still just a forward dependency for another item, so the appropriate relationship was addressed during that process.\n", - "\n", - "We have one more little housekeeping thing to do with this new graph now- due to the way that `nx.compose()` works, the individual nodes within the new graph still contain references to the old graph. We just have to make sure those nodes now use the new graph for any computation." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "730ad8cc-a7a9-4e3f-8088-015b5e59790e", - "metadata": {}, - "outputs": [], - "source": [ - "# make sure our nodes are all referencing the new updated graph\n", - "for node in new_graph.all_items():\n", - " node.graph = new_graph" - ] - }, - { - "cell_type": "markdown", - "id": "4db9c02d-b77f-42e6-bc31-250055ff1846", - "metadata": {}, - "source": [ - "Alright, awesome, now we have all newly created or recently modified items accounted for- but we still have to account for items that might have been deleted. How do we do this? \n", - "\n", - "Remember when we ran the `load_from_file()` function earlier that retrieved all of the items while rebuilding the graph? Well, any node of an item that's been deleted won't have an attached `Item` object anymore, since it wouldn't have been retrieved. Therefore, if we have a node with no associated item, we can assume the item has been deleted, and that if the node is not contained by another node, then the item is not still meant to exist. So, we can delete nodes from our graph that fit that criteria.\n", - "\n", - "One added layer of complexity: what if the node of a deleted item is contained by another node of a deleted item that just hasn't been processed yet? We can avoid this scenario by sorting our nodes in ascending order of how many items they're required by, ensuring we're prioritizing processing ones furthest up the dependency chains first (e.g., deleted item A contains B which contains C- if we analyze B or C first, we'll wrongfully keep them, but if we start with A and go down the chain, all will get deleted properly)." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "96cea807-c561-4408-aa42-4153d752fc98", - "metadata": {}, - "outputs": [], - "source": [ - "nodes = new_graph.all_items()\n", - "\n", - "# define our sort function\n", - "def count_reqs(node):\n", - " return len(node.required_by(\"id\"))\n", - "\n", - "# this orders our nodes properly\n", - "sorted_nodes = sorted(nodes, key=count_reqs)\n", - "\n", - "# remove ones that don't have items and aren't dependencies of others\n", - "for node in sorted_nodes:\n", - " if not node.item and not node.contained_by():\n", - " new_graph.remove_node(node.id)" - ] - }, - { - "cell_type": "markdown", - "id": "d89a380c-1f85-4326-8372-37b74bb5aa00", - "metadata": {}, - "source": [ - "And there we have it. Now we have a properly updated graph, one that reflects today's state of every item and their dependencies. Grabbing a node for a given item from `new_graph` should give you a holistic look of all items it relates to in an org, no matter if it's an immediate or deep relationship in either direction. To summarize, we:\n", - "\n", - "- Loaded in the graph from the last time we ran the notebook\n", - "- Determined what items had been modified/created since the last time we ran the notebook\n", - "- Created a graph from those updated items, capturing their current dependencies\n", - "- Merged the old graph with the modified graph to create a new graph with all nodes/relationships from both graphs\n", - "- Got rid of relationships that no longer existed from the new graph\n", - "- Got rid of any items that had been deleted and weren't dependencies of an item from the new graph\n", - "\n", - "Now, we'll write out the state of this graph and the timestamp at which we started everything, so we can repeat this process in the future and continue to update our graph as the items in our ArcGIS organization evolve." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "ef2845ff-c2cd-428d-9ff4-486ed0c8160c", - "metadata": {}, - "outputs": [], - "source": [ - "new_graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", - "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", - " file.write(str(timestamp))" - ] - }, - { - "cell_type": "markdown", - "id": "08f5ef15-cf3f-4317-bca6-794761166f70", - "metadata": {}, - "source": [ - "# Part 2: Using the Graph" - ] - }, - { - "cell_type": "markdown", - "id": "587f19ea-923c-4001-ad87-5dde5129b99b", - "metadata": {}, - "source": [ - "Now that we have our organization-wide graph and know that it's up to date, we can use it for some useful administration and analysis. We'll take a look at the three things mentioned in the intro: examining comprehensive reverse dependencies of items, identifying broken dependencies that need fixing, and sorting our items based on their complexity." - ] - }, - { - "cell_type": "markdown", - "id": "b60c0fc9-4523-4a93-bf0a-47be12ff689a", - "metadata": {}, - "source": [ - "### Comprehensive Reverse Dependencies\n", - "\n", - "This is a very powerful perk of having every relationship in an organization included in a graph: the ability to see _every_ single item that relies on a specific item. Say you have a feature layer that is used in numerous maps and applications throughout your org: you can instantly acquire a list of every one that consumes it, either directly or indirectly. Let's take a look." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "35636665-42d0-486d-a1bc-e9aae10bed2c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - " \n", - " \n", - " \n", - "
\n", - "\n", - "
\n", - " World Topographic Map\n", - " \n", - "
This vector tile layer provides a world topographic map. (World Edition)
Vector Tile Layer by esri_livingatlas\n", - "
Last Modified: April 26, 2025\n", - "
0 comments, 0 views\n", - "
\n", - "
\n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# grab a node corresponding to a feature layer\n", - "flayer_id = \"7dc6cea0b1764a1f9af2e679f642f0f5\"\n", - "flayer_node = new_graph.get_node(flayer_id)\n", - "flayer_node.item" - ] - }, - { - "cell_type": "markdown", - "id": "51ccb876-369a-4636-9112-f0f9c39b94b0", - "metadata": {}, - "source": [ - "Calling `.contained_by()` will show all of the items that contain our vector tile layer." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "cb088e78-1ffa-4b89-ac4e-25526b372388", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ]" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "flayer_node.contained_by(\"item\")" - ] - }, - { - "cell_type": "markdown", - "id": "d6328f75-6018-4c7a-b275-2ebfded5985f", - "metadata": {}, - "source": [ - "Calling `.required_by()` will show us all of the items that depend on our layer in some way." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "e0af9dea-2b2b-46ca-a9ee-faff7e7c6b90", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ]" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "flayer_node.required_by(\"item\")" - ] - }, - { - "cell_type": "markdown", - "id": "d4df1dfe-a652-4655-a60b-694877f9f9a9", - "metadata": {}, - "source": [ - "There we have it- we instantly determined which items would be affected by deleting or changing our layer." - ] - }, - { - "cell_type": "markdown", - "id": "e1c1bdf8-834e-4e8c-b7ad-c513e3593814", - "metadata": {}, - "source": [ - "### Finding Broken Dependencies\n", - "\n", - "In this context, we're calling an item that is contained by another item, but isn't valid or accessible, a \"broken\" dependency- these sorts of items can lead to rendering or logic issues in applications such as Web Maps, StoryMaps, Experiences, Surveys, and so on. There can be a number of reasons for why these improper dependencies may exist- an item being used by an application mistakenly got deleted, there was some sort of corruption with data, the json structure of an application might have been copied from one in a different org, and so on.\n", - "\n", - "Luckily, the way the `ItemGraph` is constructed allows us to instantly find these cases where something is potentially awry. During construction of the graph, the ID of each `ItemNode` was passed into the GIS org to see if it yielded an item. Therefore, any node that doesn't have an `.item` property could potentially be a problem." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "d50fcf1d-107f-4bbf-a21f-3ebcfd0c0fb2", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[ItemNode(id: 370b95fdf676475ca8fd184ad0931610),\n", - " ItemNode(id: 1dc6042bb3ba409c9d1eb1d7c996d6ed),\n", - " ItemNode(id: bf08d46ab087435aa4afbc62092223cb),\n", - " ItemNode(id: 123hehethiswontwork),\n", - " ItemNode(id: 2fe20a161c514e16b805a21a7e2d636b),\n", - " ItemNode(id: 15efb8c0d9e3447782789592f432fc1a),\n", - " ItemNode(id: bda2f1dc3c824c3e97f4a682554177cf),\n", - " ItemNode(id: bbf4d26d7c3340dab009c7164cc3e1e5),\n", - " ItemNode(id: d60affb34dd948a1b973da076830ad00),\n", - " ItemNode(id: 1182ef6f62a543fdba4a55c85c014431),\n", - " ItemNode(id: f32924d7b16f41d78839dba3b943b08c),\n", - " ItemNode(id: 9f91d4c34f194da793c8573b24a751a9),\n", - " ItemNode(id: 91fa101048bb4855970f7d004a4542ce),\n", - " ItemNode(id: 6e02b538bea841ed858ef9f52709b655),\n", - " ItemNode(id: 878802f78aad4ab5a83c1397c72048c5),\n", - " ItemNode(id: f1801a1b3d674de7b9de246a126eb17b),\n", - " ItemNode(id: 2),\n", - " ItemNode(id: 44c3348139a84423b4a46074a104efdf),\n", - " ItemNode(id: 74ab88e7e22d4dbd93b43a00b2d0155b),\n", - " ItemNode(id: 306cf223a2fd46d3bf6ce39225681977),\n", - " ItemNode(id: 1ee3200825ce448c91a1ec9ae4f70c28),\n", - " ItemNode(id: 72224efc9e044001934bb3be87120beb),\n", - " ItemNode(id: 90ff936dc4704a0798f61ebbb1dec357),\n", - " ItemNode(id: 0df19d2d940b47658857cc2fc9623840),\n", - " ItemNode(id: cdf23b869e7649469759cf756c1d43f0),\n", - " ItemNode(id: a5f11273b85d40adbd7cf9a162f81ef2),\n", - " ItemNode(id: 08a9b819b9e04de9a68418f2b225ec6a),\n", - " ItemNode(id: f265c79c47a3413b8b8f711909f03fe2),\n", - " ItemNode(id: 819ee7ddbf5848889effd0fa6b039a51),\n", - " ItemNode(id: 8548e23d8b1a478eaf2246e6fc3b31b9),\n", - " ItemNode(id: f97edbe48af7427f8604f20320e2de52),\n", - " ItemNode(id: b66792b3bb004fa8997fcfcef991e984),\n", - " ItemNode(id: 9204269c8e714500a565a3ddf055825d),\n", - " ItemNode(id: 28dae0b8f1c44814b281b71752453c61),\n", - " ItemNode(id: d15c117e60dd4fe299ec03a379c9caf8),\n", - " ItemNode(id: 3b6d38a456164adea4c061a2a51d89b1),\n", - " ItemNode(id: a12fcbe07c8d41f1b6981f33a10d1d0c),\n", - " ItemNode(id: ae4bea7c35824bf1ae571783142dc97d),\n", - " ItemNode(id: 8e969d9adb7f485c88a8350d317e8c9b),\n", - " ItemNode(id: 493db5d6832b44a581547a8df8c3907c),\n", - " ItemNode(id: ebe640ee5d344bea9fca7bfa4d80bb3a),\n", - " ItemNode(id: 6595a5cf08d64212a85ce9dc47700575),\n", - " ItemNode(id: 761e9fcf5efa4b368716fae9a1ffda0f),\n", - " ItemNode(id: 39f0fc3c5b424d679c2ef9ae67e71624),\n", - " ItemNode(id: 59835c8d71d94475ae04f540a8167343),\n", - " ItemNode(id: 5b2e49a83dd9427abf398aeeecc00f75),\n", - " ItemNode(id: dcf4a23abb614d7db9cda2dce90cc528),\n", - " ItemNode(id: 1d250ce2c5c0463abe0e1887597cc926),\n", - " ItemNode(id: e57b96c732cc4c34830756d53c8f3619),\n", - " ItemNode(id: 79f3399102ce4ab79bed0407b03005fc),\n", - " ItemNode(id: 872d78b038d342b98b6a3547ed8a7ac9),\n", - " ItemNode(id: 3a2d7671322e4dcbb386e4b961e28c27),\n", - " ItemNode(id: 8900b18d92ac43cfae142a5a5ad91e4a),\n", - " ItemNode(id: ba6575ad916041a89887309492473b42),\n", - " ItemNode(id: 5bbbe8978d9f43a0a7a947b5af3cdc1d),\n", - " ItemNode(id: 73196ca49b6b40c0a03206663cb10554),\n", - " ItemNode(id: 9566f596ba404a05aa8eae9221bce82a),\n", - " ItemNode(id: c2e2b6eaea3740059546951c16af5151),\n", - " ItemNode(id: 4cee55fa5973406596359e7630ab167e),\n", - " ItemNode(id: 086eb0c799794d4b99a95a39cd43dca2),\n", - " ItemNode(id: 6313031ddbe14d7ca0358c4ba8011b27),\n", - " ItemNode(id: bc68a4d142fb4801a2401a0a5a551ba1),\n", - " ItemNode(id: 07b7fe74b02c40afa1551d41f19f6d99),\n", - " ItemNode(id: 632d3de849224fcb990f6d9feae36331),\n", - " ItemNode(id: 26e87527293b43978b1fb4a24133ead1),\n", - " ItemNode(id: efff5de20fd546de94e613fbed730372),\n", - " ItemNode(id: 401d890c10d94e88948a0bd5f82e7559),\n", - " ItemNode(id: 8cf058d7e58d4f66831e8bc7ae7addbd),\n", - " ItemNode(id: fed737361fcf4815b2b62651e1cd2a57),\n", - " ItemNode(id: 46472e81856c4420aeb091e6f0fd24e8),\n", - " ItemNode(id: d1414cb87c2d41099cfcfe55aa8344e2),\n", - " ItemNode(id: c2f21b0e86de49fa9b6437cd72779488),\n", - " ItemNode(id: 77efb9bd7831430ab3788741d327e5df),\n", - " ItemNode(id: 633c43f3c0e148dea129d6ca49e7fd22),\n", - " ItemNode(id: 3dce15e4178a4a9c92cacb66f2f7f1ea),\n", - " ItemNode(id: 2a6e5de8aa4a40899e44017121c5cd89),\n", - " ItemNode(id: bccbd571d0d54e45b6a69ca0249e7132),\n", - " ItemNode(id: c8cbf786be774df7b064f149c5898fef),\n", - " ItemNode(id: 71276e9e9638459890a3072df64e31b6),\n", - " ItemNode(id: a06302053b3f4e35961584d5818bf1f2),\n", - " ItemNode(id: 5feee1e7f41a4c47b3f137457c130182),\n", - " ItemNode(id: 6e403956c5d7419b9c0628e65bed0769),\n", - " ItemNode(id: 196b5b2798204de38b6dd125823bd714),\n", - " ItemNode(id: 88ba2cd25d1c423c808fa2e1941a540b),\n", - " ItemNode(id: c1e6eb63502c4012bb631097b69aefad),\n", - " ItemNode(id: 4c56c5e083544decbd8d61f3a0bc5a67),\n", - " ItemNode(id: 905567641b10499ba6a77a0a6e4e5f13),\n", - " ItemNode(id: 861096f2cb274134bcdca7e875899d69),\n", - " ItemNode(id: 3afb37e1c7784a05b7d0b4c4c98088c1),\n", - " ItemNode(id: ae5179630d714200893cda3a6e50e460),\n", - " ItemNode(id: 2243cb05a01f43cc8d7439447ffe3bbf),\n", - " ItemNode(id: 27d2f0ad1c7545e48848b43bbd51581a),\n", - " ItemNode(id: 9dc85299a77540b0bac1507ce67e9dfa),\n", - " ItemNode(id: 16ffb93988c94d699b672d837c1e03e6),\n", - " ItemNode(id: 3668c924551b4ff2a508cd2cda897abe),\n", - " ItemNode(id: c2e075d098a6493393dc3f55876d48f4),\n", - " ItemNode(id: 53071c1408d240c1997a3779c48467b4),\n", - " ItemNode(id: 36a01f823259430197c896ff415ee493),\n", - " ItemNode(id: 21e0d7322928434d8889eba70e4c645a),\n", - " ItemNode(id: 3e5ba2fec29f4f25afd5a5dbfaadf136),\n", - " ItemNode(id: d79cd0205b03479b8019648e1dd057f4),\n", - " ItemNode(id: 8461fdc33b554ffbad1ba54afd1ff499),\n", - " ItemNode(id: 940e3b1543bf4289822790a15e66c5a4),\n", - " ItemNode(id: 15e70e3da80b42fd9b60eda8cd6e7cd4),\n", - " ItemNode(id: 4438ff8fb9174783934412c1c51f4865),\n", - " ItemNode(id: db089afa931a4a9fb1cb2afe33a6c2f6),\n", - " ItemNode(id: ba0ff62d9aaf4f628eb1a869c0bb5ee0),\n", - " ItemNode(id: d50ecf25a35a4cd9baaa1ba7035f77da),\n", - " ItemNode(id: 76e505d722f64fa6b0debd0f196c3ae1),\n", - " ItemNode(id: dfcdd3b0495d4f4cb3c3a4a401616d6e),\n", - " ItemNode(id: 03bcd4dfbeae4a91ae270a934fa27e1b),\n", - " ItemNode(id: 1c5e01156f5a4f0fae4dc61297785c1d),\n", - " ItemNode(id: 16d1d5083719466487007bf90313184f),\n", - " ItemNode(id: 2f87efbdf4ec4942ad610fe4b6bd8c36),\n", - " ItemNode(id: 97162f48110d4458820c3b66de375d67),\n", - " ItemNode(id: e98bc26706ba46c782c03c81c739a065),\n", - " ItemNode(id: 8d721aaa69aa4715911693fa4863b7cf),\n", - " ItemNode(id: 7a238f29b99f4ff1957e3a469177c56a),\n", - " ItemNode(id: ff9cafd475ff4a0abf5d8f3a34fc7646),\n", - " ItemNode(id: ae00236efed94d0b8739ef8a244cc312),\n", - " ItemNode(id: 12b7fd7eaefc4f40b2fe003604153b3c),\n", - " ItemNode(id: 1f2248e4464b4065a864cc6aab7aa780),\n", - " ItemNode(id: c13634e58a024cae9de6a15a4b3eb101),\n", - " ItemNode(id: bd6943458948460a8eb71d97baaa2ada),\n", - " ItemNode(id: 6fafb84fc46d4b9c8b25fb57dd9911a2),\n", - " ItemNode(id: c209e14b44b7420cb40ed650cfefa4f5),\n", - " ItemNode(id: 048de0545a834d8b8c31a6e0e10270d7),\n", - " ItemNode(id: 40bf682bf17c4c32a5acade2d54eafb9),\n", - " ItemNode(id: e608d5be1b4241cdbb1fbf61418513d6),\n", - " ItemNode(id: 908ceeaa2e5e4ef19e823715a35ab978),\n", - " ItemNode(id: 7d907c5ac31b4da098d47922bb31f2aa),\n", - " ItemNode(id: 5dd87bebb9864dac9c2f42604bb79b14),\n", - " ItemNode(id: 78186ce321f1433091aeb2593abbc565),\n", - " ItemNode(id: cb7a89a516e84af7b3d7e551a38afed5),\n", - " ItemNode(id: 6b63dafabf4e486183c21bede31b149e),\n", - " ItemNode(id: a962b03a45d9415ea97b96eaab7f20d6),\n", - " ItemNode(id: ac96d6152ba34373ac1c7288b2fcefe4),\n", - " ItemNode(id: d0d5d3caafed43cd9ce18b9a2609fc5f),\n", - " ItemNode(id: d9b8675be48d49078db4c55208a0d19e),\n", - " ItemNode(id: 2defd52c9e4f4759ba085f339d284cd4),\n", - " ItemNode(id: 961434231c034930801f5b3237715587),\n", - " ItemNode(id: af83304d94cd4e0da83318f76cde60c4),\n", - " ItemNode(id: 85179dd8a0fe4ea597586fed851bdeff),\n", - " ItemNode(id: d5e20e6f7a9542d5ace62983699d3212),\n", - " ItemNode(id: e3e1712a046d4feeb454e5538a6049d7),\n", - " ItemNode(id: 045ba64dd5bc4b1a94350f897de956cf),\n", - " ItemNode(id: 4fb8f3f5422d4a7696b0f8136a4b48aa),\n", - " ItemNode(id: 75113e1eb7e045229c2cb2698e43114c),\n", - " ItemNode(id: 228834a1eff64c629c80d0b638f9e43c),\n", - " ItemNode(id: 42b653e394104606987cbf4b6d1587f9),\n", - " ItemNode(id: 2c82e7cf420b4026b875ad45750c7a24),\n", - " ItemNode(id: f1894e0262e44dd6adadef875577d8aa),\n", - " ItemNode(id: 4f93f1fbebdd4f66a55b6a02f332fa20),\n", - " ItemNode(id: caa4a0e4ddcb47c9845eb92f024fcd7f),\n", - " ItemNode(id: 1a9c7b34467d41728f9472a0b6628841),\n", - " ItemNode(id: 7f4342f006a44c8780d8df79d5da5652),\n", - " ItemNode(id: a90891b098034e0d928fc4ee30dec1a3),\n", - " ItemNode(id: caa7ab7f82ab41dd9af1215c11f55a8f),\n", - " ItemNode(id: bb46d017f7af49728d5af8d8eec43c4e),\n", - " ItemNode(id: a5df7d4a77c24fc39a1115122370cd8f),\n", - " ItemNode(id: 879921e888a14e96b5f5b339af907acd),\n", - " ItemNode(id: 8dd1b1b7731c49839489e0d30146f513),\n", - " ItemNode(id: eb0499aeb1d5461f877e9b40534e225e),\n", - " ItemNode(id: 4138c0fbe6b446fbad5447ecc34c8ab8),\n", - " ItemNode(id: e2ee852f11c14d99814dd4ed42a0a16c),\n", - " ItemNode(id: e27013ac9f664054a044edd3567c763a),\n", - " ItemNode(id: ee527fed605a4088b10c49ab9c9ed096),\n", - " ItemNode(id: a7cdce7ebb404ae6b700b491f21b3243),\n", - " ItemNode(id: e0dfd02f8f61479c8e1a276c79cafcd5),\n", - " ItemNode(id: 3d0d28a295e54d25966e7945e2bf5d8e),\n", - " ItemNode(id: d8e9dfe815b44c8ab3e94a6dc1fcf201),\n", - " ItemNode(id: 3ce93787d12645f386d42d57ca57c1b4),\n", - " ItemNode(id: 9c03b76829464ee68d4e6af241cebd5e),\n", - " ItemNode(id: 5707b86b5f3f4b7c9e67ac2fd317254a),\n", - " ItemNode(id: 79719a8a27d3440d9d622041ff7b8506),\n", - " ItemNode(id: 1adc07ec24774989873cafc6c68c1536),\n", - " ItemNode(id: 1926c33e9bf34ef99b8950f1408368a3),\n", - " ItemNode(id: 892a696bf2aa4a899f5177017d998156),\n", - " ItemNode(id: 57654725661049eba50bca930ae786e8),\n", - " ItemNode(id: c85179865e0c45089e0f9bb29b7ca83e),\n", - " ItemNode(id: b9cb2d66aaa04093950683767c8eaff0),\n", - " ItemNode(id: c9b04902a93c4aeda9b92e45b303fe01),\n", - " ItemNode(id: 1c8354e6f69e4df1969befae339412c7),\n", - " ItemNode(id: ed2246c081ee49369024cfb312e34899),\n", - " ItemNode(id: 6d6bae1a02484353add60ddefaca185e),\n", - " ItemNode(id: a143d4fe84e14712bfd28e71b26ac868),\n", - " ItemNode(id: d822827df8f345d280ebf2c2be8a48a1),\n", - " ItemNode(id: 3f4789f0a58b4cdcab5b7d1a08f5f9d9),\n", - " ItemNode(id: f091f6195a194f38a47f8b329bbd9255),\n", - " ItemNode(id: 7f7c4245f03445e782e9aa4a4d06221d),\n", - " ItemNode(id: 07a05ca8a10843aba797076d40ca8f36),\n", - " ItemNode(id: https://oceans1.arcgis.com/arcgis/rest/services/USA_Drilling_Platforms/FeatureServer/0),\n", - " ItemNode(id: e26f2752e86d4a8dad52ea75501480f0),\n", - " ItemNode(id: aecf7fd35dca43fe80fc67b60fb73516),\n", - " ItemNode(id: ab924202cc404af58b41efcf99b0aafa),\n", - " ItemNode(id: 1c735ebaed8d48b5bfd6fcfcd35eb3d1),\n", - " ItemNode(id: a5846d8e82834f4398fb54e0ef0db0c5),\n", - " ItemNode(id: bbf872949f2f43a6921e716f7fbe1d72),\n", - " ItemNode(id: 1c80207bf5384974994ad4a13abf4556)]" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "no_item_nodes = [node for node in new_graph.all_items() if not node.item]\n", - "no_item_nodes" - ] - }, - { - "cell_type": "markdown", - "id": "f621f913-9b8c-47e0-b7d3-619410223d9c", - "metadata": {}, - "source": [ - "As we can see, we now have a list of nodes where the ID's don't lead to a portal item. There is one anomaly here: what appears to be a service that just doesn't have an associated portal item, but still may be valid. We can add some separate logic to ensure we test any URL for valid data." - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "5d0a224d-de59-4b6f-ad86-b209c5a91340", - "metadata": {}, - "outputs": [], - "source": [ - "from arcgis.layers import Service\n", - "updated_no_item = []\n", - "for node in no_item_nodes:\n", - " if \"https://\" in node.id:\n", - " try:\n", - " serv = Service(node.id)\n", - " if not serv:\n", - " raise\n", - " except:\n", - " updated_no_item.append(node)\n", - " else:\n", - " updated_no_item.append(node)" - ] - }, - { - "cell_type": "markdown", - "id": "fd4c5d32-2f52-44d0-a59d-c5beaec43493", - "metadata": {}, - "source": [ - "Given this list of items with ID's that lead nowhere, we can grab the node for any one of them and do what we did above- see which org items contain or require them. From there, we can figure out how to fix it- one option is using the `remap_data()` function, documented [here](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "de01da8b-84f6-4f46-864d-ceb41b31e9e5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents)]" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "broken_node = updated_no_item[0]\n", - "broken_node.contained_by()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "c4f3a39d-9c0b-4659-8705-6b114ca3a635", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents),\n", - " ItemNode(id: d3b24b91f2c3432fbb5b7d2862f7525d, item: TestInstantApp),\n", - " ItemNode(id: 7259119a69044ae4aebd3e4cd338321f, item: AZ Vehicle App)]" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "broken_node.required_by()" - ] - }, - { - "cell_type": "markdown", - "id": "014807cf-c9e1-442f-9d74-22b7a215e99a", - "metadata": {}, - "source": [ - "### Sorting Items by Degree, Type, and More\n", - "\n", - "Finally, let's put ourselves in the shoes of an organization admin that wants to learn about the items in their org: which items have the most dependencies, and which ones are needed by the most items? Which ones have the most broken dependencies? Let's take a look at how we can capitalize on some graph logic and networkx tricks to gain insights into our organization's content." - ] - }, - { - "cell_type": "markdown", - "id": "c2e3cf87-7861-4b60-ae6a-55fb62215042", - "metadata": {}, - "source": [ - "We'll start basic: just identify which nodes have the highest _degree_, or number of direct relationships (\"contains\"/\"contained by\"). Since a degree can refer to either direction relationship, we specify the _out_ degree or _in_ degree, which in an `ItemGraph` will show the amount of each node's `contains()` and `contained_by()`, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "id": "e0de0bbf-eacd-4791-97ed-a7e948adca7b", - "metadata": {}, - "outputs": [], - "source": [ - "def sort_degrees(direction = \"out\", descending = True, result_count = 50):\n", - " node_degrees = new_graph.out_degree()\n", - " if direction == \"in\":\n", - " node_degrees = new_graph.in_degree()\n", - " nodes_sorted = sorted(node_degrees, key=lambda item: item[1], reverse=descending)\n", - " if result_count and result_count > len(nodes_sorted):\n", - " result_count = len(nodes_sorted)\n", - " for node, degree in nodes_sorted[:result_count]:\n", - " graph_node = new_graph.get_node(node)\n", - " if graph_node.item:\n", - " print(f\"Title: {graph_node.item.title}, Type: {graph_node.item.type}, Degree: {degree}\")\n", - " else:\n", - " print(f\"ID: {node}, Degree: {degree}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "id": "6975d920-3314-484e-8a6e-af5929b18d42", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", - "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", - "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", - "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", - "Title: San Diego Parrot Sightings, Type: Form, Degree: 6\n", - "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 6\n", - "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 4\n", - "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", - "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", - "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", - "Title: TestInstantApp, Type: Web Mapping Application, Degree: 3\n", - "Title: map test, Type: Web Map, Degree: 3\n", - "Title: Cycling Explorer, Type: Web Map, Degree: 3\n", - "Title: AZ and NM Cities, Type: Web Map, Degree: 3\n", - "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", - "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", - "Title: map test, Type: Web Map, Degree: 3\n", - "Title: Group Layer Map Test, Type: Web Map, Degree: 3\n", - "Title: Map Series 884411, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 213975, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 959005, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 537579, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 845552, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 836403, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 639470, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 816182, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 398285, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 985608, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 287154, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 396347, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 684806, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 709821, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 587161, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 255073, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 553493, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 329174, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 37166, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 261798, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 395417, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 326103, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 116930, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 222445, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 432118, Type: Web Mapping Application, Degree: 3\n", - "Title: USA WebMap, Type: Web Map, Degree: 3\n", - "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 692346, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 772573, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 254278, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 19528, Type: Web Mapping Application, Degree: 3\n", - "Title: Map Series 238550, Type: Web Mapping Application, Degree: 3\n" - ] - } - ], - "source": [ - "# find which items contain the most other items\n", - "sort_degrees(direction = \"out\", descending = True, result_count = 50)" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "id": "6c7a1bc2-b888-4cd0-8d8e-8cf5c9e30ab5", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ID: bf08d46ab087435aa4afbc62092223cb, Degree: 153\n", - "ID: 123hehethiswontwork, Degree: 153\n", - "ID: 7f7c4245f03445e782e9aa4a4d06221d, Degree: 33\n", - "ID: 07a05ca8a10843aba797076d40ca8f36, Degree: 33\n", - "Title: World Topographic Map, Type: Vector Tile Service, Degree: 8\n", - "Title: Web Map 400800, Type: Web Map, Degree: 7\n", - "Title: Outline Map, Type: Web Map, Degree: 7\n", - "Title: Newspaper (WGS84), Type: Vector Tile Service, Degree: 5\n", - "Title: OpenStreetMap Streets with Relief, Type: Vector Tile Service, Degree: 5\n", - "ID: 2, Degree: 3\n", - "Title: Esri_Regional_Offices_US, Type: File Geodatabase, Degree: 3\n", - "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", - "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", - "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 2\n", - "Title: Basic, Type: Web Mapping Application, Degree: 2\n", - "Title: AGO World Geocoder (arcgis_python), Type: Geocoding Service, Degree: 2\n", - "ID: 2fe20a161c514e16b805a21a7e2d636b, Degree: 2\n", - "ID: 15efb8c0d9e3447782789592f432fc1a, Degree: 2\n", - "ID: bda2f1dc3c824c3e97f4a682554177cf, Degree: 2\n", - "ID: d60affb34dd948a1b973da076830ad00, Degree: 2\n", - "ID: f32924d7b16f41d78839dba3b943b08c, Degree: 2\n", - "ID: 9f91d4c34f194da793c8573b24a751a9, Degree: 2\n", - "ID: 91fa101048bb4855970f7d004a4542ce, Degree: 2\n", - "ID: 6e02b538bea841ed858ef9f52709b655, Degree: 2\n", - "Title: National Weather Service Day 1, Type: WMS, Degree: 2\n", - "Title: Enhanced Contrast Dark Map (WGS84), Type: Web Map, Degree: 2\n", - "ID: 44c3348139a84423b4a46074a104efdf, Degree: 2\n", - "Title: Test Case 12305 Survey, Type: Feature Service, Degree: 2\n", - "Title: Test Case 232 A, Type: Feature Service, Degree: 2\n", - "Title: USA_Major_Cities_Data, Type: Feature Service, Degree: 2\n", - "Title: San Diego Parrot Sightings, Type: Feature Service, Degree: 2\n", - "Title: DevSummit Theme, Type: StoryMap Theme, Degree: 2\n", - "Title: ca_public_schools, Type: Feature Service, Degree: 2\n", - "ID: cdf23b869e7649469759cf756c1d43f0, Degree: 2\n", - "ID: a5f11273b85d40adbd7cf9a162f81ef2, Degree: 2\n", - "ID: 08a9b819b9e04de9a68418f2b225ec6a, Degree: 2\n", - "ID: f265c79c47a3413b8b8f711909f03fe2, Degree: 2\n", - "ID: 819ee7ddbf5848889effd0fa6b039a51, Degree: 2\n", - "ID: 8548e23d8b1a478eaf2246e6fc3b31b9, Degree: 2\n", - "ID: f97edbe48af7427f8604f20320e2de52, Degree: 2\n", - "ID: b66792b3bb004fa8997fcfcef991e984, Degree: 2\n", - "ID: 9204269c8e714500a565a3ddf055825d, Degree: 2\n", - "ID: 28dae0b8f1c44814b281b71752453c61, Degree: 2\n", - "ID: d15c117e60dd4fe299ec03a379c9caf8, Degree: 2\n", - "ID: 3b6d38a456164adea4c061a2a51d89b1, Degree: 2\n", - "ID: a12fcbe07c8d41f1b6981f33a10d1d0c, Degree: 2\n", - "ID: ae4bea7c35824bf1ae571783142dc97d, Degree: 2\n", - "ID: 8e969d9adb7f485c88a8350d317e8c9b, Degree: 2\n", - "ID: 493db5d6832b44a581547a8df8c3907c, Degree: 2\n", - "ID: ebe640ee5d344bea9fca7bfa4d80bb3a, Degree: 2\n" - ] - } - ], - "source": [ - "# find which items are contained by the most other items\n", - "sort_degrees(direction = \"in\", descending = True, result_count = 50)" - ] - }, - { - "cell_type": "markdown", - "id": "cc04967d-5a99-47ef-bb95-85ee2e09b7c6", - "metadata": {}, - "source": [ - "We can similarly define a function that will do that for the \"deep\" degrees- finding which items have the most recursive dependencies or items dependent upon them." - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "id": "49a220a2-87e7-42c9-ab0a-da043e689aba", - "metadata": {}, - "outputs": [], - "source": [ - "def sort_deep_degrees(direction = \"out\", descending = True, result_count = 50):\n", - " if direction == \"in\":\n", - " nodes_weighted = [(node, len(node.required_by())) for node in new_graph.all_items()]\n", - " else:\n", - " nodes_weighted = [(node, len(node.requires())) for node in new_graph.all_items()]\n", - " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", - " if result_count and result_count > len(nodes_sorted):\n", - " result_count = len(nodes_sorted)\n", - " for node, degree in nodes_sorted[:result_count]:\n", - " if node.item:\n", - " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", - " else:\n", - " print(f\"ID: {node.id}, Degree: {degree}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "id": "f03263b2-d5a1-4097-a36e-f77e7a8ce65f", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Title: Testing Copy Content, Type: StoryMap, Degree: 159\n", - "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", - "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", - "Title: DS-Page1-copy-1745540879568, Type: Hub Page, Degree: 14\n", - "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", - "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", - "Title: TestInstantApp, Type: Web Mapping Application, Degree: 8\n", - "Title: San Diego Parrot Sightings, Type: Form, Degree: 8\n", - "Title: All About Arizona and New Mexico, Type: StoryMap, Degree: 8\n", - "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 8\n", - "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 7\n", - "Title: Formerly Local, Now Global Experience, Type: Web Experience, Degree: 6\n", - "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 5\n", - "Title: AZ and NM Cities, Type: Web Map, Degree: 5\n", - "Title: Ruff Ruff, Type: StoryMap, Degree: 5\n", - "Title: Group Layer Map Test, Type: Web Map, Degree: 5\n", - "Title: LimerickStoryMap, Type: StoryMap, Degree: 5\n", - "Title: test_cat_selector, Type: Dashboard, Degree: 5\n", - "Title: Copy this story, Type: StoryMap, Degree: 4\n", - "Title: map test, Type: Web Map, Degree: 4\n", - "Title: Cycling Explorer, Type: Web Map, Degree: 4\n", - "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", - "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", - "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", - "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", - "Title: California Demo, Type: StoryMap, Degree: 4\n", - "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", - "Title: California Demo, Type: StoryMap, Degree: 4\n", - "Title: California Demo, Type: StoryMap, Degree: 4\n", - "Title: California Demo, Type: StoryMap, Degree: 4\n", - "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", - "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", - "Title: California Demo, Type: StoryMap, Degree: 4\n", - "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", - "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", - "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", - "Title: Nothing Funny About This Test - updated PR, Type: Web Experience, Degree: 3\n", - "Title: Hilarious Little Test, Type: Web Experience, Degree: 3\n", - "Title: Hilarious Little Test2, Type: Web Experience, Degree: 3\n", - "Title: Hilarious Little Test - updated PR, Type: Web Experience, Degree: 3\n", - "Title: Hilarious Little Test - updated PR1, Type: Web Experience, Degree: 3\n", - "Title: No Image Test, Type: Web Experience, Degree: 3\n", - "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", - "Title: No Image Test, Type: Web Experience, Degree: 3\n", - "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", - "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", - "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", - "Title: TerrainMap, Type: Web Map, Degree: 3\n", - "Title: TerrainMap, Type: Web Map, Degree: 3\n", - "Title: TerrainMap, Type: Web Map, Degree: 3\n" - ] - } - ], - "source": [ - "sort_deep_degrees()" - ] - }, - { - "cell_type": "markdown", - "id": "d2e9dc54-59e5-4503-8ba8-267dbe9e6e25", - "metadata": {}, - "source": [ - "Finally, we can construct a custom function that can do the two prior bits, plus sort items by type, and define the result count. This allows us to easily filter and search our org's items with additional context on the weight of their dependencies." - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "id": "07dea0a0-ab93-45f1-bfde-cb13573c393d", - "metadata": {}, - "outputs": [], - "source": [ - "def filter_nodes(direction = \"out\", deep = False, descending = True, item_type = None, result_count: int = None):\n", - " if item_type:\n", - " nodes_filtered = [node for node in new_graph.all_items() if node.item and node.item.type == item_type]\n", - " else:\n", - " nodes_filtered = new_graph.all_items()\n", - " if direction == \"in\" and deep:\n", - " nodes_weighted = [(node, len(node.required_by())) for node in nodes_filtered]\n", - " elif direction == \"out\" and deep:\n", - " nodes_weighted = [(node, len(node.requires())) for node in nodes_filtered]\n", - " elif direction == \"in\" and not deep:\n", - " nodes_weighted = [(node, len(node.contained_by())) for node in nodes_filtered]\n", - " else:\n", - " nodes_weighted = [(node, len(node.contains())) for node in nodes_filtered]\n", - " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", - " if result_count and result_count > len(nodes_sorted):\n", - " result_count = len(nodes_sorted)\n", - " for node, degree in nodes_sorted[:result_count]:\n", - " if node.item:\n", - " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", - " else:\n", - " print(f\"ID: {node.id}, Degree: {degree}\")" - ] - }, - { - "cell_type": "markdown", - "id": "83550b88-950f-48b8-8c39-bb9364540e52", - "metadata": {}, - "source": [ - "## Part 3: Automating this Notebook" - ] - }, - { - "cell_type": "markdown", - "id": "b57d4e60-b053-4136-a47b-59b442080af8", - "metadata": {}, - "source": [ - "Everything we've done in this notebook is purely informative- no changes, additions, or deletions to org items were done. All we've done is update and manipulate or ItemGraph in memory and written out to file. So what does this mean? \n", - "\n", - "This means that you can download this very notebook and run it for yourself. Keeping this notebook run on a consistent timeframe will provide you with an up-to-date graph to analyze your org items. ArcGIS Notebooks, in both ArcGIS Online and ArcGIS Enteprise, provide us with an easy way to schedule automation of notebooks. Let's take a look how.\n", - "\n", - "### Scheduling a Task\n", - "\n", - "A \"task\" is a command to run a given notebook. You can create scheduled tasks that dictate when and how often to run a notebook. Each time the notebook is run according to the schedule you set, the site opens a new container and runs the notebook without user control.\n", - "\n", - "To access this function, open the \"Tasks\" pane in the notebook editor. You can schedule it to run just once in the future or on a recurring basis— from once every 15 minutes to once every 6 months.\n", - "\n", - "Once you click on the Tasks pane, you will be prompted to provide a title for the Task." - ] - }, - { - "cell_type": "markdown", - "id": "81ad1aee-9219-4490-a9bf-eda1ab7907d7", - "metadata": {}, - "source": [ - "![Image](https://github.com/user-attachments/assets/0e374e87-e08d-4789-9cb8-e6a387ac18f6)" - ] - }, - { - "cell_type": "markdown", - "id": "3ac566c6-cdca-4a13-abb0-78c0c460fec8", - "metadata": {}, - "source": [ - "You can also set other specific parameters for when and how often you would like for this notebook to run." - ] - }, - { - "cell_type": "markdown", - "id": "d36908b0-1cf0-479b-8356-9a89c0c65535", - "metadata": {}, - "source": [ - "![parameters](https://github.com/user-attachments/assets/551a68f5-976a-47ea-83c1-257c99643ffd)" - ] - }, - { - "cell_type": "markdown", - "id": "b2cdebf2-1d01-4ea5-8001-dd15a79963ad", - "metadata": {}, - "source": [ - "Once you have created this task, you can find it under the Tasks pane, and can pause, delete or edit it as necessary. " - ] - }, - { - "cell_type": "markdown", - "id": "f47c1284-c735-4688-9618-94fa954b9d5f", - "metadata": {}, - "source": [ - "![tasks](https://github.com/user-attachments/assets/975a6137-1cf7-4e6c-ae1c-85342b534d7f)" - ] - }, - { - "cell_type": "markdown", - "id": "79eb8bb0-cf28-43dd-b8c0-07fba4addfc9", - "metadata": {}, - "source": [ - "> Note: For Notebooks in ArcGIS Online, you can have a maximum of 10 active tasks across all your notebooks. If you pause some of your active tasks, you will be allowed to create more tasks until you reach 10 active tasks again. For Notebooks in ArcGIS Enterprise, the default number of maximum active tasks is set at 20. Administrators of an organization have the privilege to [change that limit](https://developers.arcgis.com/rest/enterprise-administration/portal/limits-system). " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file + "cells": [ + { + "cell_type": "markdown", + "id": "2b116b66-8015-4742-8115-bcb0f09a6e10", + "metadata": {}, + "source": [ + "# Working with an Organization-Wide Dependency Graph" + ] + }, + { + "cell_type": "markdown", + "id": "a8fd2570-ff4b-4cec-9269-cbf542cd66af", + "metadata": {}, + "source": [ + "Version 2.4.1 of the ArcGIS API for Python brought about some exciting new functionality for content management: the `arcgis.apps.itemgraph` module. This module, in it's most basic usage, allows you to take an item in an organization and examine the deep dependencies of it- what items it needs to exist, what items those items need to exist, and so on. This is very helpful for management of apps and smaller subsets of org items, but what if we really want to push the limits of what we can do with this module?\n", + "\n", + "With a little patience and creativity, we can create an actively-updated dependency graph that encapsulates every item in our organization. Doing so opens up all sorts of doors for us, such as:\n", + "- The ability to examine the total reverse dependencies of an item (e.g., take a feature layer- we can see every app or map in our org that requires it to exist, or that will be effected by a change to it\n", + "- Quick identification of all broken dependencies in our organization\n", + "- Sorting of org items by complexity (most vs. least dependencies)\n", + "\n", + "In this sample, we'll provide code to create and update an organization-wide graph, glean information from our graph, and then finally include a section on how to automate this process via ArcGIS Notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "19637729-09c6-4094-8fd4-c7daf9b94299", + "metadata": {}, + "source": [ + "## Part 1: Creating and Updating an Org-Wide Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3d4c3a05-240c-4906-9509-75ccaba0c625", + "metadata": {}, + "outputs": [], + "source": [ + "from arcgis.gis import GIS\n", + "from arcgis.apps.itemgraph import create_dependency_graph, load_from_file\n", + "import datetime\n", + "import networkx as nx\n", + "gis = GIS(\"home\")" + ] + }, + { + "cell_type": "markdown", + "id": "e74b49d1-0290-4634-9313-ceaf3334512e", + "metadata": {}, + "source": [ + "### Initial Run\n", + "\n", + "This builds the initial dependency graph by indexing over every single item in the organization. This only needs to be run once, and will likely take a very long time, depending on how many items are in the org. Once it's been run and the graph structure and time stamp are saved into files, this notebook that updates the dependency graph can be run. This first cell can also be executed outside of ArcGIS Notebooks, and the .gml and .txt files can be brought in from elsewhere.\n", + "\n", + "*Note: Comment out this cell after the first time running the notebook.*" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7d4665-5542-4d80-866b-c10e6081fc3b", + "metadata": {}, + "outputs": [], + "source": [ + "# only run this cell the very first time you index over your org and grab all the dependencies\n", + "# this will take a long time if the org has a ton of items\n", + "\n", + "import datetime\n", + "items = gis.content.search(\"\", max_items = 10000)\n", + "timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", + "graph = create_dependency_graph(gis, items)\n", + "graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", + " file.write(str(timestamp))" + ] + }, + { + "cell_type": "markdown", + "id": "adf0a4ab-8fc1-4152-bd96-82f88bb219d1", + "metadata": {}, + "source": [ + "Now, we have a snapshot of every item in the organization and how they relate to one another. But, what if we don't want to run this lengthy initial step every time we want to work with this graph? And what if there are items that are getting created, updated, and deleted, so the relationships in this graph might become outdated? This notebook will go over how we can use specific capabilities of the ItemGraph to examine massive graphs without re-indexing, and will include code that will update the graph through automation, meaning that scheduling this notebook to run will ensure that your organization-wide dependency graph stays up to date." + ] + }, + { + "cell_type": "markdown", + "id": "f4146031-7653-4d06-b2b6-563048535186", + "metadata": {}, + "source": [ + "### Efficiently Analyzing the Existent Graph\n", + "\n", + "When loading up an existent graph based on a .gml file, it still may take some time to retrieve every single item associated with each node in the graph, especially for organizations with thousands and thousands of items. If you want to instantly analyze the items and relationships in a .gml file with thousands of records, we can call `load_to_file()` and elect to *not* retrieve each item. This still gives us the power to view all item id's and their dependencies in the org, but without the overhead of retrieving each one from a REST endpoint first. Users can simply retrieve the associated items as needed, based on the id's.\n", + "\n", + "We'll show a quick example of this using the existent graph, and then use a graph loaded with the items to ensure we're up-to-date with the current state of organization. We'll only print the first few for the sake of keeping this page short." + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "63d6a566-4e5d-495f-b448-cf452db3f967", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3643" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fast_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, False)\n", + "len(fast_graph.all_items())" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "08e88638-8b71-4340-b912-88e0b5d71ddd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 72c2671bff1143c4bc577755bc00a7aa),\n", + " ItemNode(id: 405b512903e74ec0af5ce2083b863705),\n", + " ItemNode(id: 039e2c7e648b4a5d9d64c57b470d7397),\n", + " ItemNode(id: 64a096654b924b2998ed07a747524e96),\n", + " ItemNode(id: e12e8599965c43af9632a5c9633c2994),\n", + " ItemNode(id: 5b534fa4a26d4fd1868ea7509806b053),\n", + " ItemNode(id: 96cf6c756ee74c288a8a88788f980266),\n", + " ItemNode(id: 64480b5bfc474ab1a464fa18098c92e5),\n", + " ItemNode(id: 14d12cc813b2422db0f4b7b1b701bcc1),\n", + " ItemNode(id: 5a1a8ac568a942b792c1283b7acff602),\n", + " ItemNode(id: dc5014dff7014a23af6eff25b492bce6),\n", + " ItemNode(id: 1fcbf4e77ebc46ef9971d1194f412c3b),\n", + " ItemNode(id: fc02404cdda24f72842d34b28267d77a),\n", + " ItemNode(id: 4cc1488a3c134af9abbe0a268d50b499),\n", + " ItemNode(id: 24ca75398c494dad8b4e7104e2a640d5),\n", + " ItemNode(id: 4839158f96544bafb841c1739d84f11b),\n", + " ItemNode(id: 9b9de0ff974e4924b15bc278ad6d6676),\n", + " ItemNode(id: 87c2394212ad42bcb89de9e244d4072d),\n", + " ItemNode(id: 13697d5ab62449e78dd9c28037380592),\n", + " ItemNode(id: a93fd45749ec4773839f02623ebad01d)]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fast_graph.all_items()[:20]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8a3c2f4b-c416-4ef5-bb22-a1d24a628da8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " Latin America\n", + " \n", + "

Mobile Map Package by esri_nav\n", + "
Last Modified: October 01, 2017\n", + "
0 comments, 0 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random_node = fast_graph.all_items()[0]\n", + "gis.content.get(random_node.id)" + ] + }, + { + "cell_type": "markdown", + "id": "8d0d126a-8b82-4b52-ab64-b9fb8231a836", + "metadata": {}, + "source": [ + "As we can see, we can instantly load in this complicated graph and just grab the `Item` associated with a given node as needed. However, for this next part, we're going to need to retrieve everything in the graph, which could take a while; that's why it's meant for some scheduled automation.\n", + "\n", + "### Automation: Updating our Org-Wide Graph\n", + "\n", + "The items in our org might not be the same as the ones we had in it yesterday- that's why we want to update our graph periodically. We can use some attributes of the `ItemGraph` class and some networkx tricks to maintain an up-to-date record of everything in the org.\n", + "\n", + "We'll start by loading up our existent graph stored in the .gml file with every `Item` attached. This may take a while to do, depending on how many items must be retrieved. We retrieve the items so that later we can verify which ones still exist and which ones have been deleted." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ccf52250-3b9e-47e2-bcb2-81d82473d515", + "metadata": {}, + "outputs": [], + "source": [ + "# grab the graph created yesterday to update it\n", + "old_graph = load_from_file(\"/arcgis/home/graph_data/updating_graph.gml\", gis, True)" + ] + }, + { + "cell_type": "markdown", + "id": "cfe9d923-1528-4e9c-9ffb-d48783bcd977", + "metadata": {}, + "source": [ + "Keeping timestamps allows us to understand when the last time we updated the graph was and maintain an accurate graph. This approach allows for the scheduling of this notebook on any timeframe- whether you run it every day, every week, every month, or something else." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c3989f2-7047-48dc-ac27-e941f8cc0f3b", + "metadata": {}, + "outputs": [], + "source": [ + "# grab our old and new timestamps\n", + "# old is the last time we updated the graph, new is current time\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"r\") as file:\n", + " old_timestamp = int(file.read())\n", + "new_timestamp = int(datetime.datetime.now().timestamp()) * 1000\n", + "\n", + "# use these timestamps to see items that have been modified or created since last run\n", + "q = f\"modified: [{old_timestamp} TO {new_timestamp}]\"\n", + "modified_items = gis.content.search(query = q, sort_field = \"modified\", sort_order = \"desc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1dcbf4d7-02e0-471c-bd64-8e69e0462a96", + "metadata": {}, + "outputs": [], + "source": [ + "# now that we have our list of updated items, make a graph out of them\n", + "mod_graph = create_dependency_graph(gis, modified_items)" + ] + }, + { + "cell_type": "markdown", + "id": "f9a664b7-6bc8-46e5-b8e9-3972d371508e", + "metadata": {}, + "source": [ + "Now we have a graph containing only new/modified items, and all of their dependencies. We'll have to combine the new information in this graph with our existent graph, and delete the outdated information. Time for some fun graph operations!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9605f93b-b732-4379-9636-b2e9340d57b4", + "metadata": {}, + "outputs": [], + "source": [ + "# nx.compose() combines all nodes and relationships of two graphs\n", + "new_graph = nx.compose(old_graph, mod_graph)\n", + "\n", + "# find the list of items in both graphs\n", + "# these are ones that already existed but were modified, meaning dependencies might have changed\n", + "intersects = set(old_graph.all_items('id')) & set(mod_graph.all_items('id'))\n", + "\n", + "# go through these items and delete outdated forward dependencies\n", + "for itemid in list(intersects):\n", + " old_contains = set(old_graph.get_node(itemid).contains(\"id\"))\n", + " mod_contains = set(mod_graph.get_node(itemid).contains(\"id\"))\n", + " \n", + " # isolate deps that only existed in old graph\n", + " outdated = old_contains - mod_contains\n", + "\n", + " # remove these relationships from the new graph\n", + " for dep in list(outdated):\n", + " new_graph.delete_relationship(itemid, dep)" + ] + }, + { + "cell_type": "markdown", + "id": "2d76e7f6-2c07-4c45-9f3a-37112d3f26d9", + "metadata": {}, + "source": [ + "Our `new_graph` now has an accurate reflection of all item relationships in our organization- any item that got changed could have had it's forward dependencies altered, so we made sure that those got updated to reflect any changes. We didn't have to worry about changing any reverse dependencies, since every reverse dependency is still just a forward dependency for another item, so the appropriate relationship was addressed during that process.\n", + "\n", + "We have one more little housekeeping thing to do with this new graph now- due to the way that `nx.compose()` works, the individual nodes within the new graph still contain references to the old graph. We just have to make sure those nodes now use the new graph for any computation." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "730ad8cc-a7a9-4e3f-8088-015b5e59790e", + "metadata": {}, + "outputs": [], + "source": [ + "# make sure our nodes are all referencing the new updated graph\n", + "for node in new_graph.all_items():\n", + " node.graph = new_graph" + ] + }, + { + "cell_type": "markdown", + "id": "4db9c02d-b77f-42e6-bc31-250055ff1846", + "metadata": {}, + "source": [ + "Alright, awesome, now we have all newly created or recently modified items accounted for- but we still have to account for items that might have been deleted. How do we do this? \n", + "\n", + "Remember when we ran the `load_from_file()` function earlier that retrieved all of the items while rebuilding the graph? Well, any node of an item that's been deleted won't have an attached `Item` object anymore, since it wouldn't have been retrieved. Therefore, if we have a node with no associated item, we can assume the item has been deleted, and that if the node is not contained by another node, then the item is not still meant to exist. So, we can delete nodes from our graph that fit that criteria.\n", + "\n", + "One added layer of complexity: what if the node of a deleted item is contained by another node of a deleted item that just hasn't been processed yet? We can avoid this scenario by sorting our nodes in ascending order of how many items they're required by, ensuring we're prioritizing processing ones furthest up the dependency chains first (e.g., deleted item A contains B which contains C- if we analyze B or C first, we'll wrongfully keep them, but if we start with A and go down the chain, all will get deleted properly)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "96cea807-c561-4408-aa42-4153d752fc98", + "metadata": {}, + "outputs": [], + "source": [ + "nodes = new_graph.all_items()\n", + "\n", + "# define our sort function\n", + "def count_reqs(node):\n", + " return len(node.required_by(\"id\"))\n", + "\n", + "# this orders our nodes properly\n", + "sorted_nodes = sorted(nodes, key=count_reqs)\n", + "\n", + "# remove ones that don't have items and aren't dependencies of others\n", + "for node in sorted_nodes:\n", + " if not node.item and not node.contained_by():\n", + " new_graph.remove_node(node.id)" + ] + }, + { + "cell_type": "markdown", + "id": "d89a380c-1f85-4326-8372-37b74bb5aa00", + "metadata": {}, + "source": [ + "And there we have it. Now we have a properly updated graph, one that reflects today's state of every item and their dependencies. Grabbing a node for a given item from `new_graph` should give you a holistic look of all items it relates to in an org, no matter if it's an immediate or deep relationship in either direction. To summarize, we:\n", + "\n", + "- Loaded in the graph from the last time we ran the notebook\n", + "- Determined what items had been modified/created since the last time we ran the notebook\n", + "- Created a graph from those updated items, capturing their current dependencies\n", + "- Merged the old graph with the modified graph to create a new graph with all nodes/relationships from both graphs\n", + "- Got rid of relationships that no longer existed from the new graph\n", + "- Got rid of any items that had been deleted and weren't dependencies of an item from the new graph\n", + "\n", + "Now, we'll write out the state of this graph and the timestamp at which we started everything, so we can repeat this process in the future and continue to update our graph as the items in our ArcGIS organization evolve." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ef2845ff-c2cd-428d-9ff4-486ed0c8160c", + "metadata": {}, + "outputs": [], + "source": [ + "new_graph.write_to_file(\"/arcgis/home/graph_data/updating_graph.gml\")\n", + "with open(\"/arcgis/home/graph_data/updating_timestamp.txt\", \"w\") as file:\n", + " file.write(str(timestamp))" + ] + }, + { + "cell_type": "markdown", + "id": "08f5ef15-cf3f-4317-bca6-794761166f70", + "metadata": {}, + "source": [ + "## Part 2: Using the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "587f19ea-923c-4001-ad87-5dde5129b99b", + "metadata": {}, + "source": [ + "Now that we have our organization-wide graph and know that it's up to date, we can use it for some useful administration and analysis. We'll take a look at the three things mentioned in the intro: examining comprehensive reverse dependencies of items, identifying broken dependencies that need fixing, and sorting our items based on their complexity." + ] + }, + { + "cell_type": "markdown", + "id": "b60c0fc9-4523-4a93-bf0a-47be12ff689a", + "metadata": {}, + "source": [ + "### Comprehensive Reverse Dependencies\n", + "\n", + "This is a very powerful perk of having every relationship in an organization included in a graph: the ability to see _every_ single item that relies on a specific item. Say you have a feature layer that is used in numerous maps and applications throughout your org: you can instantly acquire a list of every one that consumes it, either directly or indirectly. Let's take a look." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "35636665-42d0-486d-a1bc-e9aae10bed2c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + " World Topographic Map\n", + " \n", + "
This vector tile layer provides a world topographic map. (World Edition)
Vector Tile Layer by esri_livingatlas\n", + "
Last Modified: April 26, 2025\n", + "
0 comments, 0 views\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# grab a node corresponding to a feature layer\n", + "flayer_id = \"7dc6cea0b1764a1f9af2e679f642f0f5\"\n", + "flayer_node = new_graph.get_node(flayer_id)\n", + "flayer_node.item" + ] + }, + { + "cell_type": "markdown", + "id": "51ccb876-369a-4636-9112-f0f9c39b94b0", + "metadata": {}, + "source": [ + "Calling `.contained_by()` will show all of the items that contain our vector tile layer." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "cb088e78-1ffa-4b89-ac4e-25526b372388", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "flayer_node.contained_by(\"item\")" + ] + }, + { + "cell_type": "markdown", + "id": "d6328f75-6018-4c7a-b275-2ebfded5985f", + "metadata": {}, + "source": [ + "Calling `.required_by()` will show us all of the items that depend on our layer in some way." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0af9dea-2b2b-46ca-a9ee-faff7e7c6b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "flayer_node.required_by(\"item\")" + ] + }, + { + "cell_type": "markdown", + "id": "d4df1dfe-a652-4655-a60b-694877f9f9a9", + "metadata": {}, + "source": [ + "There we have it- we instantly determined which items would be affected by deleting or changing our layer." + ] + }, + { + "cell_type": "markdown", + "id": "e1c1bdf8-834e-4e8c-b7ad-c513e3593814", + "metadata": {}, + "source": [ + "### Finding Broken Dependencies\n", + "\n", + "In this context, we're calling an item that is contained by another item, but isn't valid or accessible, a \"broken\" dependency- these sorts of items can lead to rendering or logic issues in applications such as Web Maps, StoryMaps, Experiences, Surveys, and so on. There can be a number of reasons for why these improper dependencies may exist- an item being used by an application mistakenly got deleted, there was some sort of corruption with data, the json structure of an application might have been copied from one in a different org, and so on.\n", + "\n", + "Luckily, the way the `ItemGraph` is constructed allows us to instantly find these cases where something is potentially awry. During construction of the graph, the ID of each `ItemNode` was passed into the GIS org to see if it yielded an item. Therefore, any node that doesn't have an `.item` property could potentially be a problem." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d50fcf1d-107f-4bbf-a21f-3ebcfd0c0fb2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: 370b95fdf676475ca8fd184ad0931610),\n", + " ItemNode(id: 1dc6042bb3ba409c9d1eb1d7c996d6ed),\n", + " ItemNode(id: bf08d46ab087435aa4afbc62092223cb),\n", + " ItemNode(id: 123hehethiswontwork),\n", + " ItemNode(id: 2fe20a161c514e16b805a21a7e2d636b),\n", + " ItemNode(id: 15efb8c0d9e3447782789592f432fc1a),\n", + " ItemNode(id: bda2f1dc3c824c3e97f4a682554177cf),\n", + " ItemNode(id: bbf4d26d7c3340dab009c7164cc3e1e5),\n", + " ItemNode(id: d60affb34dd948a1b973da076830ad00),\n", + " ItemNode(id: 1182ef6f62a543fdba4a55c85c014431),\n", + " ItemNode(id: f32924d7b16f41d78839dba3b943b08c),\n", + " ItemNode(id: 9f91d4c34f194da793c8573b24a751a9),\n", + " ItemNode(id: 91fa101048bb4855970f7d004a4542ce),\n", + " ItemNode(id: 6e02b538bea841ed858ef9f52709b655),\n", + " ItemNode(id: 878802f78aad4ab5a83c1397c72048c5),\n", + " ItemNode(id: f1801a1b3d674de7b9de246a126eb17b),\n", + " ItemNode(id: 2),\n", + " ItemNode(id: 44c3348139a84423b4a46074a104efdf),\n", + " ItemNode(id: 74ab88e7e22d4dbd93b43a00b2d0155b),\n", + " ItemNode(id: 306cf223a2fd46d3bf6ce39225681977),\n", + " ItemNode(id: 1ee3200825ce448c91a1ec9ae4f70c28),\n", + " ItemNode(id: 72224efc9e044001934bb3be87120beb),\n", + " ItemNode(id: 90ff936dc4704a0798f61ebbb1dec357),\n", + " ItemNode(id: 0df19d2d940b47658857cc2fc9623840),\n", + " ItemNode(id: cdf23b869e7649469759cf756c1d43f0),\n", + " ItemNode(id: a5f11273b85d40adbd7cf9a162f81ef2),\n", + " ItemNode(id: 08a9b819b9e04de9a68418f2b225ec6a),\n", + " ItemNode(id: f265c79c47a3413b8b8f711909f03fe2),\n", + " ItemNode(id: 819ee7ddbf5848889effd0fa6b039a51),\n", + " ItemNode(id: 8548e23d8b1a478eaf2246e6fc3b31b9),\n", + " ItemNode(id: f97edbe48af7427f8604f20320e2de52),\n", + " ItemNode(id: b66792b3bb004fa8997fcfcef991e984),\n", + " ItemNode(id: 9204269c8e714500a565a3ddf055825d),\n", + " ItemNode(id: 28dae0b8f1c44814b281b71752453c61),\n", + " ItemNode(id: d15c117e60dd4fe299ec03a379c9caf8),\n", + " ItemNode(id: 3b6d38a456164adea4c061a2a51d89b1),\n", + " ItemNode(id: a12fcbe07c8d41f1b6981f33a10d1d0c),\n", + " ItemNode(id: ae4bea7c35824bf1ae571783142dc97d),\n", + " ItemNode(id: 8e969d9adb7f485c88a8350d317e8c9b),\n", + " ItemNode(id: 493db5d6832b44a581547a8df8c3907c),\n", + " ItemNode(id: ebe640ee5d344bea9fca7bfa4d80bb3a),\n", + " ItemNode(id: 6595a5cf08d64212a85ce9dc47700575),\n", + " ItemNode(id: 761e9fcf5efa4b368716fae9a1ffda0f),\n", + " ItemNode(id: 39f0fc3c5b424d679c2ef9ae67e71624),\n", + " ItemNode(id: 59835c8d71d94475ae04f540a8167343),\n", + " ItemNode(id: 5b2e49a83dd9427abf398aeeecc00f75),\n", + " ItemNode(id: dcf4a23abb614d7db9cda2dce90cc528),\n", + " ItemNode(id: 1d250ce2c5c0463abe0e1887597cc926),\n", + " ItemNode(id: e57b96c732cc4c34830756d53c8f3619),\n", + " ItemNode(id: 79f3399102ce4ab79bed0407b03005fc),\n", + " ItemNode(id: 872d78b038d342b98b6a3547ed8a7ac9),\n", + " ItemNode(id: 3a2d7671322e4dcbb386e4b961e28c27),\n", + " ItemNode(id: 8900b18d92ac43cfae142a5a5ad91e4a),\n", + " ItemNode(id: ba6575ad916041a89887309492473b42),\n", + " ItemNode(id: 5bbbe8978d9f43a0a7a947b5af3cdc1d),\n", + " ItemNode(id: 73196ca49b6b40c0a03206663cb10554),\n", + " ItemNode(id: 9566f596ba404a05aa8eae9221bce82a),\n", + " ItemNode(id: c2e2b6eaea3740059546951c16af5151),\n", + " ItemNode(id: 4cee55fa5973406596359e7630ab167e),\n", + " ItemNode(id: 086eb0c799794d4b99a95a39cd43dca2),\n", + " ItemNode(id: 6313031ddbe14d7ca0358c4ba8011b27),\n", + " ItemNode(id: bc68a4d142fb4801a2401a0a5a551ba1),\n", + " ItemNode(id: 07b7fe74b02c40afa1551d41f19f6d99),\n", + " ItemNode(id: 632d3de849224fcb990f6d9feae36331),\n", + " ItemNode(id: 26e87527293b43978b1fb4a24133ead1),\n", + " ItemNode(id: efff5de20fd546de94e613fbed730372),\n", + " ItemNode(id: 401d890c10d94e88948a0bd5f82e7559),\n", + " ItemNode(id: 8cf058d7e58d4f66831e8bc7ae7addbd),\n", + " ItemNode(id: fed737361fcf4815b2b62651e1cd2a57),\n", + " ItemNode(id: 46472e81856c4420aeb091e6f0fd24e8),\n", + " ItemNode(id: d1414cb87c2d41099cfcfe55aa8344e2),\n", + " ItemNode(id: c2f21b0e86de49fa9b6437cd72779488),\n", + " ItemNode(id: 77efb9bd7831430ab3788741d327e5df),\n", + " ItemNode(id: 633c43f3c0e148dea129d6ca49e7fd22),\n", + " ItemNode(id: 3dce15e4178a4a9c92cacb66f2f7f1ea),\n", + " ItemNode(id: 2a6e5de8aa4a40899e44017121c5cd89),\n", + " ItemNode(id: bccbd571d0d54e45b6a69ca0249e7132),\n", + " ItemNode(id: c8cbf786be774df7b064f149c5898fef),\n", + " ItemNode(id: 71276e9e9638459890a3072df64e31b6),\n", + " ItemNode(id: a06302053b3f4e35961584d5818bf1f2),\n", + " ItemNode(id: 5feee1e7f41a4c47b3f137457c130182),\n", + " ItemNode(id: 6e403956c5d7419b9c0628e65bed0769),\n", + " ItemNode(id: 196b5b2798204de38b6dd125823bd714),\n", + " ItemNode(id: 88ba2cd25d1c423c808fa2e1941a540b),\n", + " ItemNode(id: c1e6eb63502c4012bb631097b69aefad),\n", + " ItemNode(id: 4c56c5e083544decbd8d61f3a0bc5a67),\n", + " ItemNode(id: 905567641b10499ba6a77a0a6e4e5f13),\n", + " ItemNode(id: 861096f2cb274134bcdca7e875899d69),\n", + " ItemNode(id: 3afb37e1c7784a05b7d0b4c4c98088c1),\n", + " ItemNode(id: ae5179630d714200893cda3a6e50e460),\n", + " ItemNode(id: 2243cb05a01f43cc8d7439447ffe3bbf),\n", + " ItemNode(id: 27d2f0ad1c7545e48848b43bbd51581a),\n", + " ItemNode(id: 9dc85299a77540b0bac1507ce67e9dfa),\n", + " ItemNode(id: 16ffb93988c94d699b672d837c1e03e6),\n", + " ItemNode(id: 3668c924551b4ff2a508cd2cda897abe),\n", + " ItemNode(id: c2e075d098a6493393dc3f55876d48f4),\n", + " ItemNode(id: 53071c1408d240c1997a3779c48467b4),\n", + " ItemNode(id: 36a01f823259430197c896ff415ee493),\n", + " ItemNode(id: 21e0d7322928434d8889eba70e4c645a),\n", + " ItemNode(id: 3e5ba2fec29f4f25afd5a5dbfaadf136),\n", + " ItemNode(id: d79cd0205b03479b8019648e1dd057f4),\n", + " ItemNode(id: 8461fdc33b554ffbad1ba54afd1ff499),\n", + " ItemNode(id: 940e3b1543bf4289822790a15e66c5a4),\n", + " ItemNode(id: 15e70e3da80b42fd9b60eda8cd6e7cd4),\n", + " ItemNode(id: 4438ff8fb9174783934412c1c51f4865),\n", + " ItemNode(id: db089afa931a4a9fb1cb2afe33a6c2f6),\n", + " ItemNode(id: ba0ff62d9aaf4f628eb1a869c0bb5ee0),\n", + " ItemNode(id: d50ecf25a35a4cd9baaa1ba7035f77da),\n", + " ItemNode(id: 76e505d722f64fa6b0debd0f196c3ae1),\n", + " ItemNode(id: dfcdd3b0495d4f4cb3c3a4a401616d6e),\n", + " ItemNode(id: 03bcd4dfbeae4a91ae270a934fa27e1b),\n", + " ItemNode(id: 1c5e01156f5a4f0fae4dc61297785c1d),\n", + " ItemNode(id: 16d1d5083719466487007bf90313184f),\n", + " ItemNode(id: 2f87efbdf4ec4942ad610fe4b6bd8c36),\n", + " ItemNode(id: 97162f48110d4458820c3b66de375d67),\n", + " ItemNode(id: e98bc26706ba46c782c03c81c739a065),\n", + " ItemNode(id: 8d721aaa69aa4715911693fa4863b7cf),\n", + " ItemNode(id: 7a238f29b99f4ff1957e3a469177c56a),\n", + " ItemNode(id: ff9cafd475ff4a0abf5d8f3a34fc7646),\n", + " ItemNode(id: ae00236efed94d0b8739ef8a244cc312),\n", + " ItemNode(id: 12b7fd7eaefc4f40b2fe003604153b3c),\n", + " ItemNode(id: 1f2248e4464b4065a864cc6aab7aa780),\n", + " ItemNode(id: c13634e58a024cae9de6a15a4b3eb101),\n", + " ItemNode(id: bd6943458948460a8eb71d97baaa2ada),\n", + " ItemNode(id: 6fafb84fc46d4b9c8b25fb57dd9911a2),\n", + " ItemNode(id: c209e14b44b7420cb40ed650cfefa4f5),\n", + " ItemNode(id: 048de0545a834d8b8c31a6e0e10270d7),\n", + " ItemNode(id: 40bf682bf17c4c32a5acade2d54eafb9),\n", + " ItemNode(id: e608d5be1b4241cdbb1fbf61418513d6),\n", + " ItemNode(id: 908ceeaa2e5e4ef19e823715a35ab978),\n", + " ItemNode(id: 7d907c5ac31b4da098d47922bb31f2aa),\n", + " ItemNode(id: 5dd87bebb9864dac9c2f42604bb79b14),\n", + " ItemNode(id: 78186ce321f1433091aeb2593abbc565),\n", + " ItemNode(id: cb7a89a516e84af7b3d7e551a38afed5),\n", + " ItemNode(id: 6b63dafabf4e486183c21bede31b149e),\n", + " ItemNode(id: a962b03a45d9415ea97b96eaab7f20d6),\n", + " ItemNode(id: ac96d6152ba34373ac1c7288b2fcefe4),\n", + " ItemNode(id: d0d5d3caafed43cd9ce18b9a2609fc5f),\n", + " ItemNode(id: d9b8675be48d49078db4c55208a0d19e),\n", + " ItemNode(id: 2defd52c9e4f4759ba085f339d284cd4),\n", + " ItemNode(id: 961434231c034930801f5b3237715587),\n", + " ItemNode(id: af83304d94cd4e0da83318f76cde60c4),\n", + " ItemNode(id: 85179dd8a0fe4ea597586fed851bdeff),\n", + " ItemNode(id: d5e20e6f7a9542d5ace62983699d3212),\n", + " ItemNode(id: e3e1712a046d4feeb454e5538a6049d7),\n", + " ItemNode(id: 045ba64dd5bc4b1a94350f897de956cf),\n", + " ItemNode(id: 4fb8f3f5422d4a7696b0f8136a4b48aa),\n", + " ItemNode(id: 75113e1eb7e045229c2cb2698e43114c),\n", + " ItemNode(id: 228834a1eff64c629c80d0b638f9e43c),\n", + " ItemNode(id: 42b653e394104606987cbf4b6d1587f9),\n", + " ItemNode(id: 2c82e7cf420b4026b875ad45750c7a24),\n", + " ItemNode(id: f1894e0262e44dd6adadef875577d8aa),\n", + " ItemNode(id: 4f93f1fbebdd4f66a55b6a02f332fa20),\n", + " ItemNode(id: caa4a0e4ddcb47c9845eb92f024fcd7f),\n", + " ItemNode(id: 1a9c7b34467d41728f9472a0b6628841),\n", + " ItemNode(id: 7f4342f006a44c8780d8df79d5da5652),\n", + " ItemNode(id: a90891b098034e0d928fc4ee30dec1a3),\n", + " ItemNode(id: caa7ab7f82ab41dd9af1215c11f55a8f),\n", + " ItemNode(id: bb46d017f7af49728d5af8d8eec43c4e),\n", + " ItemNode(id: a5df7d4a77c24fc39a1115122370cd8f),\n", + " ItemNode(id: 879921e888a14e96b5f5b339af907acd),\n", + " ItemNode(id: 8dd1b1b7731c49839489e0d30146f513),\n", + " ItemNode(id: eb0499aeb1d5461f877e9b40534e225e),\n", + " ItemNode(id: 4138c0fbe6b446fbad5447ecc34c8ab8),\n", + " ItemNode(id: e2ee852f11c14d99814dd4ed42a0a16c),\n", + " ItemNode(id: e27013ac9f664054a044edd3567c763a),\n", + " ItemNode(id: ee527fed605a4088b10c49ab9c9ed096),\n", + " ItemNode(id: a7cdce7ebb404ae6b700b491f21b3243),\n", + " ItemNode(id: e0dfd02f8f61479c8e1a276c79cafcd5),\n", + " ItemNode(id: 3d0d28a295e54d25966e7945e2bf5d8e),\n", + " ItemNode(id: d8e9dfe815b44c8ab3e94a6dc1fcf201),\n", + " ItemNode(id: 3ce93787d12645f386d42d57ca57c1b4),\n", + " ItemNode(id: 9c03b76829464ee68d4e6af241cebd5e),\n", + " ItemNode(id: 5707b86b5f3f4b7c9e67ac2fd317254a),\n", + " ItemNode(id: 79719a8a27d3440d9d622041ff7b8506),\n", + " ItemNode(id: 1adc07ec24774989873cafc6c68c1536),\n", + " ItemNode(id: 1926c33e9bf34ef99b8950f1408368a3),\n", + " ItemNode(id: 892a696bf2aa4a899f5177017d998156),\n", + " ItemNode(id: 57654725661049eba50bca930ae786e8),\n", + " ItemNode(id: c85179865e0c45089e0f9bb29b7ca83e),\n", + " ItemNode(id: b9cb2d66aaa04093950683767c8eaff0),\n", + " ItemNode(id: c9b04902a93c4aeda9b92e45b303fe01),\n", + " ItemNode(id: 1c8354e6f69e4df1969befae339412c7),\n", + " ItemNode(id: ed2246c081ee49369024cfb312e34899),\n", + " ItemNode(id: 6d6bae1a02484353add60ddefaca185e),\n", + " ItemNode(id: a143d4fe84e14712bfd28e71b26ac868),\n", + " ItemNode(id: d822827df8f345d280ebf2c2be8a48a1),\n", + " ItemNode(id: 3f4789f0a58b4cdcab5b7d1a08f5f9d9),\n", + " ItemNode(id: f091f6195a194f38a47f8b329bbd9255),\n", + " ItemNode(id: 7f7c4245f03445e782e9aa4a4d06221d),\n", + " ItemNode(id: 07a05ca8a10843aba797076d40ca8f36),\n", + " ItemNode(id: https://oceans1.arcgis.com/arcgis/rest/services/USA_Drilling_Platforms/FeatureServer/0),\n", + " ItemNode(id: e26f2752e86d4a8dad52ea75501480f0),\n", + " ItemNode(id: aecf7fd35dca43fe80fc67b60fb73516),\n", + " ItemNode(id: ab924202cc404af58b41efcf99b0aafa),\n", + " ItemNode(id: 1c735ebaed8d48b5bfd6fcfcd35eb3d1),\n", + " ItemNode(id: a5846d8e82834f4398fb54e0ef0db0c5),\n", + " ItemNode(id: bbf872949f2f43a6921e716f7fbe1d72),\n", + " ItemNode(id: 1c80207bf5384974994ad4a13abf4556)]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "no_item_nodes = [node for node in new_graph.all_items() if not node.item]\n", + "no_item_nodes" + ] + }, + { + "cell_type": "markdown", + "id": "f621f913-9b8c-47e0-b7d3-619410223d9c", + "metadata": {}, + "source": [ + "As we can see, we now have a list of nodes where the ID's don't lead to a portal item. There is one anomaly here: what appears to be a service that just doesn't have an associated portal item, but still may be valid. We can add some separate logic to ensure we test any URL for valid data." + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "5d0a224d-de59-4b6f-ad86-b209c5a91340", + "metadata": {}, + "outputs": [], + "source": [ + "from arcgis.layers import Service\n", + "updated_no_item = []\n", + "for node in no_item_nodes:\n", + " if \"https://\" in node.id:\n", + " try:\n", + " serv = Service(node.id)\n", + " if not serv:\n", + " raise\n", + " except:\n", + " updated_no_item.append(node)\n", + " else:\n", + " updated_no_item.append(node)" + ] + }, + { + "cell_type": "markdown", + "id": "fd4c5d32-2f52-44d0-a59d-c5beaec43493", + "metadata": {}, + "source": [ + "Given this list of items with ID's that lead nowhere, we can grab the node for any one of them and do what we did above- see which org items contain or require them. From there, we can figure out how to fix it- one option is using the `remap_data()` function, documented [here](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "de01da8b-84f6-4f46-864d-ceb41b31e9e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents)]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "broken_node = updated_no_item[0]\n", + "broken_node.contained_by()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "c4f3a39d-9c0b-4659-8705-6b114ca3a635", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ItemNode(id: e6430fd93abe46ccaf2a8e31b5a35c80, item: AZ Vehicle Incidents),\n", + " ItemNode(id: d3b24b91f2c3432fbb5b7d2862f7525d, item: TestInstantApp),\n", + " ItemNode(id: 7259119a69044ae4aebd3e4cd338321f, item: AZ Vehicle App)]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "broken_node.required_by()" + ] + }, + { + "cell_type": "markdown", + "id": "014807cf-c9e1-442f-9d74-22b7a215e99a", + "metadata": {}, + "source": [ + "### Sorting Items by Degree, Type, and More\n", + "\n", + "Finally, let's put ourselves in the shoes of an organization admin that wants to learn about the items in their org: which items have the most dependencies, and which ones are needed by the most items? Which ones have the most broken dependencies? Let's take a look at how we can capitalize on some graph logic and networkx tricks to gain insights into our organization's content." + ] + }, + { + "cell_type": "markdown", + "id": "c2e3cf87-7861-4b60-ae6a-55fb62215042", + "metadata": {}, + "source": [ + "We'll start basic: just identify which nodes have the highest _degree_, or number of direct relationships (\"contains\"/\"contained by\"). Since a degree can refer to either direction relationship, we specify the _out_ degree or _in_ degree, which in an `ItemGraph` will show the amount of each node's `contains()` and `contained_by()`, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "e0de0bbf-eacd-4791-97ed-a7e948adca7b", + "metadata": {}, + "outputs": [], + "source": [ + "def sort_degrees(direction = \"out\", descending = True, result_count = 50):\n", + " node_degrees = new_graph.out_degree()\n", + " if direction == \"in\":\n", + " node_degrees = new_graph.in_degree()\n", + " nodes_sorted = sorted(node_degrees, key=lambda item: item[1], reverse=descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " graph_node = new_graph.get_node(node)\n", + " if graph_node.item:\n", + " print(f\"Title: {graph_node.item.title}, Type: {graph_node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node}, Degree: {degree}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "6975d920-3314-484e-8a6e-af5929b18d42", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", + "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", + "Title: San Diego Parrot Sightings, Type: Form, Degree: 6\n", + "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 6\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 4\n", + "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", + "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", + "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", + "Title: TestInstantApp, Type: Web Mapping Application, Degree: 3\n", + "Title: map test, Type: Web Map, Degree: 3\n", + "Title: Cycling Explorer, Type: Web Map, Degree: 3\n", + "Title: AZ and NM Cities, Type: Web Map, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 3\n", + "Title: map test, Type: Web Map, Degree: 3\n", + "Title: Group Layer Map Test, Type: Web Map, Degree: 3\n", + "Title: Map Series 884411, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 213975, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 959005, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 537579, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 845552, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 836403, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 639470, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 816182, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 398285, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 985608, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 287154, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 396347, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 684806, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 709821, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 587161, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 255073, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 553493, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 329174, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 37166, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 261798, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 395417, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 326103, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 116930, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 222445, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 432118, Type: Web Mapping Application, Degree: 3\n", + "Title: USA WebMap, Type: Web Map, Degree: 3\n", + "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 692346, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 772573, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 254278, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 19528, Type: Web Mapping Application, Degree: 3\n", + "Title: Map Series 238550, Type: Web Mapping Application, Degree: 3\n" + ] + } + ], + "source": [ + "# find which items contain the most other items\n", + "sort_degrees(direction = \"out\", descending = True, result_count = 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "6c7a1bc2-b888-4cd0-8d8e-8cf5c9e30ab5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ID: bf08d46ab087435aa4afbc62092223cb, Degree: 153\n", + "ID: 123hehethiswontwork, Degree: 153\n", + "ID: 7f7c4245f03445e782e9aa4a4d06221d, Degree: 33\n", + "ID: 07a05ca8a10843aba797076d40ca8f36, Degree: 33\n", + "Title: World Topographic Map, Type: Vector Tile Service, Degree: 8\n", + "Title: Web Map 400800, Type: Web Map, Degree: 7\n", + "Title: Outline Map, Type: Web Map, Degree: 7\n", + "Title: Newspaper (WGS84), Type: Vector Tile Service, Degree: 5\n", + "Title: OpenStreetMap Streets with Relief, Type: Vector Tile Service, Degree: 5\n", + "ID: 2, Degree: 3\n", + "Title: Esri_Regional_Offices_US, Type: File Geodatabase, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", + "Title: Jy Survey 123 Connect, Type: Feature Service, Degree: 3\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 2\n", + "Title: Basic, Type: Web Mapping Application, Degree: 2\n", + "Title: AGO World Geocoder (arcgis_python), Type: Geocoding Service, Degree: 2\n", + "ID: 2fe20a161c514e16b805a21a7e2d636b, Degree: 2\n", + "ID: 15efb8c0d9e3447782789592f432fc1a, Degree: 2\n", + "ID: bda2f1dc3c824c3e97f4a682554177cf, Degree: 2\n", + "ID: d60affb34dd948a1b973da076830ad00, Degree: 2\n", + "ID: f32924d7b16f41d78839dba3b943b08c, Degree: 2\n", + "ID: 9f91d4c34f194da793c8573b24a751a9, Degree: 2\n", + "ID: 91fa101048bb4855970f7d004a4542ce, Degree: 2\n", + "ID: 6e02b538bea841ed858ef9f52709b655, Degree: 2\n", + "Title: National Weather Service Day 1, Type: WMS, Degree: 2\n", + "Title: Enhanced Contrast Dark Map (WGS84), Type: Web Map, Degree: 2\n", + "ID: 44c3348139a84423b4a46074a104efdf, Degree: 2\n", + "Title: Test Case 12305 Survey, Type: Feature Service, Degree: 2\n", + "Title: Test Case 232 A, Type: Feature Service, Degree: 2\n", + "Title: USA_Major_Cities_Data, Type: Feature Service, Degree: 2\n", + "Title: San Diego Parrot Sightings, Type: Feature Service, Degree: 2\n", + "Title: DevSummit Theme, Type: StoryMap Theme, Degree: 2\n", + "Title: ca_public_schools, Type: Feature Service, Degree: 2\n", + "ID: cdf23b869e7649469759cf756c1d43f0, Degree: 2\n", + "ID: a5f11273b85d40adbd7cf9a162f81ef2, Degree: 2\n", + "ID: 08a9b819b9e04de9a68418f2b225ec6a, Degree: 2\n", + "ID: f265c79c47a3413b8b8f711909f03fe2, Degree: 2\n", + "ID: 819ee7ddbf5848889effd0fa6b039a51, Degree: 2\n", + "ID: 8548e23d8b1a478eaf2246e6fc3b31b9, Degree: 2\n", + "ID: f97edbe48af7427f8604f20320e2de52, Degree: 2\n", + "ID: b66792b3bb004fa8997fcfcef991e984, Degree: 2\n", + "ID: 9204269c8e714500a565a3ddf055825d, Degree: 2\n", + "ID: 28dae0b8f1c44814b281b71752453c61, Degree: 2\n", + "ID: d15c117e60dd4fe299ec03a379c9caf8, Degree: 2\n", + "ID: 3b6d38a456164adea4c061a2a51d89b1, Degree: 2\n", + "ID: a12fcbe07c8d41f1b6981f33a10d1d0c, Degree: 2\n", + "ID: ae4bea7c35824bf1ae571783142dc97d, Degree: 2\n", + "ID: 8e969d9adb7f485c88a8350d317e8c9b, Degree: 2\n", + "ID: 493db5d6832b44a581547a8df8c3907c, Degree: 2\n", + "ID: ebe640ee5d344bea9fca7bfa4d80bb3a, Degree: 2\n" + ] + } + ], + "source": [ + "# find which items are contained by the most other items\n", + "sort_degrees(direction = \"in\", descending = True, result_count = 50)" + ] + }, + { + "cell_type": "markdown", + "id": "cc04967d-5a99-47ef-bb95-85ee2e09b7c6", + "metadata": {}, + "source": [ + "We can similarly define a function that will do that for the \"deep\" degrees- finding which items have the most recursive dependencies or items dependent upon them." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "49a220a2-87e7-42c9-ab0a-da043e689aba", + "metadata": {}, + "outputs": [], + "source": [ + "def sort_deep_degrees(direction = \"out\", descending = True, result_count = 50):\n", + " if direction == \"in\":\n", + " nodes_weighted = [(node, len(node.required_by())) for node in new_graph.all_items()]\n", + " else:\n", + " nodes_weighted = [(node, len(node.requires())) for node in new_graph.all_items()]\n", + " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " if node.item:\n", + " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node.id}, Degree: {degree}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "f03263b2-d5a1-4097-a36e-f77e7a8ce65f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Title: Testing Copy Content, Type: StoryMap, Degree: 159\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: New York Enriched Top Areas of Interest, Type: Web Map, Degree: 158\n", + "Title: DS-Page1-copy-1745540879568, Type: Hub Page, Degree: 14\n", + "Title: DevTechSummit2025-copy-1745540837450, Type: Hub Site Application, Degree: 13\n", + "Title: My Site in Enterprise - new, Type: Hub Site Application, Degree: 12\n", + "Title: TestInstantApp, Type: Web Mapping Application, Degree: 8\n", + "Title: San Diego Parrot Sightings, Type: Form, Degree: 8\n", + "Title: All About Arizona and New Mexico, Type: StoryMap, Degree: 8\n", + "Title: AZ Vehicle App, Type: Web Mapping Application, Degree: 8\n", + "Title: Discover Green Spaces and Wildlife in Berlin, Type: Web Mapping Application, Degree: 7\n", + "Title: Formerly Local, Now Global Experience, Type: Web Experience, Degree: 6\n", + "Title: AZ Vehicle Incidents, Type: Web Map, Degree: 5\n", + "Title: AZ and NM Cities, Type: Web Map, Degree: 5\n", + "Title: Ruff Ruff, Type: StoryMap, Degree: 5\n", + "Title: Group Layer Map Test, Type: Web Map, Degree: 5\n", + "Title: LimerickStoryMap, Type: StoryMap, Degree: 5\n", + "Title: test_cat_selector, Type: Dashboard, Degree: 5\n", + "Title: Copy this story, Type: StoryMap, Degree: 4\n", + "Title: map test, Type: Web Map, Degree: 4\n", + "Title: Cycling Explorer, Type: Web Map, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", + "Title: Living Atlas Map, Type: Web Map, Degree: 4\n", + "Title: Jy Survey 123 Connect, Type: Form, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: California Demo, Type: StoryMap, Degree: 4\n", + "Title: Offline Cloning Draft Test, Type: Web Experience, Degree: 4\n", + "Title: SimpleWebMap, Type: Web Map, Degree: 4\n", + "Title: Arkansas Hospitals, Type: Web Map, Degree: 4\n", + "Title: Nothing Funny About This Test - updated PR, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test2, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test - updated PR, Type: Web Experience, Degree: 3\n", + "Title: Hilarious Little Test - updated PR1, Type: Web Experience, Degree: 3\n", + "Title: No Image Test, Type: Web Experience, Degree: 3\n", + "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", + "Title: No Image Test, Type: Web Experience, Degree: 3\n", + "Title: Nothing Funny About This Test, Type: Web Experience, Degree: 3\n", + "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", + "Title: Esri Offices, Fancy, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n", + "Title: TerrainMap, Type: Web Map, Degree: 3\n" + ] + } + ], + "source": [ + "sort_deep_degrees()" + ] + }, + { + "cell_type": "markdown", + "id": "d2e9dc54-59e5-4503-8ba8-267dbe9e6e25", + "metadata": {}, + "source": [ + "Finally, we can construct a custom function that can do the two prior bits, plus sort items by type, and define the result count. This allows us to easily filter and search our org's items with additional context on the weight of their dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "07dea0a0-ab93-45f1-bfde-cb13573c393d", + "metadata": {}, + "outputs": [], + "source": [ + "def filter_nodes(direction = \"out\", deep = False, descending = True, item_type = None, result_count: int = None):\n", + " if item_type:\n", + " nodes_filtered = [node for node in new_graph.all_items() if node.item and node.item.type == item_type]\n", + " else:\n", + " nodes_filtered = new_graph.all_items()\n", + " if direction == \"in\" and deep:\n", + " nodes_weighted = [(node, len(node.required_by())) for node in nodes_filtered]\n", + " elif direction == \"out\" and deep:\n", + " nodes_weighted = [(node, len(node.requires())) for node in nodes_filtered]\n", + " elif direction == \"in\" and not deep:\n", + " nodes_weighted = [(node, len(node.contained_by())) for node in nodes_filtered]\n", + " else:\n", + " nodes_weighted = [(node, len(node.contains())) for node in nodes_filtered]\n", + " nodes_sorted = sorted(nodes_weighted, key=lambda item: item[1], reverse = descending)\n", + " if result_count and result_count > len(nodes_sorted):\n", + " result_count = len(nodes_sorted)\n", + " for node, degree in nodes_sorted[:result_count]:\n", + " if node.item:\n", + " print(f\"Title: {node.item.title}, Type: {node.item.type}, Degree: {degree}\")\n", + " else:\n", + " print(f\"ID: {node.id}, Degree: {degree}\")" + ] + }, + { + "cell_type": "markdown", + "id": "83550b88-950f-48b8-8c39-bb9364540e52", + "metadata": {}, + "source": [ + "## Part 3: Automating this Notebook" + ] + }, + { + "cell_type": "markdown", + "id": "b57d4e60-b053-4136-a47b-59b442080af8", + "metadata": {}, + "source": [ + "Everything we've done in this notebook is purely informative- no changes, additions, or deletions to org items were done. All we've done is update and manipulate or ItemGraph in memory and written out to file. So what does this mean? \n", + "\n", + "This means that you can download this very notebook and run it for yourself. Keeping this notebook run on a consistent timeframe will provide you with an up-to-date graph to analyze your org items. ArcGIS Notebooks, in both ArcGIS Online and ArcGIS Enteprise, provide us with an easy way to schedule automation of notebooks. Let's take a look how.\n", + "\n", + "### Scheduling a Task\n", + "\n", + "A \"task\" is a command to run a given notebook. You can create scheduled tasks that dictate when and how often to run a notebook. Each time the notebook is run according to the schedule you set, the site opens a new container and runs the notebook without user control.\n", + "\n", + "To access this function, open the \"Tasks\" pane in the notebook editor. You can schedule it to run just once in the future or on a recurring basis— from once every 15 minutes to once every 6 months.\n", + "\n", + "Once you click on the Tasks pane, you will be prompted to provide a title for the Task." + ] + }, + { + "cell_type": "markdown", + "id": "81ad1aee-9219-4490-a9bf-eda1ab7907d7", + "metadata": {}, + "source": [ + "![Image](https://github.com/user-attachments/assets/0e374e87-e08d-4789-9cb8-e6a387ac18f6)" + ] + }, + { + "cell_type": "markdown", + "id": "3ac566c6-cdca-4a13-abb0-78c0c460fec8", + "metadata": {}, + "source": [ + "You can also set other specific parameters for when and how often you would like for this notebook to run." + ] + }, + { + "cell_type": "markdown", + "id": "d36908b0-1cf0-479b-8356-9a89c0c65535", + "metadata": {}, + "source": [ + "![parameters](https://github.com/user-attachments/assets/551a68f5-976a-47ea-83c1-257c99643ffd)" + ] + }, + { + "cell_type": "markdown", + "id": "b2cdebf2-1d01-4ea5-8001-dd15a79963ad", + "metadata": {}, + "source": [ + "Once you have created this task, you can find it under the Tasks pane, and can pause, delete or edit it as necessary. " + ] + }, + { + "cell_type": "markdown", + "id": "f47c1284-c735-4688-9618-94fa954b9d5f", + "metadata": {}, + "source": [ + "![tasks](https://github.com/user-attachments/assets/975a6137-1cf7-4e6c-ae1c-85342b534d7f)" + ] + }, + { + "cell_type": "markdown", + "id": "79eb8bb0-cf28-43dd-b8c0-07fba4addfc9", + "metadata": {}, + "source": [ + "> Note: For Notebooks in ArcGIS Online, you can have a maximum of 10 active tasks across all your notebooks. If you pause some of your active tasks, you will be allowed to create more tasks until you reach 10 active tasks again. For Notebooks in ArcGIS Enterprise, the default number of maximum active tasks is set at 20. Administrators of an organization have the privilege to [change that limit](https://developers.arcgis.com/rest/enterprise-administration/portal/limits-system). " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From fdb8b547b24c33d7d437b631a09f22aa10d40ba4 Mon Sep 17 00:00:00 2001 From: John Yaist Date: Tue, 8 Jul 2025 11:43:36 -0700 Subject: [PATCH 3/7] fix misspelling --- .../itemgraph_and_remap_data.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 1822ec6001..58860b1eb9 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -112,7 +112,7 @@ "id": "da409930-f779-44b8-982b-305f146ef6d9", "metadata": {}, "source": [ - "Calling [`ItemGraph.all_items()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.all_items) lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default) by specifiying and `out_format` agrument:" + "Calling [`ItemGraph.all_items()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.all_items) lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default) by specifiying and `out_format` argument:" ] }, { From 9ba2f2a4cf3352456e57f3298d642ba28695d72b Mon Sep 17 00:00:00 2001 From: nparavicini7 Date: Wed, 9 Jul 2025 15:09:47 -0700 Subject: [PATCH 4/7] fixed little typo --- .../itemgraph_and_remap_data.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 58860b1eb9..849bcb8fdc 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -77,7 +77,7 @@ "\n", "#### [`load_from_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#load-from-file)\n", "\n", - "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved [GML file format](https://networkx.org/documentation/stable/reference/readwrite/gml.html) via the [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) method. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this [sample](/python/lateste/samples/org-wide-dependency-graph) for an advanced workflow demonstrating it.\n", + "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved [GML file format](https://networkx.org/documentation/stable/reference/readwrite/gml.html) via the [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) method. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this [sample](/python/latest/samples/org-wide-dependency-graph) for an advanced workflow demonstrating it.\n", "\n", "Now that we know the basics of the code, let's jump into it. We'll use `create_dependency_graph()` to create an `ItemGraph`, then examine `ItemNode` instances in the graph to learn what our org items contain, are contained by, require to exist, and are required by to exist. We'll start with a Survey123 item." ] @@ -991,7 +991,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.2" + "version": "3.11.10" } }, "nbformat": 4, From 26d684a3753ed31acbf7410d8aa82db03b668a5f Mon Sep 17 00:00:00 2001 From: nparavicini7 Date: Wed, 9 Jul 2025 15:11:09 -0700 Subject: [PATCH 5/7] fixed typo --- .../itemgraph_and_remap_data.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 58860b1eb9..849bcb8fdc 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -77,7 +77,7 @@ "\n", "#### [`load_from_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#load-from-file)\n", "\n", - "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved [GML file format](https://networkx.org/documentation/stable/reference/readwrite/gml.html) via the [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) method. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this [sample](/python/lateste/samples/org-wide-dependency-graph) for an advanced workflow demonstrating it.\n", + "This is the alternative way to create an `ItemGraph`. When working with a graph, users have the option to write it out to a saved [GML file format](https://networkx.org/documentation/stable/reference/readwrite/gml.html) via the [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) method. GML is a format commonly used for saving/loading graphs between graphing libraries. Passing in an `ItemGraph` GML file to this function will reconstruct a graph with the same ID's and relationships. Users have the option to populate each `ItemNode` with item objects, or leave them strictly with ID's/relationships for the sake of performance (which is good when loading in a graph with thousands of items). We won't cover this function in this guide, but please refer to this [sample](/python/latest/samples/org-wide-dependency-graph) for an advanced workflow demonstrating it.\n", "\n", "Now that we know the basics of the code, let's jump into it. We'll use `create_dependency_graph()` to create an `ItemGraph`, then examine `ItemNode` instances in the graph to learn what our org items contain, are contained by, require to exist, and are required by to exist. We'll start with a Survey123 item." ] @@ -991,7 +991,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.2" + "version": "3.11.10" } }, "nbformat": 4, From f261458b505ddd193e3c89b93b2a0a1b0aa8d31e Mon Sep 17 00:00:00 2001 From: nparavicini7 Date: Wed, 9 Jul 2025 15:35:53 -0700 Subject: [PATCH 6/7] addressed the comments --- .../itemgraph_and_remap_data.ipynb | 14 +++++++------- .../org_wide_dependency_graph.ipynb | 8 +++++--- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 849bcb8fdc..57a5650879 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -314,8 +314,8 @@ ], "source": [ "# conversely, we can grab a dependent item and see what items immediately contain it and need it to exist\n", - "result_form = graph.get_item(\"41dd3cca32914cc7ae8fd3a727f44e17\")\n", - "result_form.item" + "result_flayer = graph.get_item(\"41dd3cca32914cc7ae8fd3a727f44e17\")\n", + "result_flayer.item" ] }, { @@ -338,7 +338,7 @@ ], "source": [ "# contained_by() = items in the graph that immediately use/reference this feature layer item\n", - "result_form.contained_by()" + "result_flayer.contained_by()" ] }, { @@ -362,7 +362,7 @@ ], "source": [ "# required_by() = every item in the graph that needs this feature layer item to exist\n", - "result_form.required_by()" + "result_flayer.required_by()" ] }, { @@ -384,9 +384,9 @@ "\n", "[The documentation for this function can be found here.](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)\n", "\n", - "We've covered functionality that can identify items contained within other items- now let's take a look at functionality that can automate replacement of those items, or fix other parts of an application's structure. `remap_data()` is a powerful tool for working with your JSON-based applications in the ArcGIS system. At its core, it allows you to swap out data sources within your apps. Say you have multiple layers in a webmap you want to swap out, or a map present in a StoryMap- all you have to do is construct a replacement dictionary mapping your old item ID's to your new ones, and it will replace them, both in the draft and published versions of your app.\n", + "We've covered functionality that can identify items contained within other items- now let's take a look at functionality that can automate replacement of those items, or fix other parts of an application's structure. `remap_data()` is a powerful tool for working with your JSON-based applications in the ArcGIS system. At its core, it allows you to swap out data sources within your item's JSON structure. Say you have multiple layers in a webmap you want to swap out, or a map present in a StoryMap- all you have to do is construct a replacement dictionary mapping your old item ID's to your new ones, and it will replace them, both in the draft and published versions of your app.\n", "\n", - "When the `force` parameter is set to `False` (the default), some validation occurs under the hood. The function ensures that both items exist in the GIS organization, and that they're of the same type, so nothing gets messed up in the application. However, setting `Force` to `True` gives you more power, at the risk of altering the underlying structure without validation. You can use it to replace item ID's that no longer exist in the organization, change the name of something throughout the app, fix a typo, etc. It uses a regular expression to identify and replace instances of strings, so it will pick things up wherever they are in the structure.\n", + "When the `force` parameter is set to `False` (the default), some validation occurs under the hood. The function ensures that both items exist in the GIS organization, and that they're of the same type, to retain a valid configuration of the application. However, setting `Force` to `True` gives you more power, at the risk of altering the underlying structure without validation. You can use it to replace item ID's that no longer exist in the organization, change the name of something throughout the app, fix a typo, etc. It uses a regular expression to identify and replace instances of strings, so it will pick things up wherever they are in the structure.\n", "\n", "Let's look at a basic example of it in action. We'll examine the JSON of an application we're working with to note the effects." ] @@ -729,7 +729,7 @@ "source": [ "### Putting it Together\n", "\n", - "Now that we've seen how these things work, let's see how we can use them to speed up what might be an otherwise tedious workflow.\n", + "Now that we've seen how these things work, let's see how we can use them to speed up what might be an otherwise time-consuming workflow.\n", "\n", "Put yourself in the shoes of an admin that has been tasked with the process of migrating items to a new portal. Before migrating, you want to ensure that all of your items (such as your complex apps) are rendering correctly and not missing any data sources, but don't want to manually click through each one and/or their drafts. How can we more efficiently find out what's missing?\n", "\n", diff --git a/samples/03_org_administrators/org_wide_dependency_graph.ipynb b/samples/03_org_administrators/org_wide_dependency_graph.ipynb index 0c426da395..00e14193bd 100644 --- a/samples/03_org_administrators/org_wide_dependency_graph.ipynb +++ b/samples/03_org_administrators/org_wide_dependency_graph.ipynb @@ -18,7 +18,7 @@ "With a little patience and creativity, we can create an actively-updated dependency graph that encapsulates every item in our organization. Doing so opens up all sorts of doors for us, such as:\n", "- The ability to examine the total reverse dependencies of an item (e.g., take a feature layer- we can see every app or map in our org that requires it to exist, or that will be effected by a change to it\n", "- Quick identification of all broken dependencies in our organization\n", - "- Sorting of org items by complexity (most vs. least dependencies)\n", + "- Sorting of items in our organization by complexity (most vs. least dependencies)\n", "\n", "In this sample, we'll provide code to create and update an organization-wide graph, glean information from our graph, and then finally include a section on how to automate this process via ArcGIS Notebooks." ] @@ -91,6 +91,8 @@ "source": [ "### Efficiently Analyzing the Existent Graph\n", "\n", + "This workflow is predicated on preserving our graph offline in a [GML format file](https://networkx.org/documentation/stable/reference/readwrite/gml.html), which is a commonly used file type for storing graph structures. Our `write_to_file()` function generates a .gml file with both the basic graph structure and some additional metadata that informs our `load_from_file()` function how to grab a given item from a GIS organization.\n", + "\n", "When loading up an existent graph based on a .gml file, it still may take some time to retrieve every single item associated with each node in the graph, especially for organizations with thousands and thousands of items. If you want to instantly analyze the items and relationships in a .gml file with thousands of records, we can call `load_to_file()` and elect to *not* retrieve each item. This still gives us the power to view all item id's and their dependencies in the org, but without the overhead of retrieving each one from a REST endpoint first. Users can simply retrieve the associated items as needed, based on the id's.\n", "\n", "We'll show a quick example of this using the existent graph, and then use a graph loaded with the items to ensure we're up-to-date with the current state of organization. We'll only print the first few for the sake of keeping this page short." @@ -207,7 +209,7 @@ "\n", "### Automation: Updating our Org-Wide Graph\n", "\n", - "The items in our org might not be the same as the ones we had in it yesterday- that's why we want to update our graph periodically. We can use some attributes of the `ItemGraph` class and some networkx tricks to maintain an up-to-date record of everything in the org.\n", + "The items in our org might not be the same as the ones we had in it yesterday- that's why we want to update our graph periodically. The `ItemGraph` class is an extension of [NetworkX's DiGraph class](https://networkx.org/documentation/stable/reference/classes/digraph.html), meaning we get all sorts of handy functions and ways to manipulate our graph built in. We can use some attributes of the `ItemGraph` class and some networkx tricks to maintain an up-to-date record of everything in the org.\n", "\n", "We'll start by loading up our existent graph stored in the .gml file with every `Item` attached. This may take a while to do, depending on how many items must be retrieved. We retrieve the items so that later we can verify which ones still exist and which ones have been deleted." ] @@ -1257,7 +1259,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.2" + "version": "3.11.10" } }, "nbformat": 4, From 63f291f8b367c8e4c9f448b6d9009a96fa055b04 Mon Sep 17 00:00:00 2001 From: John Yaist Date: Thu, 10 Jul 2025 10:56:37 -0700 Subject: [PATCH 7/7] correct misspellings --- .../itemgraph_and_remap_data.ipynb | 6 +++--- .../org_wide_dependency_graph.ipynb | 12 ++++++------ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb index 57a5650879..fc75c19329 100644 --- a/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb +++ b/guide/13-managing-arcgis-applications/itemgraph_and_remap_data.ipynb @@ -112,7 +112,7 @@ "id": "da409930-f779-44b8-982b-305f146ef6d9", "metadata": {}, "source": [ - "Calling [`ItemGraph.all_items()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.all_items) lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default) by specifiying and `out_format` argument:" + "Calling [`ItemGraph.all_items()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.all_items) lets a user see all of the items in the graph. One important thing to note: with this function, as well as the `ItemNode` functions that return dependencies, a user can elect to return the items in \"item\" form, \"id\" form, or \"node\" form (the default) by specifiying an `out_format` argument:" ] }, { @@ -372,7 +372,7 @@ "source": [ "An important thing to remember is that `create_dependency_graph()` finds relationships from the top down, so [`contained_by()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.contained_by) and [`required_by()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.required_by) will only show items that have been analyzed along the way from our root node(s)- they're not a full picture of _every_ item in the organization that may contain or require a specific item, just the ones contained under the umbrella of our original item. However, [`contains()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.contains) and [`requires()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemNode.requires) do indeed show every item in an org that are contained or required by a given item.\n", "\n", - "To get the full, org-wide picture with `contained_by()` or `required_by()`, a graph would need to be made with every item in the organization. See this sample(insert link) for a guide on how to create and manage that type of graph." + "To get the full, org-wide picture with `contained_by()` or `required_by()`, a graph would need to be made with every item in the organization. See [this sample](/python/latest/samples/org-wide-dependency-graph) for a guide on how to create and manage that type of graph." ] }, { @@ -991,7 +991,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.2" } }, "nbformat": 4, diff --git a/samples/03_org_administrators/org_wide_dependency_graph.ipynb b/samples/03_org_administrators/org_wide_dependency_graph.ipynb index 00e14193bd..b46467e247 100644 --- a/samples/03_org_administrators/org_wide_dependency_graph.ipynb +++ b/samples/03_org_administrators/org_wide_dependency_graph.ipynb @@ -13,7 +13,7 @@ "id": "a8fd2570-ff4b-4cec-9269-cbf542cd66af", "metadata": {}, "source": [ - "Version 2.4.1 of the ArcGIS API for Python brought about some exciting new functionality for content management: the `arcgis.apps.itemgraph` module. This module, in it's most basic usage, allows you to take an item in an organization and examine the deep dependencies of it- what items it needs to exist, what items those items need to exist, and so on. This is very helpful for management of apps and smaller subsets of org items, but what if we really want to push the limits of what we can do with this module?\n", + "Version 2.4.1 of the ArcGIS API for Python brought about some exciting new functionality for content management: the [`arcgis.apps.itemgraph`](/python/latest/api-reference/arcgis.apps.itemgraph.html) module. This module, in it's most basic usage, allows you to take an item in an organization and examine the deep dependencies of it- what items it needs to exist, what items those items need to exist, and so on. This is very helpful for management of apps and smaller subsets of org items, but what if we really want to push the limits of what we can do with this module?\n", "\n", "With a little patience and creativity, we can create an actively-updated dependency graph that encapsulates every item in our organization. Doing so opens up all sorts of doors for us, such as:\n", "- The ability to examine the total reverse dependencies of an item (e.g., take a feature layer- we can see every app or map in our org that requires it to exist, or that will be effected by a change to it\n", @@ -54,7 +54,7 @@ "\n", "This builds the initial dependency graph by indexing over every single item in the organization. This only needs to be run once, and will likely take a very long time, depending on how many items are in the org. Once it's been run and the graph structure and time stamp are saved into files, this notebook that updates the dependency graph can be run. This first cell can also be executed outside of ArcGIS Notebooks, and the .gml and .txt files can be brought in from elsewhere.\n", "\n", - "*Note: Comment out this cell after the first time running the notebook.*" + "> **Note:** Comment out this cell after the first time running the notebook." ] }, { @@ -91,7 +91,7 @@ "source": [ "### Efficiently Analyzing the Existent Graph\n", "\n", - "This workflow is predicated on preserving our graph offline in a [GML format file](https://networkx.org/documentation/stable/reference/readwrite/gml.html), which is a commonly used file type for storing graph structures. Our `write_to_file()` function generates a .gml file with both the basic graph structure and some additional metadata that informs our `load_from_file()` function how to grab a given item from a GIS organization.\n", + "This workflow is predicated on preserving our graph offline in a [GML format file](https://networkx.org/documentation/stable/reference/readwrite/gml.html), which is a commonly used file type for storing graph structures. Our [`write_to_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.ItemGraph.write_to_file) function generates a .gml file with both the basic graph structure and some additional metadata that informs our [`load_from_file()`](/python/latest/api-reference/arcgis.apps.itemgraph.html#arcgis.apps.itemgraph.load_from_file) function how to grab a given item from a GIS organization.\n", "\n", "When loading up an existent graph based on a .gml file, it still may take some time to retrieve every single item associated with each node in the graph, especially for organizations with thousands and thousands of items. If you want to instantly analyze the items and relationships in a .gml file with thousands of records, we can call `load_to_file()` and elect to *not* retrieve each item. This still gives us the power to view all item id's and their dependencies in the org, but without the overhead of retrieving each one from a REST endpoint first. Users can simply retrieve the associated items as needed, based on the id's.\n", "\n", @@ -803,7 +803,7 @@ "id": "fd4c5d32-2f52-44d0-a59d-c5beaec43493", "metadata": {}, "source": [ - "Given this list of items with ID's that lead nowhere, we can grab the node for any one of them and do what we did above- see which org items contain or require them. From there, we can figure out how to fix it- one option is using the `remap_data()` function, documented [here](https://developers.arcgis.com/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)." + "Given this list of items with ID's that lead nowhere, we can grab the node for any one of them and do what we did above- see which org items contain or require them. From there, we can figure out how to fix it- one option is using the `remap_data()` function, documented [here](/python/latest/api-reference/arcgis.gis.toc.html#arcgis.gis.Item.remap_data)." ] }, { @@ -1183,7 +1183,7 @@ "source": [ "Everything we've done in this notebook is purely informative- no changes, additions, or deletions to org items were done. All we've done is update and manipulate or ItemGraph in memory and written out to file. So what does this mean? \n", "\n", - "This means that you can download this very notebook and run it for yourself. Keeping this notebook run on a consistent timeframe will provide you with an up-to-date graph to analyze your org items. ArcGIS Notebooks, in both ArcGIS Online and ArcGIS Enteprise, provide us with an easy way to schedule automation of notebooks. Let's take a look how.\n", + "This means that you can download this very notebook and run it for yourself. Keeping this notebook run on a consistent timeframe will provide you with an up-to-date graph to analyze your org items. ArcGIS Notebooks, in both ArcGIS Online and ArcGIS Enterprise, provide us with an easy way to schedule automation of notebooks. Let's take a look how.\n", "\n", "### Scheduling a Task\n", "\n", @@ -1259,7 +1259,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.2" } }, "nbformat": 4,