Skip to main content

geolens (CLI)

Apache-2.0 command-line interface for the GeoLens API.

Log in, scan local directories of spatial data, publish files, apply manifest-driven catalogs, replace and refresh datasets, inspect source status, run PostGIS analysis operations, export STAC metadata and plan an ArcGIS migration against any GeoLens instance.

Install

pip install geolens-cli      # installs the `geolens` command; Python 3.11 or newer

Quick start

geolens login https://geolens.example.com/api
geolens publish ./data/cities.geojson
geolens status DATASET_ID        # the UUID at the end of the URL publish printed

The CLI wraps the geolens Python SDK package.

Migrate from ArcGIS

Three commands move an ArcGIS Online organization or a self-hosted ArcGIS portal into GeoLens. They are written for an ArcGIS organization administrator, because a portal search only returns items shared with the caller and a non-admin never sees other people's private items. On the GeoLens side the session must be an admin (geolens login as one), since the run reads the user list and hands ownership to the people the plan names. The exception is one person moving their own content: when the plan maps every item to the account you are signed in as, an editor can run migrate. Nothing is transferred and no user list is read; the items stay with you. A plan that maps any item to someone else, or a role that lacks the permission the selected items need (upload for datasets, edit_metadata for maps), still needs an admin and exits 2. What an editor can't do degrades and is reported rather than refused: a public item under restrict_public_visibility becomes internal (public_blocked_by_policy in the report), collections are skipped without manage_collections, and an item shared only with ArcGIS groups is shared with the GeoLens groups you already belong to whose name matches the ArcGIS group's title (or the plan's geolens_group), or becomes private (private_no_matching_group), never internal or public. An editor creates no groups and can't read a group's members, so the report and --cutover flag every matched group's members as unread; check them in GeoLens.

geolens arcgis inventory --portal-url https://yourorg.maps.arcgis.com --scope org -o ./run
geolens arcgis plan ./run/arcgis-inventory.json --owner-map owners.json
geolens arcgis migrate ./run/arcgis-migration-plan.json
  1. inventory reads the portal and writes arcgis-inventory.json and a readable report.
  2. plan turns it into arcgis-migration-plan.json, which you review and edit. Each item has an action (import_layers, import_file, import_map, export_only or skip), a target owner, visibility, collections and title. owners.json maps ArcGIS usernames to GeoLens usernames or emails; an empty value means no owner yet.
  3. migrate runs the plan one item at a time, in dependency order. Add --dry-run first to check the plan and the owners without importing anything. With --username, the dry run also makes the one ArcGIS sign-in the run starts with, so a refused password exits 3 before the real run; a token isn't checked.

What each action does

  • import_layers: GeoLens imports the feature layers and tables of a hosted or federated service itself; the CLI never contacts the service.
  • import_file: a CSV, GeoJSON, Shapefile or File Geodatabase item is downloaded from the portal and uploaded. It is bounded by the instance's upload size limit; an item over it is skipped with its size.
  • export_only: items GeoLens can't host (dashboards, forms, StoryMaps, Hub pages and so on) are saved under export/<type>/<item id>/ next to the state file, with item.json, the item's data, its resources and, for a story, a readable story.md. export/INDEX.md lists them, and the source files of hosted layers, with what to use instead. Uploaded files keep their type: a CSV is saved as data.csv and a PDF as data.pdf, from the portal's file name or the item type, and data.bin only when neither gives one. A story.md links each map to the GeoLens map made from it at the instance's PUBLIC_APP_URL, or at the instance URL without /api when PUBLIC_APP_URL isn't set, so set it on an install that serves the web app from another origin. A map that hasn't been migrated is linked to its ArcGIS item page instead, which stops working when the portal is retired, so replace those links before cutover. --export-cap-mb (default 200) limits each item. An export can finish with files missing: one over the cap, JSON that can't be redacted, a request the portal refused, or an unsafe resource name. The item notes, the report and INDEX.md (status partial or complete, with errors) say which, so check them before retiring the ArcGIS source. A network or server error while exporting leaves the item failed, and a rerun retries it.
  • import_map: a Web Map becomes a GeoLens map through the server's web map translator. Its operational layers are matched to the datasets the run imported for their service items, so the map waits for those items (depends_on); a layer from another organization or a service that was not imported is left out. Basemaps follow the plan's basemap_map. A matched layer that the web map leaves to its source is drawn with the renderer saved on its layer item, read from the portal, or else its service layer's own renderer, read only from a host the run trusts with its token (--trust-service-host). webmap-loss/<item id>.json next to the state file lists what was not carried over, and the report lists the path under its loss reports and in the follow-ups. The state keeps each ArcGIS layer id's map layer id. The map gets the web map item's thumbnail, read from the portal with the run's credential, and a rerun gives it to a migrated map that has no thumbnail; a thumbnail already on the map is never replaced. A PNG or JPEG over the size GeoLens takes for a thumbnail, any other image type, or a failed read or upload is reported on the item and leaves the map without one. A dry run notes each new map that would get one.

