arcgis package

Submodules

arcgis.gis module

arcgis.env module

arcgis.features module

arcgis.raster module

arcgis.network module

arcgis.notebook module

arcgis.schematics module

arcgis.geocoding module

arcgis.geometry module

arcgis.geoenrichment module

arcgis.geoprocessing module

arcgis.layers module

arcgis.map module

arcgis.apps module

arcgis.workflowmanager module

Module contents

class arcgis.GIS(url=None, username=None, password=None, key_file=None, cert_file=None, verify_cert=True, set_active=True, client_id=None, profile=None, **kwargs)

Bases: object

The GIS class is representative of a single ArcGIS Online organization or an ArcGIS Enterprise deployment. The GIS object provides helper objects to manage (search, create, retrieve) GIS resources such as content, users, and groups.

Additionally, the GIS object has properties to query its state, which is accessible using the properties attribute.

Note

The GIS provides a mapping widget that can be used in the Jupyter Notebook environment for visualizing GIS content as well as the results of your analysis. To create a new map, call the map method. IE11 is no longer supported. Please use the latest version of Google Chrome, Mozilla Firefox, Apple Safari, or Microsoft Edge.

The constructor constructs a GIS object given a url and user credentials to ArcGIS Online or an ArcGIS Enterprise portal. User credentials can be passed in using username/password pair, or key_file/cert_file pair (in case of PKI). Supports built-in users, LDAP, PKI, Integrated Windows Authentication (using NTLM and Kerberos) and Anonymous access.

If no url is provided, ArcGIS Online is used. If username/password or key/cert files are not provided, the currently logged-in user’s credentials (IWA) or anonymous access is used.

Persisted profiles for the GIS can be created by giving the GIS authorization credentials and specifying a profile name. The profile stores all of the authorization credentials (except the password) in the user’s home directory in an unencrypted config file named .arcgisprofile. The profile securely stores the password in an O.S. specific password manager through the keyring python module.

Note

Linux systems may need additional software installed and configured for proper security.

Once a profile has been saved, passing the profile parameter by itself uses the authorization credentials saved in the configuration file/password manager by that profile name. Multiple profiles can be created and used in parallel.

See Working with different authentication schemes in the ArcGIS API for Python guide for examples.

Note

Once a connection is made and a GIS object is initialized, you can retrieve the token with the following code:

# Retrieving a token from a GIS object
>>> from arcgis.gis import GIS

>>> gis = GIS(
        url="url to Web GIS",
        username="user_name",
        password="secure_password"
    )

>>> token = gis.session.auth.token
>>> token

'3BMHr9i ... RTxekAdWkSmF9cKQIkM7DLy.'

Parameter	Description
url	Optional string. If URL is None, then the URL will be ArcGIS Online. This should be a web address to either an ArcGIS Enterprise portal or to ArcGIS Online in the form: <scheme>://<fully_qualified_domain_name>/<web_adaptor>. An Enterprise example is formatted in the form: https://gis.example.com/portal
username	Optional string. The login user name (case-sensitive).
password	Optional string. If a username is provided, a password is expected. This is case-sensitive. If the password is not provided, the user is prompted in the interactive dialog.
key_file	Optional string. The file path to a user’s key certificate for PKI authentication
cert_file	Optional string. The file path to a user’s certificate file for PKI authentication. If a PFX or P12 certificate is used, a password is required. If a PEM file is used, the key_file is required.
verify_cert	Optional boolean or string. If a site has an invalid SSL certificate or is being accessed via the IP or hostname instead of the name on the certificate, set this value to False. This will ensure that all SSL certificate issues are ignored. Users can pass verify_cert a path to a CA_BUNDLE file or directory with certificates of trusted CAs as well. This will use these certificates over the system’s certificates. The default is True. Warning Setting the value to False can be a security risk.
set_active	Optional boolean. The default is True. If True, the GIS object will be used as the default GIS object throughout the whole scripting session.
client_id	Optional string. Used for OAuth authentication. This is the client ID value.
profile	Optional string. the name of the profile that the user wishes to use to authenticate, if set, the identified profile will be used to login to the specified GIS.

In addition to explicitly named parameters, the GIS object supports optional key word arguments:

