Define the contents of new Infos.

        transmit() -> _what() -> create_information() -> _contents().
439046
def _contents(self):
        
        stories = [
            "ghosts.md",
            "cricket.md",
            "moochi.md",
            "outwit.md",
            "raid.md",
            "species.md",
            "tennis.md",
            "vagabond.md"
        ]
        story = random.choice(stories)
        with open("static/stimuli/{}".format(story), "r") as f:
            return f.read()
506917
def set_description(self, description):
        """"""
        self.head.description.attr(content=description)
        return self
21024
def inject(self, contents=None, **kwargs):
        
        if contents and not isinstance(contents, dict):
            raise WrongContentError(self, contents, "contents should be a dict")
        self._stable = False
        if not contents:
            contents = {}
        if kwargs:
            contents.update(kwargs)
        self.content_data.update(contents)
        return self
922619
protected function createContent(Infoset $info) {
		$profiler = $this->getProfiler();
		
		// Info
		if ($profiler instanceof ProfilerExtendedInterface
		&&  $profiler->hasAdditionalInfo()) {
			$profilerInfo = $profiler->getAdditionalInfo();
			
			if (isset($profilerInfo['__TOPOLOGY__'])
			&&  $profilerInfo['__TOPOLOGY__'] instanceof Descriptor) {
				$topology = $profilerInfo['__TOPOLOGY__'];
				unset($profilerInfo['__TOPOLOGY__']);
			}
			
			if (! empty($profilerInfo)) {
				$this->additionalInfo($info, $profilerInfo);
			}
		}
		
		if ($profiler->getTotalEvents() === 0 && ! $profiler->hasAdditionalInfo()) {
			return;
		}
		
		// Events
		if ($profiler->hasProfiles()) {
			$this->eventsInfo($info, $profiler->getProfiles());
		}
		
		// Topology
		if (isset($topology)) {
			$this->topologyInfo($info, $topology);
		}
	}
1343630
def set_content(self, data):
        
        content = self._get_content(data, 'content')

        if content == '':
            content = self._get_content(data, 'summary_detail')

        if content == '':
            if data.get('description'):
                content = data.get('description')

        return content
519893
function info(req, res) {
  var list = []
    , i
    , exec;
  for(i = 0;i < req.args.length;i++) {
    exec = this.execs[req.args[i]];
    list.push(exec ? exec.definition.getDefinition() : null);
  }
  res.send(null, list);
}
1016230
def update(self, infos):
        """"""
        for info in infos:
            if isinstance(info, LearningGene):
                self.replicate(info)
542666
def update_contents(self, stream, seek=0, size=None, chunk_size=None,
                        progress_callback=None, **kwargs):
        
        self.checksum = None
        return self.storage(**kwargs).update(
            stream, seek=seek, size=size, chunk_size=chunk_size,
            progress_callback=progress_callback
        )
96826
def put_content(self, content):
        
        if not isinstance(content, str):
            content = content.decode('utf-8')

        self.topic.publish(Message=content, **self.storage_args)
963382
def add_contents(self, dest, contents):
        
        assert not self._closed, "Archive closed"
        if not isinstance(dest, zipfile.ZipInfo):
            dest = zinfo(dest)  # see for some caveats
        # Ensure we apply the compression
        dest.compress_type = self.zip_compression
        # Mark host OS as Linux for all archives
        dest.create_system = 3
        self._zip_file.writestr(dest, contents)
1228800
def setcontents(self, source, **kwargs):
        """"""
        if isinstance(source, six.string_types):
            _file = opener.open(source, 'rb')
        else:
            _file = source

        # signals.document_before_content_set.send(self)

        data = _file.read()
        _fs, filename = opener.parse(self.uri)
        _fs.setcontents(filename, data, **kwargs)
        _fs.close()

        # signals.document_after_content_set.send(self)

        if isinstance(source, six.string_types) and hasattr(_file, 'close'):
            _file.close()
48484
def new_from_list(cls, content, fill_title=True, **kwargs):
        
        obj = cls(**kwargs)
        obj.append_from_list(content, fill_title)
        return obj
639000
def contents(self):
        
        if not hasattr(self, "_content"):
            self._content = self.get_content()
        return self._content
924404
def create_contents_and_index
      contents = []
      index    = []

      (@files+@classes).sort.each do |entry|
	content_entry = { "c_name" => entry.name, "ref" => entry.path }
	index << { "name" => entry.name, "aref" => entry.path }

	internals = []

	methods = entry.build_method_summary_list(entry.path)

	content_entry["methods"] = methods unless methods.empty?
        contents << content_entry
	index.concat methods
      end

      values = { "contents" => contents }
      template = TemplatePage.new(RDoc::Page::CONTENTS)
      File.open("contents.hhc", "w") do |f|
	template.write_html_on(f, values)
      end

      values = { "index" => index }
      template = TemplatePage.new(RDoc::Page::CHM_INDEX)
      File.open("index.hhk", "w") do |f|
	template.write_html_on(f, values)
      end      
    end
868019
def new_stat(self):
        
        key = self.ids.newstatkey.text
        value = self.ids.newstatval.text
        if not (key and value):
            # TODO implement some feedback to the effect that
            # you need to enter things
            return
        try:
            self.proxy[key] = self.engine.unpack(value)
        except (TypeError, ValueError):
            self.proxy[key] = value
        self.ids.newstatkey.text = ''
        self.ids.newstatval.text = ''
359935
public function writeContent()
    {
        $dirPath = dirname($this->getPath());

        if (!is_dir($dirPath)) {
            mkdir($dirPath, 0755, true);
        }

        file_put_contents(
            $this->getPath(),
            $this->getContent()
        );
    }
815269
private void writeDetailPageInfos(List<CmsDetailPageInfo> infos, CmsUUID newId) {

        int i = 0;
        for (CmsDetailPageInfo info : infos) {
            if (info.isInherited()) {
                continue;
            }
            CmsUUID id = info.getId();
            if (id == null) {
                id = newId;
            }
            writeValue(info.getType(), id, i);
            i += 1;
        }
    }