xqueue_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OGViMTc0NDRmNTM2MGUyMWFhMWIxZWYyMTA1NzdhOTg1ZDJjMjVhNQ==
+  data.tar.gz: !binary |-
+    NjhmYmUxYzE3Y2MyMjI4MDY1OTE0ZmVhMWIzNjlhOTM4NWViY2E1Zg==
+SHA512:
+  metadata.gz: !binary |-
+    YzQ2ZWM2MzdkMjhmMDZjYmVmNzgzZDkzODQ1YzNkMWI3MTZlM2M5ODc2NjVh
+    MmE4ODRkODFiN2NkZjE0MzA5ZDA4NjQ2MzU4YmUxN2MxOWY2MzVlNTllMjAx
+    N2I0YzUwMDQ5NWM4N2NlMWE3NmFhOTVmYmZhMTU2NmE5YjcwNzk=
+  data.tar.gz: !binary |-
+    MDQ0ZDAyNTViODVmMjgwOTY2NmZlY2FiMmQyNWFkZGNkMmUxNjg1OThhNDIx
+    YjYzY2NlNGY5ZDE3OWQwZTBmZmFhYmMwODRjZWE1NjUxMGJjYjQ0ODIzN2M0
+    MDBjNTFjZjRlNGE1OGQ5MzRhYWZiODQ4MGQxNmNmM2NmNDdlZWE=

data/lib/xqueue_ruby.rb

@@ -0,0 +1,8 @@
+require 'mechanize'
+require 'json'
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+
+require 'xqueue_ruby/xqueue_ruby'
+require 'xqueue_ruby/xqueue_submission'
+

data/lib/xqueue_ruby/xqueue_ruby.rb

@@ -0,0 +1,184 @@
+class XQueue
+  require 'mechanize'
+  require 'json'
+  require 'ruby-debug'
+  
+  # Ruby interface to the Open edX XQueue class for external checkers
+  # (autograders).  Lets you pull student-submitted work products from a
+  # named queue and post back the results of grading them.
+  #
+  # All responses from the XQueue server have a JSON object with
+  # +return_code+ and +content+ slots.  A +return_code+ of 0 normally
+  # means success.  
+  #
+  # == Example
+  #
+  # You need two sets of credentials to authenticate yourself to the
+  # xqueue server.  For historical reasons, they are called
+  # (+django_name+, +django_pass+) and (+user_name+, +user_pass+).
+  # You also need to name the queue you want to use; edX creates queues
+  # for you.  Each +XQueue+ instance is tied to a single queue name.
+  #
+  # === Retrieving an assignment:
+  #
+  #     queue = XQueue.new('dj_name', 'dj_pass', 'u_name', 'u_pass', 'my_q')
+  #     queue.length  # => an integer showing queue length
+  #     assignment = queue.get_submission  # => returns new +XQueueSubmission+ object
+  #
+  # === Posting results back
+  #
+  # The submission includes a secret key that is used in postback,
+  # so you should use the +#postback+ method defined on the submission.
+  #
+
+  # The base URI of the production Xqueue server.
+  XQUEUE_DEFAULT_BASE_URI = 'https://xqueue.edx.org'
+
+  # Error message, if any, associated with last unsuccessful operation
+  attr_reader :error
+  
+  # Queue from which to pull, established in constructor.  You need a
+  # new +XQueue+ object if you want to use a different queue.
+  attr_reader :queue_name
+
+  # The base URI used for this queue; won't change for this queue even
+  # if you later change the value of +XQueue.base_uri+
+  attr_reader :base_uri
+
+  # The base URI used when new queue instances are created
+  def self.base_uri
+    @@base_uri ||= URI(XQUEUE_DEFAULT_BASE_URI)
+  end
+  def self.base_uri=(uri)
+    @@base_uri = URI(uri)
+  end
+
+  class XQueueError < StandardError ; end
+  # Ancestor class for all XQueue-related exceptions
+  class AuthenticationError < XQueueError ;  end
+  # Raised if XQueue authentication fails
+  class IOError < XQueueError ; end
+  # Raised if there are network or I/O errors connecting to queue server
+  class NoSuchQueueError < XQueueError ; end
+  # Raised if queue name doesn't exist
+  class UpdateFailedError < XQueueError ; end
+  # Raised if a postback to the queue (to post grade) fails at
+  # application level
+
+  # Creates a new instance and attempts to authenticate to the
+  # queue server.  
+  # * +django_name+, +django_pass+: first set of auth credentials (see
+  # above)
+  # * +user_name+, +user_pass+: second set of auth credentials (see
+  # above)
+  # * +queue_name+: logical name of the queue
+  def initialize(django_name, django_pass, user_name, user_pass, queue_name)
+    @queue_name = queue_name
+    @base_uri = XQueue.base_uri
+    @django_auth = {'username' => django_name, 'password' => django_pass}
+    @session = Mechanize.new
+    @session.add_auth(@base_uri, user_name, user_pass)
+    @valid_queues = nil
+    @error = nil
+    @authenticated = nil
+  end
+
+  # Authenticates to the server.  You can call this explicitly, but it
+  # is called automatically if necessary on the first request in a new
+  # session.  
+  def authenticate
+    response = request :post, '/xqueue/login/', @django_auth
+    if response['return_code'] == 0
+      @authenticated = true
+    else
+
+      raise(AuthenticationError, "Authentication failure: #{response['content']}")
+    end
+  end
+
+  # Returns +true+ if the session has been properly authenticated to
+  # server, that is, after a successful call to +authenticate+ or to any
+  # of the request methods that may have called +authenticate+ automatically.
+  def authenticated? ; @authenticated ; end
+
+  # Returns length of the queue as an integer >= 0.
+  def queue_length
+    authenticate unless authenticated?
+    response = request(:get, '/xqueue/get_queuelen/', {:queue_name => @queue_name})
+    if response['return_code'] == 0 # success
+      response['content'].to_i
+    elsif response['return_code'] == 1 && response['content'] =~ /^Valid queue names are: (.*)/i
+      @valid_queues = $1.split(/,\s+/)
+      raise NoSuchQueueError, "No such queue: valid queues are #{$1}"
+    else
+      raise IOError, response['content']
+    end
+  end
+
+  def list_queues
+    authenticate unless authenticated?
+    if @valid_queues.nil?
+      old, @queue_name = @queue_name, 'I_AM_NOT_A_QUEUE'
+      begin queue_length rescue nil end
+    end
+    @valid_queues
+  end
+
+  # Retrieve a submission from this queue.  Returns nil if queue is empty,
+  # otherwise a new +XQueue::Submission+ instance.
+  def get_submission
+    authenticate unless authenticated?
+    if queue_length > 0
+      begin
+        json_response = request(:get, '/xqueue/get_submission/',  {:queue_name => @queue_name}) 
+        XQueueSubmission.parse_JSON(self, json_response)
+      rescue StandardError => e  # TODO: do something more interesting with the error.
+        raise e
+      end
+    else
+      nil
+    end
+  end
+  # Record a result of grading something.  It may be easier to use
+  # +XQueue::Submission#post_back+, which marshals the information
+  # needed here automatically.
+  #
+  # * +header+: secret header key (from 'xqueue_header' slot in the
+  # 'content' object of the original retrieved submission)
+  # * +score+: integer number of points (not scaled)
+  # * +correct+: true (default) means show green checkmark, else red 'x'
+  # * +message+: (optional) plain text feedback; will be coerced to UTF-8
+
+  def put_result(header, score, correct=true, message='')
+    payload = JSON.generate({
+        :xqueue_header => header,
+        :xqueue_body => {
+          :correct   => (!!correct).to_s.capitalize,
+          :score     => score,
+          :message   => message.encode('UTF-8',
+            :invalid => :replace, :undef => :replace, :replace => '?'),
+        }
+      })
+    response = request :post, '/xqueue/put_result', payload
+    if response['return_code'] != 0
+      raise UpdateFailedError, response['content']
+    end
+  end
+
+  private
+
+  # :nodoc:
+  def request(method, path, args={})
+    begin
+      response = @session.send(method, @base_uri + path, args)
+      response_json = JSON(response.body)
+
+    rescue Mechanize::ResponseCodeError => e
+      raise IOError, "Error communicating with server: #{e.message}"
+    rescue JSON::ParserError => e
+      raise IOError, "Non-JSON response from server: #{response.body.force_encoding('UTF-8')}"
+    rescue Exception => e
+      raise IOError, e.message
+    end
+  end
+end