kwargs	Description
proxy_host	(Deprecated, use proxy) Optional string. The host name of the proxy server used to allow HTTP/S access in the network where the script is run. ex: 127.0.0.1
use_gen_token	Optional Boolean. The default is False. Uses generateToken login over OAuth2 login.
proxy_port	(Deprecated, use proxy) Optional integer. The proxy host port. The default is 80.
token	Optional string. This is the Enterprise token for built-in logins. This parameter is only honored if the username/password is None and the security for the site uses BUILT-IN security. Note A token can be retrieved using gis.session.auth.token.
api_key	Optional string. This is a key generated by the developer site to allow for a limited subset of the REST API functionality.
trust_env	Optional Boolean. Trust environment settings for proxy configuration, default authentication and similar. If False the GIS class will ignore the netrc files defined on the system.
proxy	Optional Dictionary. If you need to use a proxy, you can configure individual requests with the proxy argument to any request method. See `Usage Exmaple 9: Using a Proxy` for example usage. Usage Example: { “http” : “http://10.343.10.22:111”, “https” : “https://127.343.13.22:6443” }
expiration	Optional Integer. The default is 60 minutes. The expiration time for a given token. This is used for user provided tokens and API Keys.
validate_url	Optional Boolean. The default is False. A user can choose to validate the URL on an Item’s url.
mutual_authentication	Optional String. Mutual authentication is a security feature in which a client process must prove its identity to a service, and the service must prove its identity to the client, before any application traffic is transmitted over the client/service connection. REQUIRED - By default, the API will require mutual authentication from the server, and if a server emits a non-error response which cannot be authenticated. OPTIONAL - This will cause the API to attempt mutual authentication if the server advertises that it supports it, and cause a failure if authentication fails, but not if the server does not support it at all. DISABLED - Never attempts mutual authentication, this is not recommended.
force_preemptive	If you are using Kerberos authentication, it can be forced to preemptively initiate the Kerberos GSS exchange and present a Kerberos ticket on the initial request (and all subsequent). By default, authentication only occurs after a 401 Unauthorized response containing a Kerberos or Negotiate challenge is received from the origin server. This can cause mutual authentication failures for hosts that use a persistent connection (eg, Windows/WinRM), as no Kerberos challenges are sent after the initial auth handshake. This behavior can be altered by setting force_preemptive=True. The default is False
hostname_override	Optional String. If communicating with a host whose DNS name doesn’t match its kerberos hostname (eg, behind a content switch or load balancer), the hostname used for the Kerberos GSS exchange can be overridden by setting this value.
delegate	Optional bool. Kerberos supports credential delegation (GSS_C_DELEG_FLAG). To enable delegation of credentials to a server that requests delegation, pass delegate=True. Be careful to only allow delegation to servers you trust as they will be able to impersonate you using the delegated credentials.

# Usage Example 1: Anonymous Login to ArcGIS Online

gis = GIS()

# Usage Example 2: Built-in Login to ArcGIS Online

gis = GIS(username="someuser", password="secret1234")

# Usage Example 3: Built-in Login to ArcGIS Enterprise

gis = GIS(url="http://pythonplayground.esri.com/portal",
      username="user1", password="password1")

# Usage Example 4: Built-in Login to ArcGIS Enterprise, ignoring SSL errors

gis = GIS(url="http://pythonplayground.esri.com/portal", username="user1",
          password="password1", verify_cert=False)

# Usage Example 5: Anonymous ArcGIS Online Login with Proxy

gis = GIS(proxy={'http': 'http://127.0.0.1:8888', 'https': 'http://127.0.0.1:8887'})

# Usage Example 6: PKI Login to ArcGIS Enterprise, using PKCS12 user certificate

gis = GIS(url="https://pkienterprise.esri.com/portal",
          cert_file="C:\users\someuser\mycert.pfx", password="password1")

# Usage Exmaple 7: Login with token (actual token abbreviated for this illustration)

gis = GIS(token="3G_e-FSoJdwxBgSA0RiOZg7zJVVqlOG-ENw83UtoUzDdz4 ... _L2aQMrthrEq7vKYBn39HGSc.",
          referer="https://www.arcgis.com")

# Usage Exmaple 8: Login with API Key (actual token abbreviated for this illustration)

gis = GIS(api_key="APKSoJdwxBgSA0RiOZg7zJVVqlOG-ENw83UtoUzDdz4 ... _L2aQMrth39HGSc.",
          referer="https")

# Usage Exmaple 9: Using a Proxy
proxy = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
gis = GIS(proxy=proxy)

# Usage Exmaple 10: Using a CA_BUNDLE specifying SSL certificates
certs = r"./CA_CERTS/cacert.pem"
gis = GIS(profile="your_enterprise_admin_profile", verify_cert=certs)

property api_keys

The api_keys property returns an instance of APIKeyManager object which allows the User to generate, manage and modify API Keys for controlled application access.

Note

The API Key manager is only available for ArcGIS Online

Returns:

An APIKeyManager object

property content

The content property is the resource manager for GIS content. See ContentManager for more information.

property datastore

The datastore property returns the manager for user-managed data store items.

Note

This is only available with ArcGIS Enterprise 10.7+. See PortalDataStore for more information.

Returns:

A PortalDataStore object

property groups

The groups property is resource manager for GIS groups. See GroupManager for more information.

property hosting_servers

Returns the hosting servers for the GIS

Returns:

list

property hub

The hub property is the resource manager for GIS hub. See Hub for more information.

property languages

Lists the available languages.

Returns:

List[Dict[str, Any]]

map(location=None, mode='2D')

The map method creates a map widget centered at the declared location with the specified zoom level. If an address is provided, it is geocoded using the GIS’s configured geocoders. Provided a match is found, the geographic extent of the matched address is used as the extent of the map. If a zoomlevel is also provided, the map is centered at the matched address instead and the map is zoomed to the specified zoomlevel. See Map for more information.

Note

The map widget is only supported within a Jupyter Notebook. IE11 is no longer supported. Please use the latest version of Google Chrome, Mozilla Firefox, Apple Safari, or Microsoft Edge.

Parameter	Description
location	Optional string. The address or lat-long tuple of where the map is to be centered.
mode	Optional string of either ‘2D’ or ‘3D’ to specify map mode. Defaults to ‘2D’.

Note

If the Jupyter Notebook server is running over http, you need to configure your ArcGIS Enterprise portal or ArcGIS Online organization to allow your host and port; or else you will run into CORS issues when displaying this map widget.

This can be accomplished by signing into your ArcGIS Enterprise portal or ArcGIS Online organization in a browser, then navigating to:

Organization > Settings > Security > Allow origins > Add > http://localhost:8888 (replace with the host/port you are running on)

# Usage Example

>>> gis = GIS(url="http://pythonplayground.esri.com/portal", username="user1", password="password1")

>>> gis.map("Durham,NC")

Returns:

A map or scene.

property notebook_server

The notebook_server property provides access to the NotebookServer registered with the organization or enterprise. :return: List [NotebookServer]

property org_settings

The portal settings resource is used to return a view of the portal’s configuration as seen by the current users, either anonymous or logged in. Information returned by this resource includes helper services, allowed redirect URIs, and the current configuration for any access notices or information banners.

Parameter

Description

settings

Required Dict. A dictionary of the settings Fields Description anonymousAccessNotice Dict. A JSON object representing a notice that is shown to your organization’s anonymous users. Ex: {‘title’: ‘Anonymous Access Notice Title’, ‘text’: ‘Anonymous Access Notice Text’, ‘buttons’: ‘acceptAndDecline’, ‘enabled’: True} authenticatedAccessNotice Dict. A JSON object representing a notice that is shown to your organization’s authenticated users. Ex: {‘title’: ‘Authenticated Access Notice Title’, ‘text’: ‘Authenticated Access Notice Text’, ‘buttons’: ‘okOnly’, ‘enabled’: True} informationalBanner Dict. A JSON object representing the informational banner that is shown at the top of your organization’s page. Ex: {‘text’: ‘Header Text’, ‘bgColor’: ‘grey’, ‘fontColor’: ‘blue’, ‘enabled’: True} clearEmptyFields Bool. If True, any empty dictionary will be set to null.

Returns:

Dictionary indicating ‘success’ or ‘error’

property pages

The pages property is the resource manager for a Page of an Enterprise Site. See pages for more information.

property properties

properties manages the actual properties of the GIS object.

property regions

Lists the available regions.

Returns:

List[Dict[str, Any]]

property servers

Returns the servers registered with ArcGIS Entperise. For ArcGIS Online, the return value is None.

Returns:

dict

property session

Provides the raw Esri Session object

Returns:

An EsriSession object.

property sites

The sites property is the resource manager for Enterprise Sites. See sites for more information.

property subscription_information

Returns the ArcGIS Online Subscription Information for a Site.

Returns:

dictionary

property symbol_service

Symbol service is an ArcGIS Server utility service that provides access to operations to build and generate images for Esri symbols to be consumed by internal and external web applications.

Returns:

A SymbolService object or None

update_properties(properties_dict)

The update_properties method updates the GIS’s properties from those in properties_dict. This method can be useful for updating the utility services used by the GIS.

Parameter	Description
properties_dict	Required dictionary. A dictionary of just those properties and values that are to be updated.

Returns:

A boolean indicating success (True), or failure (False)

Note

For examples of the property names and key/values to use when updating utility services, refer to the Common parameters page in the ArcGIS REST API.

# Usage Example: Update the geocode service

gis = GIS(profile='xyz')
upd = {'geocodeService': [{
  "singleLineFieldName": "Single Line Input",
  "name": "AtlantaLocator",
  "url": "https://some.server.com/server/rest/services/GeoAnalytics/AtlantaLocator/GeocodeServer",
  "itemId": "abc6e1fc691542938917893c8944606d",
  "placeholder": "",
  "placefinding": "true",
  "batch": "true",
  "zoomScale": 10000}]}

gis.update_properties(upd)

property url

The url property is a read-only URL of your GIS connection.

property users

The users property is the resource manager for GIS users. See UserManager for more information.

property velocity

The resource manager for ArcGIS Velocity. See Velocity :return: Velocity

property version

The version property returns the GIS version number

arcgis.aggregate_points(point_layer, polygon_layer=None, keep_boundaries_with_no_points=True, summary_fields=[], group_by_field=None, minority_majority=False, percent_points=False, output_name=None, context=None, gis=None, estimate=False, future=False, bin_type=None, bin_size=None, bin_size_unit=None)

The Aggregate Points task works with a layer of point features and a layer of polygon features. It first figures out which points fall within each polygon’s area. After determining this point-in-polygon spatial relationship, statistics about all points in the polygon are calculated and assigned to the area. The most basic statistic is the count of the number of points within the polygon, but you can get other statistics as well.

For example, if your points represented coffee shops and each point has a TOTAL_SALES attribute, you can get statistics like the sum of all TOTAL_SALES within the polygon, or the minimum or maximum TOTAL_SALES value, or the standard deviation of all sales within the polygon.

Parameter	Description
point_layer	Required point layer. The point features that will be aggregated into the polygons in the polygon_layer. See Feature Input.
polygon_layer	Optional polygon layer. The polygon features (areas) into which the input points will be aggregated. See Feature Input. The polygon_layer is required if the bin_type, bin_size and bin_size_unit are not specified.
keep_boundaries_with_no_points	Optional boolean. A Boolean value that specifies whether the polygons that have no points within them should be returned in the output. The default is true.
summary_fields	Optional list of strings. A list of field names and statistical summary type that you wish to calculate for all points within each polygon. Note that the count of points within each polygon is always returned. summary type is one of the following: Sum - Adds the total value of all the points in each polygon Mean - Calculates the average of all the points in each polygon. Min - Finds the smallest value of all the points in each polygon. Max - Finds the largest value of all the points in each polygon. Stddev - Finds the standard deviation of all the points in each polygon. Example [fieldName1 summaryType1,fieldName2 summaryType2].
group_by_field	Optional string. A field name in the point_layer. Points that have the same value for the group by field will have their own counts and summary field statistics. You can create statistical groups using an attribute in the analysis layer. For example, if you are aggregating crimes to neighborhood boundaries, you may have an attribute Crime_type with five different crime types. Each unique crime type forms a group, and the statistics you choose will be calculated for each unique value of Crime_type. When you choose a grouping attribute, two results are created: the result layer and a related table containing the statistics.
minority_majority	Optional boolean. This boolean parameter is applicable only when a group_by_field is specified. If true, the minority (least dominant) or the majority (most dominant) attribute values for each group field within each boundary are calculated. Two new fields are added to the aggregated_layer prefixed with Majority_ and Minority_. The default is false.
percent_points	Optional boolean. This boolean parameter is applicable only when a group_by_field is specified. If set to true, the percentage count of points for each unique group_by_field value is calculated. A new field is added to the group summary output table containing the percentages of each attribute value within each group. If minority_majority is true, two additional fields are added to the aggregated_layer containing the percentages of the minority and majority attribute values within each group.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For aggregate_points, there are three settings (overwrite is required). extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional Boolean. If True, the number of credits to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
bin_type	Optional String. The type of bin that will be generated and points will be aggregated into. Bin options are as follows: Hexagon and Square. Square is the Default. When generating bins, for Square, the number and units specified determine the height and length of the square. For Hexagon, the number and units specified determine the distance between parallel sides. Either bin_type or polygon_layer must be specified. If bin_type is chosen, then bin_size and bin_size_unit specifying the size of the bins must be included.
bin_size	Optional Float. The distance for the bins of type bin_type that the point_layer will be aggregated into. When generating bins for Square the number and units specified determine the height and length of the square. For Hexagon, the number and units specified determine the distance between parallel sides.
bin_size_unit	Optional String. The linear unit to be used with the distance value specified in bin_size. Values: Meters, Kilometers, Feet, Miles, NauticalMiles, or Yards

Returns:

result_layer : FeatureLayer if output_name is specified, else FeatureCollection.

If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To find number of permits issued in each zip code of US.

agg_result = aggregate_points(point_layer=permits,
                        polygon_layer=zip_codes,
                        keep_boundaries_with_no_points=False,
                        summary_fields=["DeclValNu mean","DeclValNu2 mean"],
                        group_by_field='Declared_V',
                        minority_majority=True,
                        percent_points=True,
                        output_name="aggregated_permits",
                        context={"extent":{"xmin":-8609738.077325115,"ymin":4743483.445485223,"xmax":-8594030.268012533,"ymax":4752206.821338257,"spatialReference":{"wkid":102100,"latestWkid":3857}}})

arcgis.calculate_composite_index(input_layer, input_variables, index_method=None, output_index_reverse=False, output_index_min_max=None, output_name=None, context=None, gis=None, future=False)

The Calculate Composite Index task combines multiple numeric variables to create a single index. This task is only available in ArcGIS Online and Enterprise 11.3+.

Parameter	Description
input_layer	Required layer. The input table or features containing the variables that will be combined into the index. Syntax: As described in detail in the Feature input topic, this parameter can be one of the following: A URL to a feature service layer with an optional filter to select specific features A FeatureCollection #Example #1: Feature Layer with selection >>> output = calculate_composite_index( input_layer= { "url": <feature service layer url>, "filter": <where clause>}, ... ) #Example #2: Feature Collection >>> output = calculate_composite_index( input_layer= {" "layerDefinition": {}, "featureSet": {}, "filter": <where clause>}, ..., )
input_variables	Required list of dictionaries. The variables that will be combined to create the index. Provide at least two variables. For each variable, specify the following: field is the numeric field from the inputLayer containing the variable. Any records in the field with missing values will not be included in the analysis. reverseVariable specifies whether the values of the variable will be reversed. If no value is specified, the value will be set to False. When True the feature or record that originally had the highest value will have the lowest value, and vice versa. Values will be reversed after scaling. To create an index, variables must be on a compatible scale; reversing some variables may be required to ensure the meaning of low and high values in each variable is consistent. weight is the relative influence of the variable on the index. If each variable should have equal contribution, set the value to 1. Increase or decrease the weight to reflect the relative importance of the variable. For example, if a variable is twice as important as the others, use a weight of 2. #Example: >>> output = calculate_composite_index( ..., input_variables = [ {"field":"median_income", "reverseVariable": True, "weight": 2}, {"field": "pct_uninsured", "reverseVariable": False, "weight": 1}, {"field": "pct_unemployed", "reverseVariable": False, "weight": 1} ], ..., )
index_method	Optional string. The methods that will be used to scale the inputVariables and combine the scaled variables to create the index. Scaling is a type of preprocessing that ensures the variables are on a compatible scale before they are combined. These scaled variables are then combined to create a single index value. The following options are available: meanScaled the index by scaling the input variables between 0 and 1 (minimum-maximum scaling) and calculating the mean of the scaled values. This method is useful for creating an index that is easy to interpret. The shape of the distribution and outliers in the input variables will impact the index. meanPercentile creates the index by scaling the ranks of the input variables between 0 and 1 (scaling by percentile) and calculating the mean of the scaled ranks. This option is useful when the rankings of the variable values are more important than the differences between values. The shape of the distribution and outliers in the input variables will not impact the index. meanRaw creates the index by calculating the mean of the raw input variables. This option is useful when variables are already on a compatible scale. geomeanScaled creates the index by scaling the input variables between 0 and 1 (minimum-maximum scaling) and calculating the geometric mean of the scaled values. High values will not cancel low values, so this option is useful for creating an index in which higher index values will occur only when there are high values in multiple variables. geomeanPercentile creates the index by scaling the ranks of the input variables between 0 and 1 (scaling by percentile) and calculating the geometric mean of the scaled ranks. This option is useful when the rankings of the variable values are more important than the differences between values and when high variable values should not cancel out low variable values. geomeanRaw creates the index by calculating the geometric mean of the raw input variables. This option is useful when variables are already on a compatible scale and when high variable values should not cancel out low variable values. sumFlagsPercentile creates the index by counting the number of input variables with values greater than or equal to the 90th percentile. This method is useful for identifying locations that may be considered the most extreme or the most in need. Values: meanScaled meanPercentile meanRaw geomeanScaled geomeanPercentile geomeanRaw sumFlagsPercentile Default: meanScaled
output_index_reverse	Optional boolean. Specifies whether the output index values will be reversed in direction. When checked, high index values will be treated as low index values and vice versa. Reversing is applied after combining the scaled variables. The default is False.
output_index_min_max	Optional list of one dictionary. The minimum and maximum of the output index values. Specifying a minimum and maximum value will apply minimum-maximum scaling to the combined variables. # Example: >>> output = calculate_composite_index( ..., ouput_index_min_max= [ {'min': 0, 'max': 100} ], ..., )
output_name	Optional dictionary. If provided, the task will create a feature service of the results. You define the name of the service. If no argument is provided, the task will return a feature collection. # Example #1: >>> output = calculate_composite_index( ..., output_name={ "serviceProperties": { "name": "<service name>" } }, ... You can overwrite an existing feature service by providing the itemId value of the existing feature service and setting the overwrite property to True. Including the serviceProperties parameter is optional. As described in the Feature output topic, you must either be the owner of the feature service or have administrative privileges to perform the overwrite. # Example #2: >>> output = calculate_composite_index( ..., ouput_name= { "itemProperties": { "itemId": "<itemID of existing service>", "overwrite": True } }, ) # Example #3: >>> output = calculate_composite_index( ..., ouput_name= { "serviceProperties": { "name": "<existing service name>" }, "itemProperties": { "itemId": "<itemID of the existing feature service>", "overwrite": True } }, ... )
context	Optional dict. The Context parameter contains the following additional settings that affect task operation: Extent (extent)—A bounding box that defines the analysis area. Only input features that intersect the bounding box will be analyzed. Output spatial reference (outSR)—The output features will be projected into the output spatial reference. # Example: >>> output = calculate_composite_index( ..., context= { "extent" : {extent}, "outSR" : {spatial reference} }, ..., )
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
future	Optional boolean. If True, the task will be performed asynchronously.

Returns:

FeatureLayer if output_name is specified, else a FeatureCollection object.

# USAGE EXAMPLE: To create a social vulnerability index.

index = calculate_composite_index(
                input_layer=demographicsLayer,
                input_variables=[
                        {'field':'pct_uninsured',
                         'reverseVariable': True,
                         'weight': 2},
                        {'field': 'pct_unemployed',
                         'reverseVariable': False,
                         'weight': 1}
                    ],
                index_method='meanPercentile',
                output_index_reverse=True,
                output_index_min_max=[
                            {'min': 0, 'max': 100}
                        ],
                output_name="Social vulnerability index")

arcgis.calculate_density(input_layer, field=None, cell_size=None, cell_size_units='Meters', radius=None, radius_units=None, bounding_polygon_layer=None, area_units=None, classification_type='EqualInterval', num_classes=10, output_name=None, context=None, gis=None, estimate=False, future=False)

The calculate_density function creates a density map from point or line features by spreading known quantities of some phenomenon (represented as attributes of the points or lines) across the map. The result is a layer of areas classified from least dense to most dense.

For point input, each point should represent the location of some event or incident, and the result layer represents a count of the incident per unit area. A higher density value in a new location means that there are more points near that location. In many cases, the result layer can be interpreted as a risk surface for future events. For example, if the input points represent locations of lightning strikes, the result layer can be interpreted as a risk surface for future lightning strikes.

For line input, the line density surface represents the total amount of line that is near each location. The units of the calculated density values are the length of line per unit area. For example, if the lines represent rivers, the result layer will represent the total length of rivers that are within the search radius. This result can be used to identify areas that are hospitable to grazing animals.

Parameter	Description
input_layer	Required layer. The point or line features from which to calculate density. See Feature Input.
field	Optional string. A numeric field name specifying the number of incidents at each location. For example, if you have points that represent cities, you can use a field representing the population of the city as the count field, and the resulting population density layer will calculate larger population densities near cities with larger populations. If not specified, each location will be assumed to represent a single count.
cell_size	Optional float. This value is used to create a mesh of points where density values are calculated. The default is approximately 1/1000th of the smaller of the width and height of the analysis extent as defined in the context parameter. The smaller the value, the smoother the polygon boundaries will be. Conversely, with larger values, the polygon boundaries will be more coarse and jagged.
cell_size_units	Optional string. The units of the cell_size value. Choice list: [‘Miles’, ‘Feet’, ‘Kilometers’, ‘Meters’]
radius	Optional float. A distance specifying how far to search to find point or line features when calculating density values.
radius_units	Optional string. The units of the radius parameter. If no distance is provided, a default will be calculated that is based on the locations of the input features and the values in the count field (if a count field is provided). Choice list: [‘Miles’, ‘Feet’, ‘Kilometers’, ‘Meters’]
bounding_polygon_layer	Optional layer. A layer specifying the polygon(s) where you want densities to be calculated. For example, if you are interpolating densities of fish within a lake, you can use the boundary of the lake in this parameter and the output will only draw within the boundary of the lake. See Feature Input.
area_units	Optional string. The units of the calculated density values. Choice list: [‘areaUnits’, ‘SquareMiles’]
classification_type	Optional string. Determines how density values will be classified into polygons. Choice list: [‘EqualInterval’, ‘GeometricInterval’, ‘NaturalBreaks’, ‘EqualArea’, ‘StandardDeviation’] EqualInterval - Polygons are created such that the range of density values is equal for each area. GeometricInterval - Polygons are based on class intervals that have a geometric series. This method ensures that each class range has approximately the same number of values within each class and that the change between intervals is consistent. NaturalBreaks - Class intervals for polygons are based on natural groupings of the data. Class break values are identified that best group similar values and that maximize the differences between classes. EqualArea - Polygons are created such that the size of each area is equal. For example, if the result has more high density values than low density values, more polygons will be created for high densities. StandardDeviation - Polygons are created based upon the standard deviation of the predicted density values.
num_classes	Optional int. This value is used to divide the range of predicted values into distinct classes. The range of values in each class is determined by the classification_type parameter.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For calculate_density, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional Boolean. Is true, the number of credits needed to run the operation will be returned as a float.
future	Optional, If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

result_layer : FeatureLayer if output_name is specified, else FeatureCollection.

If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To create a layer that shows density of collisions within 2 miles.
               The density is classified based upon the standard deviation.
               The range of density values is divided into 5 classes.

collision_density = calculate_density(input_layer=collisions,
                                radius=2,
                                radius_units='Miles',
                                bounding_polygon_layer=zoning_lyr,
                                area_units='SquareMiles',
                                classification_type='StandardDeviation',
                                num_classes=5,
                                output_name='density_of_incidents')

arcgis.choose_best_facilities(goal='Allocate', demand_locations_layer=None, demand=1, demand_field=None, max_travel_range=2147483647, max_travel_range_field=None, max_travel_range_units='Minutes', travel_mode=None, time_of_day=None, time_zone_for_time_of_day='GeoLocal', travel_direction='FacilityToDemand', required_facilities_layer=None, required_facilities_capacity=2147483647, required_facilities_capacity_field=None, candidate_facilities_layer=None, candidate_count=1, candidate_facilities_capacity=2147483647, candidate_facilities_capacity_field=None, percent_demand_coverage=100, output_name=None, context=None, gis=None, estimate=False, point_barrier_layer=None, line_barrier_layer=None, polygon_barrier_layer=None, future=False)

The choose_best_facilities method finds the set of facilities that will best serve demand from surrounding areas.

Facilities might be public institutions that offer a service, such as fire stations, schools, or libraries, or they might be commercial ones such as drug stores or distribution centers for a parcel delivery service. Demand represents the need for a service that the facilities can meet. Demand is associated with point locations, with each location representing a given amount of demand.

Parameter	Description
goal	Optional string. Specify the goal that must be satisfied when allocating demand locations to facilities. Choice list: [‘Allocate’, ‘MinimizeImpedance’, ‘MaximizeCoverage’, ‘MaximizeCapacitatedCoverage’, ‘PercentCoverage’] Default value is ‘Allocate’.
demand_locations_layer	Required point feature layer. A point layer specifying the locations that have demand for facilities. See Feature Input.
demand	Optional float. The amount of demand available at every demand locations. The default value is 1.0.
demand_field	Optional string. A numeric field on the demand_locations_layer representing the amount of demand available at each demand location. If specified, the demand parameter is ignored.
max_travel_range	Optional float. Specify the maximum travel time or distance allowed between a demand location and the facility it is allocated to. The default is unlimited (2,147,483,647.0).
max_travel_range_field	Optional string. A numeric field on the demand_locations_layer specifying the maximum travel time or distance allowed between a demand location and the facility it is allocated to. If specified, the max_travel_range parameter is ignored.
max_travel_range_units	Optional string. The units for the maximum travel time or distance allowed between a demand location and the facility it is allocated to. Choice list: [‘Seconds’, ‘Minutes’, ‘Hours’, ‘Days’, ‘Meters’, ‘Kilometers’, ‘Feet’, ‘Yards’, ‘Miles’]. The default is ‘Minutes’.
travel_mode	Specify the mode of transportation for the analysis. Choice list: [‘Driving Distance’, ‘Driving Time’, ‘Rural Driving Distance’, ‘Rural Driving Time’, ‘Trucking Distance’, ‘Trucking Time’, ‘Walking Distance’, ‘Walking Time’]
time_of_day	Optional datetime.datetime. Specify whether travel times should consider traffic conditions. To use traffic in the analysis, set travel_mode to a travel mode object whose impedance_attribute_name property is set to travel_time and assign a value to time_of_day. (A travel mode with other impedance_attribute_name values don’t support traffic.) The time_of_day value represents the time at which travel begins, or departs, from the origin points. The time is specified as datetime.datetime. The service supports two kinds of traffic: ty pical and live. Typical traffic references travel speeds that are made up of historical averages for each five-minute interval spanning a week. Live traffic retrieves speeds from a traffic feed that processes phone probe records, sensors, and other data sources to record actual travel speeds and predict speeds for the near future. The data coverage page shows the countries Esri currently provides traffic data for. Typical Traffic: To ensure the task uses typical traffic in locations where it is available, choose a time and day of the week, and then convert the day of the week to one of the following dates from 1990: Monday - 1/1/1990 Tuesday - 1/2/1990 Wednesday - 1/3/1990 Thursday - 1/4/1990 Friday - 1/5/1990 Saturday - 1/6/1990 Sunday - 1/7/1990 Set the time and date as datetime.datetime. For example, to solve for 1:03 p.m. on Thursdays, set the time and date to 1:03 p.m., 4 January 1990; and convert to datetime eg. datetime.datetime(1990, 1, 4, 1, 3). Live Traffic: To use live traffic when and where it is available, choose a time and date and convert to datetime. Esri saves live traffic data for 4 hours and references predictive data extending 4 hours into the future. If the time and date you specify for this parameter is outside the 24-hour time window, or the travel time in the analysis continues past the predictive data window, the task falls back to typical traffic speeds. Examples: from datetime import datetime “time_of_day”: datetime(1990, 1, 4, 1, 3) # 13:03, 4 January 1990. Typical traffic on Thursdays at 1:03 p.m. “time_of_day”: datetime(1990, 1, 7, 17, 0) # 17:00, 7 January 1990. Typical traffic on Sundays at 5:00 p.m. “time_of_day”: datetime(2014, 10, 22, 8, 0) # 8:00, 22 October 2014. If the current time is between 8:00 p.m., 21 Oct. 2014 and 8:00 p.m., 22 Oct. 2014, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced. “time_of_day”: datetime(2015, 3, 18, 10, 20) # 10:20, 18 March 2015. If the current time is between 10:20 p.m., 17 Mar. 2015 and 10:20 p.m., 18 Mar. 2015, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced.
time_zone_for_time_of_day	Optional string. Specify the time zone or zones of the time_of_day parameter. Choice list: [‘GeoLocal’, ‘UTC’] GeoLocal-refers to the time zone in which the origins_layer points are located. UTC-refers to Coordinated Universal Time.
travel_direction	Optional string. Specify whether to measure travel times or distances from facilities to demand locations or from demand locations to facilities. Choice list: [‘FacilityToDemand’, ‘DemandToFacility’]
required_facilities_layer	Optional point feature layer. A point layer specifying one or more locations that act as facilities by providing some kind of service. Facilities specified by this parameter are required to be part of the output solution and will be used before any facilities from the candidate_facilities_layer when allocating demand locations.
required_facilities_capacity	Optional float. Specify how much demand every facility in the required_facilities_layer is capable of supplying. The default value is unlimited (2,147,483,647).
required_facilities_capacity_field	Optional string. A field on the required_facilities_layer representing how much demand each facility in the required_facilities_layer is capable of supplying. This parameter takes precedence when required_facilities_capacity parameter is also specified.
candidate_facilities_layer	Optional point layer. A point layer specifying one or more locations that act as facilities by providing some kind of service. Facilities specified by this parameter are not required to be part of the output solution and will be used only after all the facilities from the candidate_facilities_layer have been used when allocating demand locations.
candidate_count	Optional integer. The number of candidate facilities to choose when allocating demand locations. Note that the sum of the features in the required_facilities_capacity and the value specified for candidate_count cannot exceed 100. The default value is 1.
candidate_facilities_capacity	Optional float. Specify how much demand every facility in the candidate_facilities_layer is capable of supplying. The default value is unlimited (2,147,483,647.0).
candidate_facilities_capacity_field	Optional string. A field on the candidate_facilities_layer representing how much demand each facility in the candidate_facilities_layer is capable of supplying. This parameter takes precedence when candidate_facilities_capacity parameter is also specified.
percent_demand_coverage	Optional float. Specify the percentage of the total demand that you want the chosen and required facilities to capture. The default value is 100.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For choose_best_facilities, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. Is true, the number of credits needed to run the operation will be returned as a float.
point_barrier_layer	Optional layer. Specify one or more point features that act as temporary restrictions (in other words, barriers) when traveling on the underlying streets. A point barrier can model a fallen tree, an accident, a downed electrical line, or anything that completely blocks traffic at a specific position along the street. Travel is permitted on the street but not through the barrier. See Feature Input.
line_barrier_layer	Optional layer. Specify one or more line features that prohibit travel anywhere the lines intersect the streets. A line barrier prohibits travel anywhere the barrier intersects the streets. For example, a parade or protest that blocks traffic across several street segments can be modeled with a line barrier. See Feature Input.
polygon_barrier_layer	Optional layer. Specify one or more polygon features that completely restrict travel on the streets intersected by the polygons. One use of this type of barrier is to model floods covering areas of the street network and making road travel there impossible. See Feature Input.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

When an output_name is specified, a FeatureCollection with 3 layers is returned (see dictionary below for details), else a dict with the following keys:

”allocated_demand_locations_layer” : layer (FeatureCollection)

”allocation_lines_layer” : layer (FeatureCollection)

”assigned_facilities_layer” : layer (FeatureCollection)

USAGE EXAMPLE: To minimize overall distance travelled for travelling from esri offices to glider airports.

best_facility = choose_best_facilities(goal="MinimizeImpedance",
                            demand_locations_layer=esri_offices,
                            travel_mode='Driving Distance',
                            travel_direction="DemandToFacility",
                            required_facilities_layer=gliderport_lyr,
                            candidate_facilities_layer=balloonport_lyr,
                            candidate_count=1,
                            output_name="choose best facilities")

arcgis.connect_origins_to_destinations(origins_layer, destinations_layer, measurement_type=None, origins_layer_route_id_field=None, destinations_layer_route_id_field=None, time_of_day=None, time_zone_for_time_of_day='GeoLocal', output_name=None, context=None, gis=None, estimate=False, point_barrier_layer=None, line_barrier_layer=None, polygon_barrier_layer=None, future=False, route_shape='FollowStreets', include_route_layers=False)

The Connect Origins to Destinations task measures the travel time or distance between pairs of points. Using this tool, you can

• Calculate the total distance or time commuters travel on their home-to-work trips.

• Measure how far customers are traveling to shop at your stores. Use this information to define your market reach, especially when targeting advertising campaigns or choosing new store locations.

• Calculate the expected trip mileage for your fleet of vehicles. Afterward, run the Summarize Within tool to report mileage by state or other region.

You provide starting and ending points, and the tool returns a layer containing route lines, including measurements, between the paired origins and destinations.

Parameter	Description
origins_layer	Required layer. The starting point or points of the routes to be generated. See Feature Input.
destinations_layer	Required layer. The routes end at points in the destinations layer. See Feature Input.
measurement_type	Required string. The origins and destinations can be connected by measuring straight-line distance, or by measuring travel time or travel distance along a street network using various modes of transportation known as travel modes. Valid values are a string, StraightLine, which indicates Euclidean distance to be used as distance measure or a Python dictionary representing settings for a travel mode. When using a travel mode for the measurement_type, you need to specify a dictionary containing the settings for a travel mode supported by your organization. The code in the example section below generates a valid Python dictionary and then passes it as the value for the measurement_type parameter. Supported travel modes: [‘Driving Distance’, ‘Driving Time’, ‘Rural Driving Distance’, ‘Rural Driving Time’, ‘Trucking Distance’, ‘Trucking Time’, ‘Walking Distance’, ‘Walking Time’]
origins_layer_route_id_field	Optional string. Specify the field in the origins layer containing the IDs that pair origins with destinations. The ID values must uniquely identify points in the origins layer Each ID value must also correspond with exactly one route ID value in the destinations layer. Route IDs that match across the layers create origin-destination pairs, which the tool connects together. Specifying origins_layer_route_id_field is optional when there is exactly one point feature in the origins or destinations layer. The tool will connect all origins to the one destination or the one origin to all destinations, depending on which layer contains one point.
destinations_layer_route_id_field	Optional string. Specify the field in the destinations layer containing the IDs that pair origins with destinations. The ID values must uniquely identify points in the destinations layer. Each ID value must also correspond with exactly one route ID value in the origins layer. Route IDs that match across the layers create origin-destination pairs, which the tool connects together. Specifying destinations_layer_route_id_field is optional when there is exactly one point feature in the origins or destinations layer. The tool will connect all origins to the one destination or the one origin to all destinations, depending on which layer contains one point.
time_of_day	Optional datetime.datetime. Specify whether travel times should consider traffic conditions. To use traffic in the analysis, set measurement_type to a travel mode object whose impedance_attribute_name property is set to travel_time and assign a value to time_of_day. (A travel mode with other impedance_attribute_name values don’t support traffic.) The time_of_day value represents the time at which travel begins, or departs, from the origin points. The time is specified as datetime.datetime. The service supports two kinds of traffic: typical and live. Typical traffic references travel speeds that are made up of historical averages for each five-minute interval spanning a week. Live traffic retrieves speeds from a traffic feed that processes phone probe records, sensors, and other data sources to record actual travel speeds and predict speeds for the near future. The data coverage page shows the countries Esri currently provides traffic data for. Typical Traffic: To ensure the task uses typical traffic in locations where it is available, choose a time and day of the week, and then convert the day of the week to one of the following dates from 1990: Monday - 1/1/1990 Tuesday - 1/2/1990 Wednesday - 1/3/1990 Thursday - 1/4/1990 Friday - 1/5/1990 Saturday - 1/6/1990 Sunday - 1/7/1990 Set the time and date as datetime.datetime. For example, to solve for 1:03 p.m. on Thursdays, set the time and date to 1:03 p.m., 4 January 1990; and convert to datetime eg. datetime.datetime(1990, 1, 4, 1, 3). Live Traffic: To use live traffic when and where it is available, choose a time and date and convert to datetime. Esri saves live traffic data for 4 hours and references predictive data extending 4 hours into the future. If the time and date you specify for this parameter is outside the 24-hour time window, or the travel time in the analysis continues past the predictive data window, the task falls back to typical traffic speeds. # Examples: from datetime import datetime “time_of_day”: datetime(1990, 1, 4, 1, 3) # 13:03, 4 January 1990. Typical traffic on Thursdays at 1:03 p.m. “time_of_day”: datetime(1990, 1, 7, 17, 0) # 17:00, 7 January 1990. Typical traffic on Sundays at 5:00 p.m. “time_of_day”: datetime(2014, 10, 22, 8, 0) # 8:00, 22 October 2014. If the current time is between 8:00 p.m., 21 Oct. 2014 and 8:00 p.m., 22 Oct. 2014, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced. “time_of_day”: datetime(2015, 3, 18, 10, 20) # 10:20, 18 March 2015. If the current time is between 10:20 p.m., 17 Mar. 2015 and 10:20 p.m., 18 Mar. 2015, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced.
time_zone_for_time_of_day	Optional string. Specify the time zone or zones of the timeOfDay parameter. Choice list: [‘GeoLocal’, ‘UTC’] GeoLocal-refers to the time zone in which the originsLayer points are located. UTC-refers to Coordinated Universal Time.
include_route_layers	Optional Boolean. When include_route_layers is set to True, each route from the result is also saved as a route layer item. A route layer includes all the information for a particular route such as the stops assigned to the route as well as the travel directions. Creating route layers is useful if you want to share individual routes with other members in your organization. The route layers use the output feature service name provided in the output_name parameter as a prefix and the route name generated as part of the analysis is added to create a unique name for each route layer. Caution: Route layers cannot be created when the output is a feature collection. The task will raise an error if output_name is not specified (which indicates feature collection output) and include_route_layers is True. The maximum number of route layers that can be created is 1,000. If the result contains more than 1,000 routes and include_route_layers is True, the task will only create the output feature service.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For connect_origins_to_destinations, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional Boolean. Is True, the number of credits needed to run the operation will be returned as a float.
point_barrier_layer	Optional layer. Specify one or more point features that act as temporary restrictions (in other words, barriers) when traveling on the underlying streets. A point barrier can model a fallen tree, an accident, a downed electrical line, or anything that completely blocks traffic at a specific position along the street. Travel is permitted on the street but not through the barrier. See Feature Input.
line_barrier_layer	Optional layer. Specify one or more line features that prohibit travel anywhere the lines intersect the streets. A line barrier prohibits travel anywhere the barrier intersects the streets. For example, a parade or protest that blocks traffic across several street segments can be modeled with a line barrier. See Feature Input.
polygon_barrier_layer	Optional string. Specify one or more polygon features that completely restrict travel on the streets intersected by the polygons. One use of this type of barrier is to model floods covering areas of the street network and making road travel there impossible. See Feature Input.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
route_shape	Optional String. Specify the shape of the route that connects each origin to it’s destination when using a travel mode. Values: FollowStreets or StraightLine Default: FollowStreets FollowStreets - The shape is based on the underlying street network. This option is best when you want to generate the routes between origins and destinations. This is the default value when using a travel mode. StraightLine - The shape is a straight line connecting the origin-destination pair. This option is best when you want to g enerate spider diagrams or desire lines (for example, to show which stores customers are visiting). This is the default value when not using a travel mode. The best route between an origin and it’s matched destination is always calculated based on the travel mode, regardless of which route shape is chosen.

Returns:

A dictionary with the following keys:

”routes_layer” : layer (FeatureCollection)

”unassigned_origins_layer” : layer (FeatureCollection)

”unassigned_destinations_layer” : layer (FeatureCollection)

# USAGE EXAMPLE: To retrieve trvel modes and run connect_origins_to_destinations tool.

This example creates route between esri regional offices to esri headquarter.

routes =  connect_origins_to_destinations(origins_layer=esri_regional,
                                 destinations_layer=dest_layer,
                                 measurement_type='Rural Driving Distance',
                                 time_of_day=datetime(1990, 1, 4, 1, 3),
                                 output_name="routes_from_offices_to_hq")

arcgis.create_buffers(input_layer, distances=[], field=None, units='Meters', dissolve_type='None', ring_type='Disks', side_type='Full', end_type='Round', output_name=None, context=None, gis=None, estimate=False, future=False)

The create_buffers task creates polygons that cover a given distance from a point, line, or polygon feature. Buffers are typically used to create areas that can be further analyzed using a tool such as overlay_layers. For example, if the question is “What buildings are within one mile of the school?”, the answer can be found by creating a one-mile buffer around the school and overlaying the buffer with the layer containing building footprints. The end result is a layer of those buildings within one mile of the school.

Parameter	Description
input_layer	Required point, line or polygon feature layer. The input features to be buffered. See Feature Input.
distances	Optional list of floats to buffer the input features. The distance(s) that will be buffered. You must supply values for either the distances or field parameter. You can enter a single distance value or multiple values. The units of the distance values is suppied by the units parameter.
field	Optional string. A field on the input_layer containing a buffer distance. Buffers will be created using field values. Unlike the distances parameter, multiple distances are not supported on field input.
units	Optional string. The linear unit to be used with the distance value(s) specified in distances or contained in the field value. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘NauticalMiles’, ‘Yards’] The default is ‘Meters’.
dissolve_type	Optional string. Determines how overlapping buffers are processed. Choice list: [‘None’, ‘Dissolve’] None-Overlapping areas are kept. This is the default. Dissolve-Overlapping areas are combined.
ring_type	Optional string. Determines how multiple-distance buffers are processed. Choice list: [‘Disks’, ‘Rings’] Disks-buffers are concentric and will overlap. For example, if your distances are 10 and 14, the result will be two buffers, one from 0 to 10 and one from 0 to 14. This is the default. Rings buffers will not overlap. For example, if your distances are 10 and 14, the result will be two buffers, one from 0 to 10 and one from 10 to 14.
side_type	Optional string. When buffering line features, you can choose which side of the line to buffer. Typically, you choose both sides (Full, which is the default). Left and right are determined as if you were walking from the first x,y coordinate of the line (the start coordinate) to the last x,y coordinate of the line (the end coordinate). Choosing left or right usually means you know that your line features were created and stored in a particular direction (for example, upstream or downstream in a river network). When buffering polygon features, you can choose whether the buffer includes or excludes the polygon being buffered. Choice list: [‘Full’, ‘Left’, ‘Right’, ‘Outside’] Full-both sides of the line will be buffered. This is the default for line featuress. Left-only the right side of the line will be buffered. Right-only the right side of the line will be buffered. Outside when buffering a polygon, the polygon being buffered is excluded in the result buffer. If side_type not supplied, the polygon being buffered is included in the result buffer. This is the default for polygon features.
end_type	Optional string. The shape of the buffer at the end of line input features. This parameter is not valid for polygon input features. At the ends of lines the buffer can be rounded (Round) or be straight across (Flat). Choice list: [‘Round’, ‘Flat’] Round-buffers will be rounded at the ends of lines. This is the default. Flat-buffers will be flat at the ends of lines.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For create_buffers, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

