Get the form contents
325234
public function getContent()
    {
        if ($this->content === null) {
            if (is_array($this->variables)) {
                extract($this->variables);
            } else {
                if ($this->variables !== null) {
                    throw new \InvalidArgumentException('$variables argument should be null or an array');
                }
            }

            ob_start();
            include($this->path);
            $this->content = ob_get_clean();
        }

        return $this->content;
    }
484398
def form(self) -> Optional['HTMLFormElement']:
        """"""
        if self.__form:
            return self.__form
        parent = self.parentNode
        while parent:
            if isinstance(parent, HTMLFormElement):
                return parent
            else:
                parent = parent.parentNode
        return None
406009
async def get_form(self, request):
        """"""
        if not self.form:
            return None
        formdata = await request.post()
        return self.form(formdata, obj=self.resource)
24710
def get_contents(self, folder: Folder):
        
        log.debug("Listing Contents of %s/%s" % (folder.course.id, folder.id))
        if isinstance(folder, Course):
            response = json.loads(self._get('/api/documents/%s/folder' % folder.course.id).text)
        else:
            response = json.loads(self._get('/api/documents/%s/folder/%s' % (folder.course.id, folder.id)).text)
            log.debug("Got response: %s" % response)

        documents = [Document.from_response(response, folder) for response in response["documents"]]

        folders = [Folder.from_response(response, folder) for response in response["folders"]]

        return documents + folders
1215716
public final function getContents(): string
   {
       if (!$this->isReadable()) {
           throw new RuntimeException(
               "Can't getContents: stream is not readable");
       }
       $this->meta["eof"] = true;
       return (string) stream_get_contents($this->stream);
   }
378654
function getContents($joinChar = '')
    {
        $contents = array();
        foreach($this->subfields as $subfield) {
            $contents[] = $subfield->getData();
        }
        return implode($joinChar, $contents);
    }
736630
def get_form(self, form, name):
        
        kwargs = self.get_kwargs(form, name)
        form_class = self.get_form_class(form, name)
        composite_form = form_class(
            data=form.data if form.is_bound else None,
            files=form.files if form.is_bound else None,
            **kwargs)
        return composite_form
357349
def get_form(self, request, rel, admin_site):
        """"""
        return DynamicRawIDFilterForm(
            admin_site=admin_site,
            rel=rel,
            field_name=self.field_path,
            data=self.used_parameters,
        )
689006
public function view()
    {
        ob_start();
        $form = $this;
        require_once dirname(__FILE__) . DIRECTORY_SEPARATOR . 'view' . DIRECTORY_SEPARATOR . 'form.php';
        $html = ob_get_clean();
        return $html;
    }
214449
async def get_contents(self, **params):
		
		logging.debug("[+] -- Get contents")
		if params.get("message"):
			params = json.loads(params.get("message", "{}"))

		if not params or not params.get("public_key"):
			return {"error":400, "reason":"Missed required fields"}

		# Try to get account
		account = await self.collection.find_one({"public_key":params["public_key"]})
		# Return error if does not exist the one
		if not account:
			return {"error":404, "reason":"Get contents. Not found account"}

		contents = {i:[] for i in settings.AVAILABLE_COIN_ID}
		for coinid in settings.AVAILABLE_COIN_ID:
			logging.debug(coinid)
			database = client[coinid]
			content_collection = database[settings.CONTENT]
			async for document in content_collection.find({"owner":account["public_key"]}):
				contents[coinid].append((document["cid"], document["txid"]))

		return contents
945880
def get_configuration(form, out):
    """"""
    config = configuration.Configuration()
    config["recursionlevel"] = int(formvalue(form, "level"))
    config["logger"] = config.logger_new('html', fd=out, encoding=HTML_ENCODING)
    config["threads"] = 2
    if "anchors" in form:
        config["enabledplugins"].append("AnchorCheck")
    if "errors" not in form:
        config["verbose"] = True
    # avoid checking of local files or other nasty stuff
    pat = "!^%s$" % urlutil.safe_url_pattern
    config["externlinks"].append(get_link_pat(pat, strict=True))
    config.sanitize()
    return config
565929
function form () {
  form.form = $("#swagger-parser-form");

  form.allow = {
    label: form.form.find("#allow-label"),
    menu: form.form.find("#allow-menu"),
    json: form.form.find("input[name=allow-json]"),
    yaml: form.form.find("input[name=allow-yaml]"),
    text: form.form.find("input[name=allow-text]"),
    empty: form.form.find("input[name=allow-empty]"),
    unknown: form.form.find("input[name=allow-unknown]")
  };

  form.refs = {
    label: form.form.find("#refs-label"),
    menu: form.form.find("#refs-menu"),
    external: form.form.find("input[name=refs-external]"),
    circular: form.form.find("input[name=refs-circular]")
  };

  form.validate = {
    label: form.form.find("#validate-label"),
    menu: form.form.find("#validate-menu"),
    schema: form.form.find("input[name=validate-schema]"),
    spec: form.form.find("input[name=validate-spec]")
  };

  form.tabs = {
    url: form.form.find("#url-tab"),
    text: form.form.find("#text-tab")
  };

  form.method = {
    button: form.form.find("button[name=method]"),
    menu: form.form.find("#method-menu")
  };

  form.samples = {
    url: {
      container: form.form.find("#url-sample"),
      link: form.form.find("#url-sample-link"),
    },
    text: {
      container: form.form.find("#text-sample"),
      link: form.form.find("#text-sample-link"),
    }
  };

  form.url = form.form.find("input[name=url]");
  form.textBox = null; // This is set in editors.js
  form.bookmark = form.form.find("#bookmark");
}
1149480
public function getContent()
    {
        if (null === $this->content && $this->fromGlobal) {
            $this->content = file_get_contents('php://input');
        }
        return $this->content;
    }
1105536
public function getContent() {
        static $content  = '';
        static $isRead = false;

        if (!$isRead) {
            if ($this->getContentType() == 'multipart/form-data') {
                // file upload
                if ($_POST) {                                                           // php://input is not available with
                    $content = '$_POST => '.print_r($_POST, true).NL;                   // enctype="multipart/form-data"
                    // TODO: we should limit excessive variable values to 1KB
                }
                $content .= '$_FILES => '.print_r($this->getFiles(), true);
            }
            else {
                // regular request body
                $content = file_get_contents('php://input');
            }
            $isRead = true;
        }
        return $content;
    }
975902
def contents(self):
        

        params = self.request_params
        params.update({'wsfunction': 'core_course_get_contents',
                       'courseid': self.course_id})

        return requests.get(self.api_url, params=params, verify=False).json()
1106750
def forms(self):
        
        if not self.is_tagged(ANALYSIS):
            self.tag_analysis()
        return self.get_analysis_element(FORM)
483818
def get_form(self, form_class):
        """"""
        if not hasattr(self, '_form'):
            kwargs = self.get_form_kwargs()
            self._form = form_class(**kwargs)
        return self._form