gtfs_df 0.1.1

data/lib/gtfs_df/schema/fare_media.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class FareMedia < BaseGtfsTable
+      SCHEMA = {
+        "fare_media_id" => Polars::String,
+        "fare_media_name" => Polars::String,
+        "fare_media_type" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        fare_media_id
+        fare_media_name
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/fare_products.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class FareProducts < BaseGtfsTable
+      SCHEMA = {
+        "fare_product_id" => Polars::String,
+        "fare_product_name" => Polars::String,
+        "amount" => Polars::Float64,
+        "currency" => Polars::String,
+        "duration" => Polars::Int64,
+        "duration_type" => Polars::String,
+        "fare_media_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        fare_product_id
+        fare_product_name
+        amount
+        currency
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/fare_rules.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class FareRules < BaseGtfsTable
+      SCHEMA = {
+        "fare_id" => Polars::String,
+        "route_id" => Polars::String,
+        "origin_id" => Polars::String,
+        "destination_id" => Polars::String,
+        "contains_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        fare_id
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/fare_transfer_rules.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class FareTransferRules < BaseGtfsTable
+      SCHEMA = {
+        "fare_transfer_rule_id" => Polars::String,
+        "from_leg_group_id" => Polars::String,
+        "to_leg_group_id" => Polars::String,
+        "transfer_count" => Polars::Int64,
+        "duration_limit" => Polars::Int64,
+        "duration_limit_type" => Polars::String,
+        "fare_product_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        fare_transfer_rule_id
+        from_leg_group_id
+        to_leg_group_id
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/feed_info.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class FeedInfo < BaseGtfsTable
+      SCHEMA = {
+        "feed_publisher_name" => Polars::String,
+        "feed_publisher_url" => Polars::String,
+        "feed_lang" => Polars::String,
+        "default_lang" => Polars::String,
+        "feed_start_date" => Polars::String,
+        "feed_end_date" => Polars::String,
+        "feed_version" => Polars::String,
+        "feed_contact_email" => Polars::String,
+        "feed_contact_url" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[feed_publisher_name feed_publisher_url feed_lang].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/frequencies.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Frequencies < BaseGtfsTable
+      SCHEMA = {
+        "trip_id" => Polars::String,
+        "start_time" => Polars::String,
+        "end_time" => Polars::String,
+        "headway_secs" => Polars::Int64,
+        "exact_times" => Polars::Int64
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        trip_id
+        start_time
+        end_time
+        headway_secs
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/levels.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Levels < BaseGtfsTable
+      SCHEMA = {
+        "level_id" => Polars::String,
+        "level_index" => Polars::Float64,
+        "level_name" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[level_id level_index].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/location_group_stops.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class LocationGroupStops < BaseGtfsTable
+      SCHEMA = {
+        "location_group_id" => Polars::String,
+        "stop_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        location_group_id
+        stop_id
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/location_groups.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class LocationGroups < BaseGtfsTable
+      SCHEMA = {
+        "location_group_id" => Polars::String,
+        "location_group_name" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        location_group_id
+        location_group_name
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/networks.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Networks < BaseGtfsTable
+      SCHEMA = {
+        "network_id" => Polars::String,
+        "network_name" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        network_id
+        network_name
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/pathways.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Pathways < BaseGtfsTable
+      SCHEMA = {
+        "pathway_id" => Polars::String,
+        "from_stop_id" => Polars::String,
+        "to_stop_id" => Polars::String,
+        "pathway_mode" => Polars::Enum.new(EnumValues::PATHWAY_MODE.map(&:first)),
+        "is_bidirectional" => Polars::Enum.new(EnumValues::IS_BIDIRECTIONAL.map(&:first)),
+        "length" => Polars::Float64,
+        "traversal_time" => Polars::Int64,
+        "stair_count" => Polars::Int64,
+        "max_slope" => Polars::Float64,
+        "min_width" => Polars::Float64,
+        "signposted_as" => Polars::String,
+        "reversed_signposted_as" => Polars::String
+      }
+
+      REQUIRED_FIELDS = %w[pathway_id from_stop_id to_stop_id pathway_mode is_bidirectional].freeze
+
+      ENUM_VALUE_MAP = {
+        "pathway_mode" => :PATHWAY_MODE,
+        "is_bidirectional" => :IS_BIDIRECTIONAL
+      }
+    end
+  end
+end

data/lib/gtfs_df/schema/rider_categories.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class RiderCategories < BaseGtfsTable
+      SCHEMA = {
+        "rider_category_id" => Polars::String,
+        "rider_category_name" => Polars::String,
+        "rider_category_description" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        rider_category_id
+        rider_category_name
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/route_networks.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class RouteNetworks < BaseGtfsTable
+      SCHEMA = {
+        "route_id" => Polars::String,
+        "network_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        route_id
+        network_id
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/routes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Routes < BaseGtfsTable
+      SCHEMA = {
+        "route_id" => Polars::String,
+        "agency_id" => Polars::String,
+        "route_short_name" => Polars::String,
+        "route_long_name" => Polars::String,
+        "route_desc" => Polars::String,
+        "route_type" => Polars::String,
+        "route_url" => Polars::String,
+        "route_color" => Polars::String,
+        "route_text_color" => Polars::String,
+        "route_sort_order" => Polars::String,
+        "continuous_pickup" => Polars::Int64,
+        "continuous_drop_off" => Polars::Int64,
+        "network_id" => Polars::String,
+        "cemv_support" => Polars::Enum.new(EnumValues::CEMV_SUPPORT.map(&:first))
+      }
+
+      REQUIRED_FIELDS = %w[route_id route_type].freeze
+
+      ENUM_VALUE_MAP = {
+        "route_type" => :ROUTE_TYPE,
+        "continuous_pickup" => :CONTINUOUS_PICKUP,
+        "continuous_drop_off" => :CONTINUOUS_DROP_OFF,
+        "cemv_support" => :CEMV_SUPPORT
+      }
+    end
+  end
+end

data/lib/gtfs_df/schema/shapes.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../base_gtfs_table"
+
+module GtfsDf
+  module Schema
+    class Shapes < BaseGtfsTable
+      SCHEMA = {
+        "shape_id" => Polars::String,
+        "shape_pt_lat" => Polars::Float64,
+        "shape_pt_lon" => Polars::Float64,
+        "shape_pt_sequence" => Polars::Int64,
+        "shape_dist_traveled" => Polars::Float64
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        shape_id
+        shape_pt_lat
+        shape_pt_lon
+        shape_pt_sequence
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/stop_areas.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class StopAreas < BaseGtfsTable
+      SCHEMA = {
+        "stop_area_id" => Polars::String,
+        "stop_area_name" => Polars::String,
+        "stop_area_type" => Polars::String,
+        "parent_stop_area_id" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        stop_area_id
+        stop_area_name
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/stop_attributes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class StopAttributes < BaseGtfsTable
+      SCHEMA = {
+        "stop_id" => Polars::String,
+        "wheelchair_boarding" => Polars::Int64,
+        "bikes_allowed" => Polars::Int64
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        stop_id
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/stop_times.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class StopTimes < BaseGtfsTable
+      SCHEMA = {
+        "trip_id" => Polars::String,
+        "arrival_time" => Polars::String,
+        "departure_time" => Polars::String,
+        "stop_id" => Polars::String,
+        "location_group_id" => Polars::String,
+        "location_id" => Polars::String,
+        "stop_sequence" => Polars::Int64,
+        "stop_headsign" => Polars::String,
+        "start_pickup_drop_off_window" => Polars::String,
+        "end_pickup_drop_off_window" => Polars::String,
+        "pickup_type" => Polars::Enum.new(EnumValues::PICKUP_TYPE.map(&:first)),
+        "drop_off_type" => Polars::Enum.new(EnumValues::DROP_OFF_TYPE.map(&:first)),
+        "continuous_pickup" => Polars::Enum.new(EnumValues::CONTINUOUS_PICKUP.map(&:first)),
+        "continuous_drop_off" => Polars::Enum.new(EnumValues::CONTINUOUS_DROP_OFF.map(&:first)),
+        "shape_dist_traveled" => Polars::Float64,
+        "timepoint" => Polars::Enum.new(EnumValues::TIMEPOINT.map(&:first)),
+        "pickup_booking_rule_id" => Polars::String,
+        "drop_off_booking_rule_id" => Polars::String
+      }
+
+      REQUIRED_FIELDS = %w[trip_id stop_sequence stop_id]
+
+      ENUM_VALUE_MAP = {
+        "pickup_type" => :PICKUP_TYPE,
+        "drop_off_type" => :DROP_OFF_TYPE,
+        "continuous_pickup" => :CONTINUOUS_PICKUP,
+        "continuous_drop_off" => :CONTINUOUS_DROP_OFF,
+        "timepoint" => :TIMEPOINT
+      }
+    end
+  end
+end

data/lib/gtfs_df/schema/stops.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Stops < BaseGtfsTable
+      SCHEMA = {
+        "stop_id" => Polars::String,
+        "stop_code" => Polars::String,
+        "stop_name" => Polars::String,
+        "tts_stop_name" => Polars::String,
+        "stop_desc" => Polars::String,
+        "stop_lat" => Polars::String,
+        "stop_lon" => Polars::Float64,
+        "zone_id" => Polars::String,
+        "stop_url" => Polars::String,
+        "location_type" => Polars::Enum.new(EnumValues::LOCATION_TYPE.map(&:first)),
+        "parent_station" => Polars::String,
+        "stop_timezone" => Polars::String,
+        "wheelchair_boarding" => Polars::Enum.new(EnumValues::WHEELCHAIR_BOARDING.map(&:first)),
+        "level_id" => Polars::String,
+        "platform_code" => Polars::String,
+        "stop_access" => Polars::Enum.new(EnumValues::STOP_ACCESS.map(&:first))
+      }
+
+      REQUIRED_FIELDS = %w[stop_id stop_name stop_lat stop_lon].freeze
+
+      ENUM_VALUE_MAP = {
+        "location_type" => :LOCATION_TYPE,
+        "wheelchair_boarding" => :WHEELCHAIR_BOARDING,
+        "stop_access" => :STOP_ACCESS
+      }
+    end
+  end
+end

data/lib/gtfs_df/schema/transfers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Transfers < BaseGtfsTable
+      SCHEMA = {
+        "from_stop_id" => Polars::String,
+        "to_stop_id" => Polars::String,
+        "transfer_type" => Polars::Int64,
+        "min_transfer_time" => Polars::Int64
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        from_stop_id
+        to_stop_id
+        transfer_type
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/translations.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Translations < BaseGtfsTable
+      SCHEMA = {
+        "table_name" => Polars::String,
+        "field_name" => Polars::String,
+        "language" => Polars::String,
+        "translation" => Polars::String,
+        "record_id" => Polars::String,
+        "record_sub_id" => Polars::String,
+        "field_value" => Polars::String
+      }.freeze
+
+      REQUIRED_FIELDS = %w[
+        table_name
+        field_name
+        language
+        translation
+      ].freeze
+    end
+  end
+end

data/lib/gtfs_df/schema/trips.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  module Schema
+    class Trips < BaseGtfsTable
+      SCHEMA = {
+        "route_id" => Polars::String,
+        "service_id" => Polars::String,
+        "trip_id" => Polars::String,
+        "trip_headsign" => Polars::String,
+        "trip_short_name" => Polars::String,
+        "direction_id" => Polars::Enum.new(EnumValues::DIRECTION_ID.map(&:first)),
+        "block_id" => Polars::String,
+        "shape_id" => Polars::String,
+        "wheelchair_accessible" => Polars::Enum.new(EnumValues::WHEELCHAIR_ACCESSIBLE.map(&:first)),
+        "bikes_allowed" => Polars::Enum.new(EnumValues::BIKES_ALLOWED.map(&:first)),
+        "cars_allowed" => Polars::Enum.new(EnumValues::CARS_ALLOWED.map(&:first))
+      }
+
+      REQUIRED_FIELDS = %w[route_id service_id trip_id]
+
+      ENUM_VALUE_MAP = {
+        "direction_id" => :DIRECTION_ID,
+        "wheelchair_accessible" => :WHEELCHAIR_ACCESSIBLE,
+        "bikes_allowed" => :BIKES_ALLOWED,
+        "cars_allowed" => :CARS_ALLOWED
+      }
+    end
+  end
+end

data/lib/gtfs_df/schema_validator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module GtfsDf
+  class SchemaValidator
+    def initialize(df, klass)
+      @df = df
+      @required_fields = klass::REQUIRED_FIELDS
+      @schema = klass.const_defined?(:SCHEMA) ? klass::SCHEMA : {}
+      @source_class = klass
+      @errors = []
+      @validated = false
+    end
+
+    def valid?
+      validate unless @validated
+      @errors.empty?
+    end
+
+    def errors
+      validate unless @validated
+      @errors
+    end
+
+    private
+
+    def validate
+      @errors.clear
+      if @df.is_a?(Polars::LazyFrame)
+        # Required fields
+        @required_fields.each do |field|
+          @errors << "#{field}: missing" unless @df.columns.include?(field)
+        end
+
+        # Type validation
+        schema = @df.schema
+        @schema.each do |field, expected_type|
+          next unless schema.key?(field)
+
+          actual_type = schema[field]
+          if actual_type != expected_type
+            @errors << "#{field}: Type mismatch. Expected #{expected_type}, got #{actual_type}"
+          end
+        end
+      # Enum and null checks are skipped for LazyFrame
+      # Reason: Both require accessing actual column data, which would
+      # materialize the LazyFrame and defeat lazy evaluation. Only schema-based
+      # checks (required fields, types) are safe to run on LazyFrame metadata.
+
+      else
+        # Required fields
+        @required_fields.each do |field|
+          if !@df.include?(field)
+            @errors << "#{field}: missing"
+          elsif @df[field].null_count > 0
+            @errors << "#{field}: null"
+          end
+        end
+
+        # Enum validation
+        @schema.each do |field, expected_type|
+          next unless @df.include?(field)
+
+          next unless expected_type.is_a?(Polars::Enum)
+
+          allowed = expected_type.categories.to_a
+          invalid = @df[field].drop_nulls.to_a.reject { |v| allowed.include?(v.to_s) }
+          next if invalid.empty?
+
+          # Try to get value descriptions from ENUM_VALUE_MAP
+          value_descs = nil
+          if @source_class&.const_defined?(:ENUM_VALUE_MAP)
+            enum_map = @source_class::ENUM_VALUE_MAP
+            enum_key = enum_map[field] if enum_map
+            if enum_key && GtfsDf::Schema::EnumValues.const_defined?(enum_key)
+              value_descs = GtfsDf::Schema::EnumValues.const_get(enum_key)
+            end
+          end
+          allowed_str = if value_descs
+            value_descs.map { |val, desc| "#{val} (#{desc})" }.join(", ")
+          else
+            allowed.join(", ")
+          end
+          @errors << "#{field}: Invalid value(s) #{invalid.uniq.join(", ")}. Allowed: #{allowed_str}"
+        end
+      end
+      @validated = true
+    end
+  end
+end

data/lib/gtfs_df/utils.rb

@@ -0,0 +1,52 @@
+module GtfsDf
+  module Utils
+    # Parses a GTFS time string
+    #
+    # The input string is expected to be in the HH:MM:SS format (H:MM:SS is
+    # also accepted).
+    #
+    # The time is measured from "noon minus 12h" of the service day
+    # (effectively midnight except for days on which daylight savings time
+    # changes occur). For times occurring after midnight on the service day,
+    # enter the time as a value greater than 24:00:00 in HH:MM:SS.
+    #
+    # @example 14:30:00 for 2:30PM or
+    # 25:35:00 for 1:35AM on the next day.
+    #
+    # @param str String
+    # Parses a GTFS time string or returns integer seconds if already provided.
+    # Accepts Integer (returns as-is), or HH:MM:SS string (possibly >24h).
+    def self.parse_time(str)
+      return str if str.is_a?(Integer)
+      return nil if str.nil? || (str.respond_to?(:strip) && str.strip.empty?)
+
+      parts = str.to_s.split(":")
+      return nil unless parts.size == 3 && parts.all? { |p| p.match?(/^\d+$/) }
+
+      hours, mins, secs = parts.map(&:to_i)
+      hours * 3600 + mins * 60 + secs
+    rescue
+      nil
+    end
+
+    # Parses a GTFS date string
+    #
+    # The input string is expected to be a service day in the YYYYMMDD format.
+    # Since time within a service day may be above 24:00:00, a service day may
+    # contain information for the subsequent day(s).
+    #
+    # @example 20180913 for September 13th, 2018.
+    #
+    # @param str String
+    def self.parse_date(str)
+      return nil if str.nil? || str.strip.empty?
+      return nil unless str.match?(/^\d{8}$/)
+
+      begin
+        Date.strptime(str, "%Y%m%d")
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/gtfs_df/version.rb

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