result_layer : FeatureLayer if output_name is specified, else FeatureCollection.

USAGE EXAMPLE: To create 5 mile buffer around US parks, within the specified extent.

polygon_lyr_buffer = create_buffers(input_layer=parks_lyr,
                         distances=[5],
                         units='Miles',
                         ring_type='Rings',
                         end_type='Flat',
                         output_name='create_buffers',
                         context={"extent":{"xmin":-12555831.656684224,"ymin":5698027.566358956,"xmax":-11835489.102124758,"ymax":6104672.556836072,"spatialReference":{"wkid":102100,"latestWkid":3857}}})

arcgis.create_drive_time_areas(input_layer, break_values=[5, 10, 15], break_units='Minutes', travel_mode=None, overlap_policy='Overlap', time_of_day=None, time_zone_for_time_of_day='GeoLocal', output_name=None, context=None, gis=None, estimate=False, point_barrier_layer=None, line_barrier_layer=None, polygon_barrier_layer=None, future=False, travel_direction='AwayFromFacility', show_holes=False, include_reachable_streets=False)

The create_drive_time_areas method creates areas that can be reached within a given drive time or drive distance. It can help you answer questions such as:

• How far can I drive from here in five minutes?

• What areas are covered within a three-mile drive distance of my stores?

• What areas are within four minutes of our fire stations?

