{ "info": { "author": "Caleb Mackey", "author_email": "calebma@bolton-menk.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: GNU General Public License v2 (GPLv2)", "Natural Language :: English", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Topic :: Scientific/Engineering :: GIS" ], "description": "# restapi\nThis is a Python API for working with ArcGIS REST API, ArcGIS Online, and Portal/ArcGIS Enterprise. This package has been designed to work with [arcpy](https://pro.arcgis.com/en/pro-app/arcpy/get-started/what-is-arcpy-.htm) when available, or the included open source module [pyshp](https://pypi.org/project/pyshp/). It will try to use arcpy if available for some data conversions, otherwise will use open source options. Also included is a subpackage for administering ArcGIS Server Sites. This is updated often, so continue checking here for new functionality!\n\n### Why would you use this package?\nEsri currently provides the [ArcGIS API for Python](https://developers.arcgis.com/python/) which provides complete bindings to the ArcGIS REST API. This package has less coverage of the REST API, but has many convience functions not available in the ArcGIS API for Python and has a strong focus on downloading and querying data. This package will also support older versions of Python (i.e. 2.7.x) whereas Esri's package only supports 3.x.\n\n## Release History\n[Release History](ReleaseNotes.md)\n\n## Installation\n`restapi` is supported on Python 2.7 and 3.x. It can be found on [Github](https://github.com/Bolton-and-Menk-GIS/restapi) and [PyPi](https://pypi.org/project/bmi-arcgis-restapi/). To install using pip: \n\n````sh\npip install bmi-arcgis-restapi\n````\n\nAfter installation, it should be available to use in Python: \n````py\nimport restapi\n````\n\n## A note about `arcpy`\nBy default, `restapi` will import Esri's `arcpy` module if available. However, this module is not required to use this package. `arcpy` is only used when available to write data to disk in esri specific formats (file geodatabase, etc) and working with `arcpy` Geometries. When `arcpy` is not availalbe, the [pyshp](https://pypi.org/project/pyshp/) module is used to write data (shapefile format only) and work with `shapefile.Shape` objects (geometry). Also worth noting is that open source version is much faster than using `arcpy`.\n\nThat being said, there may be times when you want to force `restapi` to use the open source version, even when you have access to `arcpy`. Some example scenarios being when you don't need to write any data in an Esri specific format, you want the script to execute very fast, or you are working in an environment where `arcpy` may not play very nicely ([Flask](https://palletsprojects.com/p/flask/), [Django](https://www.djangoproject.com/), etc.). To force `restapi` to use the open source version, you can simply create an environment variable called `RESTAPI_USE_ARCPY` and set it to `FALSE` or `0`. This variable will be checked before attempting to import `arcpy`.\n\nHere is an example on how to force open source at runtime:\n\n```py\nimport os\nos.environ['RESTAPI_USE_ARCPY'] = 'FALSE'\n\n# now import restapi\nimport restapi\n```\n\n## requests.exceptions.SSLError\nIf you are seeing `requests.exceptions.SSLError` exceptions in `restapi` >= 2.0, this is probaly due to a change in handling servers without valid SSL certificates. Because many ArcGIS Server instances are accessed using SSL with a self-signed certificate, or through a MITM proxy like Fiddler, `restapi` < 2.0 defaulted to ignoring SSL errors by setting the `request` client's `verify` option to `False`. The new default behavior is to enable certificate verification. If you are receiving this error, you are probably accessing your server with a self-signed certificate, or through a MITM proxy. If that is not the case, you should investigate why you are seeing SSL errors, as there would likely be an issue with the server configuration, or some other security issues.\n\nTo mimic the previous behavior in the newer versions of `restapi`, there are 2 options - disable certificate verification (less secure), or [build a custom CA bundle ](https://requests.readthedocs.io/en/stable/user/advanced/#ssl-cert-verification) which includes any self-signed certificates needed to access your server (more secure). Both of these can be done using the new [restapi.RequestClient()](#requestclient) feature.\n\n````py\nimport restapi\nimport requests\nsession = requests.Session()\nclient = restapi.RequestClient(session)\nrestapi.set_request_client(client)\n\n# Disable verification\nclient.session.verify = False\n\n# -or-\n\n# Use custom CA bundle\nclient.session.verify = '/path/to/certfile'\n````\nSince `verify = False` is a commonly used setting when dealing with ArcGIS Server instances, it's also possible to use an environment variable. The variable must be set before `restapi` is imported.\n````py\nos.environ['RESTAPI_VERIFY_CERT'] = 'FALSE'\nimport restapi\n````\n\n\n## Connecting to an ArcGIS Server\n\n> samples for this section can be found in the [connecting_to_arcgis_server.py](./restapi/samples/connecting_to_arcgis_server.py) file.\n> \nOne of the first things you might do is to connect to a services directory (or catalog):\n\n\n````py\nimport restapi\n\n# connect to esri's sample server 6\nrest_url = 'https://sampleserver6.arcgisonline.com/arcgis/rest/services'\n\n# connect to restapi.ArcServer instance \nags = restapi.ArcServer(rest_url)\n````\n\n\n```py\n>>> # get folder and service properties\n>>> print('Number of folders: {}'.format(len(ags.folders)))\n>>> print('Number of services: {}\\n'.format(len(ags.services)))\n>>> \n>>> # walk thru directories\n>>> for root, services in ags.walk():\n>>> print('Folder: {}'.format(root))\n>>> print('Services: {}\\n'.format(services))\n\nNumber of folders: 13\nNumber of services: 60\n\nFolder: None\nServices: ['911CallsHotspot/GPServer', '911CallsHotspot/MapServer', 'Census/MapServer', 'CharlotteLAS/ImageServer', 'CommercialDamageAssessment/FeatureServer', 'CommercialDamageAssessment/MapServer', 'CommunityAddressing/FeatureServer', 'CommunityAddressing/MapServer', '<...>', 'Water_Network/MapServer', 'Wildfire/FeatureServer', 'Wildfire/MapServer', 'WindTurbines/MapServer', 'World_Street_Map/MapServer', 'WorldTimeZones/MapServer']\n\nFolder: AGP\nServices: ['AGP/Census/MapServer', 'AGP/Hurricanes/MapServer', 'AGP/USA/MapServer', 'AGP/WindTurbines/MapServer']\n\nFolder: Elevation\nServices: ['Elevation/earthquakedemoelevation/ImageServer', 'Elevation/ESRI_Elevation_World/GPServer', 'Elevation/GlacierBay/MapServer', 'Elevation/MtBaldy_Elevation/ImageServer', 'Elevation/WorldElevations/MapServer']\n\n# ..etc\n```\n\n#### Connecting to a child service\n\nfrom an `ArcServer` instance, you can connect to any service within that instance by providing a child path or wildcard search match.\n\n````py\n# connect to a specific service\n# using just the service name (at the root)\nusa = ags.getService('USA') #/USA/MapServer -> restapi.common_types.MapService\n\n# using the relative path to a service in a folder\ncensus = ags.getService('AGP/Census') #/AGP/Census/MapServer -> restapi.common_types.MapService\n\n# can also just use the service name, but be weary of possible duplicates\ninfastructure = ags.getService('Infrastructure') #/Energy/Infrastructure/FeatureServer -> restapi.common_types.FeatureService\n\n# using a wildcard search\ncovid_cases = ags.getService('*Covid19Cases*') #/NYTimes_Covid19Cases_USCounties/MapServer -> restapi.common_types.MapService\n````\n\ncheck outputs:\n\n```py\n>>> for service in [usa, census, infastructure, covid_cases]:\n>>> print('name: \"{}\"'.format(service.name))\n>>> print('repr: \"{}\"'.format(repr(service)))\n>>> print('url: {}\\n'.format(service.url))\n\nname: \"USA\"\nrepr: \"\"\nurl: https://sampleserver6.arcgisonline.com/arcgis/rest/services/USA/MapServer\n\nname: \"Census\"\nrepr: \"\"\nurl: https://sampleserver6.arcgisonline.com/arcgis/rest/services/AGP/Census/MapServer\n\nname: \"Infrastructure\"\nrepr: \"\"\nurl: https://sampleserver6.arcgisonline.com/arcgis/rest/services/Energy/Infrastructure/FeatureServer\n\nname: \"NYTimes_Covid19Cases_USCounties\"\nrepr: \"\"\nurl: https://sampleserver6.arcgisonline.com/arcgis/rest/services/NYTimes_Covid19Cases_USCounties/MapServer\n```\n\n### Working with layers \n\n> samples for this section can be found in the [working_with_layers.py](./restapi/samples/working_with_layers.py) file.\n\nYou can connect to `MapServiceLayer`s or `FeatureLayer`s directly by passing the url, or by accessing from the parent `FeatureService` or `MapService`.\n\n\nalso query the layer and get back arcpy.da Cursor like access\n\n```py\n# get access to the \"Cities\" layer from USA Map Service\ncities = usa.layer('Cities') # or can use layer id: usa.layer(0)\n\n# query the map layer for all cities in California with population > 100000\nwhere = \"st = 'CA' and pop2000 > 100000\"\n\n# the query operation returns a restapi.FeatureSet or restapi.FeatureCollection depending on the return format\nfeatureSet = cities.query(where=where)\n\n# get result count, can also use len(featureSet)\nprint('Found {} cities in California with Population > 100K'.format(featureSet.count))\n\n# print first feature (restapi.Feature). The __str__ method is pretty printed JSON\n# can use an index to fetch via its __getitem__ method\nprint(featureSet[0])\n```\n\n#### exceeding the `maxRecordCount`\nIn many cases, you may run into issues due to the `maxRecordCount` set for a service, which by default is `1000` features. This limit can be exceeded by using the `exceed_limit` parameter. If `exceed_limit` is set to `True`, the `query_in_chunks` method will be called internally to keep fetching until all queried features are returned.\n\n```py\n# fetch first 1000\nfirst1000 = cities.query()\nprint('count without exceed_limit: {}'.format(first1000.count)) # can also use len()\n\n# fetch all by exceeding limit\nallCities = cities.query(exceed_limit=True)\nprint('count without exceed_limit: {}'.format(len(allCities)))\n```\n\ncheck outputs:\n\n```py\nFound 57 cities in California with Population > 100K\n{\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Point\",\n \"coordinates\": [\n -117.88976896399998,\n 33.836165033999976\n ]\n },\n \"properties\": {\n \"areaname\": \"Anaheim\"\n }\n}\ncount without exceed_limit: 1000\ntotal records: 3557\ncount with exceed_limit: 3557\n```\n\n#### using a search cursor\n\nA query can also be done by using a search cursor, which behaves very similarly to the [arcpy.da.SearchCursor](https://pro.arcgis.com/en/pro-app/latest/arcpy/data-access/searchcursor-class.htm). While the `restapi.Cursor` does support usage of a `with` statement, it is not necessary as there is no file on disk that is opened. When using the `cursor()` method on a `MapServiceLayer` or `FeatureLayer` it will actually make a call to the ArcGIS Server and will return a tuple of values based on the `fields` requested. The default `fields` value is `*`, which will return all fields. Like the arcpy cursors, the `SHAPE@` token can be used to fetch geometry, while the `OID@` token will fetch the object id.\n\n```py\n# if you don't want the json/FeatureSet representation, you can use restapi cursors\n# for the query which are similar to the arcpy.da cursors. The `SearchCursor` will return a tuple\ncursor = restapi.SearchCursor(cities, fields=['areaname', 'pop2000', 'SHAPE@'], where=where)\nfor row in cursor:\n print(row)\n````\n\ncheck outputs:\n```py\n('Anaheim', 328014, )\n('Bakersfield', 247057, )\n('Berkeley', 102743, )\n('Burbank', 100316, )\n('Chula Vista', 173556, )\n('Concord', 121780, )\n('Corona', 124966, )\n# ... etc\n```\n\nalso supports `with` statements:\n\n```py\nwith restapi.SearchCursor(cities, fields=['areaname', 'pop2000', 'SHAPE@'], where=where) as cursor:\n for row in cursor:\n print(row)\n```\n\nIn the above examples, when the `SearchCursor` is instantiated, it actually kicked off a new query for the cursor results. If you already have a `FeatureSet` or `FeatureCollection` like we did above, you can also save a network call by constructing the `restapi.Cursor` from the feature set by doing:\n\n```py\nfeatureSet = cities.query(where=where)\n\n# can pass in fields as second argument to limit results\ncursor = restapi.Cursor(featureSet, ['areaname', 'pop2000', 'SHAPE@'])\n```\n\n> note: Both the `MapServiceLayer` and `FeatureLayer` also have a `searchCursor()` convenience method, which will allow you to use the same functionality as shown above but without passing in the layer itself: \n> `rows = cities.searchCursor(['areaname', 'pop2000', 'SHAPE@'])`\n#### exporting features from a layer\n\nData can also be easily exported from a `FeatureLayer` or `MapServicelayer`. This can be done by exporting a feature set directly or from the layer itself:\n\n```py\n# set output folder\nout_folder = os.path.join(os.path.expanduser('~'), 'Documents', 'restapi_samples')\n\n# create output folder if it doesn't exist\nif not os.path.exists(out_folder):\n os.makedirs(out_folder)\n\n# output shapefile\nshp = os.path.join(out_folder, 'CA_Cities_100K.shp')\n\n# export layer from map service\ncities.export_layer(shp, where=where)\n```\n\nYou can also export a feature set directly if you already have one loaded:\n```py\nrestapi.exportFeatureSet(featureSet, shp)\n```\n\nexporting layers or feature sets also supports a `fields` filter, where you can limit which fields are exported. Other options are supported as well such as an output spatial reference. One important thing to note, if you do not have access to `arcpy`, you can only export to shapefile format. If you do have `arcpy`, any output format supported by esri will work. If the output is a [geodatabase feature class](https://desktop.arcgis.com/en/arcmap/latest/manage-data/feature-classes/a-quick-tour-of-feature-classes.htm), you can also choose to include things like [domains](https://desktop.arcgis.com/en/arcmap/latest/manage-data/geodatabases/an-overview-of-attribute-domains.htm) if applicable.\n\n```py\n# exporting features \nout_folder = os.path.join(os.path.expanduser('~'), 'Documents', 'restapi_samples')\nif not os.path.exists(out_folder):\n os.makedirs(out_folder)\nshp = os.path.join(out_folder, 'CA_Cities_100K.shp')\n\n# export layer to a shapefile\ncities.export_layer(shp, where=where)\n\n# if there is an existing feature set, you can also export that directly\n# restapi.exportFeatureSet(featureSet, shp)\n```\n\n### selecting features by geometry\nBoth the `MapServiceLayer` and `FeatureLayer` support arcgis spatial selections using [arcgis geometry](https://developers.arcgis.com/documentation/common-data-types/geometry-objects.htm) objects. The `select_layer_by_location` method will return a `FeatureSet` or `FeatureCollection`, while the `clip` method will actually export the spatial selection to a shapffile or Feature Class (latter only available with `arcpy`).\n\n#### the `geometry-helper` application\nThis package now includes a [geometry-helper](geometry-helper/README.md) application that can be used to quickly create geometries and copy the geometry in either `esri-json` or `geojson` format to form geometry necessary to make queries:\n\n![geometry-helper app](docs/images/geometry-helper.png)\n\nto open this application in a web browser, simply call:\n\n```py\nrestapi.open_geometry_helper()\n```\n\n#### select by location\nto select a layer by location, first create a geometry object as json (can be esri or geojson format) and make the selection:\n\n```py\n# select layer by location\nuniversities_url = 'https://services1.arcgis.com/Hp6G80Pky0om7QvQ/arcgis/rest/services/Colleges_and_Universities/FeatureServer/0'\n\n# get feature layer\nuniversities = restapi.FeatureLayer(universities_url)\nprint('universities: ', repr(universities))\n\n# form geometry (do not have to cast to restapi.Geometry, this will happen under the hood automatically)\ngeometry = restapi.Geometry({\n \"spatialReference\": {\n \"latestWkid\": 3857,\n \"wkid\": 102100\n },\n \"rings\": [\n [\n [\n -10423340.4579098,\n 5654465.8453829475\n ],\n [\n -10324889.565478457,\n 5654465.8453829475\n ],\n [\n -10324889.565478457,\n 5584449.527473665\n ],\n [\n -10423340.4579098,\n 5584449.527473665\n ],\n [\n -10423340.4579098,\n 5654465.8453829475\n ]\n ]\n ]\n})\n\n# make selection\nfeatureCollection = universities.select_by_location(geometry)\nprint('Number of Universities in Twin Cities area: {}'.format(featureCollection.count))\n\n# can also export the feature collection directly or call the clip() method (makes a new call to server)\nuniversities_shp = os.path.join(out_folder, 'TwinCities_Univiersities.shp')\nuniversities.clip(geometry, universities_shp)\n```\n\ncheck outputs:\n```py\nuniversities: \ntotal records: 50\nNumber of Universities in Twin Cities area: 50\ntotal records: 50\nCreated: \"L:\\Users\\calebma\\Documents\\restapi_samples\\TwinCities_Univiersities.shp\"\nFetched all records\n```\n\n## FeatureLayer Editing\n\n> samples for this section can be found in the [feature_layer_editing.py](./restapi/samples/feature_layer_editing.py) file.\n\n\nThis package also includes comprehensive support for working with [FeatureLayers](https://enterprise.arcgis.com/en/portal/latest/use/feature-layers.htm). These are editable layers hosted by an ArcGIS Server, Portal, or ArcGIS Online. A `FeatureLayer` is an extension of the `MapServiceLayer` that supports editing options.\n\n#### add features using `FeatureLayer.addFeatures()`\n```py\n# connect to esri's Charlotte Hazards Sample Feature Layer for incidents\nurl = 'https://services.arcgis.com/V6ZHFr6zdgNZuVG0/ArcGIS/rest/services/Hazards_Uptown_Charlotte/FeatureServer/0'\n\n# instantiate a FeatureLayer\nhazards = restapi.FeatureLayer(url)\n\n# create a new feature as json\nfeature = {\n \"attributes\" : { \n \"HazardType\" : \"Road Not Passable\", \n \"Description\" : \"restapi test\", \n \"SpecialInstructions\" : \"Contact Dispatch\", \n \"Priority\" : \"High\",\n \"Status\": \"Active\"\n }, \n \"geometry\": create_random_coordinates()\n}\n\n# add json feature\nadds = hazards.addFeatures([ feature ])\nprint(adds)\n```\ncheck outputs:\n```py\nAdded 1 feature(s)\n{\n \"addResults\": [\n {\n \"globalId\": \"8B643546-7253-4F0B-80DE-2DE8F1754C03\",\n \"objectId\": 11858,\n \"success\": true,\n \"uniqueId\": 11858\n }\n ]\n}\n```\n\n#### add an attachment\n```py\n# add attachment to new feature using the OBJECTID of the new feature\noid = adds.addResults[0].objectId\nimage = os.path.join(os.path.abspath('...'), 'docs', 'images', 'geometry-helper.png')\nattRes = hazards.addAttachment(oid, image)\nprint(attRes)\n\n# now query attachments for new feature\nattachments = hazards.attachments(oid)\nprint(attachments)\n```\ncheck outputs:\n```py\nAdded attachment '211' for feature objectId\n{\n \"addAttachmentResult\": {\n \"globalId\": \"f370a4e0-3976-4809-b0d5-f5d1b5990b4b\",\n \"objectId\": 211,\n \"success\": true\n }\n}\n[]\n```\n\n#### update features \n```py\n# update the feature we just added, payload only has to include OBJECTID and any fields to update\nupdatePayload = [\n { \n \"attributes\": { \n \"OBJECTID\": r.objectId, \n \"Description\": \"restapi update\" \n } \n } for r in adds.addResults\n]\nupdates = hazards.updateFeatures(updatePayload)\nprint(updates)\n```\n\ncheck outputs:\n\n```py\nUpdated 1 feature(s)\n{\n \"updateResults\": [\n {\n \"globalId\": null,\n \"objectId\": 11858,\n \"success\": true,\n \"uniqueId\": 11858\n }\n ]\n}\n```\n\n#### delete features\n\n```py\n# delete features by passing in a list of objectIds\ndeletePayload = [r.objectId for r in updates.updateResults]\ndeletes = hazards.deleteFeatures(deletePayload)\nprint(deletes)\n```\n\ncheck outputs:\n```py\nDeleted 1 feature(s)\n{\n \"deleteResults\": [\n {\n \"globalId\": null,\n \"objectId\": 11858,\n \"success\": true,\n \"uniqueId\": 11858\n }\n ]\n}\n```\n\n### feature editing with `restapi` cursors\n\n`restapi` also supports cursors similar to what you get when using `arcpy`. However, these work directly with the REST API and JSON features while also supporting `arcpy` and `shapefile` geometry types. See the below example on how to use an `insertCursor` to add new records:\n\n#### adding features with an `InsertCursor`\n\nNew records can be added using an `InsertCursor`. This can be instantiated using the `InsertCursor` class itself, or by calling the `insertCursor` method of a `FeatureLayer`. When called as `FeatureLayer.insertCursor`, the layer itself will not need to be passed in.\n\n```py\n>>> # add 5 new features using an insert cursor \n>>> # using this in a \"with\" statement will call applyEdits on __exit__\n>>> fields = [\"SHAPE@\", 'HazardType', \"Description\", \"Priority\"]\n>>> with restapi.InsertCursor(hazards, fields) as irows:\n for i in list(range(1,6)):\n desc = \"restapi insert cursor feature {}\".format(i)\n irows.insertRow([create_random_coordinates(), \"Wire Down\", desc, \"High\"])\n\nAdded 5 feature(s)\n```\nAny time an insert or update cursor will save changes, it will print a short message showing how many features were affected. You can always get at the raw edit information from the `FeatureLayer` by calling the `editResults` property. This will be an array that stores the results of every `applyEdits` operation, so the length will reflect how many times edits have been saved. \n\n```py\n>>> # we can always view the results by calling FeatureLayer.editResults which stores\n>>> # an array of edit results for each time applyEdits() is called.\n>>> print(hazards.editResults)\n[{\n \"addResults\": [\n {\n \"globalId\": \"2774C9ED-D8F8-4B71-9F37-B26B40790710\",\n \"objectId\": 12093,\n \"success\": true,\n \"uniqueId\": 12093\n },\n {\n \"globalId\": \"18411060-F6FF-49FB-AD91-54DB65C13D06\",\n \"objectId\": 12094,\n \"success\": true,\n \"uniqueId\": 12094\n },\n {\n \"globalId\": \"8045C840-F1B9-4BD2-AEDC-72F4D65EB7A6\",\n \"objectId\": 12095,\n \"success\": true,\n \"uniqueId\": 12095\n },\n {\n \"globalId\": \"EC9DB6FC-0D34-4B83-8C98-398C7B48666D\",\n \"objectId\": 12096,\n \"success\": true,\n \"uniqueId\": 12096\n },\n {\n \"globalId\": \"C709033F-DF3B-43B3-8148-2299E7CEE986\",\n \"objectId\": 12097,\n \"success\": true,\n \"uniqueId\": 12097\n }\n ],\n \"deleteResults\": [],\n \"updateResults\": []\n}]\n```\n\n> note: when using a `with` statement for the `InsertCursor` and `UpdateCursor` it will automatically call the `applyEdits()` method on `__exit__`, which is critical to submitting the new, deleted, or updated features to the server. If not using a `with` statement, you will need to call `applyEdits()` manually after changes have been made.\n\n\n#### updating features with an `UpdateCursor`\n\nrecords can be updated or deleted with an `updateCursor` and a where clause. Note that the `OBJECTID` field must be included in the query to indicate which records will be updated. The `OID@` field token can be used to retreive the `objectIdFieldName`:\n\n```py\n>>> # now update records with updateCursor for the records we just added. Can use the \n>>> # editResults property of the feature layer to get the oids of our added features\n>>> addedOids = ','.join(map(str, [r.objectId for r in hazards.editResults[0].addResults]))\n>>> whereClause = \"{} in ({})\".format(hazards.OIDFieldName, addedOids)\n>>> with restapi.UpdateCursor(hazards, [\"Priority\", \"Description\", \"OID@\"], where=whereClause) as rows:\n for row in rows:\n if not row[2] % 2:\n # update rows with even OBJECTID's\n row[0] = \"Low\"\n rows.updateRow(row)\n else:\n # delete odd OBJECTID rows\n print('deleting row with odd objectid: ', row[2])\n rows.deleteRow(row)\n \nUpdated 2 feature(s)\nDeleted 3 feature(s) \n\n>>> # now delete the rest of the records we added\n>>> whereClause = \"Description like 'restapi%'\"\n>>> with restapi.UpdateCursor(hazards, [\"Description\", \"Priority\", \"OID@\"], where=whereClause) as rows:\n for row in rows:\n rows.deleteRow(row)\n irows.insertRow([create_random_coordinates(), \"Wire Down\", desc, \"High\"])\n\nDeleted 2 feature(s)\n```\n\n#### attachment editing\n\nOffline capabilities (Sync)\n\n````py\n# if sync were enabled, we could create a replica like this:\n# can pass in layer ID (0) or name ('incidents', not case sensative)\nreplica = fs.createReplica(0, 'test_replica', geometry=adds[0]['geometry'], geometryType='esriGeometryPoint', inSR=4326)\n\n# now export the replica object to file geodatabase (if arcpy access) or shapefile with hyperlinks (if open source)\nrestapi.exportReplica(replica, folder)\n````\n\nWorking with Image Services\n---------------------------\n\n````py\nurl = 'http://pca-gis02.pca.state.mn.us/arcgis/rest/services/Elevation/DEM_1m/ImageServer'\nim = restapi.ImageService(url)\n\n# clip DEM\ngeometry = {\"rings\":[[\n [240006.00808044084, 4954874.19629429],\n [240157.31010183255, 4954868.8053006204],\n [240154.85966611796, 4954800.0316874133],\n [240003.55764305394, 4954805.4226145679],\n [240006.00808044084, 4954874.19629429]]],\n \"spatialReference\":{\"wkid\":26915,\"latestWkid\":26915}}\n\ntif = os.path.join(folder, 'dem.tif')\nim.clip(geometry, tif)\n\n# test point identify\nx, y = 400994.780878, 157878.398217\nelevation = im.pointIdentify(x=x, y=y, sr=103793)\nprint(elevation)\n````\n\nGeocoding\n---------\n\n````py\n# hennepin county, MN geocoder\nhenn = 'http://gis.hennepin.us/arcgis/rest/services/Locators/HC_COMPOSITE/GeocodeServer'\ngeocoder = restapi.Geocoder(henn)\n# find target field, use the SingleLine address field by default\ngeoResult = geocoder.findAddressCandidates('353 N 5th St, Minneapolis, MN 55403')\n\n# export results to shapefile\nprint('found {} candidates'.format(len(geoResult))\ngeocoder.exportResults(geoResult, os.path.join(folder, 'target_field.shp'))\n\n# Esri geocoder\nesri_url = 'http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Locators/ESRI_Geocode_USA/GeocodeServer'\nesri_geocoder = restapi.Geocoder(esri_url)\n\n# find candidates using key word arguments (**kwargs) to fill in locator fields, no single line option\ncandidates = esri_geocoder.findAddressCandidates(Address='380 New York Street', City='Redlands', State='CA', Zip='92373')\nprint('Number of address candidates: {}'.format(len(candidates)))\nfor candidate in candidates:\n print(candidate.location)\n\n# export results to shapefile\nout_shp = os.path.join(folder, 'Esri_headquarters.shp')\ngeocoder.exportResults(candidates, out_shp)\n````\n\nGeoprocessing Services\n----------------------\n\n````py\n# test esri's drive time analysis GP Task\ngp_url = 'http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Network/ESRI_DriveTime_US/GPServer/CreateDriveTimePolygons'\ngp = restapi.GPTask(gp_url)\n\n# get a list of gp parameters (so we know what to pass in as kwargs)\nprint('\\nGP Task \"{}\" parameters:\\n'.format(gp.name)\nfor p in gp.parameters:\n print('\\t', p.name, p.dataType)\n\npoint = {\"geometryType\":\"esriGeometryPoint\",\n \"features\":[\n {\"geometry\":{\"x\":-10603050.16225853,\"y\":4715351.1473399615,\n \"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}}],\n \"sr\":{\"wkid\":102100,\"latestWkid\":3857}}\n\n# run task, passing in gp parameters as keyword arguments (**kwargs)\ngp_res = gp.run(Input_Location=str(point), Drive_Times = '1 2 3', inSR = 102100)\n\n# returns a GPResult() object, can get at the first result by indexing (usually only one result)\n# can test if there are results by __nonzero__()\nif gp_res:\n result = gp_res.results[0]\n \n # this returned a GPFeatureRecordSetLayer as an outputParameter, so we can export this to polygons\n print('\\nOutput Result: \"{}\", data type: {}\\n'.format(result.paramName, result.dataType))\n\n # now export the result value to fc (use the value property of the GPResult object from run())\n drive_times = os.path.join(folder, 'drive_times.shp')\n restapi.exportFeatureSet(drive_times, gp_res.value)\n````\n\nA note about input Geometries\n-----------------------------\n\nrestapi will try to use arcpy first if you have it, otherwise will defer to open source. Both\nsupport the reading of shapefiles to return the first feature back as a restapi.Geometry object\n\nIt also supports arcpy Geometries and shapefile.Shape() objects\n````py\n>>> shp = r'C:\\TEMP\\Polygons.shp' # a shapefile on disk somewhere\n>>> geom = restapi.Geometry(shp)\n>>> print(geom.envelope())\n-121.5,38.3000000007,-121.199999999,38.6000000015\n````\n\nToken Based Security\n--------------------\n\nrestapi also supports secured services. This is also session based, so if you sign in once to an\nArcGIS Server Resource (on the same ArcGIS Site), the token will automatically persist via the \nIdentityManager().\n\nThere are 3 ways to authticate:\n\n````py\n# **kwargs for all accessing all ArcGIS resources are\n# usr -- username\n# pw -- password\n# token -- token (as string or restapi.Token object)\n# proxy -- url to proxy\n\n# secured url\nsecured_url = 'http://some-domain.com/arcgis/rest/services'\n\n# 1. username and password\nags = restapi.ArcServer(url, 'username', 'password') # token is generated and persists\n\n# 2. a token that has already been requested\nags = restapi.ArcServer(url, token=token) # uses a token that is already active\n\n# 3. via a proxy (assuming using the standard esri proxy)\n# this will forward all subsequent requests through the proxy\nags = restapi.ArcServer(url, proxy='http://some-domain.com/proxy.ashx')\n````\n\nYou can even just generate a token and let the IdentityManager handle the rest. It is even smart enough to handle multiple tokens for different sites:\n\n```py\n# login to instance 1\nusr = 'username'\npw = 'password'\n\n# urls to two different ArcGIS Server sites\nurl_1 = 'http://some-domain.com/arcserver1/rest/services'\nurl_2 = 'http://domain2.com/arcgis/rest/services'\n\n# generate tokens\ntok1 = restapi.generate_token(url_1, usr, pw)\ntok2 = restapi.generate_token(url_2, usr, pw)\n\n# now we should be able to access both ArcGIS Server sites via the IdentityManager\narcserver1 = restapi.ArcServer(url_1) # tok1 is automatically passed in and handled\narcserver2 = restapi.ArcServer(url_2) # tok2 is used here\n```\n\nThe admin Subpackage\n--------------------\n\nrestapi also contains an administrative subpackage (warning: most functionality has not been tested!). You can import this module like this:\n\n```py\nfrom restapi import admin\n```\n\n\n### Connecting to a Portal\n```py\nurl = 'https://domain.gis.com/portal/home'\nportal = admin.Portal(url, 'username', 'password')\n\n# get servers\nservers = portal.servers\n\n# stop sample cities service\nserver = servers[0]\n\nservice = server.service('SampleWorldCities.MapServer')\nservice.stop()\n\n```\n\nTo connect to an ArcGIS Server instance that you would like to administer you can do the following:\n\n```py\n# test with your own servers\nurl = 'localhost:6080/arcgis/admin/services' #server url\nusr = 'username'\npw = 'password'\n\n# connect to ArcGIS Server instance\narcserver = admin.ArcServerAdmin(url, usr, pw)\n```\n\nTo list services within a folder, you can do this:\n\n```py\nfolder = arcserver.folder('SomeFolder') # supply name of folder as argument\nfor service in folder.iter_services():\n print(service.serviceName, service.configuredState\n\n # can stop a service like this\n # service.stop()\n\n # or start like this\n # service.start()\n\nprint('\\n' * 3)\n\n# show all services and configured state (use iter_services to return restapi.admin.Service() object!)\nfor service in arcserver.iter_services():\n print(service.serviceName, service.configuredState)\n```\nSecurity\n--------\n\nYou can set security at the folder or service level. By default, the addPermssion() method used by Folder and Service objects will make the service unavailable to the general public and only those in the administrator role can view the services. This is done by setting the 'esriEveryone' principal \"isAllowed\" value to false. You can also assign permissions based on roles.\n\n```py\narcserver.addPermission('SomeFolder') # by default it will make private True \n\n# now make it publically avaiable (unsecure)\narcserver.addPermission('SomeFolder', private=False)\n\n# secure based on role, in this case will not allow assessor group to see utility data\n# assessor is name of assessor group role, Watermain is folder to secure\narcserver.addPermission('Watermain', 'assessor', False) \n\n# note, this can also be done at the folder level:\nfolder = arcserver.folder('Watermain')\nfolder.addPermission('assessor', False)\n```\n\nStopping and Starting Services\n------------------------------\n\nServices can easily be started and stopped with this module. This can be done from the ArcServerAdmin() or Folder() object:\n\n```py\n# stop all services in a folder\narcserver.stopServices(folderName='SomeFolder') # this can take a few minutes\n\n# look thru the folder to check the configured states, should be stopped\nfor service in arcserver.folder('SomeFolder').iter_services():\n print(service.serviceName, service.configuredState)\n\n# now restart\narcserver.startServices(folderName='SomeFolder') # this can take a few minutes\n\n# look thru folder, services should be started\nfor service in arcserver.folder('SomeFolder').iter_services():\n print(service.serviceName, service.configuredState)\n \n# to do this from a folder, simply get a folder object back\nfolder = arcserver.folder('SomeFolder')\nfolder.stopServices()\nfor service in folder.iter_services():\n print(service.serviceName, service.configuredState)\n```\n\nUpdating Service Properties\n---------------------------\n\nThe admin package can be used to update the service definitions via JSON. By default, the Service.edit() method will pass in the original service definition as JSON so no changes are made if no arguments are supplied. The first argument is the service config as JSON, but this method also supports keyword arguments to update single properties (**kwargs). These represent keys of a the dictionary in Python.\n\n```py\n# connect to an individual service (by wildcard) - do not need to include full name, just\n# enough of the name to make it a unique name query\nservice = arcserver.service('SampleWorldCities') #provide name of service here\n\n# get original service description\ndescription = service.description\n\n# now edit the description only by using description kwarg (must match key exactly to update)\nservice.edit(description='This is an updated service description')\n\n# edit description again to set it back to the original description\nservice.edit(description=description)\n```\n\nThere are also some helper methods that aren't available out of the box from the ArcGIS REST API such as enabling or disabling extensions:\n\n```py\n# disable Feature Access and kml downloads\nservice.disableExtensions(['FeatureServer', 'KmlServer'])\n\n# you can also list enabled/disabled services\nprint(service.enabledExtensions)\n# [u'KmlServer', u'WFSServer', u'FeatureServer']\n\nservice.disabledExtensions\n# [u'NAServer', u'MobileServer', u'SchematicsServer', u'WCSServer', u'WMSServer']\n\n# Edit service extension properites\n# get an extension and view its properties\nfs_extension = service.getExtension('FeatureServer')\n\nprint(fs_extension) # will print as pretty json\n```\n\nFor Service objects, all properties are represented as pretty json. Below is what the FeatureService Extension looks like:\n\n```py\n{\n \"allowedUploadFileTypes\": \"\", \n \"capabilities\": \"Query,Create,Update,Delete,Uploads,Editing\", \n \"enabled\": \"true\", \n \"maxUploadFileSize\": 0, \n \"properties\": {\n \"allowGeometryUpdates\": \"true\", \n \"allowOthersToDelete\": \"false\", \n \"allowOthersToQuery\": \"true\", \n \"allowOthersToUpdate\": \"false\", \n \"allowTrueCurvesUpdates\": \"false\", \n \"creatorPresent\": \"false\", \n \"dataInGdb\": \"true\", \n \"datasetInspected\": \"true\", \n \"editorTrackingRespectsDayLightSavingTime\": \"false\", \n \"editorTrackingTimeInUTC\": \"true\", \n \"editorTrackingTimeZoneID\": \"UTC\", \n \"enableOwnershipBasedAccessControl\": \"false\", \n \"enableZDefaults\": \"false\", \n \"maxRecordCount\": \"1000\", \n \"realm\": \"\", \n \"syncEnabled\": \"false\", \n \"syncVersionCreationRule\": \"versionPerDownloadedMap\", \n \"versionedData\": \"false\", \n \"xssPreventionEnabled\": \"true\", \n \"zDefaultValue\": \"0\"\n }, \n \"typeName\": \"FeatureServer\"\n}\n```\n\nSetting properties for extensions is also easy:\n\n```py\n# set properties for an extension using helper method, use **kwargs for setting capabilities\nservice.setExtensionProperties('FeatureServer', capabilities='Query,Update,Delete,Editing')\n\n# verify changes were made\nprint(fs_extension.capabilities\n# 'Query,Update,Delete,Editing'\n\n# alternatively, you can edit the service json directly and call the edit method\n# change it back to original settings\nfs_extension.capabilities = 'Query,Create,Update,Delete,Uploads,Editing'\nservice.edit()\n\n# verify one more time...\nprint(fs_extension.capabilities)\n# 'Query,Create,Update,Delete,Uploads,Editing'\n```\n\nAccess the Data Store\n---------------------\n\nYou can iterate through the data store items easily to read/update/add items:\n\n```py\n# connect to the server's data store\nds = arcserver.dataStore\n\n# iterate through all items of data store\nfor item in ds:\n print(item.type, item.path\n # if it is an enterprise database connection, you can get the connection string like this\n if item.type == 'egdb':\n print(item.info.connectionString)\n # else if a folder, print(server path\n elif item.type == 'folder':\n print(item.info.path)\n print('\\n')\n```\n\nUser and Role Stores\n--------------------\n\nWhen viewing usernames/roles you can limit the number of names returned using the \"maxCount\" keyword argument. To view and make changes to Role Store:\n\n```py\n# connect to role store\nrs = arcserver.roleStore\n\n# print roles\nfor role in rs:\n print(role)\n\n# find users within roles\nfor role in rs:\n print(role, 'Users: ', rs.getUsersWithinRole(role))\n\n# add a user to role\nrs.addUsersToRole('Administrators', 'your-domain\\\\someuser')\n\n# remove user from role\nrs.removeUsersFromRole('Administrators', 'your-domain\\\\someuser')\n\n# remove an entire role\nrs.removeRole('transportation')\n```\n\nTo view and make changes to the User Store:\n\n```py\n# connect to user store\nus = arcserver.userStore\n\n# get number of users\nprint(len(us)\n\n# iterate through first 10 users\nfor user in us.searchUsers(maxCount=10):\n print(user)\n \n# add new user\nus.addUser('your-domain\\\\someuser', 'password')\n\n# assign roles by using comma separated list of role names\nus.assignRoles('your-domain\\\\someuser', 'Administrators,Publishers')\n\n# get privileges from user\nus.getPrivilegeForUser('your-domain\\\\someuser')\n\n# remove roles from user \nus.removeRoles('your-domain\\\\someuser', 'Administrators,Publishers')\n```\n\nLog Files\n---------\n\nYou can easily query server log files like this:\n\n```py\nimport restapi\nimport datetime\n\n# query log files (within last 3 days), need to convert to milliseconds\nthreeDaysAgo = restapi.date_to_mil(datetime.datetime.now() - relativedelta(days=3))\nfor log in arcserver.queryLogs(endTime=threeDaysAgo, pageSize=25):\n print(log.time\n for message in log:\n print(message)\n print('\\n')\n```\n\nA note about verbosity\n----------------------\n\nWhen using the admin subpackage you will likely be making changes to services/permissions etc. On operations that change a configuration, the @passthrough decorator will report back if the operation is successful and return results like this:\n\n```py\n{u'status': u'SUCCESS'}\n```\n\nThe printing of these messages can be shut off by changing the global \"VERBOSE\" variable so these messages are not reported. This can be disabled like this:\n\n```py\nadmin.VERBOSE = False \n```\n\n\n## Advanced Usage\n\n### RequestClient\n\nFrom version 2.0, it is possible to use a custom `requests.Session()` instance. This instance can be defined globally for all requests made by `restapi`, or it can be passed on each function call as a `restapi.RequestClient()` object. This can be useful if different parameters are needed to access different servers.\n\nUse this functionality to access servers behind HTTP or SOCKS proxies, to disable certificate validation or use custom CA certificates, or if additional authentication is needed. Refer to the [requests.Session()](https://requests.readthedocs.io/en/master/user/advanced/#session-objects) documentation for details\n\n```py\n# Create a restapi.RequestClient() object.\ncustom_session = requests.Session()\ncustom_client = restapi.RequestClient(custom_session)\n\n# Customize the client\nproxies = {\n \u201chttp\u201d: \u201chttp://10.10.10.10:8000\u201d,\n \u201chttps\u201d: \u201chttp://10.10.10.10:8000\u201d,\n}\ncustom_client.session.proxies = proxies\ncustom_client.session.headers['Source-Client'] = 'Custom'\n\n# Use the client for an individual call\nrest_url = 'https://gis.ngdc.noaa.gov/arcgis/rest/services'\narcserver = restapi.ArcServer(rest_url, client=custom_client)\n\n# Set a different client as client as restapi's default\nglobal_session = requests.Session()\nglobal_client = restapi.RequestClient(global_session)\nglobal_client.session.headers['Source-Client'] = 'Global'\nrestapi.set_request_client(global_client)\n\n# Now any call made by restapi will use the custom client\narcserver = restapi.ArcServer(rest_url)\n\n# The global client can also be accessed directly\nrestapi.requestClient.headers['Another-Header'] = 'Header is here'\n\n```\n\nAny session objects which extend `requests.Session()` should be supported, for example, [pypac.PACSession()](https://pypi.org/project/pypac/).\n\n", "description_content_type": "text/markdown", "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/Bolton-and-Menk-GIS/restapi", "keywords": "", "license": "GPL", "maintainer": "", "maintainer_email": "", "name": "bmi-arcgis-restapi", "package_url": "https://pypi.org/project/bmi-arcgis-restapi/", "platform": null, "project_url": "https://pypi.org/project/bmi-arcgis-restapi/", "project_urls": { "Homepage": "https://github.com/Bolton-and-Menk-GIS/restapi" }, "release_url": "https://pypi.org/project/bmi-arcgis-restapi/2.2/", "requires_dist": null, "requires_python": "", "summary": "Package for working with ArcGIS REST API", "version": "2.2", "yanked": false, "yanked_reason": null }, "last_serial": 13628578, "releases": { "1.0": [ { "comment_text": "", "digests": { "md5": "2a2344ca5dfdd5c5d7178753266f8cfc", "sha256": "5f1cafd2d0f3352bb4df16ae1a189cd8eb0bac7f40e6099ece9e7f8cfd8ece29" }, "downloads": -1, "filename": "bmi-arcgis-restapi-1.0.tar.gz", "has_sig": false, "md5_digest": "2a2344ca5dfdd5c5d7178753266f8cfc", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 472518, "upload_time": "2019-10-29T17:18:46", "upload_time_iso_8601": "2019-10-29T17:18:46.580862Z", "url": "https://files.pythonhosted.org/packages/ca/c4/ff5698e57c5b8c7d23d6bf97d014af73f135f627fb2401c9efbc40b7a1b4/bmi-arcgis-restapi-1.0.tar.gz", "yanked": false, "yanked_reason": null } ], "1.0.2": [ { "comment_text": "", "digests": { "md5": "0dde14fc817982d8254780a7d99aa23b", "sha256": "0a912590158c1e6ce17e3983bc1abcb22d8c8224b5fa5ceb60b3aa2e8e50ec30" }, "downloads": -1, "filename": "bmi-arcgis-restapi-1.0.2.tar.gz", "has_sig": false, "md5_digest": "0dde14fc817982d8254780a7d99aa23b", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 472955, "upload_time": "2019-12-06T21:52:52", "upload_time_iso_8601": "2019-12-06T21:52:52.495301Z", "url": "https://files.pythonhosted.org/packages/29/89/d1bb161a032acc83f0fe38bbf9db553562836555deabf00c15d7812f003c/bmi-arcgis-restapi-1.0.2.tar.gz", "yanked": false, "yanked_reason": null } ], "1.0.3": [ { "comment_text": "", "digests": { "md5": "a2357c237a130389ee8aa8f175dbadde", "sha256": "9a4651ae5ff518f6863372472490904d0633b8087b96ed072971ff1d64e8667e" }, "downloads": -1, "filename": "bmi-arcgis-restapi-1.0.3.tar.gz", "has_sig": false, "md5_digest": "a2357c237a130389ee8aa8f175dbadde", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 472975, "upload_time": "2020-01-06T19:00:33", "upload_time_iso_8601": "2020-01-06T19:00:33.897451Z", "url": "https://files.pythonhosted.org/packages/a7/21/8bb8eea7557761b1870db3a0838db624a00da5c9c8709a6991edc77f8bd9/bmi-arcgis-restapi-1.0.3.tar.gz", "yanked": false, "yanked_reason": null } ], "1.0.4": [ { "comment_text": "", "digests": { "md5": "ba2ae50775c633e30563d86591bbe4b9", "sha256": "52fd6d3c2bbdedf5d11df2ebdeef53c116ac26188248c2ad3033ad166d248614" }, "downloads": -1, "filename": "bmi-arcgis-restapi-1.0.4.tar.gz", "has_sig": false, "md5_digest": "ba2ae50775c633e30563d86591bbe4b9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 473944, "upload_time": "2020-03-04T20:09:07", "upload_time_iso_8601": "2020-03-04T20:09:07.995062Z", "url": "https://files.pythonhosted.org/packages/72/b1/e5fcd6d3b70a36a8e91259f5a828e39dfc650d8128850e6433a1320e1876/bmi-arcgis-restapi-1.0.4.tar.gz", "yanked": false, "yanked_reason": null } ], "1.0.5": [ { "comment_text": "", "digests": { "md5": "ef1cc9c9321991c407967cd4635a5569", "sha256": "46d3e620fd112fa13853c60001df66ad9640dc5add3e039841a57f51fd56a054" }, "downloads": -1, "filename": "bmi-arcgis-restapi-1.0.5.tar.gz", "has_sig": false, "md5_digest": "ef1cc9c9321991c407967cd4635a5569", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 474031, "upload_time": "2020-05-22T15:00:30", "upload_time_iso_8601": "2020-05-22T15:00:30.655122Z", "url": "https://files.pythonhosted.org/packages/c6/1d/e2c35eacfd4bdebedf60e7d2c779b1a587e24d615d713c3f84e290753e16/bmi-arcgis-restapi-1.0.5.tar.gz", "yanked": false, "yanked_reason": null } ], "2.0": [ { "comment_text": "", "digests": { "md5": "1aab376116c2e1332f8729abb60b388a", "sha256": "a912b416a511e988c966c9a4b542b9ae91c7f2e4ff7062472249cd09675b9ff6" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.0.tar.gz", "has_sig": false, "md5_digest": "1aab376116c2e1332f8729abb60b388a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 486030, "upload_time": "2020-09-24T17:27:52", "upload_time_iso_8601": "2020-09-24T17:27:52.984560Z", "url": "https://files.pythonhosted.org/packages/f5/06/c36760e34086cab3a39582d3e43a6d9ba26c823d4ef3d71503cb75f4e1e7/bmi-arcgis-restapi-2.0.tar.gz", "yanked": false, "yanked_reason": null } ], "2.0.1": [ { "comment_text": "", "digests": { "md5": "470a3e95b7faa2f3cffcc3fd265387ff", "sha256": "0426a9d4565ccb94f423775177a354201ffb2a17bcc61c17b34ff9099fbbdb34" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.0.1.tar.gz", "has_sig": false, "md5_digest": "470a3e95b7faa2f3cffcc3fd265387ff", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 486045, "upload_time": "2020-10-02T02:24:14", "upload_time_iso_8601": "2020-10-02T02:24:14.246899Z", "url": "https://files.pythonhosted.org/packages/ae/60/ff56525684d55cc7eff6d494799f4f6858e877be252b2138462a2f3bf95b/bmi-arcgis-restapi-2.0.1.tar.gz", "yanked": false, "yanked_reason": null } ], "2.0.2": [ { "comment_text": "", "digests": { "md5": "929549352d0245687c956a785b7d70ce", "sha256": "dc35626982989e1c5586009e7e103542b425db649eda6bce70631a51cf3e2457" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.0.2.tar.gz", "has_sig": false, "md5_digest": "929549352d0245687c956a785b7d70ce", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 486356, "upload_time": "2020-11-13T14:26:07", "upload_time_iso_8601": "2020-11-13T14:26:07.001942Z", "url": "https://files.pythonhosted.org/packages/af/6f/b98bb59e686881e97be53bd32b13a7af510fbe830c3d4ec9ab17fdbbfc69/bmi-arcgis-restapi-2.0.2.tar.gz", "yanked": false, "yanked_reason": null } ], "2.1": [ { "comment_text": "", "digests": { "md5": "674814786c5f0e52d210e03658a2c7d2", "sha256": "9d2cd3dc5567e87fa1cef7dd283cdc9d6ed7f703e9cf9ab5196dbe4ad4aefb35" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.1.tar.gz", "has_sig": false, "md5_digest": "674814786c5f0e52d210e03658a2c7d2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509833, "upload_time": "2021-06-02T18:45:32", "upload_time_iso_8601": "2021-06-02T18:45:32.457370Z", "url": "https://files.pythonhosted.org/packages/35/7b/39c074cbf17226c9a5e2e6da197206df04c529ad5906465e3b10daca1df3/bmi-arcgis-restapi-2.1.tar.gz", "yanked": false, "yanked_reason": null } ], "2.1.1": [ { "comment_text": "", "digests": { "md5": "91fcccb1c2733386b4d2b90c9b9ed363", "sha256": "69c5aa6a0f80e1a6a0772fa19422f9f70aedb8b6ced161b3020a4f0c63819e15" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.1.1.tar.gz", "has_sig": false, "md5_digest": "91fcccb1c2733386b4d2b90c9b9ed363", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509931, "upload_time": "2021-06-02T20:51:03", "upload_time_iso_8601": "2021-06-02T20:51:03.483573Z", "url": "https://files.pythonhosted.org/packages/b7/34/7cc9bbeb7bd4125812ae2310db4493c22f88f5be2747874ec07c86502a51/bmi-arcgis-restapi-2.1.1.tar.gz", "yanked": false, "yanked_reason": null } ], "2.1.2": [ { "comment_text": "", "digests": { "md5": "0f3f59f836fdc484117a039af655e0cf", "sha256": "ca6008674a0becc7966d78c71b1394060e8aa1eb3b740df8ec7b9a1bb12018da" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.1.2.tar.gz", "has_sig": false, "md5_digest": "0f3f59f836fdc484117a039af655e0cf", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 510028, "upload_time": "2021-07-16T15:54:56", "upload_time_iso_8601": "2021-07-16T15:54:56.550350Z", "url": "https://files.pythonhosted.org/packages/56/7c/0605b750b6f2c0fbea35aac10263aab70896d8732729cb81920a77c47085/bmi-arcgis-restapi-2.1.2.tar.gz", "yanked": false, "yanked_reason": null } ], "2.1.3": [ { "comment_text": "", "digests": { "md5": "d9f119eba4a7166b6df065a69ab1d2c6", "sha256": "292bcd6b277445b85c8e88d85373644e73a24f0c7a83678f52b25726ee4deae5" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.1.3.tar.gz", "has_sig": false, "md5_digest": "d9f119eba4a7166b6df065a69ab1d2c6", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509135, "upload_time": "2022-04-06T19:12:37", "upload_time_iso_8601": "2022-04-06T19:12:37.894244Z", "url": "https://files.pythonhosted.org/packages/12/05/a0b785abbd8a92517f08192e20e5e1145ac998f021d758531bc313a018fa/bmi-arcgis-restapi-2.1.3.tar.gz", "yanked": false, "yanked_reason": null } ], "2.2": [ { "comment_text": "", "digests": { "md5": "c8667f1d718f1f8b8304835e74fa20bd", "sha256": "bc1b00436e915457ff8e384cf9e5080c53d2f8d1125538fd5c04a3effb37b5c4" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.2.tar.gz", "has_sig": false, "md5_digest": "c8667f1d718f1f8b8304835e74fa20bd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509383, "upload_time": "2022-04-26T14:42:11", "upload_time_iso_8601": "2022-04-26T14:42:11.603908Z", "url": "https://files.pythonhosted.org/packages/04/e2/6e0a776592f0d7ba9caa166c343e67eb1fedcce406f0791b99c25bc55b5d/bmi-arcgis-restapi-2.2.tar.gz", "yanked": false, "yanked_reason": null } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "c8667f1d718f1f8b8304835e74fa20bd", "sha256": "bc1b00436e915457ff8e384cf9e5080c53d2f8d1125538fd5c04a3effb37b5c4" }, "downloads": -1, "filename": "bmi-arcgis-restapi-2.2.tar.gz", "has_sig": false, "md5_digest": "c8667f1d718f1f8b8304835e74fa20bd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509383, "upload_time": "2022-04-26T14:42:11", "upload_time_iso_8601": "2022-04-26T14:42:11.603908Z", "url": "https://files.pythonhosted.org/packages/04/e2/6e0a776592f0d7ba9caa166c343e67eb1fedcce406f0791b99c25bc55b5d/bmi-arcgis-restapi-2.2.tar.gz", "yanked": false, "yanked_reason": null } ], "vulnerabilities": [] }