the information inside.
171595
public static void main(String[] args) throws Exception {
    if (args.length != 1) {
      System.err.println("Usage:  ListPeople ADDRESS_BOOK_FILE");
      System.exit(-1);
    }

    // Read the existing address book.
    AddressBook addressBook =
      AddressBook.parseFrom(new FileInputStream(args[0]));

    Print(addressBook);
  }
1083173
def info(self, text):
		
		self.logger.info("{}{}".format(self.message_prefix, text))
212344
def get_info(self):
        """"""
        return [self.display_name.encode(),
                self.enabled and b'enabled' or b'disabled',
                STATE_NAMES[self.state].encode() + b':',
                self.last_printed_line.strip()]
214292
def log_info(self, data):
        '''  '''
        info = 'label={label}, id={id}, ilx={ilx}, superclass_tid={super_id}'
        info_filled = info.format(label    = data['label'],
                                  id       = data['id'],
                                  ilx      = data['ilx'],
                                  super_id = data['superclasses'][0]['id'])
        logging.info(info_filled)
        return info_filled
548865
def information_content(self):
        
        ic = 0
        for row in self.pwm:
            ic += 2.0 + np.sum([row[x] * log(row[x])/log(2) for x in range(4) if row[x] > 0])
        return ic
995488
def GetPageInfo(self):
        

        return self.first_tab, self.last_tab, self.first_tab, self.last_tab
858761
def info(self):
        
        print('Number of subjects: ' + str(self.n_subjects))
        print('Number of lists per subject: ' + str(self.n_lists))
        print('Number of words per list: ' + str(self.list_length))
        print('Date created: ' + str(self.date_created))
        print('Meta data: ' + str(self.meta))
1062077
private function readInfo()
    {
        if (!$this->info)
        {
            $info = getimagesize($this->path);
            $this->info = array(
                'width' => $info[0],
                'height' => $info[1],
            );
        }
    }
788042
def info(self):
        
        if (len(self.values()) > 0):
            info_str = self.__class__.__name__ +\
                       " containing %d items of type %s\n" % (len(self.keys()),
                                                              type(self.values()[0]).__name__)
        else:
            info_str = self.__class__.__name__ + " containing no items\n"
        info_str += ('-' * (len(info_str)-1)) + "\n\n"
        aliases = {v: k for k, v in self._dim_aliases.items()}
        for group in self._dim_groups:
            dimensions = getattr(self, group)
            if dimensions:
                group = aliases[group].split('_')[0]
                info_str += '%s Dimensions: \n' % group.capitalize()
            for d in dimensions:
                dmin, dmax = self.range(d.name)
                if d.value_format:
                    dmin, dmax = d.value_format(dmin), d.value_format(dmax)
                info_str += '\t %s: %s...%s \n' % (d.pprint_label, dmin, dmax)
        print(info_str)
47636
def get_info(self):
        '''
        
        '''
        field = self._current_field()
        if field:
            info = field.get_info()
            info['path'] = '%s/%s' % (self.name if self.name else '<no name>', info['path'])
        else:
            info = super(Container, self).get_info()
        return info
293617
def data(self):
        """"""
        if self.kind == 'data':
            return self._data.data
        else:
            with self.open() as f:
                return f.read()
27213
def info(self):
        
        info = super(TensorTerm, self).info
        info.update({'terms':[term.info for term in self._terms]})
        return info
998067
private function _info()
    {
        if (empty($this->_output)) {
            return;
        }
        $model = array();
        $percCharge = array();
        $lines = explode(PHP_EOL, implode($this->_output));
        if (count($lines)>1) {
            $model = explode('FW:', $lines[1]);
            if (strpos($model[0], 'InternalBattery') === false) {
                $dev = new UPSDevice();
                $percCharge = explode(';', $lines[1]);
                $dev->setName('UPS');
                if ($model !== false) {
                    $dev->setModel(substr(trim($model[0]), 1));
                }
                if ($percCharge !== false) {
                    $dev->setBatterCharge(trim(substr($percCharge[0], -4, 3)));
                    $dev->setStatus(trim($percCharge[1]));
                    if (isset($percCharge[2])) {
                        $time = explode(':', $percCharge[2]);
                        $hours = $time[0];
                        $minutes = $hours*60+substr($time[1], 0, 2);
                        $dev->setTimeLeft($minutes);
                    }
                }
                $dev->setMode("pmset");
                $this->upsinfo->setUpsDevices($dev);
            }
        }
    }
1148116
function info() {
    var _console4;

    if (LatticeLogs.failFast(LatticeLogs.INFO)) return;

    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
      args[_key6] = arguments[_key6];
    }

    (_console4 = console).info.apply(_console4, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
  }
478245
def descriptions(self):
        """"""
        return {key: val[2] for key, val in six.iteritems(self.defaultParams)
                if len(val) >= 3}
437534
def get_info(self):
        ''''''
        if self._min_disk:
            for path in self._resource_paths:
                usage = psutil.disk_usage(path)

                yield ResourceInfo(path, usage.free, self._min_disk)

        if self._min_memory:
            usage = psutil.virtual_memory()

            yield ResourceInfo(None, usage.available, self._min_memory)
252397
def info(self):
        
        result = dict()
        for name, namespace in self._namespaces.items():
            result[name] = namespace.info_all()
        return result