cta_redux 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69b3ea9908066bc8bdbf52865df0885b2c7bc5a3
+  data.tar.gz: 60ec4638cb25ad8a65e1282252bc630972c9fa8f
+SHA512:
+  metadata.gz: f77382a34fb99fce097142a98c22c3bed8a25992e31279ea18887c3a0398c97346717138019486d5cfdebbefe67a0f3173a517383d8021d516faa8366e8efcbd
+  data.tar.gz: 513d7dca04757788ebc544f1437b852094f9ab1e13c1331380395cc7a369c5d82f97022879052fbfb4bcd6842433fe6c8d15f57e1a66d49597fde5cfd2085200

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+*.swp
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+/data/cta-gtfs.db

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cta-api-redux.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Andrew Hayworth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,16 @@
+# cta_redux
+
+# Reloading CTA GTFS data
+
+Note that this will take a long time - there are several million stop_time records.
+
+1. cd data && curl 'http://www.transitchicago.com/downloads/sch_data/<latest file>' > gtfs.zip && unzip gtfs.zip
+
+2. cd ../script && for i in `ls ../data/*.txt`; do echo $i; ./gtfs_to_sqlite.rb $i ../data/cta-gtfs.db; done
+
+3. rm ../data/*{txt,htm,zip}
+
+4. cd ../data && gzip cta-gtfs.db
+
+5. Commit / push / create release and gem
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/cta_redux.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cta_redux/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cta_redux"
+  spec.version       = CTA::VERSION
+  spec.authors       = ["Andrew Hayworth"]
+  spec.email         = ["ahayworth@gmail.com"]
+  spec.summary       = %q{A clean, integrated API for CTA BusTracker, TrainTracker, customer alerts, and GTFS data.}
+  spec.description   = %q{cta_redux takes the data provided by the CTA in its various forms, and turns it into a clean,
+                          cohesive client API that can be used to easily build a transit related project. Using Sequel,
+                          we integrate GTFS scheduled service data with live data provided by the CTA's various APIs (like
+                          BusTracker, TrainTracker, and the CTA customer alerts feed.}
+  spec.homepage      = "http://ctaredux.ahayworth.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_dependency "sequel", ">= 4.19.0"
+  spec.add_dependency "sqlite3", ">= 1.3.10"
+  spec.add_dependency "faraday", ">= 0.9.1"
+  spec.add_dependency "faraday_middleware", ">= 0.9.1"
+  spec.add_dependency "multi_xml", ">= 0.5.5"
+end

data/lib/cta_redux/api/api_response.rb

@@ -0,0 +1,45 @@
+module CTA
+  class API
+    class Error
+      attr_reader :code
+      attr_reader :message
+
+      def initialize(options = {})
+        @message = options[:message] || "OK"
+        @code = options[:code] ? options[:code].to_i : (@message == "OK" ? 0 : 1)
+      end
+    end
+
+    class Response
+      attr_reader :timestamp
+      attr_reader :error
+      attr_reader :raw_body
+      attr_reader :parsed_body
+
+      def initialize(parsed_body, raw_body, debug)
+        if parsed_body["bustime_response"]
+          @timestamp = DateTime.now
+          if parsed_body["bustime_response"].has_key?("error")
+            @error = Error.new({ :message => parsed_body["bustime_response"]["error"]["msg"] })
+          else
+            @error = Error.new
+          end
+        elsif parsed_body["ctatt"]
+          @timestamp = DateTime.parse(parsed_body["ctatt"]["tmst"])
+          @error = Error.new({ :code => parsed_body["ctatt"]["errCd"], :message => parsed_body["ctatt"]["errNm"] })
+        else # CustomerAlert
+          key = parsed_body["CTARoutes"] ? "CTARoutes" : "CTAAlerts"
+          code = Array.wrap(parsed_body[key]["ErrorCode"]).flatten.compact.uniq.first
+          msg = Array.wrap(parsed_body[key]["ErrorMessage"]).flatten.compact.uniq.first
+          @timestamp = DateTime.parse(parsed_body[key]["TimeStamp"])
+          @error = Error.new({ :code => code, :message => msg })
+        end
+
+        if debug
+          @parsed_body = parsed_body
+          @raw_body = raw_body
+        end
+      end
+    end
+  end
+end

data/lib/cta_redux/api/bus_tracker.rb

@@ -0,0 +1,178 @@
+require 'date'
+require 'faraday'
+require 'multi_xml'
+
+module CTA
+  class BusTracker
+
+    class VehiclesResponse < CTA::API::Response
+      attr_reader :vehicles
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @vehicles = Array.wrap(parsed_body["bustime_response"]["vehicle"]).map do |v|
+          bus = CTA::Bus.find_active_run(v["rt"], v["tmstmp"], (v["dly"] == "true")).first
+          bus.live!(v)
+
+          bus
+        end
+      end
+    end
+
+    class TimeResponse < CTA::API::Response
+      attr_reader :timestamp
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @timestamp = DateTime.parse(parsed_body["bustime_response"]["tm"])
+      end
+    end
+
+    class RoutesResponse < CTA::API::Response
+      attr_reader :routes
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @routes = Array.wrap(parsed_body["bustime_response"]["route"]).map do |r|
+          rt = CTA::Route.where(:route_id => r["rt"]).first
+          rt.route_color = r["rtclr"]
+
+          rt
+        end
+      end
+    end
+
+    class DirectionsResponse < CTA::API::Response
+      attr_reader :directions
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @directions = Array.wrap(parsed_body["bustime_response"]["dir"]).map { |d| Direction.new(d) }
+      end
+    end
+
+    class StopsResponse < CTA::API::Response
+      attr_reader :stops
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @stops = Array.wrap(parsed_body["bustime_response"]["stop"]).map do |s|
+          CTA::Stop.where(:stop_id => s["stpid"]).first || CTA::Stop.new_from_api_response(s)
+        end
+      end
+    end
+
+    class PatternsResponse < CTA::API::Response
+      attr_reader :patterns
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @patterns = Array.wrap(parsed_body["bustime_response"]["ptr"]).map { |p| Pattern.new(p) }
+      end
+    end
+
+    class PredictionsResponse < CTA::API::Response
+      attr_reader :vehicles
+      attr_reader :predictions
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @vehicles = Array.wrap(parsed_body["bustime_response"]["prd"]).map do |p|
+          bus = CTA::Bus.find_active_run(p["rt"], p["tmstmp"], (p["dly"] == "true")).first
+          bus.live!(p, p)
+
+          bus
+        end
+        @predictions = @vehicles.map(&:predictions).flatten
+      end
+    end
+
+    class ServiceBulletinsResponse < CTA::API::Response
+      attr_reader :bulletins
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @bulletins = Array.wrap(parsed_body["bustime_response"]["sb"]).map { |sb| ServiceBulletin.new(sb) }
+      end
+    end
+
+    class ServiceBulletin
+      attr_reader :name, :subject, :details, :brief, :priority, :affected_services
+
+      def initialize(sb)
+        @name = sb["nm"]
+        @subject = sb["sbj"]
+        @details = sb["dtl"]
+        @brief = sb["brf"]
+        @priority = sb["prty"].downcase.to_sym
+
+        @affected_services = Array.wrap(sb["srvc"]).map { |svc| Service.new(svc) }
+      end
+    end
+
+    class Service
+      attr_reader :route
+      attr_reader :direction
+      attr_reader :stop
+      attr_reader :stop_name
+
+      def initialize(s)
+        @route = CTA::Route.where(:route_id => s["rt"]).first
+        @direction = Direction.new(s["rtdir"]) if s["rtdir"]
+        if s["stpid"]
+          @stop = CTA::Stop.where(:stop_id => s["stpid"]).first || CTA::Stop.new_from_api_response(s)
+          @stop_name = @stop.name
+        else
+          @stop_name = s["stpnm"] # ugh
+        end
+      end
+
+      def predictions!
+        options = { :route => self.route }
+        options.merge!({ :stop => self.stop_id }) if self.stop_id
+        CTA::BusTracker.predictions!(options)
+      end
+    end
+
+    class Pattern
+      attr_reader :id
+      attr_reader :pattern_id
+      attr_reader :length
+      attr_reader :direction
+      attr_reader :points
+
+      def initialize(p)
+        @id = @pattern_id = p["pid"].to_i
+        @length = p["ln"].to_f
+        @direction = Direction.new(p["rtdir"])
+
+        @points = Array.wrap(p["pt"]).map { |pnt| Point.new(pnt) }
+      end
+    end
+
+    class Point
+      attr_reader :sequence, :lat, :lon, :latitude, :longitude, :type, :stop, :distance
+
+      def initialize(p)
+        @sequence = p["seq"].to_i
+        @lat = @latitude = p["lat"].to_f
+        @lon = @longitude = p["lon"].to_f
+        @type = (p["typ"] == "S" ? :stop : :waypoint)
+        @stop = CTA::Stop.where(:stop_id => p["stpid"]).first || CTA::Stop.new_from_api_response(p)
+        @distance = p["pdist"].to_f if p["pdist"]
+      end
+
+      def <=>(other)
+        self.sequence <=> other.sequence
+      end
+    end
+
+    class Direction
+      attr_reader :direction
+
+      def initialize(d)
+        @direction = d
+      end
+    end
+  end
+end

data/lib/cta_redux/api/customer_alerts.rb

@@ -0,0 +1,68 @@
+require 'date'
+require 'faraday'
+require 'multi_xml'
+
+module CTA
+  class CustomerAlerts
+    class RouteStatus
+      attr_reader :route, :route_color, :route_text_color, :service_id, :route_url, :status, :status_color
+
+      def initialize(s)
+        @route = CTA::Route.where(:route_id => s["Route"].split(" ").first).or(:route_id => s["ServiceId"]).first
+        @route_color = s["RouteColorCode"]
+        @route_text_color = s["RouteTextColor"]
+        @status = s["RouteStatus"]
+        @status_color = s["RouteStatusColor"]
+      end
+    end
+
+    class Alert
+      attr_reader :id, :alert_id, :headline, :short_description, :full_description, :score,
+                  :severity_color, :category, :impact, :start, :end, :tbd, :major_alert, :is_major_alert,
+                  :url, :services
+
+      def initialize(a)
+        @id = @alert_id = a["AlertId"].to_i
+        @headline = a["Headline"]
+        @short_description = a["ShortDescription"]
+        @full_description = a["FullDescription"]
+        @score = a["SeverityScore"].to_i
+        @severity_color = a["SeverityColor"]
+        @category = a["SeverityCSS"].downcase.to_sym
+        @impact = a["Impact"]
+        @start = DateTime.parse(a["EventStart"]) if a["EventStart"]
+        @end = DateTime.parse(a["EventEnd"]) if a["EventEnd"]
+        @tbd = (a["TBD"] == "1")
+        @major_alert = @is_major_alert = (a["MajorAlert"] == "1")
+        @url = a["AlertURL"]
+
+        @services = Array.wrap(a["ImpactedService"]["Service"]).map do |s|
+          CTA::Route.where(:route_id => s["ServiceName"].split(" ")).or(:route_id => s["ServiceId"]).first
+        end
+      end
+
+      def major?
+        @major_alert
+      end
+    end
+
+    class AlertsResponse < CTA::API::Response
+      attr_reader :alerts
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @alerts = Array.wrap(parsed_body["CTAAlerts"]["Alert"]).map { |a| Alert.new(a) }
+      end
+    end
+
+    class RouteStatusResponse < CTA::API::Response
+      attr_reader :routes
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @routes = Array.wrap(parsed_body["CTARoutes"]["RouteInfo"]).map { |r| RouteStatus.new(r) }
+      end
+    end
+
+  end
+end

data/lib/cta_redux/api/train_tracker.rb

@@ -0,0 +1,89 @@
+module CTA
+  class TrainTracker
+    class ArrivalsResponse < CTA::API::Response
+      attr_reader :routes, :trains, :predictions
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+
+        eta_map = Array.wrap(parsed_body["ctatt"]["eta"]).inject({}) do |h, eta|
+          h[eta["rt"]] ||= []
+          h[eta["rt"]] << eta
+
+          h
+        end
+
+        @routes = eta_map.map do |rt, etas|
+          trains = etas.map do |t|
+            train = CTA::Train.find_active_run(t["rn"], self.timestamp, (t["isDly"] == "1")).first
+            if !train
+              train = CTA::Train.find_active_run(t["rn"], self.timestamp, true).first
+            end
+            position = t.select { |k,v| ["lat", "lon", "heading"].include?(k) }
+            train.live!(position, t)
+
+            train
+          end
+
+          route = CTA::Route.where(:route_id => rt.capitalize).first
+          route.live!(trains)
+
+          route
+        end
+
+        @trains = @routes.map(&:vehicles).flatten
+        @predictions = @trains.map(&:predictions).flatten
+      end
+    end
+
+    class FollowResponse < CTA::API::Response
+      attr_reader :train, :predictions
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+
+        train_info = Array.wrap(parsed_body["ctatt"]["eta"]).first
+        @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, (train_info["isDly"] == "1")).first
+        if !@train
+          @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, true).first
+        end
+        @train.live!(parsed_body["ctatt"]["position"], parsed_body["ctatt"]["eta"])
+        @predictions = @train.predictions
+      end
+    end
+
+    class PositionsResponse < CTA::API::Response
+      attr_reader :routes, :trains, :predictions
+
+      def initialize(parsed_body, raw_body, debug)
+        super(parsed_body, raw_body, debug)
+        @routes = Array.wrap(parsed_body["ctatt"]["route"]).map do |route|
+          rt = Route.where(:route_id => route["name"].capitalize).first
+
+          trains = Array.wrap(route["train"]).map do |train|
+            t = CTA::Train.find_active_run(train["rn"], self.timestamp, (train["isDly"] == "1")).first
+            if !t # Sometimes the CTA doesn't report things as delayed even when they ARE
+              t = CTA::Train.find_active_run(train["rn"], self.timestamp, true).first
+            end
+
+            if !t
+              puts "Couldn't find train #{train["rn"]} - this is likely a bug."
+              next
+            end
+
+            position = train.select { |k,v| ["lat", "lon", "heading"].include?(k) }
+            t.live!(position, train)
+
+            t
+          end
+
+          rt.live!(trains)
+          rt
+        end.compact
+
+        @trains = @routes.compact.map(&:vehicles).flatten
+        @predictions = @trains.compact.map(&:predictions).flatten
+      end
+    end
+  end
+end