See Create Drive-Time Areas for details on the Spatial Analysis Service that runs this task.

Parameter	Description
input_layer	Required point feature layer. The points around which travel areas based on a mode of transportation will be drawn. See Feature Input.
travel_mode	Optional string or dict. Specify the mode of transportation for the analysis. Choice list: [‘Driving Distance’, ‘Driving Time’, ‘Rural Driving Distance’, ‘Rural Driving Time’, ‘Trucking Distance’, ‘Trucking Time’, ‘Walking Distance’, ‘Walking Time’] The default is ‘Driving Time’.
break_values	Optional list of floats. The size of the polygons to create. The units for break_values is specified with the break_units parameter. By setting many unique values in the list, polygons of different sizes are generated around each input location. The default is [5, 10, 15].
break_units	Optional string. The units of the break_values parameter. To create areas showing how far you can go along roads or walkways within a given time, specify a time unit. Alternatively, specify a distance unit to generate areas bounded by a maximum travel distance. When the travel_mode is time based, a time unit should be specified for the break_units. When the travel_mode is distance based, a distance unit should be specified for the break_units. Choice list: [‘Seconds’, ‘Minutes’, Hours’, ‘Feet’, ‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘Yards’] The default is ‘Minutes’.
overlap_policy	Optional string. Determines how overlapping areas are processed. Choice list: [‘Overlap’, ‘Dissolve’, ‘Split’] Overlap-Overlapping areas are kept. This is the default. Dissolve-Overlapping areas are combined by break value. Because the areas are dissolved, use this option when you need to know the areas that can be reached within a given time or distance, but you don’t need to know which input points are nearest. Split-Overlapping areas are split in the middle. Use this option when you need to know the one nearest input location to the covered area. The default is ‘Overlap’
time_of_day	Optional datetime.datetime. Specify whether travel times should consider traffic conditions. To use traffic in the analysis, set measurement_type to a travel mode object whose impedance_attribute_name property is set to travel_time and assign a value to time_of_day. (A travel mode with other impedance_attribute_name values don’t support traffic.) The time_of_day value represents the time at which travel begins, or departs, from the origin points. The time is specified as datetime.datetime. The service supports two kinds of traffic: typical and live. Typical traffic references travel speeds that are made up of historical averages for each five-minute interval spanning a week. Live traffic retrieves speeds from a traffic feed that processes phone probe records, sensors, and other data sources to record actual travel speeds and predict speeds for the near future. The data coverage page shows the countries Esri currently provides traffic data for. Typical Traffic: To ensure the task uses typical traffic in locations where it is available, choose a time and day of the week, and then convert the day of the week to one of the following dates from 1990: Monday - 1/1/1990 Tuesday - 1/2/1990 Wednesday - 1/3/1990 Thursday - 1/4/1990 Friday - 1/5/1990 Saturday - 1/6/1990 Sunday - 1/7/1990 Set the time and date as datetime.datetime. For example, to solve for 1:03 p.m. on Thursdays, set the time and date to 1:03 p.m., 4 January 1990; and convert to datetime eg. datetime.datetime(1990, 1, 4, 1, 3). Live Traffic: To use live traffic when and where it is available, choose a time and date and convert to datetime. Esri saves live traffic data for 4 hours and references predictive data extending 4 hours into the future. If the time and date you specify for this parameter is outside the 24-hour time window, or the travel time in the analysis continues past the predictive data window, the task falls back to typical traffic speeds. Examples: from datetime import datetime “time_of_day”: datetime(1990, 1, 4, 1, 3) # 13:03, 4 January 1990. Typical traffic on Thursdays at 1:03 p.m. “time_of_day”: datetime(1990, 1, 7, 17, 0) # 17:00, 7 January 1990. Typical traffic on Sundays at 5:00 p.m. “time_of_day”: datetime(2014, 10, 22, 8, 0) # 8:00, 22 October 2014. If the current time is between 8:00 p.m., 21 Oct. 2014 and 8:00 p.m., 22 Oct. 2014, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced. “time_of_day”: datetime(2015, 3, 18, 10, 20) # 10:20, 18 March 2015. If the current time is between 10:20 p.m., 17 Mar. 2015 and 10:20 p.m., 18 Mar. 2015, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced.
time_zone_for_time_of_day	Optional string. Specify the time zone or zones of the time_of_day parameter. Choice list: [‘GeoLocal’, ‘UTC’] GeoLocal-refers to the time zone in which the originsLayer points are located. UTC-refers to Coordinated Universal Time. The default is ‘GeoLocal’.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For create_drive_time_areas, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
point_barrier_layer	Optional layer. Specify one or more point features that act as temporary restrictions (in other words, barriers) when traveling on the underlying streets. A point barrier can model a fallen tree, an accident, a downed electrical line, or anything that completely blocks traffic at a specific position along the street. Travel is permitted on the street but not through the barrier. See Feature Input.
line_barrier_layer	Optional layer. Specify one or more line features that prohibit travel anywhere the lines intersect the streets. A line barrier prohibits travel anywhere the barrier intersects the streets. For example, a parade or protest that blocks traffic across several street segments can be modeled with a line barrier. See Feature Input.
polygon_barrier_layer	Optional string. Specify one or more polygon features that completely restrict travel on the streets intersected by the polygons. One use of this type of barrier is to model floods covering areas of the street network and making road travel there impossible. See Feature Input.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
travel_direction	Optiona String. Specify whether the direction of travel used to generate the travel areas is toward or away from the input locations. Values: AwayFromFacility or TowardsFacility The travel direction can influence how the areas are generated. CreateDriveTimeAreas will obey one-way streets, avoid illegal turns, and follow other rules based on the direction of travel. You should select the direction of travel based on the type of input locations and the context of your analysis. For example, the drive-time area for a pizza delivery store should be created away from the facility, whereas the drive-time area for a hospital should be created toward the facility.
show_holes	Optional boolean. When set to true, the output areas will include holes if some streets couldn’t be reached without exceeding the cutoff or due to travel restrictions imposed by the travel mode.
include_reachable_streets	Optional string. Only applicable if output_name is specified. When True (and output_name is specified), a second layer named Reachable Streets is created in the output Feature Layer. This layer contains the streets that were used to define the drive time area polygons. Set this to true if you want a potentially more accurate result of which streets are actually covered within a specific travel distance than what the drive-time areas would contain.

