smo_scottish_lidar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e863ff5b29426cd4b10ab869f95e6a87cd1a5531d0a9210b0f84cec1ff3fa0f3
+  data.tar.gz: a3c1b55c62746a9dd9661dc1541c9b0f0f67cf1f969419373333c760aa31f989
+SHA512:
+  metadata.gz: c7ac311402bce11dfbea9e8bcf030df07e7e9d3269f462eb942a8705a6a1d3a3815242f211c1b03dbf6e7413ef6e4dda4250c197dc2696241285a6b16dd8ff74
+  data.tar.gz: b853e6a7f50d7ec73ac3b016dd266bb4352ffe86ab72433689502d6139f15e4e81b16245ca38f38ce2fce7d6216991a13b71b2b5c88eafbd7d450e270441164f

data/README.md

@@ -0,0 +1,246 @@
+# smo_scottish_lidar
+
+A pure Ruby gem for listing and downloading Scottish Public Sector LiDAR data from the [Registry of Open Data on AWS](https://registry.opendata.aws/scottish-lidar/). Built by Sebastian Madrid Ontiveros to support hydraulic modellers in Scotland working on 1D-2D flood risk assessments and model build workflows.
+
+No external dependencies. No AWS CLI. No credentials. Uses only Ruby stdlib (`net/http`, `uri`, `fileutils`). Compatible with InfoWorks ICM 2027 embedded Ruby.
+
+---
+
+## What is this data?
+
+The Scottish Government has made LiDAR survey data publicly available through an S3 bucket (`srsp-open-data`). The dataset covers most of Scotland across five survey phases plus a dedicated Outer Hebrides survey. Each phase includes:
+
+- **DSM** - Digital Surface Model (includes buildings, trees, structures)
+- **DTM** - Digital Terrain Model (bare earth, vegetation removed)
+- **LAZ** - Raw LiDAR point cloud in compressed LAS format
+
+Files are organised by OS National Grid square (e.g. NS, NT, NO, NN) and are free to download.
+
+| Phase | Area covered |
+|---|---|
+| phase-1 | Central Scotland |
+| phase-2 | South and East Scotland |
+| phase-3 | North and West Scotland |
+| phase-4 | Additional coverage |
+| phase-5 | Latest survey phase |
+| outer-hebrides | Western Isles (25cm and 50cm resolution) |
+
+---
+
+## Installation
+
+```sh
+gem install smo_scottish_lidar
+```
+
+```ruby
+require "smo_scottish_lidar"
+```
+
+---
+
+## Quick start
+
+```ruby
+require "smo_scottish_lidar"
+
+# List all Phase 1 DSM tiles in the NS grid square
+lister = SmoScottishLidar::Lister.new
+lister.summary("phase-1", "dsm", grid_square: "NS")
+
+# Download a single tile
+downloader = SmoScottishLidar::Downloader.new
+downloader.download_file("phase-1", "dsm", "NS56_1M_DSM_PHASE1.tif",
+  destination: "/tmp/lidar"
+)
+
+# Batch download all NS tiles for Phase 1 DSM
+downloader.download("phase-1", "dsm",
+  destination: "/tmp/lidar/phase-1/dsm",
+  grid_square: "NS"
+)
+```
+
+---
+
+## API reference
+
+### `SmoScottishLidar::Lister`
+
+Lists available files from the S3 bucket. All filtering is done client-side after fetching the S3 listing.
+
+```ruby
+lister = SmoScottishLidar::Lister.new(verbose: false)
+```
+
+#### `lister.list(phase, type, grid_square: nil, resolution: nil)`
+
+Returns an `Array<Hash>` of matching files. Each hash contains:
+
+| Key | Type | Description |
+|---|---|---|
+| `:key` | String | Full S3 object key |
+| `:filename` | String | Bare filename (e.g. `NS56_1M_DSM_PHASE1.tif`) |
+| `:size` | Integer | File size in bytes |
+| `:last_modified` | String | ISO 8601 timestamp |
+
+```ruby
+files = lister.list("phase-1", "dsm", grid_square: "NS")
+files.each { |f| puts "#{f[:filename]}  #{f[:size]} bytes" }
+```
+
+#### `lister.summary(phase, type, grid_square: nil, resolution: nil)`
+
+Prints a formatted table to stdout and returns the same `Array<Hash>`.
+
+```ruby
+lister.summary("phase-2", "dtm", grid_square: "NT")
+lister.summary("outer-hebrides", "dsm", resolution: "50cm")
+```
+
+---
+
+### `SmoScottishLidar::Downloader`
+
+Downloads files from the S3 bucket. Streams in chunks to avoid loading large files into memory.
+
+```ruby
+downloader = SmoScottishLidar::Downloader.new(verbose: false)
+```
+
+#### `downloader.download(phase, type, destination:, ...)`
+
+Downloads all tiles matching the given filters. Returns a summary hash `{ downloaded: [...], skipped: [...], failed: [...] }`.
+
+```ruby
+downloader.download(
+  "phase-1", "dsm",
+  destination:   "/tmp/lidar/phase-1/dsm",
+  grid_square:   "NS",          # optional. nil downloads everything
+  skip_existing: true,          # skip files already on disk at the correct size
+  dry_run:       false          # set true to preview without downloading
+)
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `destination:` | required | Local directory to save files into |
+| `grid_square:` | `nil` | OS grid square filter, e.g. `"NS"`, `"NT"` |
+| `resolution:` | `nil` | Outer Hebrides only, e.g. `"25cm"`, `"50cm"`, `"4ppm"`, `"16ppm"` |
+| `skip_existing:` | `true` | Skip files that already exist locally at the correct size |
+| `dry_run:` | `false` | Print what would be downloaded without downloading |
+
+#### `downloader.download_file(phase, type, filename, destination:, resolution: nil)`
+
+Downloads a single tile by exact filename.
+
+```ruby
+downloader.download_file(
+  "phase-1", "dsm", "NS56_1M_DSM_PHASE1.tif",
+  destination: "/tmp/lidar"
+)
+```
+
+---
+
+### `SmoScottishLidar.prefix_for(phase, type, resolution: nil)`
+
+Returns the S3 prefix string for a given phase and type. Useful if you need to build custom queries.
+
+```ruby
+SmoScottishLidar.prefix_for("phase-1", "dsm")
+# => "lidar/phase-1/dsm/27700/gridded/"
+
+SmoScottishLidar.prefix_for("outer-hebrides", "dtm", resolution: "50cm")
+# => "lidar/outer-hebrides/2019/dtm/50cm/27700/gridded/"
+```
+
+---
+
+## Valid phases and types
+
+```ruby
+SmoScottishLidar::PHASES
+# => ["phase-1", "phase-2", "phase-3", "phase-4", "phase-5", "outer-hebrides"]
+
+SmoScottishLidar::DATASET_TYPES
+# => ["dsm", "dtm", "laz"]
+```
+
+### Outer Hebrides resolutions
+
+| Type | Available resolutions |
+|---|---|
+| dsm | `"25cm"` (default), `"50cm"` |
+| dtm | `"25cm"` (default), `"50cm"` |
+| laz | `"4ppm"` (default), `"16ppm"` |
+
+---
+
+## Examples
+
+The `examples/` directory contains ready-to-run scripts:
+
+| Script | Description |
+|---|---|
+| `demo.rb` | Full walkthrough of all features |
+| `phase_1_dsm.rb` | List Phase 1 DSM tiles |
+| `phase_1_dtm.rb` | List Phase 1 DTM tiles |
+| `phase_1_laz.rb` | List Phase 1 LAZ tiles |
+| `phase_2_dsm.rb` ... | One script per phase and type |
+| `outer_hebrides_dsm.rb` | Outer Hebrides DSM |
+| `outer_hebrides_dtm.rb` | Outer Hebrides DTM |
+| `outer_hebrides_laz.rb` | Outer Hebrides LAZ |
+| `download_individual_tile.rb` | Download a single named tile |
+| `download_batch_tiles.rb` | Batch download with grid square filter |
+
+Run any script with:
+
+```sh
+ruby examples/phase_1_dsm.rb
+```
+
+---
+
+## Typical workflow for hydraulic modelling
+
+```ruby
+require "smo_scottish_lidar"
+
+downloader = SmoScottishLidar::Downloader.new(verbose: true)
+
+# 1. Check what is available for your catchment (e.g. NS and NS grid squares)
+lister = SmoScottishLidar::Lister.new
+lister.summary("phase-1", "dtm", grid_square: "NS")
+
+# 2. Dry run first to confirm file sizes and count
+downloader.download("phase-1", "dtm",
+  destination: "/projects/my_catchment/lidar/dtm",
+  grid_square: "NS",
+  dry_run: true
+)
+
+# 3. Download for real
+downloader.download("phase-1", "dtm",
+  destination: "/projects/my_catchment/lidar/dtm",
+  grid_square: "NS",
+  dry_run: false
+)
+
+# 4. If the download is interrupted, re-run the same command.
+# Files already on disk at the correct size are skipped automatically.
+```
+
+---
+
+## Support
+
+If this gem saves you time on a project, you can buy me a coffee.
+
+[![Buy Me a Coffee](https://github.com/Sebasmadridmx/SMO-WGS84-TO-BNG/blob/main/temp_png/buymecoffeeqr.png)](https://buymeacoffee.com/smadrid)
+
+---
+
+## License
+
+MIT. Copyright (c) 2024 Sebastian Madrid Ontiveros.

data/lib/smo_scottish_lidar/client.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module SmoScottishLidar
+  # Low-level S3 client. Uses only Ruby stdlib net/http.
+  # Accesses the public (unsigned) srsp-open-data bucket directly over HTTPS.
+  class Client
+    MAX_KEYS = 1000
+
+    def initialize(verbose: false)
+      @verbose = verbose
+    end
+
+    # Lists all object keys under a given S3 prefix.
+    # Handles S3 pagination (continuation tokens) automatically.
+    # Returns an Array of Hashes: [{ key:, size:, last_modified: }, ...]
+    def list_objects(prefix)
+      objects = []
+      continuation_token = nil
+
+      loop do
+        xml = fetch_list_page(prefix, continuation_token)
+        page_objects, next_token, truncated = parse_list_response(xml)
+        objects.concat(page_objects)
+
+        break unless truncated
+
+        continuation_token = next_token
+      end
+
+      objects
+    end
+
+    # Downloads a single S3 object key to a local file path.
+    # Follows redirects, streams in chunks to avoid loading into memory.
+    # Returns true on success, raises on error.
+    def download_object(key, local_path, &progress_block)
+      url = "#{BASE_URL}/#{key}"
+      log "Downloading: #{url} -> #{local_path}"
+
+      uri = URI.parse(url)
+      fetch_with_redirect(uri, local_path, &progress_block)
+      true
+    end
+
+    private
+
+    def fetch_list_page(prefix, continuation_token)
+      params = {
+        "list-type" => "2",
+        "prefix"    => prefix,
+        "max-keys"  => MAX_KEYS.to_s
+      }
+      params["continuation-token"] = continuation_token if continuation_token
+
+      query = params.map { |k, v| "#{uri_encode(k)}=#{uri_encode(v)}" }.join("&")
+      uri = URI.parse("#{BASE_URL}/?#{query}")
+
+      log "Listing: #{uri}"
+      response = get_response(uri)
+      response.body
+    end
+
+    def parse_list_response(xml)
+      objects = []
+
+      xml.scan(%r{<Contents>(.*?)</Contents>}m).each do |match|
+        block = match[0]
+        key   = extract_tag(block, "Key")
+        size  = extract_tag(block, "Size").to_i
+        mtime = extract_tag(block, "LastModified")
+        objects << { key: key, size: size, last_modified: mtime }
+      end
+
+      truncated = extract_tag(xml, "IsTruncated") == "true"
+      next_token = extract_tag(xml, "NextContinuationToken")
+
+      [objects, next_token, truncated]
+    end
+
+    def fetch_with_redirect(uri, local_path, redirects_remaining: 5, &progress_block)
+      raise "Too many redirects" if redirects_remaining.zero?
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        request = Net::HTTP::Get.new(uri.request_uri)
+        http.request(request) do |response|
+          case response.code.to_i
+          when 200
+            total = response["content-length"]&.to_i
+            received = 0
+            File.open(local_path, "wb") do |f|
+              response.read_body do |chunk|
+                f.write(chunk)
+                received += chunk.bytesize
+                progress_block&.call(received, total)
+              end
+            end
+          when 301, 302, 307, 308
+            location = response["location"]
+            raise "Redirect with no Location header" unless location
+
+            log "Redirect -> #{location}"
+            fetch_with_redirect(URI.parse(location), local_path,
+                                redirects_remaining: redirects_remaining - 1,
+                                &progress_block)
+          else
+            raise "HTTP #{response.code} for #{uri}"
+          end
+        end
+      end
+    end
+
+    def get_response(uri, redirects_remaining: 5)
+      raise "Too many redirects listing #{uri}" if redirects_remaining.zero?
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        response = http.get(uri.request_uri)
+        case response.code.to_i
+        when 200
+          response
+        when 301, 302, 307, 308
+          location = response["location"]
+          raise "Redirect with no Location header" unless location
+
+          log "Redirect -> #{location}"
+          get_response(URI.parse(location), redirects_remaining: redirects_remaining - 1)
+        else
+          raise "HTTP #{response.code} listing #{uri}"
+        end
+      end
+    end
+
+    def extract_tag(xml, tag)
+      match = xml.match(%r{<#{tag}>(.*?)</#{tag}>}m)
+      match ? match[1].strip : ""
+    end
+
+    def uri_encode(str)
+      URI.encode_uri_component(str.to_s)
+    end
+
+    def log(msg)
+      warn "[smo_scottish_lidar] #{msg}" if @verbose
+    end
+  end
+end

data/lib/smo_scottish_lidar/constants.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SmoScottishLidar
+  BUCKET = "srsp-open-data"
+  BASE_PREFIX = "lidar"
+  REGION = "eu-west-2"
+  BASE_URL = "https://#{BUCKET}.s3.#{REGION}.amazonaws.com"
+
+  # Valid phases and dataset types derived from the Scottish Government
+  # Registry of Open Data on AWS documentation.
+  PHASES = %w[phase-1 phase-2 phase-3 phase-4 phase-5 outer-hebrides].freeze
+  DATASET_TYPES = %w[dsm dtm laz].freeze
+
+  # Outer Hebrides has resolution sub-folders; all other phases do not.
+  OUTER_HEBRIDES_RESOLUTIONS = {
+    "dsm" => %w[25cm 50cm],
+    "dtm" => %w[25cm 50cm],
+    "laz" => %w[4ppm 16ppm]
+  }.freeze
+
+  # Canonical S3 prefix builder. Returns the prefix string (no bucket).
+  # Examples:
+  #   prefix_for("phase-1", "dsm")           => "lidar/phase-1/dsm/27700/gridded/"
+  #   prefix_for("outer-hebrides", "dtm", resolution: "50cm") => "lidar/outer-hebrides/2019/dtm/50cm/27700/gridded/"
+  def self.prefix_for(phase, type, resolution: nil)
+    validate_phase!(phase)
+    validate_type!(type)
+
+    if phase == "outer-hebrides"
+      res = resolve_outer_hebrides_resolution(type, resolution)
+      "#{BASE_PREFIX}/outer-hebrides/2019/#{type}/#{res}/27700/gridded/"
+    else
+      "#{BASE_PREFIX}/#{phase}/#{type}/27700/gridded/"
+    end
+  end
+
+  def self.validate_phase!(phase)
+    return if PHASES.include?(phase)
+
+    raise ArgumentError, "Unknown phase '#{phase}'. Valid: #{PHASES.join(', ')}"
+  end
+
+  def self.validate_type!(type)
+    return if DATASET_TYPES.include?(type)
+
+    raise ArgumentError, "Unknown dataset type '#{type}'. Valid: #{DATASET_TYPES.join(', ')}"
+  end
+
+  def self.resolve_outer_hebrides_resolution(type, resolution)
+    available = OUTER_HEBRIDES_RESOLUTIONS[type]
+    if resolution.nil?
+      available.first
+    elsif available.include?(resolution)
+      resolution
+    else
+      raise ArgumentError,
+            "Resolution '#{resolution}' not available for outer-hebrides #{type}. " \
+            "Available: #{available.join(', ')}"
+    end
+  end
+end

data/lib/smo_scottish_lidar/downloader.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SmoScottishLidar
+  # Downloads LiDAR files from the Scottish Government S3 bucket.
+  # No external dependencies. Uses only Ruby stdlib.
+  class Downloader
+    attr_reader :client, :lister
+
+    def initialize(verbose: false)
+      @client  = Client.new(verbose: verbose)
+      @lister  = Lister.new(verbose: verbose)
+      @verbose = verbose
+    end
+
+    # Download all files for a given phase/type, with optional filtering.
+    #
+    # @param phase        [String]  e.g. "phase-1", "outer-hebrides"
+    # @param type         [String]  "dsm", "dtm", or "laz"
+    # @param destination  [String]  Local directory to save files into
+    # @param grid_square  [String, nil] OS grid square filter e.g. "NS"
+    # @param resolution   [String, nil] Outer Hebrides resolution e.g. "50cm"
+    # @param skip_existing [Boolean] Skip files that already exist locally (default: true)
+    # @param dry_run      [Boolean] List what would be downloaded without downloading
+    # @return [Hash] { downloaded: [...], skipped: [...], failed: [...] }
+    def download(phase, type,
+                 destination:,
+                 grid_square: nil,
+                 resolution: nil,
+                 skip_existing: true,
+                 dry_run: false)
+
+      FileUtils.mkdir_p(destination) unless dry_run
+
+      objects = lister.list(phase, type, grid_square: grid_square, resolution: resolution)
+
+      if objects.empty?
+        puts "No files matched your criteria."
+        return { downloaded: [], skipped: [], failed: [] }
+      end
+
+      total_bytes = objects.sum { |o| o[:size] }
+      puts "Found #{objects.size} file(s) (#{format_bytes(total_bytes)} total)"
+      puts "Destination: #{destination}"
+      puts "(Dry run - no files will be downloaded)" if dry_run
+      puts
+
+      results = { downloaded: [], skipped: [], failed: [] }
+
+      objects.each_with_index do |obj, idx|
+        local_path = File.join(destination, obj[:filename])
+        label = "[#{idx + 1}/#{objects.size}] #{obj[:filename]} (#{format_bytes(obj[:size])})"
+
+        if skip_existing && File.exist?(local_path) && File.size(local_path) == obj[:size]
+          puts "SKIP  #{label}"
+          results[:skipped] << obj[:filename]
+          next
+        end
+
+        if dry_run
+          puts "WOULD #{label}"
+          results[:downloaded] << obj[:filename]
+          next
+        end
+
+        print "GET   #{label} ... "
+        $stdout.flush
+
+        begin
+          client.download_object(obj[:key], local_path) do |received, total|
+            next unless @verbose && total
+
+            pct = (received.to_f / total * 100).round(1)
+            print "\rGET   #{label} ... #{pct}%"
+            $stdout.flush
+          end
+          puts "OK"
+          results[:downloaded] << obj[:filename]
+        rescue StandardError => e
+          puts "FAILED (#{e.message})"
+          results[:failed] << { file: obj[:filename], error: e.message }
+        end
+      end
+
+      print_summary(results)
+      results
+    end
+
+    # Convenience: download a single file by its S3 key or filename.
+    #
+    # @param phase       [String]
+    # @param type        [String]
+    # @param filename    [String] Exact filename to download
+    # @param destination [String] Local directory
+    # @param resolution  [String, nil]
+    def download_file(phase, type, filename, destination:, resolution: nil)
+      prefix = SmoScottishLidar.prefix_for(phase, type, resolution: resolution)
+      key    = "#{prefix}#{filename}"
+      local  = File.join(destination, filename)
+
+      FileUtils.mkdir_p(destination)
+      puts "Downloading #{filename} ..."
+      client.download_object(key, local)
+      puts "Saved to #{local}"
+      local
+    end
+
+    private
+
+    def print_summary(results)
+      puts
+      puts "Done. Downloaded: #{results[:downloaded].size}, " \
+           "Skipped: #{results[:skipped].size}, " \
+           "Failed: #{results[:failed].size}"
+
+      return if results[:failed].empty?
+
+      puts "Failed files:"
+      results[:failed].each { |f| puts "  #{f[:file]}: #{f[:error]}" }
+    end
+
+    def format_bytes(bytes)
+      units = %w[B KB MB GB TB]
+      idx = 0
+      size = bytes.to_f
+      while size >= 1024 && idx < units.size - 1
+        size /= 1024.0
+        idx += 1
+      end
+      format("%.1f %s", size, units[idx])
+    end
+  end
+end

data/lib/smo_scottish_lidar/lister.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SmoScottishLidar
+  # Lists available LiDAR files from the Scottish Government S3 bucket.
+  # All filtering is done client-side after fetching the S3 listing.
+  class Lister
+    attr_reader :client
+
+    def initialize(verbose: false)
+      @client = Client.new(verbose: verbose)
+    end
+
+    # List files for a given phase and dataset type.
+    #
+    # @param phase       [String] e.g. "phase-1", "outer-hebrides"
+    # @param type        [String] "dsm", "dtm", or "laz"
+    # @param grid_square [String, nil] Optional OS grid square filter, e.g. "NS", "NT"
+    # @param resolution  [String, nil] For outer-hebrides only, e.g. "50cm", "4ppm"
+    # @return [Array<Hash>] Array of { key:, size:, last_modified:, filename: }
+    def list(phase, type, grid_square: nil, resolution: nil)
+      prefix = SmoScottishLidar.prefix_for(phase, type, resolution: resolution)
+      objects = client.list_objects(prefix)
+
+      objects.map! do |obj|
+        obj.merge(filename: File.basename(obj[:key]))
+      end
+
+      if grid_square
+        pattern = grid_square.upcase
+        objects.select! { |obj| obj[:filename].upcase.start_with?(pattern) }
+      end
+
+      objects
+    end
+
+    # Print a human-readable summary of available files.
+    def summary(phase, type, grid_square: nil, resolution: nil)
+      objects = list(phase, type, grid_square: grid_square, resolution: resolution)
+
+      if objects.empty?
+        puts "No files found."
+        return objects
+      end
+
+      total_bytes = objects.sum { |o| o[:size] }
+
+      puts "Phase     : #{phase}"
+      puts "Type      : #{type}"
+      puts "Grid sq.  : #{grid_square || '(all)'}"
+      puts "Files     : #{objects.size}"
+      puts "Total size: #{format_bytes(total_bytes)}"
+      puts
+      puts format("%-50s %10s  %s", "Filename", "Size", "Last Modified")
+      puts "-" * 80
+      objects.each do |obj|
+        puts format("%-50s %10s  %s", obj[:filename], format_bytes(obj[:size]), obj[:last_modified])
+      end
+
+      objects
+    end
+
+    private
+
+    def format_bytes(bytes)
+      units = %w[B KB MB GB TB]
+      idx = 0
+      size = bytes.to_f
+      while size >= 1024 && idx < units.size - 1
+        size /= 1024.0
+        idx += 1
+      end
+      format("%.1f %s", size, units[idx])
+    end
+  end
+end

data/lib/smo_scottish_lidar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SmoScottishLidar
+  VERSION = "0.1.0"
+end

data/lib/smo_scottish_lidar.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "smo_scottish_lidar/version"
+require_relative "smo_scottish_lidar/constants"
+require_relative "smo_scottish_lidar/client"
+require_relative "smo_scottish_lidar/downloader"
+require_relative "smo_scottish_lidar/lister"

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: smo_scottish_lidar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sebastian Madrid Ontiveros
+bindir: bin
+cert_chain: []
+date: 2026-05-04 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Developed by Sebastian Madrid Ontiveros to support hydraulic modellers in Scotland
+  building 1D-2D hydraulic models and flood risk assessments. Provides a pure Ruby
+  interface for listing and downloading Scottish Public Sector LiDAR datasets (DSM,
+  DTM, LAZ) from the Registry of Open Data on AWS. Supports all survey phases (1-5)
+  and Outer Hebrides, OS National Grid square filtering, paginated S3 listing, streamed
+  downloads with resume support, and dry-run mode. No external dependencies. Uses only
+  Ruby stdlib (net/http, uri, fileutils). If this gem saves you time, consider buying
+  Sebastian a coffee at https://buymeacoffee.com/smadrid
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/smo_scottish_lidar.rb
+- lib/smo_scottish_lidar/client.rb
+- lib/smo_scottish_lidar/constants.rb
+- lib/smo_scottish_lidar/downloader.rb
+- lib/smo_scottish_lidar/lister.rb
+- lib/smo_scottish_lidar/version.rb
+homepage: https://github.com/Sebasmadridmx/smo_scottish_lidar
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Download Scottish Public Sector LiDAR data from the Registry of Open Data
+  on AWS.
+test_files: []