GIS Automation Using Python Training Course

Participants can write core Python constructs used in GIS processing scripts.

• Variables, strings, numbers and Boolean expressions in data-processing scripts
• Lists, dictionaries and tuples for layer parameters and metadata
• Conditional logic controlling geoprocessing branches and validation responses
• Loops applied to feature classes, files, fields and map layers
• Functions designed with arguments, return values and clear responsibilities
• Exceptions handled using try, except, finally and informative messages

Participants can inspect, organise and safely read common GIS data sources.

• Vector geometry types, feature attributes and topology-related processing implications
• Raster bands, cells, nodata values and spatial extent metadata
• GeoPackage, File Geodatabase, Shapefile and GeoJSON format trade-offs
• Pathlib methods for portable paths and systematic file discovery
• Schema inspection before automated joins, appends and field calculations
• Metadata capture for source lineage, dates and processing assumptions

Participants can apply coordinate reference system checks and transformations within scripts.

• Geographic versus projected coordinate systems and measurement consequences
• EPSG identifiers used to specify reproducible coordinate reference systems
• Datum transformation selection for authoritative spatial data sources
• Projection checks before distance, area, buffer and overlay operations
• Reprojecting vector layers with GeoPandas and ArcPy methods
• Raster alignment controls for projection, resolution, extent and cell origin

Participants can automate standard ArcGIS geoprocessing tasks using ArcPy.

• ArcPy workspace settings, environments and overwrite output controls
• Feature class iteration using arcpy.da cursors and field lists
• Buffer, clip, dissolve and intersect tools called from scripts
• Selection workflows using attribute queries and spatial relationships
• Field mapping rules for append, merge and export operations
• ArcPy messages, warnings and errors captured in execution logs

Participants can process vector datasets with GeoPandas and Shapely operations.

• Reading spatial files with geopandas read_file and explicit encodings
• GeoDataFrame filtering using Pandas expressions and attribute conditions
• Spatial joins based on intersects, within and nearest predicates
• Overlay operations for intersection, difference, union and identity analysis
• Geometry repair checks using validity tests and buffer techniques
• Writing GeoPackage outputs with controlled layer names and schemas

Participants can build reliable attribute transformations and GIS data joins.

• Pandas DataFrames used for nonspatial reference and transaction data
• Key-field profiling before one-to-one and one-to-many joins
• Data type conversion, null handling and controlled value standardisation
• Calculated fields created with vectorised Pandas and ArcPy expressions
• Duplicate record detection using composite keys and grouping methods
• Join validation through record counts, unmatched rows and summary statistics

Participants can script repeatable spatial analysis procedures with defined parameters.

• Parameterised buffer analysis using distances, units and exclusion zones
• Proximity analysis with nearest features and distance threshold rules
• Site screening models combining constraints, opportunities and weighted criteria
• Point-in-polygon summaries for service coverage and administrative reporting
• Network analysis inputs prepared for routing and accessibility workflows
• Sensitivity checks comparing alternative thresholds and classification rules

Participants can automate raster inspection, transformation and analysis tasks.

• Rasterio datasets inspected for bands, transforms, masks and coordinate systems
• GDAL commands applied for translation, warping and format conversion
• NumPy arrays used for cell calculations and raster classification
• Raster clipping using vector boundaries and aligned output grids
• Band mathematics for indices, thresholds and change-detection inputs
• Nodata handling prevents false values in zonal and summary outputs

Participants can construct controlled Python workflows for satellite and aerial imagery processing.

• Image acquisition inventories organised by sensor, date, tile and cloud cover
• Band selection rules for Sentinel-2 and Landsat analytical products
• Cloud masks and quality bands applied before raster calculations
• Normalized Difference Vegetation Index calculated with explicit scaling assumptions
• Temporal composites prepared using date windows and pixel selection rules
• Classification outputs assessed using reference samples and confusion matrices

Participants can implement automated checks for spatial and attribute data quality.