Returns:

result_layer : FeatureLayer if output_name is specified, else Feature Collection.

USAGE EXAMPLE: To create drive time areas around USA airports, within the specified extent.

target_area4 = create_drive_time_areas(airport_lyr,
                               break_values=[2, 4],
                               break_units='Hours',
                               travel_mode='Trucking Time',
                               overlap_policy='Split',
                               time_of_day=datetime(2019, 5, 13, 7, 52),
                               output_name='create_drive_time_areas',
                               context={"extent":{"xmin":-11134400.655784884,"ymin":3368261.7800108367,"xmax":-10682810.692676282,"ymax":3630899.409198575,"spatialReference":{"wkid":102100,"latestWkid":3857}}})

arcgis.create_route_layers(route_data_item, delete_route_data_item=False, tags=None, summary=None, route_name_prefix=None, folder_name=None, gis=None, estimate=False, future=False)

The create_route_layers method creates route layer items on the portal from the input route data.

A route layer includes all the information for a particular route such as the stops assigned to the route as well as the travel directions. Creating route layers is useful if you want to share individual routes with other members in your organization.

Parameter	Description
route_data	Required item. The item id for the route data item that is used to create route layer items. Before running this task, the route data must be added to your portal as an item.
delete_route_data_item	Required boolean. Indicates if the input route data item should be deleted. You may want to delete the route data in case it is no longer required after the route layers have been created from it. When delete_route_data_item is set to true and the task fails to delete the route data item, it will return a warning message but still continue execution. The default value is False.
tags	Optional string. Tags used to describe and identify the route layer items. Individual tags are separated using a comma. The route name is always added as a tag even when a value for this argument is not specified.
summary	Optional string. The summary displayed as part of the item information for the route layer item. If a value for this argument is not specified, a default summary text “Route and directions for <Route Name>” is used.
route_name_prefix	Optional string. A qualifier added to the title of every route layer item. This can be used to designate all routes that are shared for a specific purpose to have the same prefix in the title. The name of the route is always appended after this qualifier. If a value for the route_name_prefix is not specified, the title for the route layer item is created using only the route name.
folder_name	Optional string. The folder within your personal online workspace (My Content in your ArcGIS Online or Portal for ArcGIS organization) where the route layer items will be created. If a folder with the specified name does not exist, a new folder will be created. If a folder with the specified name exists, the items will be created in the existing folder. If a value for folder_name is not specified, the route layer items are created in the root folder of your online workspace.
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

result_layer : A list (items) or an Item.

If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To create route layers from geodatabase item.
route = create_route_layers(route_data_item=route_item,
                    delete_route_data_item=False,
                    tags="datascience",
                    summary="example of create route layers method",
                    route_name_prefix="santa_ana",
                    folder_name="create route layers")

arcgis.create_viewshed(input_layer, dem_resolution='Finest', maximum_distance=None, max_distance_units='Meters', observer_height=None, observer_height_units='Meters', target_height=None, target_height_units='Meters', generalize=True, output_name=None, context=None, gis=None, estimate=False, future=False)

The create_viewshed method identifies visible areas based on the observer locations you provide. The results are areas where the observers can see the observed objects (and the observed objects can see the observers).

Parameter	Description
input_layer	Required point feature layer. The features to use as the observer locations. See Feature Input.
dem_resolution	Optional string. The approximate spatial resolution (cell size) of the source elevation data used for the calculation. The resolution values are an approximation of the spatial resolution of the digital elevation model. While many elevation sources are distributed in units of arc seconds, the keyword is an approximation of those resolutions in meters for easier understanding. Choice list: [‘FINEST’, ‘10m’, ‘24m’, ‘30m’, ‘90m’] The default is the finest resolution available.
maximum_distance	Optional float. This is a cutoff distance where the computation of visible areas stops. Beyond this distance, it is unknown whether the analysis points and the other objects can see each other. It is useful for modeling current weather conditions or a given time of day, such as dusk. Large values increase computation time. Unless specified, a default maximum distance will be computed based on the resolution and extent of the source DEM. The allowed maximum value is 50 kilometers. Use max_distance_units to set the units for maximum_distance.
max_distance_units	Optional string. The units for the maximum_distance parameter. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘Yards’] The default is ‘Meters’.
observer_height	Optional float. This is the height above the ground of the observer locations. The default is 1.75 meters, which is approximately the average height of a person. If you are looking from an elevated location, such as an observation tower or a tall building, use that height instead. Use observer_height_units to set the units for observer_height.
observer_height_units	Optional string. The units for the observer_height parameter. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘Yards’] The default is ‘Meters’.
target_height	Optional float. This is the height of structures or people on the ground used to establish visibility. The result viewshed are those areas where an input point can see these other objects. The converse is also true; the other objects can see an input point. If your input points represent wind turbines and you want to determine where people standing on the ground can see the turbines, enter the average height of a person (approximately 6 feet). The result is those areas where a person standing on the ground can see the wind turbines. If your input points represent fire lookout towers and you want to determine which lookout towers can see a smoke plume 20 feet high or higher, enter 20 feet for the height. The result is those areas where a fire lookout tower can see a smoke plume at least 20 feet high. If your input points represent scenic overlooks along roads and trails and you want to determine where wind turbines 400 feet high or higher can be seen, enter 400 feet for the height. The result is those areas where a person standing at a scenic overlook can see a wind turbine at least 400 feet high. If your input points represent scenic overlooks and you want to determine how much area on the ground people standing at the overlook can see, enter zero. The result is those areas that can be seen from the scenic overlook. Use target_height_units to set the units for target_height.
target_height_units	Optional string. The units for the target_height parameter. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘Yards’] The default is ‘Meters’.
generalize	Optional boolean. Determines whether or not the viewshed polygons are to be generalized. The viewshed calculation is based on a raster elevation model that creates a result with stair-stepped edges. To create a more pleasing appearance and improve performance, the default behavior is to generalize the polygons. The generalization process smooths the boundary of the visible areas and may remove some single-cell visible areas. The default value is True.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For create_viewshed, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

