Returns the students for a section
 @param id
 @param [Hash] opts the optional parameters
 @option opts [Integer] :limit
 @option opts [String] :starting_after
 @option opts [String] :ending_before
 @return [StudentsResponse]
516508
def get_students_for_section(id, opts = {})
      data, _status_code, _headers = get_students_for_section_with_http_info(id, opts)
      return data
    end
1063085
def get_section_key_line(self, data, key, opt_extension=''):
        
        start = 0
        init = 0
        while start != -1:
            start = self.get_next_section_start_line(data[init:])
            init += start
            if start != -1:
                if data[init].strip().lower() == self.opt[key] + opt_extension:
                    break
                init += 1
        if start != -1:
            start = init
        return start
495369
def find_by_id(self, section, params={}, **options): 
        
        path = "/sections/%s" % (section)
        return self.client.get(path, params, **options)
305205
def get(self, id):
        ''''''
        args = parser.parse_args()
        model = self.model.objects.only('id').get_or_404(id=id)
        qs = Follow.objects(following=model, until=None)
        return qs.paginate(args['page'], args['page_size'])
313770
protected function getString($id = false, array $array = [], $section, $modelClass = __CLASS__)
    {
        $string = $section . $modelClass;

        if ($id) {
            $string = $string . 'id' . $id;
        }

        if ($array) {
            foreach ($array as $key => $value) {
                $string = $string . $key;
            }
        }

        return $string;
    }
1159944
function (opts, id) {
        let uri = this.classUrl
        if (id) {
          uri += '/' + id
        }

        return new Promise(function (resolve, reject) {
          new Requestor({ api_version: instance.api_version }).request({
            method: 'post',
            url: [Conekta.api_base, uri].join(''),
            data: opts.data || {},
            next: function (error, response) {
              if (!error) {
                response = this.listObjectsToArray(response)
                this._json = response
                this._id = response.id
                this.build_children()
              }
              if (opts.next !== undefined) {
                opts.next(error, this)
              } else {
                if (error) {
                  reject(error)
                } else {
                  resolve(this)
                }
              }
            }.bind(this)
          })
        }.bind(this))
      }
190312
public static function get_sections_from_courseid($courseid) {
        global $DB;

        // Get all sections belonging to requested course
        $sectionsarr = array();
        $sections = $DB->get_records('course_sections', array('course' => $courseid), 'section');
        foreach ($sections as $section) {
            $sectionsarr[] = $section->id;
        }
        return $sectionsarr;
    }
146756
def get_district_for_term(id, opts = {})
      data, _status_code, _headers = get_district_for_term_with_http_info(id, opts)
      return data
    end
985007
def get_students_for_teacher(id, opts = {})
      data, _status_code, _headers = get_students_for_teacher_with_http_info(id, opts)
      return data
    end
294101
def get_user_lists(self, course, classroomid):
        
        tutor_list = course.get_staff()

        # Determine if user is grouped or not in the classroom
        student_list = list(self.database.classrooms.aggregate([
            {"$match": {"_id": ObjectId(classroomid)}},
            {"$unwind": "$students"},
            {"$project": {
                "students": 1,
                "grouped": {
                    "$anyElementTrue": {
                        "$map": {
                            "input": "$groups.students",
                            "as": "group",
                            "in": {
                                "$anyElementTrue": {
                                    "$map": {
                                        "input": "$$group",
                                        "as": "groupmember",
                                        "in": {"$eq": ["$$groupmember", "$students"]}
                                    }
                                }
                            }
                        }
                    }
                }
            }}
        ]))

        student_list = dict([(student["students"], student) for student in student_list])

        other_students = [entry['students'] for entry in list(self.database.classrooms.aggregate([
            {"$match": {"courseid": course.get_id(), "_id": {"$ne": ObjectId(classroomid)}}},
            {"$unwind": "$students"},
            {"$project": {"_id": 0, "students": 1}}
        ]))]

        users_info = self.user_manager.get_users_info(other_students + list(student_list.keys()) + tutor_list)

        # Order the non-registered students
        other_students = sorted(other_students, key=lambda val: (("0"+users_info[val][0]) if users_info[val] else ("1"+val)))

        return student_list, tutor_list, other_students, users_info
