env-able 2.0.0__tar.gz → 2.0.1__tar.gz

{env_able-2.0.0 → env_able-2.0.1}/.gitignore

@@ -172,3 +172,4 @@ tests/*
 # ~175 MB of it. Only the README that says what each scenario is for is kept.
 tests/maps/*
 !tests/maps/README.md
+/incubator

{env_able-2.0.0 → env_able-2.0.1}/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [2.0.1] - 2026-10-15
+### Added
+- **Calculate Field** in the attribute table: ArcGIS Pro's `!FIELD!` syntax, the selected
+  records only when there is a selection, Preview, and one Undo for the whole column. Parsed with
+  `ast` and interpreted, never `eval`'d: no import, no attribute walk, no oversized strings.
+- **The attribute table has Pro's toolbar**: All | Selected tabs with counts, Select All, Switch,
+  Clear, Zoom To, Add Field and Calculate.
+- **Select is an arrow with a ▾ menu** of Click, Rectangle and Lasso, each with its icon, as in Pro.
+- **Click mode is Pro's Select**: a click picks the topmost feature, a drag picks a box, and
+  Shift adds and Ctrl removes either way. Middle-drag pans while Select is on.
+
+### Fixed
+- **Shift-drag to add to a selection zoomed the map instead**: Shift-drag is MapLibre's box zoom.
+  Select turns it off while it is on. A tiny Ctrl-drag no longer clears the selection.
+- **Opening an attribute table started editing**, showing Undo, Save As and "Editing" to somebody
+  who had come to read it. Edit, Add Field and Calculate arm it now.
+- **A `.shp` dragged on its own lost its `.prj` and `.dbf`**: the CRS was guessed from the
+  coordinate range and every attribute dropped. Atlas now reads the file where it lives, sidecars
+  and all, when name, size, modified time and a hash of its first and last 256 KB match.
+- **From URL on an ArcGIS group layer loaded nothing**: the group was queried directly and the
+  service answered "Invalid or missing input parameters". A group now loads as its sublayers, a
+  whole `…/MapServer` as every feature layer in it, and a `…/query` address as its layer.
+- **An upload froze the whole application while it loaded**: the read ran on the server's event
+  loop, so the poll, the tiles and the Claude pane all waited. It runs on a worker thread now.
+- **From URL held the layer lock for the whole download**, so every other map change waited on a
+  remote server. It is held for the add only.
+
+### Changed
+- **Add Layer no longer uploads a file Atlas can find on disk.** A 34,596-feature well layer
+  (183 MB with its `.dbf`) went from 11.2 s to 3.5 s, and is referenced by a save rather than copied.
+- **GeoJSON conversion is 40% faster** (3.3 s to 2.0 s on that layer): attributes column-wise, and
+  points and lines from one vectorised coordinate read. Byte-identical output.
+- **ArcGIS services are fetched by object id, six pages at a time, three layers at once**, with a
+  toast that counts features as they arrive. A ten-layer Alberta service: 72 s to 31 s.
+
 ## [2.0.0] - 2026-10-07
 Atlas becomes two products on one engine. **Atlas Pro** (`atlas-pro`) is the desktop GIS and draws
 only with MapLibre. **atlas** is the skill: a folder in, a finished map out, in any assistant or an

{env_able-2.0.0 → env_able-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: env-able
-Version: 2.0.0
+Version: 2.0.1
 Summary: AI-ready GIS toolkit for energy and subsurface workflows.
 License: MIT
 License-File: LICENSE
@@ -404,6 +404,41 @@ print(f"{rows:,} rows written")
 ---
 
 ## Changelog
+### v2.0.1 — 2026-10-15
+**Added**
+- **Calculate Field** in the attribute table: ArcGIS Pro's `!FIELD!` syntax, the selected
+  records only when there is a selection, Preview, and one Undo for the whole column. Parsed with
+  `ast` and interpreted, never `eval`'d: no import, no attribute walk, no oversized strings.
+- **The attribute table has Pro's toolbar**: All | Selected tabs with counts, Select All, Switch,
+  Clear, Zoom To, Add Field and Calculate.
+- **Select is an arrow with a ▾ menu** of Click, Rectangle and Lasso, each with its icon, as in Pro.
+- **Click mode is Pro's Select**: a click picks the topmost feature, a drag picks a box, and
+  Shift adds and Ctrl removes either way. Middle-drag pans while Select is on.
+
+**Fixed**
+- **Shift-drag to add to a selection zoomed the map instead**: Shift-drag is MapLibre's box zoom.
+  Select turns it off while it is on. A tiny Ctrl-drag no longer clears the selection.
+- **Opening an attribute table started editing**, showing Undo, Save As and "Editing" to somebody
+  who had come to read it. Edit, Add Field and Calculate arm it now.
+- **A `.shp` dragged on its own lost its `.prj` and `.dbf`**: the CRS was guessed from the
+  coordinate range and every attribute dropped. Atlas now reads the file where it lives, sidecars
+  and all, when name, size, modified time and a hash of its first and last 256 KB match.
+- **From URL on an ArcGIS group layer loaded nothing**: the group was queried directly and the
+  service answered "Invalid or missing input parameters". A group now loads as its sublayers, a
+  whole `…/MapServer` as every feature layer in it, and a `…/query` address as its layer.
+- **An upload froze the whole application while it loaded**: the read ran on the server's event
+  loop, so the poll, the tiles and the Claude pane all waited. It runs on a worker thread now.
+- **From URL held the layer lock for the whole download**, so every other map change waited on a
+  remote server. It is held for the add only.
+
+**Changed**
+- **Add Layer no longer uploads a file Atlas can find on disk.** A 34,596-feature well layer
+  (183 MB with its `.dbf`) went from 11.2 s to 3.5 s, and is referenced by a save rather than copied.
+- **GeoJSON conversion is 40% faster** (3.3 s to 2.0 s on that layer): attributes column-wise, and
+  points and lines from one vectorised coordinate read. Byte-identical output.
+- **ArcGIS services are fetched by object id, six pages at a time, three layers at once**, with a
+  toast that counts features as they arrive. A ten-layer Alberta service: 72 s to 31 s.
+
 ### v2.0.0 — 2026-10-07
 Atlas becomes two products on one engine. **Atlas Pro** (`atlas-pro`) is the desktop GIS and draws
 only with MapLibre. **atlas** is the skill: a folder in, a finished map out, in any assistant or an

{env_able-2.0.0 → env_able-2.0.1}/README.md

@@ -378,6 +378,41 @@ print(f"{rows:,} rows written")
 ---
 
 ## Changelog
+### v2.0.1 — 2026-10-15
+**Added**
+- **Calculate Field** in the attribute table: ArcGIS Pro's `!FIELD!` syntax, the selected
+  records only when there is a selection, Preview, and one Undo for the whole column. Parsed with
+  `ast` and interpreted, never `eval`'d: no import, no attribute walk, no oversized strings.
+- **The attribute table has Pro's toolbar**: All | Selected tabs with counts, Select All, Switch,
+  Clear, Zoom To, Add Field and Calculate.
+- **Select is an arrow with a ▾ menu** of Click, Rectangle and Lasso, each with its icon, as in Pro.
+- **Click mode is Pro's Select**: a click picks the topmost feature, a drag picks a box, and
+  Shift adds and Ctrl removes either way. Middle-drag pans while Select is on.
+
+**Fixed**
+- **Shift-drag to add to a selection zoomed the map instead**: Shift-drag is MapLibre's box zoom.
+  Select turns it off while it is on. A tiny Ctrl-drag no longer clears the selection.
+- **Opening an attribute table started editing**, showing Undo, Save As and "Editing" to somebody
+  who had come to read it. Edit, Add Field and Calculate arm it now.
+- **A `.shp` dragged on its own lost its `.prj` and `.dbf`**: the CRS was guessed from the
+  coordinate range and every attribute dropped. Atlas now reads the file where it lives, sidecars
+  and all, when name, size, modified time and a hash of its first and last 256 KB match.
+- **From URL on an ArcGIS group layer loaded nothing**: the group was queried directly and the
+  service answered "Invalid or missing input parameters". A group now loads as its sublayers, a
+  whole `…/MapServer` as every feature layer in it, and a `…/query` address as its layer.
+- **An upload froze the whole application while it loaded**: the read ran on the server's event
+  loop, so the poll, the tiles and the Claude pane all waited. It runs on a worker thread now.
+- **From URL held the layer lock for the whole download**, so every other map change waited on a
+  remote server. It is held for the add only.
+
+**Changed**
+- **Add Layer no longer uploads a file Atlas can find on disk.** A 34,596-feature well layer
+  (183 MB with its `.dbf`) went from 11.2 s to 3.5 s, and is referenced by a save rather than copied.
+- **GeoJSON conversion is 40% faster** (3.3 s to 2.0 s on that layer): attributes column-wise, and
+  points and lines from one vectorised coordinate read. Byte-identical output.
+- **ArcGIS services are fetched by object id, six pages at a time, three layers at once**, with a
+  toast that counts features as they arrive. A ten-layer Alberta service: 72 s to 31 s.
+
 ### v2.0.0 — 2026-10-07
 Atlas becomes two products on one engine. **Atlas Pro** (`atlas-pro`) is the desktop GIS and draws
 only with MapLibre. **atlas** is the skill: a folder in, a finished map out, in any assistant or an

{env_able-2.0.0 → env_able-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "env-able"
-version = "2.0.0"
+version = "2.0.1"
 description = "AI-ready GIS toolkit for energy and subsurface workflows."
 readme = "README.md"
 requires-python = ">=3.8"

{env_able-2.0.0 → env_able-2.0.1}/src/env_able/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 
 # Resolve GDAL_DATA / PROJ_LIB before anything imports osgeo. IDEs and bare
 # `python script.py` runs skip conda's activation scripts, which is where those

env_able-2.0.1/src/env_able/atlas/calc.py

@@ -0,0 +1,211 @@
+"""
+Calculate Field: one expression, evaluated per row, with nothing else reachable.
+
+    calc.compile_expr("!EUR! * 1000", fields)      -> a callable taking a row dict
+    calc.compile_expr("!NAME!.upper()", fields)
+
+ArcGIS Pro's syntax, so an expression copied out of Pro works here: a field is written
+`!FIELD!`. A bare name works too when it is a field (`EUR * 1000`), because that is what people
+type first.
+
+It is Python's grammar, NOT Python. The expression is parsed with `ast` and walked by an
+interpreter that knows a short list of node types; anything else -- attribute access other than
+the string methods below, comprehensions, lambdas, imports, dunder names, calls to anything not
+in FUNCS -- is refused at compile time with the reason. `eval` is never called. That matters
+because the Claude pane can reach this through the same endpoint, and an expression is text a
+model may have been handed by a document it was asked to read.
+"""
+from __future__ import annotations
+
+import ast
+import math
+import operator
+import re
+
+FUNCS = {
+    "abs": abs, "round": round, "min": min, "max": max, "len": len,
+    "str": str, "int": int, "float": float, "bool": bool,
+    "sqrt": math.sqrt, "floor": math.floor, "ceil": math.ceil, "log": math.log,
+    "log10": math.log10, "exp": math.exp,
+}
+#: Methods a string may be asked for. Each returns a string, a bool or an int, so a chain of
+#: them cannot reach anything that is not data.
+STR_METHODS = {"upper", "lower", "title", "capitalize", "strip", "lstrip", "rstrip", "replace",
+               "zfill", "startswith", "endswith", "find", "count", "center", "ljust", "rjust"}
+NAMES = {"None": None, "True": True, "False": False, "pi": math.pi}
+
+_BIN = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
+        ast.Div: operator.truediv, ast.FloorDiv: operator.floordiv, ast.Mod: operator.mod,
+        ast.Pow: operator.pow}
+_UN = {ast.USub: operator.neg, ast.UAdd: operator.pos, ast.Not: operator.not_}
+_CMP = {ast.Eq: operator.eq, ast.NotEq: operator.ne, ast.Lt: operator.lt, ast.LtE: operator.le,
+        ast.Gt: operator.gt, ast.GtE: operator.ge, ast.In: lambda a, b: a in b,
+        ast.NotIn: lambda a, b: a not in b, ast.Is: operator.is_, ast.IsNot: operator.is_not}
+
+_MAX_POW = 1000
+_MAX_LEN = 10_000
+
+
+class CalcError(ValueError):
+    pass
+
+
+def _field_token(i: int) -> str:
+    return "__f%d" % i
+
+
+def compile_expr(expr: str, fields):
+    """
+    A function row -> value for `expr`, or CalcError naming what is not allowed.
+
+    Fields are resolved now, not per row, so a misspelt `!EURR!` fails before anything runs.
+    """
+    src = (expr or "").strip()
+    if not src:
+        raise CalcError("The expression is empty.")
+    if len(src) > 2000:
+        raise CalcError("The expression is too long (2,000 characters at most).")
+    fields = list(fields)
+    lookup = {f.lower(): f for f in fields}
+    slots = {}
+
+    def sub(m):
+        name = m.group(1).strip()
+        real = name if name in fields else lookup.get(name.lower())
+        if real is None:
+            raise CalcError("!%s! is not a field in this layer." % name)
+        if real not in slots:
+            slots[real] = _field_token(len(slots))
+        return slots[real]
+
+    src = re.sub(r"!([^!]+)!", sub, src)
+    try:
+        tree = ast.parse(src, mode="eval")
+    except SyntaxError as e:
+        raise CalcError("That is not a valid expression: %s" % (e.msg or e))
+    byslot = {v: k for k, v in slots.items()}
+
+    def check(node):
+        for n in ast.walk(node):
+            if isinstance(n, ast.Name):
+                if n.id.startswith("__f") and n.id in byslot:
+                    continue
+                if n.id in NAMES or n.id in FUNCS:
+                    continue
+                if n.id in fields or n.id.lower() in lookup:
+                    continue
+                raise CalcError("%r is not a field or a function. Write a field as !NAME!." % n.id)
+            elif isinstance(n, ast.Attribute):
+                if n.attr not in STR_METHODS:
+                    raise CalcError(".%s is not allowed; string methods are: %s"
+                                    % (n.attr, ", ".join(sorted(STR_METHODS))))
+            elif isinstance(n, ast.Call):
+                f = n.func
+                if not ((isinstance(f, ast.Name) and f.id in FUNCS)
+                        or (isinstance(f, ast.Attribute) and f.attr in STR_METHODS)):
+                    raise CalcError("Only these functions are available: %s"
+                                    % ", ".join(sorted(FUNCS)))
+                if n.keywords:
+                    raise CalcError("Keyword arguments are not supported.")
+            elif not isinstance(n, (ast.Expression, ast.BinOp, ast.UnaryOp, ast.BoolOp,
+                                    ast.Compare, ast.IfExp, ast.Constant, ast.Load,
+                                    ast.Subscript, ast.Slice, ast.Tuple, ast.JoinedStr,
+                                    ast.FormattedValue, ast.operator, ast.unaryop,
+                                    ast.boolop, ast.cmpop)):
+                raise CalcError("%s is not allowed in a field calculation."
+                                % type(n).__name__)
+
+    check(tree)
+
+    def ev(n, row):
+        t = type(n)
+        if t is ast.Expression:
+            return ev(n.body, row)
+        if t is ast.Constant:
+            return n.value
+        if t is ast.Name:
+            if n.id in byslot:
+                return row.get(byslot[n.id])
+            if n.id in NAMES:
+                return NAMES[n.id]
+            if n.id in FUNCS:
+                return FUNCS[n.id]
+            return row.get(n.id if n.id in fields else lookup[n.id.lower()])
+        if t is ast.BinOp:
+            a, b = ev(n.left, row), ev(n.right, row)
+            if isinstance(n.op, ast.Pow) and isinstance(b, (int, float)) and abs(b) > _MAX_POW:
+                raise CalcError("An exponent over %d is refused." % _MAX_POW)
+            if isinstance(n.op, ast.Mult) and (isinstance(a, str) or isinstance(b, str)):
+                s, k = (a, b) if isinstance(a, str) else (b, a)
+                if isinstance(k, int) and len(s) * k > _MAX_LEN:
+                    raise CalcError("That would make a string over %d characters." % _MAX_LEN)
+            return _BIN[type(n.op)](a, b)
+        if t is ast.UnaryOp:
+            return _UN[type(n.op)](ev(n.operand, row))
+        if t is ast.BoolOp:
+            if isinstance(n.op, ast.And):
+                v = True
+                for x in n.values:
+                    v = ev(x, row)
+                    if not v:
+                        return v
+                return v
+            v = False
+            for x in n.values:
+                v = ev(x, row)
+                if v:
+                    return v
+            return v
+        if t is ast.Compare:
+            left = ev(n.left, row)
+            for op, c in zip(n.ops, n.comparators):
+                right = ev(c, row)
+                if not _CMP[type(op)](left, right):
+                    return False
+                left = right
+            return True
+        if t is ast.IfExp:
+            return ev(n.body, row) if ev(n.test, row) else ev(n.orelse, row)
+        if t is ast.Call:
+            if isinstance(n.func, ast.Attribute):
+                obj = ev(n.func.value, row)
+                if not isinstance(obj, str):
+                    raise CalcError(".%s() needs text, and this row has %r"
+                                    % (n.func.attr, obj))
+                args = [ev(a, row) for a in n.args]
+                #  zfill(10**9) and friends build the string before anything could cap it.
+                if n.func.attr in ("zfill", "center", "ljust", "rjust") and any(
+                        isinstance(a, int) and a > _MAX_LEN for a in args):
+                    raise CalcError("A width over %d is refused." % _MAX_LEN)
+                return getattr(obj, n.func.attr)(*args)
+            return FUNCS[n.func.id](*[ev(a, row) for a in n.args])
+        if t is ast.Attribute:
+            raise CalcError(".%s must be called, as .%s()" % (n.attr, n.attr))
+        if t is ast.Subscript:
+            obj = ev(n.value, row)
+            s = n.slice
+            if type(s) is ast.Slice:
+                return obj[slice(*(ev(x, row) if x is not None else None
+                                   for x in (s.lower, s.upper, s.step)))]
+            return obj[ev(s, row)]
+        if t is ast.Tuple:
+            return tuple(ev(x, row) for x in n.elts)
+        if t is ast.JoinedStr:
+            return "".join(str(ev(v, row)) for v in n.values)
+        if t is ast.FormattedValue:
+            v = ev(n.value, row)
+            spec = ev(n.format_spec, row) if n.format_spec is not None else ""
+            if any(int(d) > _MAX_LEN for d in re.findall(r"\d+", spec)):
+                raise CalcError("A width over %d is refused." % _MAX_LEN)
+            return format(v, spec)
+        raise CalcError("%s is not allowed in a field calculation." % t.__name__)
+
+    def run(row):
+        try:
+            return ev(tree, row)
+        except CalcError:
+            raise
+        except Exception as e:                                # noqa: BLE001 - row-level, named
+            raise CalcError("%s: %s" % (type(e).__name__, e))
+
+    return run

{env_able-2.0.0 → env_able-2.0.1}/src/env_able/atlas/docs/atlas-guide.md

@@ -8,7 +8,7 @@ GeoPackages, GeoJSON and spreadsheets, browses spatial tables in Databricks, sty
 analyses them, lets you edit their attributes, and lays the result out for print.
 
 It is part of **env-able** (see the separate *env-able* page for the Python library that
-drives it). Version 1.10.
+drives it). Version 2.0.
 
 > **New to Atlas? Take the tour.** There is a **Take the tour** button on the start page,
 > and **File ▸ Take the tour** inside the map. Thirteen steps that spotlight each area and
@@ -332,16 +332,20 @@ says so, rather than freezing.
 ### Selecting features
 
 **Select** on the *General* tab turns selection on; **Esc** turns it off and clears what is
-selected. The dropdown beside it decides how you pick:
+selected. Its icon is an arrow showing the current mode, and the **▾** under it chooses how you
+pick, as ArcGIS Pro's does. Choosing a mode also turns Select on. The cursor is an arrow for
+Click and a crosshair for the modes that draw:
 
 | Mode | How |
 |---|---|
-| **Click** | Click a feature to select the topmost one under the cursor. Panning still works |
+| **Click** | ArcGIS Pro's Select: click a feature to select the topmost one under the cursor, or click and drag a box to select everything it touches |
 | **Rectangle** | Drag a box; everything it touches is selected |
 | **Lasso** | Draw a freehand loop; everything inside it is selected, including a polygon big enough to contain the whole loop |
 
 **Shift** adds to the selection and **Ctrl** removes from it, in every mode. Clicking empty
-space clears it.
+space clears it. While Select is on, Shift-drag selects rather than box-zooming the map, and a
+left drag selects rather than pans: **drag with the middle button** (the wheel) to pan, and the
+wheel still zooms.
 
 The rest of the **Selection** group:
 
@@ -352,7 +356,7 @@ The rest of the **Selection** group:
 | **Clear** | Drops the selection |
 | **Switch** | Selects what is not selected, in each layer that has a selection |
 | **Zoom To** | Frames the selected features |
-| **Attributes** | Opens the attribute table showing only the selected rows. **Selected Only** in the table turns that on and off |
+| **Attributes** | Opens the attribute table on its **Selected** view. **All** and **Selected** at the top of the table switch between the two |
 
 A selection is made **among what the map shows**: features a query has filtered out are out of
 reach, as a definition query puts them out of reach in ArcGIS Pro. Geoprocessing runs on a layer's
@@ -508,9 +512,16 @@ one-line entry in `env_layers.py`.
 
 **Add Layer** on the *Data* group, or **drag a file onto the map**.
 
-Supported: `.shp` (drag the whole folder or pick the `.shp` — Atlas needs the sidecar files),
-`.gpkg`, `.gdb`, `.geojson`/`.json`, `.fgb` (FlatGeobuf), `.parquet` (GeoParquet, the format a
-Databricks table exports to), `.kml`, `.kmz`, `.gpx`, `.csv`, `.xlsx`.
+Supported: `.shp`, `.gpkg`, `.gdb`, `.geojson`/`.json`, `.fgb` (FlatGeobuf), `.parquet`
+(GeoParquet, the format a Databricks table exports to), `.kml`, `.kmz`, `.gpx`, `.csv`, `.xlsx`.
+
+**Atlas reads a file where it lives when it can find it**, so nothing is uploaded. It looks for
+the file in the folders it already knows (where earlier layers and projects came from, and the
+folders around where Atlas was started) and accepts it only if the name, size, modified time and
+a hash of its first and last 256 KB all match. That is why a `.shp` dragged **on its own** still
+gets its `.prj` and `.dbf`: they are read from beside the original. A layer found this way is
+recorded as its own source, so a save references it instead of copying it. A file Atlas cannot
+find is uploaded as before, and a lone `.shp` then needs its sidecars dragged with it.
 
 A **GPX** or **KML** file declares several layers and usually leaves most of them empty — a GPX
 file has waypoints, routes and tracks whether or not it holds any — so Atlas reads the first one
@@ -519,8 +530,11 @@ from a WKT column, including **EWKT** (`SRID=4326;POINT (...)`) as PostGIS and D
 
 **From URL** (beside Add Layer) takes a web address: a file — GeoJSON, GeoPackage, GeoParquet,
 FlatGeobuf, KML/KMZ, GPX, a zipped shapefile — or a **feature service**: an ArcGIS REST layer
-(`…/FeatureServer/0` or `…/MapServer/0`), an OGC API Features collection or a WFS. A service is read
-the way it is designed to be, paged by its own record limit; a file is downloaded once and kept in a
+(`…/FeatureServer/0` or `…/MapServer/0`), an OGC API Features collection or a WFS. An ArcGIS
+**group layer** loads as each of its sublayers, and a whole service (`…/MapServer`) as every
+feature layer in it; an address ending in `/query` is read as its layer. ArcGIS pages are fetched by
+object id, six at a time, three layers at once, and the toast counts features as they arrive.
+Other services are paged by their own record limit; a file is downloaded once and kept in a
 cache, and a file whose address names no format is recognised from its first bytes. Either way the
 result is a file on disk, so it takes the house style like anything dragged in, and a saved project
 reopens it without the network. Downloads are capped at 512 MB and services at 200,000 features.
@@ -848,9 +862,33 @@ cell size.
 The **⋯ menu ▸ Attributes** on a layer row opens its table. You can sort, filter, freeze
 columns, and reorder them.
 
+Across the top, as in ArcGIS Pro:
+
+| Control | Does |
+|---|---|
+| **All** / **Selected** | Two views of the table, each with its count. Selected is greyed when nothing is |
+| **Select All**, **Switch**, **Clear**, **Zoom To** | The selection, for this table's layer only |
+| **Add Field** | Opens Fields with the new-field row ready |
+| **Calculate** | Calculate Field (below) |
+
+### Calculate Field
+
+Pick a field and write an expression, ArcGIS Pro's way: a field is `!NAME!` (click a field
+under the box to insert it). Arithmetic, comparisons, `a if test else b`, f-strings, text
+methods (`.upper()`, `.lower()`, `.title()`, `.strip()`, `.replace()`, `.zfill()` and a few
+more) and `abs`, `round`, `min`, `max`, `len`, `str`, `int`, `float`, `sqrt`, `floor`, `ceil`,
+`log`, `log10`, `exp` are available. Nothing else: an expression cannot import, open files or
+reach anything that is not the row's values.
+
+With a selection it calculates **only the selected records**, and says so; otherwise all of
+them. **Preview** shows the first five results without changing anything. Every row is checked
+against the field's type and domain first, and one that fails stops the whole calculation with
+its row number. The result is staged as **one edit**, so one Undo puts it all back.
+
 ### Editing
 
-Turn on **Edit** in the panel. Then:
+Opening a table does not start editing. Turn on **Edit** in the panel (Add Field and Calculate
+turn it on themselves). Then:
 
 - **double-click a cell** to change a value
 - **right-click a column** to rename it, change its type, or set a domain
@@ -1991,11 +2029,17 @@ naming the host it could not reach.
 
 **Setup failed on GDAL.**
 See *Install* at the top. Setup tries conda-forge then pip; if both failed,
-`conda install -c conda-forge gdal` by hand, then run setup again.
+`conda install -c conda-forge gdal` by hand, then run setup again. With no conda, or a conda that
+is itself broken, install GDAL with **pip** from Christoph Gohlke's Windows wheels
+(github.com/cgohlke/geospatial-wheels) into the skill's own `venv`; the skill's `INSTALL.md` has
+the one command.
 
 **"DLL load failed while importing _gdal" (or any wheel failing to import).**
-The Microsoft C++ runtime, not Python. Nothing in that message says so, which is why setup
-checks for it and prints the download link. Installing it needs admin rights.
+Read the end of the message. *The specified module could not be found* is the Microsoft C++
+runtime, not Python: setup checks for it and prints the download link, and installing it needs
+admin rights. *The specified procedure could not be found* is two GDAL builds mixed in one
+Python, usually after a `conda install` from another channel replaced GDAL's libraries. Do not
+repair that Python; use the pip route above in the skill's own `venv`.
 
 **Colouring by a number does nothing, or everything comes out one colour.**
 Fixed in 1.2, in both Unique Values and Graduated. On an earlier version, type the real min and

{env_able-2.0.0 → env_able-2.0.1}/src/env_able/atlas/docs/env-able-library.md

@@ -8,7 +8,7 @@ Databricks, runs GDAL-backed geoprocessing, translates between formats, and driv
 the interactive map application (see the separate *Atlas* page).
 
 It is designed so an AI assistant can use it reliably: one obvious way to do each thing,
-results that report what happened, and errors that say what to fix. Version 1.10.
+results that report what happened, and errors that say what to fix. Version 2.0.
 
 ---
 
@@ -313,7 +313,8 @@ r1, r2, r3 = await asyncio.gather(
 ```
 
 Async variants exist for every operation: `clip_async`, `buffer_async`, `intersect_async`,
-`union_async`, `dissolve_async`, `near_async`, `spatial_join_async`, `morph_async`, and
+`union_async`, `dissolve_async`, `near_async`, `spatial_join_async`, `erase_async`,
+`simplify_async`, `morph_async`, and
 `SpatialPipeline.run_async()`.
 
 ---