Items are imported as you, then handed to the owner the plan names. Each target user needs a role with upload (datasets) or edit_metadata (maps). --unmapped-owner names an owner for items whose plan owner can't take them yet: the mapping is empty, the user hasn't signed in to GeoLens yet (an OIDC user before first sign-in), is inactive, or has a role without that permission, such as the viewer role new OIDC users get. Those items go to the --unmapped-owner for now and are recorded as waiting; a later run hands each one to its owner once the owner can take it, or to a new --unmapped-owner if you pass another. For a role, the run asks you to promote the user to editor instead of letting the transfer fail, and when GeoLens itself refuses a transfer because of the user's role, the item fails with the same request. Without --unmapped-owner such items stop the run before anything is imported, except a role without the permission, which is a warning and the server decides. When the refusal is an empty owner_map entry and GeoLens already has an account with the same username and the email the inventory read for that owner, the message names it; migrate doesn't map it for you, because an owner gets the item itself, which is more than group membership. A migrated item whose plan owner you later edit to an empty value, a name that matches no user or one that matches two is listed in the output and the report, and stays with its current owner. When an item's ArcGIS owner changes after it was migrated, a rerun hands it to the GeoLens user owner_map gives the new owner, one object at a time, and each object moves only while it is as the last run left it; one transferred or changed in GeoLens since then keeps its owner and is reported. A handover that stops part way is recorded as incomplete; the next run gives each of the item's objects that someone else owns to the owner the plan then names, and --cutover refuses until every object has that owner. Items are handed over in dependency order, so a map moves after the datasets it shows. --dry-run lists the handovers the run would make (handovers in --json), with the same --only selection. An item the last merged inventory didn't list isn't handed over until an inventory lists it again. A portal owner change that the plan's target.owner overrides is listed under owner_conflicts in the output and as owner_conflict in the report. An item whose target.owner you set keeps that owner, and the run lists the new ArcGIS owner under owner_conflicts. A new owner you give an item after it was migrated, through target.owner or an owner_map edit, is handed over the same way as an ArcGIS owner change, on an ordinary run and on --cutover; --dry-run previews it under handovers. An inactive new owner is listed under owner_unresolved and nothing moves. A handover that is refused, or that a run didn't attempt because --only left the item out or the run stopped first, stays in the output and the report as owner_changed; rerun with the item selected, or transfer it by hand. Folders become collections (defaults.collection_from in the plan: folder or none). A folder whose name another collection holds is filed under <portal name> - <folder>. When that name is held too, the run stops before importing anything, as it does when a group's name and ArcGIS - <name> are both taken; rename the folder in the items' target.collections, or set collection_from to none.

Sharing and groups