362571
def get_term(id, opts = {})
      data, _status_code, _headers = get_term_with_http_info(id, opts)
      return data
    end
111868
def get_schools_for_student(id, opts = {})
      data, _status_code, _headers = get_schools_for_student_with_http_info(id, opts)
      return data
    end
1050376
def help_center_section_subscription_show(self, section_id, id, locale=None, **kwargs):
        ""
        api_path = "/api/v2/help_center/sections/{section_id}/subscriptions/{id}.json"
        api_path = api_path.format(section_id=section_id, id=id)
        if locale:
            api_opt_path = "/api/v2/help_center/{locale}/sections/{section_id}/subscriptions/{id}.json"
            api_path = api_opt_path.format(section_id=section_id, id=id, locale=locale)
        return self.call(api_path, **kwargs)
325637
def get_term_for_section(id, opts = {})
      data, _status_code, _headers = get_term_for_section_with_http_info(id, opts)
      return data
    end
550488
public function getStudentsAsync($limit = null, $starting_after = null, $ending_before = null)
    {
        return $this->getStudentsAsyncWithHttpInfo($limit, $starting_after, $ending_before)
            ->then(
                function ($response) {
                    return $response[0];
                }
            );
    }
736825
def get_sections_for_term(id, opts = {})
      data, _status_code, _headers = get_sections_for_term_with_http_info(id, opts)
      return data
    end
508690
function get( opts, clbk ) {
	var ratelimit;
	var scount;
	var fcount;
	var count;
	var users;
	var eFLG;
	var out;
	var idx;
	var len;
	var i;

	// Output data store:
	out = {};
	out.meta = {};
	out.data = {};
	out.failures = {};

	// Number of completed requests:
	count = 0;
	scount = 0; // success
	fcount = 0; // failures

	// Request id:
	idx = 0;

	users = opts.usernames;
	len = users.length;

	debug( 'Number of usernames: %d.', len );
	out.meta.total = len;

	debug( 'Beginning queries...' );
	for ( i = 0; i < NUM_CONCURRENT_REQUESTS; i++ ) {
		next();
	}
	/**
	* FUNCTION: next()
	*	Requests user details data for the next username in the queue. Once requests for all desired usernames have completed, invokes the provided callback.
	*
	* @private
	* @returns {Void}
	*/
	function next() {
		var u;
		if ( count === len ) {
			debug( 'Finished all queries.' );
			out.meta.success = scount;
			out.meta.failure = fcount;
			return clbk( null, out, ratelimit );
		}
		if ( idx < len ) {
			u = users[ idx ];
			debug( 'Querying for username: `%s` (%d).', u, idx );
			opts.pathname = '/users/' + u;
			request( opts, onResponse( u, idx ) );
			idx += 1;
		}
	} // end FUNCTION next()

	/**
	* FUNCTION: onResponse( username, idx )
	*	Returns a response callback.
	*
	* @private
	* @param {String} username - username
	* @param {Number} idx - request index
	* @returns {Function} response callback
	*/
	function onResponse( username, idx ) {
		/**
		* FUNCTION: onResponse( error, details, info )
		*	Callback invoked upon receiving a request response.
		*
		* @private
		* @param {Error|Null} error - error object
		* @param {Object} details - response data
		* @param {Object} info - rate limit info
		* @returns {Void}
		*/
		return function onResponse( error, details, info ) {
			if ( eFLG ) {
				return;
			}
			debug( 'Response received for username: `%s` (%d).', username, idx );
			if ( arguments.length === 1 ) {
				eFLG = true;
				debug( 'Encountered an application-level error for username `%s` (%d): %s', username, idx, error.message );
				return clbk( error );
			}
			ratelimit = updateRateLimit( ratelimit, info );
			if ( error ) {
				debug( 'Failed to resolve username `%s` (%d): %s', username, idx, error.message );
				out.failures[ username ] = error.message;
				fcount += 1;
			} else {
				debug( 'Successfully resolved username `%s` (%d).', username, idx );
				out.data[ username ] = details;
				scount += 1;
			}
			count += 1;
			debug( 'Request %d of %d complete.', count, len );
			next();
		}; // end FUNCTION onResponse()
	} // end FUNCTION onResponse()
}