result_layer : FeatureLayer if output_name is specified, else FeatureCollection.

USAGE EXAMPLE: To create viewshed around esri headquarter office.

viewshed3 = create_viewshed(hq_lyr,
                    maximum_distance=9,
                    max_distance_units='Miles',
                    target_height=6,
                    target_height_units='Feet',
                    output_name="create Viewshed")

arcgis.create_watersheds(input_layer, search_distance=None, search_units='Meters', source_database='FINEST', generalize=True, output_name=None, context=None, gis=None, estimate=False, future=False)

The create_watersheds method determines the watershed, or upstream contributing area, for each point in your analysis layer. For example, suppose you have point features representing locations of waterborne contamination, and you want to find the likely sources of the contamination. Since the source of the contamination must be somewhere within the watershed upstream of the point, you would use this tool to define the watersheds containing the sources of the contaminant.

Parameter	Description
input_layer	Required point feature layer. The point features used for calculating watersheds. These are referred to as pour points, because it is the location at which water pours out of the watershed. See Feature Input.
search_distance	Optional float. The maximum distance to move the location of an input point. Use search_units to set the units for search_distance. If your input points are located away from a drainage line, the resulting watersheds are likely to be very small and not of much use in determining the upstream source of contamination. In most cases, you want your input points to snap to the nearest drainage line in order to find the watersheds that flows to a point located on the drainage line. To find the closest drainage line, specify a search distance. If you do not specify a search distance, the tool will compute and use a conservative search distance. To use the exact location of your input point, specify a search distance of zero. For analysis purposes, drainage lines have been precomputed by Esri using standard hydrologic models. If there is no drainage line within the search distance, the location containing the highest flow accumulation within the search distance is used.
search_units	Optional string. The linear units specified for the search distance. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Miles’, ‘Yards’]
source_database	Optional string. Keyword indicating the data source resolution that will be used in the analysis. Choice list: [‘Finest’, ‘30m’, ‘90m’] Finest (Default): Finest resolution available at each location from all possible data sources. 30m: The hydrologic source was built from 1 arc second - approximately 30 meter resolution, elevation data. 90m: The hydrologic source was built from 3 arc second - approximately 90 meter resolution, elevation data.
generalize	Optional boolean. Determines if the output watersheds will be smoothed into simpler shapes or conform to the cell edges of the original DEM. True: The polygons will be smoothed into simpler shapes. This is the default. False: The edge of the polygons will conform to the edges of the original DEM. The default value is True.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For create_watersheds, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

:returns result_layer : FeatureLayer if output_name is specified, else FeatureCollection.

USAGE EXAMPLE: To create watersheds for Chennai lakes.

lakes_watershed = create_watersheds(lakes_lyr,
                                    search_distance=3,
                                    search_units='Kilometers',
                                    source_database='90m',
                                    output_name='create watersheds')

arcgis.derive_new_locations(input_layers=[], expressions=[], output_name=None, context=None, gis=None, estimate=False, future=False)

The derive_new_locations method derives new features from the input layers that meet a query you specify. A query is made up of one or more expressions. There are two types of expressions: attribute and spatial. An example of an attribute expression is that a parcel must be vacant, which is an attribute of the Parcels layer (STATUS = ‘VACANT’). An example of a spatial expression is that the parcel must also be within a certain distance of a river (Parcels within a distance of 0.75 Miles from Rivers).

The derive_new_locations method is very similar to the find_existing_locations method, the main difference is that the result of derive_new_locations can contain partial features.

• In both methods, the attribute expression where and the spatial relationships within and contains return the same result. This is because these relationships return entire features.

• When intersects or within_distance is used, derive_new_locations creates new features in the result. For example, when intersecting a parcel feature and a flood zone area that partially overlap each other, find_existing_locations will return the entire parcel whereas derive_new_locations will return just the portion of the parcel that is within the flood zone.

Parameter	Description
input_layers	Required list of feature layers. A list of layers that will be used in the expressions parameter. Each layer in the list can be: a feature service layer with an optional filter to select specific features, or a feature collection
expressions	Required dict. There are two types of expressions, attribute and spatial. Example attribute expression: { “operator”: “and”, “layer”: 0, “where”: “STATUS = ‘VACANT’” } Note operator can be either and or or layer is the index of the layer in the input_layers parameter. The where clause must be surrounded by double quotes. When dealing with text fields, values must be single-quoted (‘VACANT’). Date fields support all queries except LIKE. Dates are strings in YYYY:MM:DD hh:mm:ss format. Here’s an example using the date field ObsDate: “where”: “ObsDate >= ‘1998-04-30 13:30:00’ “ = Equal > Greater than < Less than >= Greater than or equal to <= Less than or equal to <> Not equal LIKE ‘% <string>’ A percent symbol (%) signifies a wildcard, meaning that anything is acceptable in its place-one character, a hundred characters, or no character. This expression would select Mississippi and Missouri among USA state names: STATE_NAME LIKE ‘Miss%’ BETWEEN <value1> AND <value2> Selects a record if it has a value greater than or equal to <value1> and less than or equal to <value2>. For example, this expression selects all records with an HHSIZE value greater than or equal to 3 and less than or equal to 10: HHSIZE BETWEEN 3 AND 10 The above is equivalent to: HHSIZE >= 3 AND HHSIZE <= 10 This operator applies to numeric or date fields. Here is an example of a date query on the field ObsDate: ObsDate BETWEEN ‘1998-04-30 00:00:00’ AND ‘1998-04-30 23:59:59’ Time is optional. NOT BETWEEN <value1> AND <value2> Selects a record if it has a value outside the range between <value1> and less than or equal to <value2>. For example, this expression selects all records whose HHSIZE value is less than 5 and greater than 7. HHSIZE NOT BETWEEN 5 AND 7 The above is equivalent to: HHSIZE < 5 OR HHSIZE > 7 This operator applies to numeric or date fields. You can use the contains relationship with points and lines. For example, you have a layer of street centerlines (lines) and a layer of manhole covers (points), and you want to find streets that contain a manhole cover. You could use contains to find streets that contain manhole covers, but in order for a line to contain a point, the point must be exactly on the line (that is, in GIS terms, they are snapped to each other). If there is any doubt about this, use the withinDistance relationship with a suitable distance value. Example spatial expression: { “operator”: “and”, “layer”: 0, “spatialRel”: “withinDistance”, “selectingLayer”: 1, “distance”: 10, “units”: “miles” } operator can be either and or or layer is the index of the layer in the input_layers parameter. The result of the expression is features in this layer. spatialRel is the spatial relationship. There are nine spatial relationships. distance is the distance to use for the withinDistance and notWithinDistance spatial relationship. units is the units for distance. Units choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Yards’, ‘Miles’] spatialRel Description intersects notIntersects A feature in layer passes the intersect test if it overlaps any part of a feature in selectingLayer, including touches (where features share a common point). intersects - If a feature in layer intersects a feature in selectingLayer, the portion of the feature in layer that intersects the feature in selectingLayer is included in the output. notintersects - If a feature in layer intersects a feature in selectingLayer, the portion of the feature in layer that intersects the feature in selectingLayer is excluded from the output. withinDistance notWithinDistance The within a distance relationship uses the straight-line distance between features in layer to those in selectingLayer. withinDistance - The portion of the feature in layer that is within the specified distance of a feature in selectingLayer is included in the output. * notwithinDistance - The portion of the feature in layer that is within the specified distance of a feature in selectingLayer is excluded from output. You can think of this relationship as “is farther away than”. contains notContains A feature in layer passes this test if it completely surrounds a feature in selectingLayer. No portion of the containing feature an be outside the containing feature; however, the contained feature is allowed to touch the containing feature (that is, share a common point along its boundary). contains - If a feature in layer contains a feature in selectingLayer, the feature in layer is included in the output. * notcontains - If a feature in layer contains a feature in selectingLayer, the feature in the first layer is excluded. within notWithin A feature in layer passes this test if it is completely surrounded by a feature in selectingLayer. The entire feature layer must be within the containing feature; however, the two features are allowed to touch (that is, share a common point along its boundary). within - If a feature in layer is completely within a feature in selectingLayer, the feature in layer is included in the output. notwithin - If a feature in layer is completely within a feature in selectingLayer, the feature in layer is excluded from the output. Note: You can use the within relationship for points and lines, just as you can with the contains relationship. For example, your first layer contains points representing manhole covers and you want to find the manholes that are on street centerlines (as opposed to parking lots or other non-street features). You could use within to find manhole points within street centerlines, but in order for a point to contain a line, the point must be exactly on the line (that is, in GIS terms, they are snapped to each other). If there is any doubt about this, use the withinDistance relationship with a suitable distance value. | relationship with a suitable distance value. | An expression may be a list, which denotes a group. The first operator in the group indicates how the group expression is added to the previous expression. Grouping expressions is only necessary when you need to create two or more distinct sets of features from the same layer. One way to think of grouping is that without grouping, you would have to execute derive_new_locations multiple times and merge the results.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For derive_new_locations, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the number of credits needed to run the operation will be returned as a float.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

FeatureLayer if output_name is specified, else FeatureCollection.

USAGE EXAMPLE: To identify areas that are suitable cougar habitat using the criteria defined by experts.

new_location = derive_new_locations(input_layers=[slope, vegetation, streams, highways],
                            expressions=[{"operator":"","layer":0,"selectingLayer":1,"spatialRel":"intersects"},
                                         {"operator":"and","layer":0,"selectingLayer":2,"spatialRel":"withinDistance","distance":500,"units":"Feet"},
                                         {"operator":"and","layer":0,"selectingLayer":3,"spatialRel":"notWithinDistance","distance":1500,"units":"Feet"},
                                         {"operator":"and","layer":0,"where":"GRIDCODE = 1"}],
                            output_name='derive_new_locations')

arcgis.dissolve_boundaries(input_layer, dissolve_fields=[], summary_fields=[], output_name=None, context=None, gis=None, estimate=False, multi_part_features=True, future=False)

The dissolve_boundaries method finds polygons that overlap or share a common boundary and merges them together to form a single polygon.

You can control which boundaries are merged by specifying a field. For example, if you have a layer of counties, and each county has a State_Name attribute, you can dissolve boundaries using the State_Name attribute. Adjacent counties will be merged together if they have the same value for State_Name. The end result is a layer of state boundaries.

Parameter	Description
input_layer	Required layer. The layer containing polygon features that will be dissolved. See Feature Input.
dissolve_fields	Optional list of strings. One or more fields on the input_layer that control which polygons are merged. If you don’t supply dissolve_fields , or you supply an empty list of fields, polygons that share a common border (that is, they are adjacent) or polygon areas that overlap will be dissolved into one polygon. If you do supply values for the dissolve_fields parameter, polygons that share a common border and contain the same value in one or more fields will be dissolved. For example, if you have a layer of counties, and each county has a State_Name attribute, you can dissolve boundaries using the State_Name attribute. Adjacent counties will be merged together if they have the same value for State_Name. The end result is a layer of state boundaries.If two or more fields are specified, the values in these fields must be the same for the boundary to be dissolved.
summary_fields	Optional list of strings. A list of field names and statistical summary types that you wish to calculate from the polygons that are dissolved together: [“fieldName summaryType”, “fieldName2 summaryType”] fieldName is the name of one of the numeric fields found in the input_layer. summary type is one of the following: Sum - Adds the total value of all the points in each polygon Mean - Calculates the average of all the points in each polygon. Min - Finds the smallest value of all the points in each polygon. Max - Finds the largest value of all the points in each polygon. Stddev - Finds the standard deviation of all the points in each polygon. For example, if you are dissolving counties based on State_Name, and each county has a Population field, you can sum the Population for all the counties sharing the same State_Name attribute. The result would be a layer of state boundaries with total population. # Usage Example >>> dissolve_boundaries(input_layer="US_Counties", dissolve_fields="State_Name", summary_fields=["Population Sum"], output_name="US_States")
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For calculate_density, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 11+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional Boolean. If True, the number of credits to run the operation will be returned.
multi_part_features	Optional boolean. Specifies whether multipart features (i.e. features which share a common attribute table but are not visibly connected) are allowed in the output feature class. Choice list: [True, False] True: Specifies multipart features are allowed. False: Specifies multipart features are not allowed. Instead of creating multipart features, individual features will be created for each part. The default value is True.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

