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

{env_able-2.0.0 → env_able-2.1.0}/.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.1.0}/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.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: env-able
-Version: 2.0.0
+Version: 2.1.0
 Summary: AI-ready GIS toolkit for energy and subsurface workflows.
 License: MIT
 License-File: LICENSE
@@ -235,6 +235,14 @@ Lines and polygons with fewer vertices, no edge moved more than `tolerance`. Mea
 result = env.Simplify("counties.shp", 200, "meters", output="counties_light.gpkg")
 ```
 
+### `env.SummaryStatistics(input_table, statistics_fields, case_field=None, output=None, separator=", ")`
+ArcGIS Pro's Summary Statistics: one row per unique set of `case_field` values, with each statistic asked for, as a **table** (no geometry). The input is a path, a DataFrame or a GeoDataFrame. The statistics are Dissolve's plus `MODE`; a text field takes only `MIN`, `MAX`, `COUNT`, `FIRST`, `LAST`, `UNIQUE`, `CONCATENATE` and `MODE`. Columns are named `SUM_EUR`, and blanks are left out of every statistic.
+
+```python
+result = env.SummaryStatistics("wells.gpkg", [["EUR", "SUM"], ["API", "COUNT"]], case_field="OPERATOR")
+result.gdf          # a pandas DataFrame, one row per operator
+```
+
 ---
 
 ### `env.load(source)` — fluent spatial pipeline
@@ -404,6 +412,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.1.0}/README.md

@@ -209,6 +209,14 @@ Lines and polygons with fewer vertices, no edge moved more than `tolerance`. Mea
 result = env.Simplify("counties.shp", 200, "meters", output="counties_light.gpkg")
 ```
 
+### `env.SummaryStatistics(input_table, statistics_fields, case_field=None, output=None, separator=", ")`
+ArcGIS Pro's Summary Statistics: one row per unique set of `case_field` values, with each statistic asked for, as a **table** (no geometry). The input is a path, a DataFrame or a GeoDataFrame. The statistics are Dissolve's plus `MODE`; a text field takes only `MIN`, `MAX`, `COUNT`, `FIRST`, `LAST`, `UNIQUE`, `CONCATENATE` and `MODE`. Columns are named `SUM_EUR`, and blanks are left out of every statistic.
+
+```python
+result = env.SummaryStatistics("wells.gpkg", [["EUR", "SUM"], ["API", "COUNT"]], case_field="OPERATOR")
+result.gdf          # a pandas DataFrame, one row per operator
+```
+
 ---
 
 ### `env.load(source)` — fluent spatial pipeline
@@ -378,6 +386,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.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "env-able"
-version = "2.0.0"
+version = "2.1.0"
 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.1.0}/src/env_able/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 # 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
@@ -9,8 +9,9 @@ _gdal_env.configure()
 
 from .vector import (
     Clip, Buffer, Intersect, Union, Dissolve, Near, SpatialJoin, Erase, Simplify,
+    SummaryStatistics,
     clip_async, buffer_async, intersect_async, union_async, dissolve_async,
-    near_async, spatial_join_async, erase_async, simplify_async,
+    near_async, spatial_join_async, erase_async, simplify_async, summary_statistics_async,
     SJ_MATCH,
     load,
 )

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