• Validation rules defined for completeness, validity, consistency and uniqueness
• Geometry checks identify nulls, empties, duplicates and invalid features
• Domain validation compares attributes against approved code lists
• Range and tolerance tests applied to coordinates, areas and lengths
• Topology exceptions recorded for overlaps, gaps and boundary mismatches
• Quality reports summarise failed records, severity and corrective actions

Participants can connect scripts to managed spatial data stores using safe query patterns.

• PostGIS tables queried through SQLAlchemy connections and parameterised SQL
• Spatial SQL functions for filtering, aggregation and geometry relationships
• Enterprise geodatabase connection files managed outside source code
• Transaction boundaries protect production datasets during automated updates
• Read-only extracts separated from edit workflows and operational tables
• Indexes assessed for spatial query performance and processing time

Participants can retrieve and publish GIS data through controlled web-service requests.

• REST API requests constructed with authentication, parameters and pagination
• Feature service queries filtered by attributes, geometry and record limits
• JSON responses parsed into tabular and spatial processing structures
• Rate limits, retries and timeouts managed for reliable service calls
• ArcGIS REST endpoints used for item, layer and feature operations
• API response logs retained for traceability and incident investigation

Participants can generate standardised maps, charts and tables from automated workflows.

• ArcPy map automation updates layers, symbology and layout text
• Matplotlib charts created from spatial summaries and quality indicators
• Template-based reports populated with run dates and key statistics
• Map export settings controlled for PDF, PNG and resolution requirements
• Classification breaks documented for reproducible thematic map outputs
• Output folders structured by project, date, run and deliverable type

Participants can apply PyQGIS methods within QGIS-based automation environments.

• PyQGIS console, processing toolbox and project objects explained
• QGIS Processing algorithms called with named parameters and outputs
• Model Builder workflows converted into reusable Python processing scripts
• Layer styling applied through QML files and project templates
• Virtual layers and SQL queries used for lightweight analysis
• Open-source library selection based on licensing, support and deployment needs

Participants can diagnose failures and test GIS automation scripts against expected outputs.

• Debugging with breakpoints, variable inspection and controlled test datasets
• Unit tests written for functions, transformations and validation rules
• Test fixtures isolate input data, temporary outputs and expected results
• Assertions compare feature counts, schemas, extents and calculated values
• Logging levels distinguish diagnostic messages, warnings and failures
• Failure scenarios tested for missing files, invalid geometry and empty selections

Participants can prepare readable, documented and transferable GIS automation code.

• PEP 8 naming, formatting and import conventions applied consistently
• Docstrings specify function purpose, parameters, returns and exceptions
• README files describe installation, inputs, outputs and execution steps
• Configuration templates separate user settings from processing logic
• Git commits record purposeful changes and support code review
• Dependency files specify reproducible package versions and environment requirements

Participants can prepare a GIS script for controlled operational use.

• Command-line arguments provide controlled runtime parameters and input locations
• Windows Task Scheduler configured for recurring unattended script execution
• Environment activation ensures scheduled jobs use required package versions
• Runbooks define pre-run checks, escalation paths and recovery procedures
• Access controls protect credentials, sensitive datasets and output locations
• Performance monitoring tracks duration, volumes, failures and resource consumption

Participants can plan a GIS automation initiative with ownership, controls and measurable value.

• Process mapping identifies handoffs, decision points and manual interventions
• Requirements translated into acceptance criteria, test cases and output specifications
• Risk assessment addresses data sensitivity, failures and incorrect automated decisions
• RACI matrices assign script ownership, review authority and operational support
• Benefits measures track time saved, error reduction and service performance
• Implementation roadmaps sequence pilot, validation, release and maintenance activities

Participants can build, review and present a complete documented GIS automation solution for a defined operational requirement.

• Problem statement defines users, source datasets, outputs and acceptance criteria
• Workflow design specifies processing stages, parameters, dependencies and controls
• Python script automates spatial processing, validation and output generation
• Test evidence demonstrates expected results, exceptions and data-quality findings
• Documentation package includes README, configuration template, runbook and data dictionary
• Peer review assesses code clarity, reproducibility, risks and maintainability
• Presentation explains design choices, outputs, controls and implementation recommendations