I prefer to use Cursors for all my joins and relates since in my experience they're much faster than any other option. SearchCursors are cheap and you can use them to extract and manipulate data all you want, then structure that and apply it in one UpdateCursor operation:
from collections.abc import Iterator, Sequence
from typing import Any
from arcpy import Polygon
from arcpy.da import SearchCursor, UpdateCursor
type UpdateMap = dict[int, dict[str, Any]]
"""Mapping of OBJECTID to Field Updates {FieldName: FieldValue, ...}"""
type FeatureMap = dict[str, str]
"""Mapping of FeatureClass to extracted field"""
def get_shapes(fc: str, field: str) -> Iterator[tuple[Polygon, str]]:
yield from SearchCursor(fc, ['SHAPE@', field])
def update_feats(fc: str, updates: UpdateMap, fields: Sequence[str]) -> None:
"""Applies an UpdateMap to the target FeatureClass (Only supplied fields are updated)"""
with UpdateCursor(fc, ['OID@'] + list(fields)) as cur:
for oid, _ in filter(lambda r: r[0] in updates, cur):
cur.updateRow([updates[oid][f] for f in cur.fields[1:]])
def get_intersecting(fc: str, field: str, shape: Polygon, value: Any) -> UpdateMap:
"""Gets all features in the input FeatureClass and matches them with
the target value based on spatial relation
"""
return {
oid: {field: value}
for oid,
in SearchCursor(
fc, ['OID@'],
spatial_filter=shape,
where_clause=f'{field} != {value} OR {field} IS NULL',
search_order='SPATIALFIRST',
)
}
def merge_updates(*updates: UpdateMap) -> UpdateMap:
"""Merges multiple UpdateMaps into one"""
merged: UpdateMap = {}
for update in updates:
for oid, vals in update.items():
if oid in merged:
merged[oid].update(vals)
else:
merged[oid] = vals
return merged
def apply_join(fc: str, feat_map: FeatureMap):
"""Applies Updates to the input features based on the mapping supplied"""
updates: list[UpdateMap] = []
for mapped_feat, field in feat_map.items():
for shape, val in get_shapes(mapped_feat, field):
updates.append(get_intersecting(fc, field, shape, val))
update_feats(fc, merge_updates(*updates), list(feat_map.values()))
def main():
poly_features: FeatureMap = {
'PolyFC1': 'Zone',
'PolyFC2': 'Location',
}
apply_join('PointFC1', poly_features)
apply_join('PointFC2', poly_features)
That apply_join function is the entire business logic, everything else is just to abstract the cursor operations away.
1) Iterate the PolygonClass/Value mapping (PolyFC1 has Zone, etc.)
2) Iterate all Shape/Value combos in that featureclass
3) Get all intersecting points for each shape and add them to an update mapping
4) Merge all updates into one Update map for the Target Point features
5) Apply the updates
Additionally, if you aren't sure that your target features have a matching field name, you can ensure it with a guard clause in the update_feats function:
def update_feats(fc: str, updates: UpdateMap, fields: Sequence[str]) -> None:
"""Applies an UpdateMap to the target FeatureClass (Only supplied fields are updated)"""
for field in fields:
ensure_field(fc, field)
get_fields.cache_clear()
with UpdateCursor(fc, ['OID@'] + list(fields)) as cur:
for oid, _ in filter(lambda r: r[0] in updates, cur):
cur.updateRow([updates[oid][f] for f in cur.fields[1:]])
@cache
def get_fields(fc: str) -> list[str]:
return [f.name for f in ListFields(fc)]
def ensure_field(fc: str, field: str, field_info: dict[str, Any] | None = None, default_type: str = 'TEXT'):
if not field_info:
field_info = {}
if field not in get_fields(fc):
AddField(fc, field, field_info.get(field, default_type))
the @cache decorator is from functools and will prevent the ListFields function from running for every input field. We need to clear the cache after ensuring fields since we've now update the field list. If you want, you can use a global map for the field_info parameter, or you can expose that in update_feats and pass it along.
This is definitely a overengineered solution to this, but I always prefer to be able to adjust the main loop when things change without manually adding tons more code blocks.