@@ -0,0 +1,308 @@
+"""
+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!`. ArcMap's `[FIELD]` works too, because people still type it, and so does a bare name
+when it is a field (`EUR * 1000`), because that is what people type first.
+
+A null propagates: `!EUR! * 1000` on a row with no EUR gives no value rather than failing the
+whole calculation on that row, and a comparison against a null is false. That is what a database
+does, and it is what someone calculating a 30,000-row column with a few blanks in it expects.
+
+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 keyword
+import math
+import operator
+import re
+
+def _iif(test, a, b):                    # never called: ev() evaluates only the branch taken
+    return a if test else b
+
+
+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,
+    #  The function forms people know from ArcMap and from spreadsheets. iif is lazy, so
+    #  iif(!N! != 0, 1 / !N!, 0) does not divide by zero on the rows it is guarding.
+    "iif": _iif, "upper": str.upper, "lower": str.lower, "trim": str.strip,
+}
+#: Functions that pass a null through rather than tripping over it. bool and iif decide what a
+#: null means themselves, so they are not in it.
+_NULL_SAFE = set(FUNCS) - {"bool", "iif"}
+
+#: One line each, for the expression box's suggestions. Every function and method is listed;
+#: verify.py checks the two agree, so a function cannot be added without its help.
+HELP = {
+    "abs": ("abs(x)", "the value without its sign"),
+    "round": ("round(x, n)", "x to n decimal places"),
+    "min": ("min(a, b)", "the smaller value"),
+    "max": ("max(a, b)", "the larger value"),
+    "len": ("len(text)", "how many characters"),
+    "str": ("str(x)", "x as text"),
+    "int": ("int(x)", "x as a whole number"),
+    "float": ("float(x)", "x as a number"),
+    "bool": ("bool(x)", "true or false"),
+    "sqrt": ("sqrt(x)", "square root"),
+    "floor": ("floor(x)", "round down"),
+    "ceil": ("ceil(x)", "round up"),
+    "log": ("log(x)", "natural logarithm"),
+    "log10": ("log10(x)", "base-10 logarithm"),
+    "exp": ("exp(x)", "e to the power x"),
+    "iif": ("iif(test, a, b)", "a when test is true, otherwise b"),
+    "upper": ("upper(text)", "capitals"),
+    "lower": ("lower(text)", "lower case"),
+    "trim": ("trim(text)", "without leading and trailing spaces"),
+}
+#: 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)
+
+    def sub_bracket(m):
+        #  [NAME] is a field only when NAME is one, and only where a value could start: after a
+        #  name, a closing bracket or a quote it is a subscript (!NAME![0], !NAME![:3]), which
+        #  is Python's and stays Python's.
+        before = src[:m.start()].rstrip()
+        word = re.search(r"[A-Za-z_]\w*$", before)
+        #  ...except after a keyword: `not [ID] == 3` is a value, though `not` ends in a letter.
+        if before and (before[-1].isalnum() or before[-1] in "_)]'\"") and not (
+                word and keyword.iskeyword(word.group(0))):
+            return m.group(0)
+        name = m.group(1).strip()
+        real = name if name in fields else lookup.get(name.lower())
+        if real is None:
+            return m.group(0)
+        if real not in slots:
+            slots[real] = _field_token(len(slots))
+        return slots[real]
+
+    src = re.sub(r"\[([^\[\]]+)\]", sub_bracket, 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.List):
+                #  What a [NAME] that matched no field parses as. Saying "List is not allowed"
+                #  about a typo in a field name would send somebody looking in the wrong place.
+                if len(n.elts) == 1 and isinstance(n.elts[0], ast.Name):
+                    raise CalcError("[%s] is not a field in this layer." % n.elts[0].id)
+                raise CalcError("A list is not allowed in a field calculation.")
+            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 a is None or b is None:
+                return None
+            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:
+            v = ev(n.operand, row)
+            if v is None and not isinstance(n.op, ast.Not):
+                return None
+            return _UN[type(n.op)](v)
+        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)
+                #  Only ==, != and `is` have an answer about a null; anything else is false.
+                if (left is None or right is None) and not isinstance(
+                        op, (ast.Eq, ast.NotEq, ast.Is, ast.IsNot)):
+                    return False
+                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 obj is None:
+                    return None
+                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)
+            fname = n.func.id
+            if fname == "iif":
+                if len(n.args) != 3:
+                    raise CalcError("iif() takes three values: iif(test, a, b).")
+                return ev(n.args[1], row) if ev(n.args[0], row) else ev(n.args[2], row)
+            args = [ev(a, row) for a in n.args]
+            if fname in _NULL_SAFE and any(a is None for a in args):
+                return None
+            if fname in ("upper", "lower", "trim"):
+                if len(args) != 1:
+                    raise CalcError("%s() takes one value." % fname)
+                return FUNCS[fname](str(args[0]))
+            return FUNCS[fname](*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)
+            if obj is None:
+                return None
+            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:
+            #  A null anywhere makes the whole string null, as text concatenation does in a
+            #  database, rather than writing the word "None" into somebody's labels.
+            parts = [ev(v, row) for v in n.values]
+            if any(p is None for p in parts):
+                return None
+            return "".join(str(p) for p in parts)
+        if t is ast.FormattedValue:
+            v = ev(n.value, row)
+            if v is None:
+                return None
+            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