result_layer : FeatureLayer if output_name is specified, else Feature Collection. If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To dissolve boundaries of polygons with same state name. The dissolved polygons are summarized using population as summary field and standard deviation as summary type.
diss_counties = dissolve_boundaries(input_layer=usa_counties,
                                    dissolve_fields=["STATE_NAME"],
                                    summary_fields=["POPULATION Stddev"],
                                    output_name="DissolveBoundaries")

arcgis.enrich_layer(input_layer, data_collections=[], analysis_variables=[], country=None, buffer_type=None, distance=None, units=None, output_name=None, context=None, gis=None, estimate=False, return_boundaries=False, future=False)

The enrich_layer method enriches your data by getting facts about the people, places, and businesses that surround your data locations. For example: What kind of people live here? What do people like to do in this area? What are their habits and lifestyles? What kind of businesses are there in this area?

The result will be a new layer of input features that includes all demographic and geographic information from given data collections.

Parameter	Description
input_layer	Required layer. The features to enrich with new data. See Feature Input.
data_collections	Optional list of strings. This optional parameter defines the collections of data you want to use to enrich your features. Its value is a list of strings. If you don’t provide this parameter, you must provide the analysis_variables parameter. For more information about data collections and the values for this parameter, visit the Esri Demographics site.
analysis_variables	Optional list of strings. The parameter defines the specific variables within a data collection you want to use to your features. Its value is a list of strings in the form of “dataCollection.VariableName”. If you don’t provide this parameter, you must provide the dataCollections parameter. You can provide both parameters. For example, if you want all variables in the KeyGlobalFacts data collection, specify it in the dataCollections parameter and use this parameter for specific variables in other collections. For more information about variables in data collections, visit the Esri Demographics site. Each data collection has a PDF file describing variables and their names.
country	Optional string. This optional parameter further defines what is returned from data collection. For example, your input features may be countries in Western Europe, and you want to enrich them with the KeyWEFacts data collection. However, you only want data for France, not every country in your input layer. The value is the two-character country code. For more information about data collections and the values for this parameter, visit the Esri Demographics site.
buffer_type (Required if input_layer contains point or line features)	Optional string. If your input features are points or lines, you must define an area around your features that you want to enrich. Features that are within (or equal to) the distances you enter will be enriched. Choice list: [‘StraightLine’, ‘Driving Distance’, ‘Driving Time ‘, ‘Rural Driving Distance’, ‘Rural Driving Time’, ‘Trucking Distance’, ‘Trucking Time’, ‘Walking Distance’, ‘Walking Time’]
distance (Required if input_layer contains point or line features)	Optional float. A value that defines the search distance or time. The units of the distance value is supplied by the units parameter.
units	Optional string. The linear unit to be used with the distance value(s) specified in the distance parameter. Choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Yards’, ‘Miles’, ‘Seconds’, ‘Minutes’. ‘Hours’]
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For enrich_layer, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 11+ # Example Usage "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
return_boundaries	Optional boolean. Applies only for point and line input features. If True, a result layer of areas is returned. The returned areas are defined by the specified buffer_type. For example, if using a buffer_type of StraightLine with a distance of 5 miles, your result will contain areas with a 5 mile radius around the input features and requested analysis_variables variables. If False, the resulting layer will return the same features as the input layer with analysis_variables variables. The default value is False.
future	Optional, If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

:returns FeatureLayer if output_name is specified, else FeatureCollection. If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To enrich US block groups with population as analysis variable.
blkgrp_enrich = enrich_layer(block_groups,
                             analysis_variables=["AtRisk.MP27002A_B"],
                             country='US',
                             output_name='enrich layer')

arcgis.extract_data(input_layers, extent=None, clip=False, data_format=None, output_name=None, gis=None, estimate=False, future=False, context=None)

The extract_data method is used to extract data from one or more layers within a given extent. The extracted data format can be a file geodatabase, shapefiles, csv, or kml. File geodatabases and shapefiles are added to a zip file that can be downloaded.

Parameter	Description
input_layers	Required list of feature layers and tables. A list of input layers to be extracted. See Feature Input.
extent	Optional feature layer. The extent is the area of interest used to extract the input features. If not specified, all features from each input layer are extracted. See Feature Input.
clip	Optional boolean. A Boolean value that specifies whether the features within the input layer are clipped within the extent. By default, features are not clipped and all features intersecting the extent are returned. The default is false.
data_format	Optional string. A keyword defining the output data format for your extracted data. Choice list: [‘FileGeodatabase’, ‘ShapeFile’, ‘KML’, ‘CSV’] The default is ‘CSV’. If FileGeodatase is specified and the input layer has attachments: if clip=False, the attachments will be extracted to the output file if clip=True, the attachments will not be extracted
output_name	Optional string or dict. When output_name is a string, the output item in your My contents page will be named by the value. Other item properties will receive default values. output_name = "my_extracted_item" To explicitly provide other item properties, use a dict with the following Syntax. output_name = {"title": "<title>", "tag": "<tags>", "snippet": "<snippet>", "description": "<description>"} For more information on these and other item properties, see the Item resource page in the ArcGIS REST API.
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the number of credits to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For extract_data, there are two settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}}

Returns:

resulting item : Item if output_name is specified, else Feature Collection.

If future = True, then the result is a Future object. Call result() to get the response.

# USAGE EXAMPLE: To extract data from highways layer with the extent of a state boundary.

ext_state_highway = extract_data(input_layers=[highways.layers[0]],
                         extent=state_area_boundary.layers[0],
                         clip=True,
                         data_format='shapefile',
                         output_name='state highway extracted')

arcgis.find_centroids(input_layer, point_location=False, output_name=None, context=None, gis=None, estimate=False, future=False)

The find_centroids method that finds and generates points from the representative center (centroid) of each input multipoint, line, or polygon feature. Finding the centroid of a feature is very common for many analytical workflows where the resulting points can then be used in other analytic workflows.

For example, polygon features that contain demographic data can be converted to centroids that can be used in network analysis.

Parameter	Description
input_layer	Required feature layer. The multipoint, line, or polygon features that will be used to generate centroid point features. See Feature Input.
point_location	Optional boolean. A Boolean value that determines the output location of the points. True - Output points will be the nearest point to the actual centroid, but located inside or contained by the bounds of the input feature. False - Output point locations will be determined by the calculated geometric center of each input feature. This is the default.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in *contextI, new layer will overwrite existing layer. If output_name not provided, a new FeatureCollection is created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For find_centroids, there are three context settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+. # Example Usage centroids_res = find_centroids( ... context = { "extent": { "xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{ "wkid":102100, "latestWkid":3857 } }, "outSR": {"wkid": 3857}, "overwrite": True } ... )
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the number of credits to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned which can be queried for results. The process will return control to user. If False, the process completes before returning control to the user. The default is False.

Returns:

• FeatureLayer if output_name is specified

• FeatureCollection if output_name not specified

# USAGE EXAMPLE: To find centroids of madison fields nearest to the actual centroids.

centroid = find_centroids(madison_fields,
                          point_location=True,
                          output_name='find centroids')

arcgis.find_existing_locations(input_layers=None, expressions=None, output_name=None, context=None, gis=None, estimate=False, future=False)

The find_existing_locations method selects features in the input layer that meet a query you specify. A query is made up of one or more expressions. There are two types of expressions: attribute and spatial. An example of an attribute expression is that a parcel must be vacant, which is an attribute of the Parcels layer (where STATUS = ‘VACANT’). An example of a spatial expression is that the parcel must also be within a certain distance of a river (Parcels within a distance of 0.75 Miles from Rivers).

Parameter	Description
input_layers	Required list of feature layers. A list of layers that will be used in the expressions parameter. Each layer in the list can be: a feature service layer with an optional filter to select specific features, or a feature collection See Feature Input.
expressions	Required list of dicts. There are two types of expressions, attribute and spatial. Example attribute expression: [{ “operator”: “and”, “layer”: 0, “where”: “STATUS = ‘VACANT’” }] Note operator can be either and or or layer is the index of the layer in the input_layers parameter. The where clause must be surrounded by double quotes. When dealing with text fields, values must be single-quoted (‘VACANT’). Date fields support all queries except LIKE. Dates are strings in YYYY:MM:DD hh:mm:ss format. Here’s an example using the date field ObsDate: “where”: “ObsDate >= ‘1998-04-30 13:30:00’ “ = Equal > Greater than < Less than >= Greater than or equal to <= Less than or equal to <> Not equal LIKE ‘% <string>’ A percent symbol (%) signifies a wildcard, meaning that anything is acceptable in its place-one character, a hundred characters, or no character. This expression would select Mississippi and Missouri among USA state names: STATE_NAME LIKE ‘Miss%’ BETWEEN <value1> AND <value2> Selects a record if it has a value greater than or equal to <value1> and less than or equal to <value2>. For example, this expression selects all records with an HHSIZE value greater than or equal to 3 and less than or equal to 10: HHSIZE BETWEEN 3 AND 10 The above is equivalent to: HHSIZE >= 3 AND HHSIZE <= 10 This operator applies to numeric or date fields. Here is an example of a date query on the field ObsDate: ObsDate BETWEEN ‘1998-04-30 00:00:00’ AND ‘1998-04-30 23:59:59’ Time is optional. NOT BETWEEN <value1> AND <value2> Selects a record if it has a value outside the range between <value1> and less than or equal to <value2>. For example, this expression selects all records whose HHSIZE value is less than 5 and greater than 7. HHSIZE NOT BETWEEN 5 AND 7 The above is equivalent to: HHSIZE < 5 OR HHSIZE > 7 This operator applies to numeric or date fields. Note You can use the contains relationship with points and lines. For example, you have a layer of street centerlines (lines) and a layer of manhole covers (points), and you want to find streets that contain a manhole cover. You could use contains to find streets that contain manhole covers, but in order for a line to contain a point, the point must be exactly on the line (that is, in GIS terms, they are snapped to each other). If there is any doubt about this, use the withinDistance relationship with a suitable distance value. Example spatial expression: { “operator”: “and”, “layer”: 0, “spatialRel”: “withinDistance”, “selectingLayer”: 1, “distance”: 10, “units”: “miles” } Note operator can be either and or or layer is the index of the layer in the input_layers parameter. The result of the expression is features in this layer. spatialRel is the spatial relationship. There are nine spatial relationships. distance is the distance to use for the withinDistance and notWithinDistance spatial relationship. units is the units for distance. Units choice list: [‘Meters’, ‘Kilometers’, ‘Feet’, ‘Yards’, ‘Miles’] An expression may be a list, which denotes a group. The first operator in the group indicates how the group expression is added to the previous expression. Grouping expressions is only necessary when you need to create two or more distinct sets of features from the same layer. One way to think of grouping is that without grouping, you would have to execute find_existing_locations multiple times and merge the results.
output_name	Optional string or FeatureLayer . Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For find_existing_locations, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional. The GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

FeatureLayer if output_name is specified, else FeatureCollection.

#USAGE EXAMPLE: To find busy (where SEGMENT_TY is 1 and where ARTERIAL_C is 1) streets from the existing seattle streets layer.

arterial_streets = find_existing_locations(input_layers=[bike_route_streets],
                                           expressions=[{"operator":"","layer":0,"where":"SEGMENT_TY = 1"},
                                           {"operator":"and","layer":0,"where":"ARTERIAL_C = 1"}],
                                           output_name='ArterialStreets')

