Returns the complete record for a single section.

        Parameters
        ----------
        section : {Id} The section to get.
        [params] : {Object} Parameters for the request
495369
def find_by_id(self, section, params={}, **options): 
        
        path = "/sections/%s" % (section)
        return self.client.get(path, params, **options)
552759
def get_school_for_section(id, opts = {})
      data, _status_code, _headers = get_school_for_section_with_http_info(id, opts)
      return data
    end
1183355
public function get_sections() {
        global $DB;
        if ($this->sections === null) {
            $this->sections = array_values($DB->get_records('quiz_sections',
                    array('quizid' => $this->get_quizid()), 'firstslot'));
        }
        return $this->sections;
    }
907538
def get_section(self, *key):
        
        section = self._get_item_or_section(key)
        if not section.is_section:
            raise RuntimeError('{} is an item, not a section'.format(key))
        return section
380495
def get(self, section, key, default=MANIFEST_NULL_KEY):
        
        if not self.manifest.has_option(section, key) and default is not MANIFEST_NULL_KEY:
            return default
        return self.manifest.get(section, key)
328074
def safe_get(self, section, key):
        
        try:
            #Use full parent function so we can replace it in the class
            # if desired
            return configparser.RawConfigParser.get(self, section, key)
        except (configparser.NoSectionError,
                configparser.NoOptionError):
            return None
541262
private int
sectionToWire(DNSOutput out, int section, Compression c,
	      int maxLength)
{
	int n = sections[section].size();
	int pos = out.current();
	int rendered = 0;
	Record lastrec = null;

	for (int i = 0; i < n; i++) {
		Record rec = (Record)sections[section].get(i);
		if (lastrec != null && !sameSet(rec, lastrec)) {
			pos = out.current();
			rendered = i;
		}
		lastrec = rec;
		rec.toWire(out, section, c);
		if (out.current() > maxLength) {
			out.jump(pos);
			return n - rendered;
		}
	}
	return 0;
}
622273
def get(key, section='main'):
    
    return nago.settings.get_option(option_name=key, section_name=section)
1264426
def get_section_by_offset(self, offset):
        """"""

        sections = [s for s in self.sections if s.contains_offset(offset)]

        if sections:
            return sections[0]

        return None
442472
def get_sections(self, section_name):
        
        sections = []
        for timer in self.timers():
            for sect in timer.sections:
                if sect.name == section_name:
                    sections.append(sect)
                    break
            else:
                sections.append(AbinitTimerSection.fake())

        return sections
1030242
def section(self, dept, course_number, sect_number):
        
        section_id = dept + course_number + sect_number
        sections = self.search({'course_id': section_id})
        try:
            return next(sections)
        except StopIteration:
            raise ValueError('Section %s not found' % section_id)
580845
def _get_section(self, name, type):
        
        for section in self.sections:
            if section['name'] == name and section['type'] == type:
                return section
        return None
882115
def get(self, *keys, fallback=None):
        

        section, *keys = keys
        out = super().get(section, fallback)

        while isinstance(out, dict):
            key = keys.pop(0)
            out = out.get(key, fallback)

        return out
743873
def load_child_sections_for_section(context, section, count=None):
    '''
    
    '''
    page = section.get_main_language_page()
    locale = context.get('locale_code')

    qs = SectionPage.objects.child_of(page).filter(
        language__is_main_language=True)

    if not locale:
        return qs[:count]
    return get_pages(context, qs, locale)
33084
def get(self, request):
        
        sections_list = self.generate_sections()

        p = Paginator(sections_list, 25)

        page = request.GET.get('page')

        try:
            sections = p.page(page)
        except PageNotAnInteger:
            # If page is not an integer, deliver first page.
            sections = p.page(1)
        except EmptyPage:
            # If page is out of range (e.g. 9999), return last page of results.
            sections = p.page(p.num_pages)

        context = {
            'sections': sections,
            'page_title': self.generate_page_title(),
            'browse_type': self.browse_type
        }

        return render(
            request,
            self.template_path,
            context
        )
616582
def __load_section(self, section_key):
        
        if self._sections[section_key] is not None: return

        articles = []
        for page in count(1):
            if page > 50:
                raise Exception('Last page detection is probably broken')

            url = '{domain}{section}&iMenuID=1&iSubMenuID={page}'.format(
                domain = DOMAIN,
                section = SECTIONS[section_key],
                page = page
            )

            body = self._session.get(url).content

            # This is a very hacky way of detecting the last page
            # that will probably break again in the future
            if "알수 없는 주소" in body: # "Unknown Address"
                break

            # Parse out all the article links
            root = html.fromstring(body)
            title_lines = root.find_class('ListNewsLineTitle')
            for title_line in title_lines:
                title_link = title_line.find('a')

                # The links do a JS open in a new window, so we need to parse
                # it out using this ugly, brittle junk
                href = title_link.get('href')
                match = re.match("javascript:article_open\('(.+)'\)", href)
                if not match:
                    raise Exception("The site's link format has changed and is not compatible")
                path = match.group(1).decode('string_escape')

                articles.append(Article(
                    self._session,
                    title_link.text_content().strip(),
                    DOMAIN + '/en/' + path
                ))

        self._sections[section_key] = articles
616820
def get(section, name):
    
    cfg = ConfigParser.SafeConfigParser({"working_dir": "/tmp", "debug": "0"})
    cfg.read(CONFIG_LOCATIONS)
    val = cfg.get(section, name)
    return val.strip("'").strip('"')