data/lib/xqueue_ruby/xqueue_submission.rb

@@ -0,0 +1,61 @@
+require 'active_model'
+require 'json'
+require 'debugger'
+
+class XQueueSubmission
+  include ActiveModel::Validations
+
+  class InvalidSubmissionError < StandardError ;  end
+
+  attr_reader :queue
+  # The +XQueue+ from which this assignment was retrieved (and to which the grade should be posted back)
+  attr_reader :secret
+  # XQueue-server-supplied nonce that will be needed to post back a grade for this submission
+  attr_accessor :files
+  attr_reader :submission_time
+  # When student submitted assignment via edX (a Time object)
+  attr_reader :student_id
+  # one-way hash of edX student ID
+  attr_accessor :score
+  # Numeric: score reported by autograder
+  attr_accessor :message
+  # String: textual feedback from autograder
+  attr_accessor :correct
+  # Boolean: if true when posted back, shows green checkmark, otherwise red X
+
+  validates_presence_of :student_id
+  validates_presence_of :submission_time
+  validates_presence_of :secret
+  
+  DEFAULTS = {correct: false, score: 0, message: '', errors: ''}
+  def initialize(hash)
+    begin
+      fields_hash = DEFAULTS.merge(hash)
+      fields_hash.each {|key, value| instance_variable_set("@#{key}", value)}
+    rescue NoMethodError => e
+      if e.message == "undefined method `[]' for nil:NilClass"
+        raise InvalidSubmissionError, "Missing element(s) in JSON: #{hash}"
+      end
+      raise StandardError 'yoloswag'
+    end
+  end
+
+  def post_back()
+    @queue.put_result(@secret, @score, @correct, @message)
+  end
+
+  def self.parse_JSON(xqueue, json_response)
+    parsed = JSON.parse(json_response)
+    header, files, body = parsed['xqueue_header'], parsed['xqueue_files'], parsed['xqueue_body']
+    grader_payload = body['grader_payload']
+    anonymous_student_id, submission_time = body['student_info']['anonymous_student_id'], Time.parse(body['student_info']['submission_time'])
+    XQueueSubmission.new({queue: xqueue, secret: header, files: files, student_id: anonymous_student_id, submission_time: submission_time })
+  end
+
+  def expand_files
+    # @files = @files.map each do 
+    #   do something
+    # end
+    # self
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: xqueue_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Armando Fox
+- Aaron Zhang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: getopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Pull interface to Open edX XQueue
+email: fox@cs.berkeley.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xqueue_ruby.rb
+- lib/xqueue_ruby/xqueue_ruby.rb
+- lib/xqueue_ruby/xqueue_submission.rb
+homepage: http://github.com/saasbook/x_queue
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Pull interface to Open edX XQueue
+test_files: []