arcgis.find_hot_spots(analysis_layer, analysis_field=None, divided_by_field=None, bounding_polygon_layer=None, aggregation_polygon_layer=None, output_name=None, context=None, gis=None, estimate=False, shape_type=None, cell_size=None, cell_size_unit=None, distance_band=None, distance_band_unit=None, future=False)

The find_hot_spots method analyzes point data (such as crime incidents, traffic accidents, or trees) or field values associated with points or area features (such as the number of people in each census tract or the total sales for retail stores). It finds statistically significant spatial clusters of high values (hot spots) and low values (cold spots). For point data when no field is specified, hot spots are locations with lots of points and cold spots are locations with very few points.

The result map layer shows hot spots in red and cold spots in blue. The darkest red features indicate the strongest clustering of high values or point densities; you can be 99 percent confident that the clustering associated with these features could not be the result of random chance. Similarly, the darkest blue features are associated with the strongest spatial clustering of low values or the lowest point densities. Features that are beige are not part of a statistically significant cluster; the spatial pattern associated with these features could very likely be the result of random processes and random chance.

Parameter	Description
analysis_layer	Required layer. The point or polygon feature layer for which hot spots will be calculated. See Feature Input.
analysis_field	Optional string. Required if the analysis_layer contains polygons. The numeric field that will be analyzed. The field you select might represent: counts (such as the number of traffic accidents) rates (such as the number of crimes per square mile) averages (such as the mean math test score) indices (such as a customer satisfaction score) If an analysis_field is not supplied, hot spot results are based on point densities only.
divided_by_field	Optional string. The numeric field in the analysis_layer that will be used to normalize your data. For example, if your points represent crimes, dividing by total population would result in an analysis of crimes per capita rather than raw crime counts. You can use esriPopulation to geoenrich each area feature with the most recent population values, which will then be used as the attribute to divide by. This option will use credits.
bounding_polygon_layer	Optional layer. When the analysis layer is points and no analysis_field is specified, you can provide polygons features that define where incidents could have occurred. For example, if you are analyzing boating accidents in a harbor, the outline of the harbor might provide a good boundary for where accidents could occur. When no bounding areas are provided, only locations with at least one point will be included in the analysis. See Feature Input.
aggregation_polygon_layer	Optional layer. When the analysis_layer contains points and no analysis_field is specified, you can provide polygon features into which the points will be aggregated and analyzed, such as administrative units. The number of points that fall within each polygon are counted, and the point count in each polygon is analyzed. See Feature Input.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For find_hot_spots, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online and ArcGIS Enterprise 11.1+. # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional Boolean. Is true, the number of credits needed to run the operation will be returned as a float.
shape_type	Optional string. The shape of the polygon mesh the input features will be aggregated into. Fishnet-The input features will be aggregated into a grid of square (fishnet) cells. Hexagon-The input features will be aggregated into a grid of hexagonal cells.
cell_size	Optional float. The size of the grid cells used to aggregate your features. When aggregating into a hexagon grid, this distance is used as the height to construct the hexagon polygons.
cell_size_unit	Optional string. The units of the cell_size value. You must provide a value if cell_size has been set. Choice list: [‘Meters’, ‘Miles’, ‘Feet’, ‘Kilometers’]
distance_band	Optional float. The spatial extent of the analysis neighborhood. This value determines which features are analyzed together in order to assess local clustering.
distance_band_unit	Optional string. The units of the distance_band value. You must provide a value if distance_band has been set.
future	Optional, If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

FeatureLayer if output_name is specified, else a dictionary with a FeatureCollection and processing messages.

If future = True, then the result is a Future object. Call result() to get the response.

USAGE EXAMPLE: To find significant hot ot cold spots of collisions involving a bicycle within a specific boundary.
collision_hot_spots = find_hot_spots(collisions,
                                     bounding_polygon_layer=boundry_lyr,
                                     output_name='collision_hexagon_hot_spots',
                                     shape_type='hexagon')

arcgis.find_nearest(analysis_layer, near_layer, measurement_type='StraightLine', max_count=100, search_cutoff=2147483647, search_cutoff_units=None, time_of_day=None, time_zone_for_time_of_day='GeoLocal', output_name=None, context=None, gis=None, estimate=False, include_route_layers=None, point_barrier_layer=None, line_barrier_layer=None, polygon_barrier_layer=None, future=False)

The find_nearest method measures the straight-line distance, driving distance, or driving time from features in the analysis layer to features in the near layer, and copies the nearest features in the near layer to a new layer. Connecting lines showing the measured path are returned as well. find_nearest also reports the measurement and relative rank of each nearest feature. There are options to limit the number of nearest features to find or the search range in which to find them. The results from this method can help you answer the following kinds of questions:

• What is the nearest park from here?

• Which hospital can I reach in the shortest drive time? And how long would the trip take on a Tuesday at 5:30 p.m. during rush hour?

• What are the road distances between major European cities?

• Which of these patients reside within two miles of these chemical plants?

Find Nearest returns a layer containing the nearest features and a line layer that links the start locations to their nearest locations. The connecting line layer contains information about the start and nearest locations and the distances between.

Parameter	Description
analysis_layer	Required layer. The features from which the nearest locations are found. This layer can have point, line, or polygon features. See Feature Input.
near_layer	Required layer. The nearest features are chosen from this layer. This layer can have point, line, or polygon features. See Feature Input.
measurement_type	Required string. Specify the mode of transportation for the analysis. Choice list: [‘StraightLine’, ‘Driving Distance’, ‘Driving Time ‘, ‘Rural Driving Distance’, ‘Rural Driving Time’, ‘Trucking Distance’, ‘Trucking Time’, ‘Walking Distance’, ‘Walking Time’] The default is ‘StraightLine’.
max_count	Optional string. The maximum number of nearest locations to find for each feature in analysis_layer. The default is the maximum cutoff allowed by the service, which is 100. Note that setting a maxCount for this parameter doesn’t guarantee that many features will be found. The search_cutoff and other constraints may also reduce the number of features found.
search_cutoff	Optional float. The maximum range to search for nearest locations from each feature in the analysis_layer. The units for this parameter is always minutes when measurement_type is set to a time based travel mode; otherwise the units are set in the search_cutoff_units parameter. The default is to search without bounds.
search_cutoff_units	The units of the search_cutoff parameter. This parameter is ignored when measurement_type is set to a time based travel mode because the units for search_cutoff are always minutes in those cases. If measurement_type is set to StraightLine or another distance-based travel mode, and a value for search_cutoff is specified, set the cutoff units using this parameter. Choice list: [‘Kilometers’, ‘Meters’, ‘Miles’, ‘Feet’, ‘’] The default value is null, which causes the service to choose either miles or kilometers according to the units property of the user making the request.
time_of_day	Optional datetime.datetime. Specify whether travel times should consider traffic conditions. To use traffic in the analysis, set measurement_type to a travel mode object whose impedance_attribute_name property is set to travel_time and assign a value to time_of_day. (A travel mode with other impedance_attribute_name values don’t support traffic.) The time_of_day value represents the time at which travel begins, or departs, from the origin points. The time is specified as datetime.datetime. The service supports two kinds of traffic: typical and live. Typical traffic references travel speeds that are made up of historical averages for each five-minute interval spanning a week. Live traffic retrieves speeds from a traffic feed that processes phone probe records, sensors, and other data sources to record actual travel speeds and predict speeds for the near future. The data coverage page shows the countries Esri currently provides traffic data for. Typical Traffic: To ensure the task uses typical traffic in locations where it is available, choose a time and day of the week, and then convert the day of the week to one of the following dates from 1990: Monday - 1/1/1990 Tuesday - 1/2/1990 Wednesday - 1/3/1990 Thursday - 1/4/1990 Friday - 1/5/1990 Saturday - 1/6/1990 Sunday - 1/7/1990 Set the time and date as datetime.datetime. For example, to solve for 1:03 p.m. on Thursdays, set the time and date to 1:03 p.m., 4 January 1990; and convert to datetime eg. datetime.datetime(1990, 1, 4, 1, 3). Live Traffic: To use live traffic when and where it is available, choose a time and date and convert to datetime. Esri saves live traffic data for 4 hours and references predictive data extending 4 hours into the future. If the time and date you specify for this parameter is outside the 24-hour time window, or the travel time in the analysis continues past the predictive data window, the task falls back to typical traffic speeds. Examples: from datetime import datetime “time_of_day”: datetime(1990, 1, 4, 1, 3) # 13:03, 4 January 1990. Typical traffic on Thursdays at 1:03 p.m. “time_of_day”: datetime(1990, 1, 7, 17, 0) # 17:00, 7 January 1990. Typical traffic on Sundays at 5:00 p.m. “time_of_day”: datetime(2014, 10, 22, 8, 0) # 8:00, 22 October 2014. If the current time is between 8:00 p.m., 21 Oct. 2014 and 8:00 p.m., 22 Oct. 2014, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced. “time_of_day”: datetime(2015, 3, 18, 10, 20) # 10:20, 18 March 2015. If the current time is between 10:20 p.m., 17 Mar. 2015 and 10:20 p.m., 18 Mar. 2015, live traffic speeds are referenced in the analysis; otherwise, typical traffic speeds are referenced.
time_zone_for_time_of_day	Optional string. Specify the time zone or zones of the time_of_day parameter. Choice list: [‘GeoLocal’, ‘UTC’] GeoLocal-refers to the time zone in which the origins_layer points are located. UTC-refers to Coordinated Universal Time.
include_route_layers	Optional boolean. When include_route_layers is set to True, each route from the result is also saved as a route layer item. A route layer includes all the information for a particular route such as the stops assigned to the route as well as the travel directions. Creating route layers is useful if you want to share individual routes with other members in your organization. The route layers use the output feature service name provided in the output_name parameter as a prefix and the route name generated as part of the analysis is added to create a unique name for each route layer. Caution: Route layers cannot be created when the output is a feature collection. The task will raise an error if output_name is not specified (which indicates feature collection output) and include_route_layers is True. The maximum number of route layers that can be created is 1,000. If the result contains more than 1,000 routes and include_route_layers is True, the task will only create the output feature service.
point_barrier_layer	Optional layer. Specify one or more point features that act as temporary restrictions (in other words, barriers) when traveling on the underlying streets. A point barrier can model a fallen tree, an accident, a downed electrical line, or anything that completely blocks traffic at a specific position along the street. Travel is permitted on the street but not through the barrier.
line_barrier_layer	Optional layer. Specify one or more line features that prohibit travel anywhere the lines intersect the streets. A line barrier prohibits travel anywhere the barrier intersects the streets. For example, a parade or protest that blocks traffic across several street segments can be modeled with a line barrier.
polygon_barrier_layer	Optional layer. Specify one or more polygon features that completely restrict travel on the streets intersected by the polygons. One use of this type of barrier is to model floods covering areas of the street network and making road travel there impossible.
output_name	Optional string or FeatureLayer. Existing feature layer will cause the new layer to be appended to the Feature Service. If overwrite is True in context, new layer will overwrite existing layer. If output_name not indicated then new FeatureCollection created.
context	Optional dict. Additional settings such as processing extent and output spatial reference. For find_nearest, there are three settings. extent - a bounding box that defines the analysis area. Only those features in the input_layer that intersect the bounding box will be analyzed. outSR - the output features will be projected into the output spatial reference referred to by the wkid. overwrite - if True, then the feature layer in output_name will be overwritten with new feature layer. Available for ArcGIS Online or Enterprise 10.9.1+ # Example Usage context = {"extent": {"xmin": 3164569.408035, "ymin": -9187921.892449, "xmax": 3174104.927313, "ymax": -9175500.875353, "spatialReference":{"wkid":102100,"latestWkid":3857}}, "outSR": {"wkid": 3857}, "overwrite": True}
gis	Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
estimate	Optional boolean. If True, the estimated number of credits required to run the operation will be returned.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.

Returns:

A dictionary with the following keys:

”nearest_layer” : layer (FeatureCollection)

”connecting_lines_layer” : layer (FeatureCollection)

#USAGE EXAMPLE: To find which regional office can be reached in the shortest drive time from esri headquarter.

result1 = find_nearest(analysis_layer=esri_hq_lyr,
                       near_layer=regional_offices_lyr,
                       measurement_type="Driving Time",
                       output_name="find nearest office",
                       include_route_layers=True,
                       point_barrier_layer=road_closures_lyr))