ArcGIS sharing maps to GeoLens visibility: private stays private, org becomes internal, public stays public, and an item shared only with groups becomes restricted, shared with a GeoLens group for each of its ArcGIS groups. Under the restrict_public_visibility setting, a public item whose owner isn't a GeoLens admin becomes internal instead; when a run has public items and can't read that setting, it stops before importing anything. Each ArcGIS group's entry in the plan's group_map decides its GeoLens group through geolens_group. Left null, migrate creates a group named after the ArcGIS group (or ArcGIS - <name> when another group already has that name; it never joins a group it didn't create) and adds the members the inventory read. A member resolves like an owner: through owner_map when it lists them, otherwise by the same username or email in GeoLens, but only when the email the inventory read for that ArcGIS user, if any, is the account's. --dry-run and the report list which GeoLens user each ArcGIS member became, so check that a same-named account belongs to the same person. A member who isn't a GeoLens user yet, or whom GeoLens refused to add, stays pending and is added by a later run (the output counts members without a GeoLens account once and lists their names, and names geolens admin users import --from-inventory as the way to create them; the report keeps one line per member and group); a refused add also makes the run exit 1. Set geolens_group to an existing group's exact name to share with that group instead (a name that matches several groups apart from case is refused); its members are left as they are, since adding to it would also give them the rest of what it can read, and the ArcGIS members it lacks are listed. An empty string maps the ArcGIS group to no GeoLens group, and an item none of whose groups maps to one becomes private. plan also writes each entry's collection, the ArcGIS group's title, which names a group migrate creates only when the inventory has no title for it, and visibility, the group's ArcGIS access, which migrate doesn't read. A rerun follows the plan: an item gets the groups its plan entry now names, and loses the groups migrate itself added that the entry no longer names (none while its groups weren't read). Groups shared with an item in GeoLens stay, even when the plan later names them too, and a group someone removes from an item in GeoLens isn't added again or removed later. GeoLens makes a private dataset or map shared with any group restricted, so one the plan keeps private while groups shared in GeoLens remain on it is reported instead of changed. A rerun that can't bring an item up to date leaves its groups as they are and lists the changes still waiting. Sharing replaces an item's whole group list, so a group change someone makes to the same item while migrate shares it can be overwritten; run it while nobody is editing sharing. A map is shared with its groups without widening its layers, which keep the sharing of their own items. A map's groups are written only while the map is as migrate last left it, and migrate records the version GeoLens answers the write with; a GeoLens older than 1.30 doesn't answer one, so a later change to such a map is reported rather than told apart from the share. A member migrate added to a group it created is removed again on a rerun once the ArcGIS member it was added for has left the group. A member still listed but no longer resolving (renamed, deactivated, or mapped to someone else in owner_map) keeps the account it was added as, nothing is removed while a group's members weren't read, and anyone added or removed in GeoLens stays as they are. The output, --dry-run and the report list each removal. A state file from before version 4 doesn't say which members migrate added, so the next run lists them once for you to check by hand and removes none of them. It doesn't say which groups migrate shared an item with either, so a group the plan no longer names that is still on an item is listed once for you to check, and left. A rerun prints each item it shared with a group or took a group off, and the report lists them under "Item sharing changed by this run".

Only an organization administrator sees every group an item is shared with, and a group can hide its members from everyone but its managers and administrators. plan lists items shared only with groups that a non-admin's inventory may have missed, and the report lists, as under_shared follow-ups, items whose groups weren't all read or carried over. A rerun changes a migrated map's groups the same way while the map is as migrate left it and both it and its plan entry are private or restricted; a map changed in GeoLens since, or one whose plan now gives it another visibility, is reported rather than changed.

Users

Owners and group members have to be GeoLens users before migrate can hand them items or add them to groups. geolens admin users import users.csv creates them from a CSV with a header row naming username, email and role (admin, editor or viewer; empty means viewer), and skips anyone GeoLens already has with that username and email. A row whose username belongs to an account with another email, or whose email belongs to another account, is a conflict: it isn't created, and the run exits 1. --from-inventory arcgis-inventory.json takes the users from an inventory instead: every item owner as an editor, with the email the inventory read, and every member of a group an item is shared with as a viewer. Add --seed-csv users.csv to write those rows to a new file you can review and edit, creating nothing. It refuses to overwrite a file, and a cell starting with =, +, - or @ gets a leading ' so a spreadsheet doesn't run it as a formula. The import drops that ' again, so a name or email that really starts with ' followed by one of those characters can't be given in a CSV. --dry-run says what would be created. The command needs a GeoLens admin session and exits 3 without one. It exits 1 when any user couldn't be created.

Each new user gets a generated 72-character password, the longest GeoLens accepts, so it meets any password policy. --print-passwords shows each one once on standard output; nothing else writes them anywhere, so without it nobody knows them and you set one for each user through the admin password reset (Admin, Users) and pass it on.

An instance that signs in through an identity provider (OpenID Connect, SAML or a sign-in extension) creates its users at their first sign-in, so the import creates nobody there: those owners and members stay pending, and a migrate rerun after they sign in hands them their items and adds them to their groups. --link-by-email creates them anyway, with a random password nobody is shown, so their first sign-in links to the account by email. GeoLens links only when the provider sends email_verified; without it that sign-in is refused. Users without an email stay pending. GeoLens counts an email an admin enters as verified, so whoever signs in through the provider with that address gets the account: check every email in a seeded CSV before importing it with --link-by-email. Ctrl-C stops before the next user and still prints the passwords made so far.

Credentials

Public items need none. For anything else pass --token, ARCGIS_TOKEN or --token-stdin, --username with the password in ARCGIS_PASSWORD, --password-stdin or a prompt, or --client-id to sign in through the browser. A token made from a password or a browser sign-in is renewed before it expires. A token you pasted is not: when it runs out the run stops, writes the state file and tells you to resume with a fresh one. The tokens and passwords the run was given are never written to the state file or the report, and they are masked in the item JSON the export folder holds and in every message and --json payload the command prints through its output formatter, on stdout and stderr. A few lines are printed without that mask: a network error on the connection to GeoLens, a credential-store warning, the browser sign-in notices (the account name they show is masked) and an option the command line parser rejects before the run starts, which it echoes as given. No request that holds one is sent to GeoLens: an item whose title, description, tags, layer names, map title or collection name holds one stops with a reason naming the field. In all of these places a credential is found as given and in these encodings: composed and decomposed Unicode, URL percent-encoding (with or without / encoded, + for a space, escapes in either letter case) and JSON string escaping; other encodings are not detected. The contents of a data file an item holds (a CSV, a shapefile, a PDF) are uploaded to GeoLens and saved to the export folder as they are, and aren't checked. Text that only looks like a credential is copied as it is.

Accounts that sign in with SAML or OpenID Connect have no password to give here, so they use --client-id (or GEOLENS_ARCGIS_CLIENT_ID). Register an OAuth 2.0 credentials item in your organization (Content, New item, Developer credentials) with http://127.0.0.1 as a redirect URL, and pass its client ID. Write 127.0.0.1, not localhost: the portal treats them as different hosts. A redirect URL with no port matches the free port the command picks; if you register a port or path, register exactly http://127.0.0.1:<port>/callback and pass --redirect-port <port>. The command prints a sign-in link and opens it in your browser. You sign in on the portal's own login page, and the portal sends the browser back to a listener on 127.0.0.1. The refresh token is saved in the OS keyring (or credentials.toml without one) for that portal and client ID, so the next run signs in without the browser. Once that token is past half of its lifetime, a run exchanges it for a new one, so the sign-in lasts as long as the command runs at least once within the token's lifetime (two weeks on ArcGIS Online's defaults). geolens arcgis logout --portal-url <url> --client-id <id> deletes that saved sign-in from both places.

The command prints Signed in to <portal> as <username> on stderr after a browser sign-in and at the start of each run that reuses a saved one (--quiet hides it). If the browser already holds an ArcGIS session, it reuses that session without asking, so use a private window or sign out first when it holds another account. Members with a SAML or OpenID Connect login pass their organization's URL as --portal-url; the saved sign-in is kept per portal URL.

A private service hosted on a federated ArcGIS Server whose host differs from the portal's (or from arcgis.com) only receives the token when you name its host with --trust-service-host <host> (repeatable); without it the item fails before any import and the error names the host to pass.

GeoLens needs REDIS_URL set to take a token for a private service import; without it the instance answers 503 and the run stops with that message.

Updating the plan

Run plan again on a newer inventory to bring an existing plan up to date. The plan records the defaults it gave each item, so the merge can tell your edits apart: a value you edited stays, and one you left alone takes the new default. When both changed, your value stays and plan prints what the inventory now gives. An edit stays an edit until you set it back to its default, even when the portal later changes to match it. New portal items are added at the end with defaults; the rest keep your order. An item gone from the portal stays in the plan with "removed": true; migrate doesn't run it again, and what it already migrated stays in GeoLens. Only a complete --scope org inventory read by an organization administrator marks items removed, since anyone else misses items not shared with them. Any other inventory (partial, truncated, user scope, anonymous, a non-admin account, or one written before the CLI recorded the account's role) marks the items it doesn't list "unlisted": true, and migrate leaves those pending, so the run exits 1 until a merge lists them again. If you never run a complete org inventory as an admin, an item deleted from the portal stays unlisted; set its action to skip, or delete it from the plan, to finish. A non-admin also may not see every group an item is shared with, so its inventory only adds groups to an item's groups; a group it doesn't list is kept until an admin's inventory leaves it out. plan and migrate refuse an inventory of another ArcGIS organization than the plan's, which matters on www.arcgis.com, where every organization shares one URL; a plan from an earlier version records no organization, so only its portal URL is checked. Your owner_map, group_map, basemap_map and plan defaults entries win over the inventory and --owner-map. To leave an item out, set its action to skip: an item deleted from the plan comes back with defaults on the next merge. --force replaces the plan with fresh defaults instead.

Plans written by earlier versions still migrate. They record no defaults and no inventory scope, so their items keep every value as an edit on every merge, depends_on included. Delete an item from the plan, or use --force, to give it defaults that follow the portal.

Resuming and reports

Progress is saved in arcgis-migration-state.json (mode 0600) after every item. Run the same command again to resume: failed items are retried (--no-retry leaves them alone), and layers already imported are never imported twice. --only <item id> runs one item plus the unfinished items it depends on. Only one run can use a state file at a time. A run that finds no state file at its path checks whether GeoLens already holds datasets imported from the plan's items, and when it does it stops before importing anything and names a few of them, since it would import them all again. Point --state at the earlier run's state file, or pass --start-fresh to run anyway. GeoLens keeps one copy of a service layer per account, so a layer you already hold is reused and given the plan's title and visibility; a layer handed to another owner, a data file and a web map are imported again as new copies.

A rerun first hands waiting items to their owners, then imports what isn't finished, then brings every item migrated before up to date. Each dataset of a service item is refreshed from its source with the run's ArcGIS credential, so private items need --token or --username on every rerun. A data file item is downloaded again and replaces its datasets. An export_only item is exported again when the portal changed it since its bundle was written, which the new bundle replaces in one step; if that export fails, the earlier bundle stays and the item is reported as not up to date. A service item is probed even when it had nothing to import, so a layer added since is reported. A migrated web map whose portal item changed since the last run is translated again into the same GeoLens map: its layers, initial view, basemap and the loss report in its notes are replaced, each layer keeping its GeoLens layer id, and the loss report file is rewritten, or removed when nothing was lost. A web map that no longer has an initial view leaves the GeoLens map's view and rotation as they are, and the map's notes and the report say so. When GeoLens has no basemap enabled the translation names none, and the map keeps its basemap. A layer whose dataset the run's account can't read, also one the portal repointed to such a dataset, is left out of the translation and its map layer is kept as it was, and the item's notes list it; each later run translates the map again until no layer is left out. A layer the portal dropped whose map layer the run couldn't read, and a layer whose service the plan imports but the run hasn't finished, are translated again the same way; layers of unsupported or unplanned sources are only reported. A web map with such a layer still owed is reported as not up to date, so --cutover refuses it until the layer is applied; the first import records the layers its unfinished sources owe too. A save whose answer was lost is adopted by the next run only when the map still holds exactly what the save sent: every field of the map, layer styles and notes included, with a style sent null checked against the one the server filled in at the last confirmed save that also sent it null. A map with a layer hidden from the run, or a style with no such record, is reported as a change made in GeoLens instead. Kept and hidden layers count toward the map's 200-layer cap, so a translation that would pass it gives up its last layers, which the notes and the loss report list as layer_cap. A map changed in GeoLens since the last run is reported and left as it is, and so is one GeoLens changes while the new translation is saved. A map the state has no record of leaving, such as one imported while its owner was pending under a version that didn't record it, is reported for you to update by hand rather than translated again. Re-translating needs GeoLens and the geolens package 1.30 or newer; with either older, the map is reported instead. The item's metadata is written again on each dataset that a refresh or replacement published, and a field the portal has emptied since is emptied too, unless it was edited in GeoLens. A visibility the portal's sharing changed since the import is applied to each dataset, unless it was changed in GeoLens or the state file can't tell, which is reported instead. Every service item is refreshed, because an item's modified date doesn't move when its features are edited. A refresh that stops for review (live edits, a destructive schema change, an empty result) publishes nothing: the run reports it with the geolens refresh <dataset> --accept-blocked-run <run> command that accepts it, and never accepts it for you. A rerun recognises the run you accept it with, and a refresh GeoLens accepted but whose answer was lost, as this command's own. A migrated web map whose owner was changed in GeoLens is reported, and one waiting for its planned owner is not handed over after such a change. A map whose state records no baseline, from a version before baselines were recorded, is never handed over or kept on the strength of a read: it is reported for you to update by hand, or to rerun once you have checked it. --only limits the rerun to the items it names.

A rerun never overwrites a change made in GeoLens. After each write the state file records the dataset's last update, feature count and data revision, which counts every feature and column edit, your own included. Each dataset is compared right before its own refresh or replacement; one whose values differ (edited, transferred or refreshed in GeoLens) is reported and left alone, and so is one deleted there. The request carries the recorded revision, so GeoLens stops the publication for review if the data is edited after the check, and a file replacement is checked again after its upload. A GeoLens too old to report data revisions gets no refresh or replacement at all; each dataset is reported until you upgrade it. A refresh that doesn't publish leaves the dataset's record as it was, and one edited while its refresh ran is reported and not recorded. Set the item's action to skip to stop bringing it up to date. Change a finished export_only or skip item's action to import_file, import_layers or import_map and the next run imports it (the export bundle stays on disk but is no longer tracked); other action changes on a finished item aren't acted on. A state file from an earlier version has no recorded values, so a dataset is taken as unchanged only when your GeoLens account made its last change, before the item finished. The state file is now version 6, which an earlier CLI refuses to read rather than rewrite.

A run that gets as far as the item loop writes arcgis-migration-report.md and .json next to the state file, also when it is interrupted or stops on a failed request. --dry-run writes none, and neither does a run refused before it starts (an unusable plan, state file or owner mapping, or a failed GeoLens check). The report covers every item of the plan: the manual follow-ups (failed items, skipped files and layers, group-only sharing, partial exports, items that can't run yet or wait on others) and the unsupported items with where each was saved.

Exit codes:

  • 0: no item of the plan is failed, no item the run selected was left waiting or unable to run, and no group membership change failed; or a --cutover run that didn't stop refused nothing, because every check that failed was accepted with its --accept-* flag, and no group membership change failed. Skipped items (a file over the upload limit or with too many layers) and pending items the run did not select, such as items that can't run yet, don't change it, so read the report's counts and follow-ups before treating the migration as complete.
  • 1: an item of the plan is failed (including one this run left out with --only or --no-retry, and a portal download or GeoLens server error once items are running), an item the run selected was left pending because its action can't run yet or it waits on another item, a migrated item couldn't be brought up to date or handed to its owner, a group membership change failed, --cutover refused (any failing check left unaccepted), or the run stopped (for example on an expired pasted token).
  • 2: the plan, state file, owner mapping or credentials couldn't be used, the GeoLens session isn't an admin's and the plan names another owner (or the role can't upload), a group or collection name the run needs is taken, there is no state file while GeoLens holds datasets migrated from the plan's items, or the portal URL redirected before any item ran. --dry-run exits 2 on a taken name or those datasets too. A redirect refused once items are running fails that item (exit 1).
  • 3: authentication failed before any item ran (the GeoLens checks, or an ArcGIS password sign-in), or the server rejected a GEOLENS_TOKEN at any point, which stops the run with this code. A stored login that is rejected once items are running fails that item (exit 1).
  • 4: the portal couldn't be reached while signing in, or a GeoLens request couldn't connect or timed out at any point, which stops the run with this code. The exception is a timeout on the status poll of an import job: it is retried until the poll's deadline, and a deadline that runs out fails that item (exit 1). A portal download that fails once items are running also fails only that item (exit 1).
  • 5: a server error from the GeoLens checks, before any item ran.
  • 130: interrupted; run the same command to resume.

For a large migration, run the GeoLens worker with WORKER_CONCURRENCY=2 or more, since each layer import and refresh is a background job.

Cutover

A migration ends with one last run after the portal stops changing, marked with --cutover:

  1. Tell the portal's users that it is frozen, and stop edits to its items and services.
  2. Run inventory --scope org again as an organization administrator, then plan on it, so the plan holds everything the portal has now.
  3. Run migrate --dry-run --cutover to see what the cutover would refuse, and fix what you can: retry failed items, map owners, promote owners to editor, accept or fix refreshes that stopped for review.
  4. Run migrate --cutover with the same credentials as before. It first checks what no run can change, the inventory's freshness and the owners it can't hand items to (a plan owner that doesn't resolve, an item held for an owner who can't take it, a plan owner that names no single user, or whose handover can't be queued), and when one of those fails without its --accept-* flag it stops before importing or refreshing anything. Otherwise it runs like any rerun, then checks what wouldn't carry over and marks the run as the final one only when nothing is left, or when you accept each loss:
    • --accept-unfinished-items: a plan item isn't done (failed, skipped, can't run yet or waits on another item), is unlisted (even a finished one, since a rerun doesn't bring it up to date) or isn't up to date (its refresh failed or stopped for review, or GeoLens changed it). Items set to skip and items gone from the portal don't count.
    • --accept-incomplete-inventory: the plan wasn't last merged from a complete --scope org inventory read by an organization administrator, or the portal has items of the organization changed since that inventory started reading it, by the portal's own clock, so the plan may miss or misstate them. Items the plan skips don't count; an item created since the inventory does, since the plan doesn't hold it. An inventory written by an earlier version, or by a portal that sent no time, records no start and fails this check; run it again. The run asks the portal with its ArcGIS credential, which must be an organization administrator's; without one, or when the portal can't answer, this check fails too.
    • --accept-attachment-loss: a migrated layer has attachments, or its service doesn't say. GeoLens doesn't import attachments yet.
    • --accept-unresolved-users: an item still waits for its owner, its plan owner doesn't name one GeoLens user, or its plan now names an owner a handover couldn't move it to; or a member of an ArcGIS group isn't in its GeoLens group yet.
    • --accept-under-sharing: an item shared only with ArcGIS groups may reach fewer people in GeoLens: the inventory wasn't read by an organization administrator, one of its groups maps to no GeoLens group, or a group's members couldn't be read.
  5. Read arcgis-migration-report.md, which records the cutover and the losses you accepted (a later refused --cutover run keeps that line), and keep it with the state file. Then retire the portal. A refresh after that fails with the service's error, and the datasets stay as they are.

A refused cutover exits 1 and leaves the run unmarked; nothing it imported or refreshed is undone. A marked cutover exits 0 even when the items you accepted are still failed or not up to date, and the report lists them. --cutover runs the whole plan, so it can't be combined with --only.

Documentation

The full command reference, manifest schema, exit codes and CI setup are in the CLI guide.

Metadata

Release files for geolens-cli 1.32.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for geolens-cli 1.32.0
File Size Uploaded Provenance Actions
geolens_cli-1.32.0.tar.gz 631.0 kB Without provenance Details for geolens_cli-1.32.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for geolens-cli 1.32.0
File Interpreter ABI Platform Actions
geolens_cli-1.32.0-py3-none-any.whl Python 3 none any Details for geolens_cli-1.32.0-py3-none-any.whl

Total release size: 959.9 kB

Release files / geolens_cli-1.32.0.tar.gz

Download URL geolens_cli-1.32.0.tar.gz
Size 631.0 kB
Tags Source
SHA-256 checksum
How to use checksums
67b87bce0a9de512dba7a3f1317e797058fef51bcbfa38b295f4b4320c800a7a
BLAKE2b-256 checksum
How to use checksums
8c35f544a8d729ce5378aa05928ff69fa71f55e27fffb7ddf3135ad16f27d877
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.10.2 {"installer":{"name":"uv","version":"0.10.2","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / geolens_cli-1.32.0-py3-none-any.whl

Download URL geolens_cli-1.32.0-py3-none-any.whl
Size 328.9 kB
Tags Python 3
SHA-256 checksum
How to use checksums
96b9cc0aabfa70ca9465723d58a1772fc5267b35d30e5be6ae225f4ab11dde7c
BLAKE2b-256 checksum
How to use checksums
9b9dc62f70ec158ec12c07d65062cf3a5cd28a5d0794e25e777eba68b6bd1afd
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.10.2 {"installer":{"name":"uv","version":"0.10.2","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Security for geolens-cli 1.32.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

1.32.0 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page