Prints information about the lease,
    such as the entity covered by the lease,
    and HTTP URLs for up/downloading file backings.
    :param info:
    :type info: vim.HttpNfcLease.Info
    :return:
185293
def print_http_nfc_lease_info(info):
    
    print 'Lease timeout: {0.leaseTimeout}\n' \
          'Disk Capacity KB: {0.totalDiskCapacityInKB}'.format(info)
    device_number = 1
    if info.deviceUrl:
        for device_url in info.deviceUrl:
            print 'HttpNfcLeaseDeviceUrl: {1}\n' \
                  'Device URL Import Key: {0.importKey}\n' \
                  'Device URL Key: {0.key}\n' \
                  'Device URL: {0.url}\n' \
                  'Device URL Size: {0.fileSize}\n' \
                  'SSL Thumbprint: {0.sslThumbprint}\n'.format(device_url,
                                                               device_number)
            if not device_url.targetId:
                print "No targetId found for this device"
                print "Device is not eligible for export. This could be a mounted iso or img of some sort"
                print "It will NOT be downloaded\n"

            device_number += 1
    else:
        print 'No devices were found.'
1243252
def info(message):
        
        message = message or ""
        if Console.color:
            Console.cprint('OKBLUE', "INFO: ", message)
        else:
            print(Console.msg("INFO: " + message))
426057
def plugin_info(self):
        
        if self._plugin_info_manager is None:
            self._plugin_info_manager = PluginInfoManager(session=self._session)
        return self._plugin_info_manager
728858
def info():
    
    application = get_current_application()
    info = application.info()
    stdout.write(info)
    return info
1218001
def info(self, text=None):
        
        return self.stop_and_persist(symbol=LogSymbols.INFO.value, text=text)
746354
def get_info(cls):
        
        return '\n'.join(
            [str(cls._instances[key]) for key in cls._instances]
        )
1007948
def _store_information(self):
        
        
        print '<<< Generating Information Storage >>>'

        # Stores information on Workbench commands and signatures
        for name, meth in inspect.getmembers(self, predicate=inspect.isroutine):
            if not name.startswith('_'):
                info = {'command': name, 'sig': str(funcsigs.signature(meth)), 'docstring': meth.__doc__}
                self.store_info(info, name, type_tag='command')

        # Stores help text into the workbench information system
        self.store_info({'help': '<<< Workbench Server Version %s >>>' % self.version}, 'version', type_tag='help')
        self.store_info({'help': self._help_workbench()}, 'workbench', type_tag='help')
        self.store_info({'help': self._help_basic()}, 'basic', type_tag='help')
        self.store_info({'help': self._help_commands()}, 'commands', type_tag='help')
        self.store_info({'help': self._help_workers()}, 'workers', type_tag='help')
1354465
def info(package, long_description, classifiers, license):
    
    client = requests.Session()
    for name_or_url in package:
        package = get_package(name_or_url, client)
        if not package:
            secho(u'Invalid name or URL: "{name}"'.format(name=name_or_url),
                  fg='red', file=sys.stderr)
            continue

        # Name and summary
        try:
            info = package.data['info']
        except NotFoundError:
            secho(u'No versions found for "{0}". '
                  u'Skipping. . .'.format(package.name),
                  fg='red', file=sys.stderr)
            continue
        echo_header(name_or_url)
        if package.summary:
            echo(package.summary)

        # Version info
        echo()
        echo('Latest release:   {version:12}'.format(version=info['version']))

        # Long description
        if long_description:
            echo()
            echo(package.description)

        # Download info
        echo()
        echo_download_summary(package)

        # Author info
        echo()
        author, author_email = package.author, package.author_email
        if author:
            echo(u'Author:   {author:12}'.format(**locals()))
        if author_email:
            echo(u'Author email: {author_email:12}'.format(**locals()))

        # Maintainer info
        maintainer, maintainer_email = (package.maintainer,
                                        package.maintainer_email)
        if maintainer or maintainer_email:
            echo()
        if maintainer:
            echo(u'Maintainer:   {maintainer:12}'.format(**locals()))
        if maintainer_email:
            echo(u'Maintainer email: {maintainer_email:12}'.format(**locals()))

        # URLS
        echo()
        echo(u'PyPI URL:  {pypi_url:12}'.format(pypi_url=package.package_url))
        if package.home_page:
            echo(u'Home Page: {home_page:12}'.format(
                home_page=package.home_page))
        if package.docs_url:
            echo(u'Documentation: {docs_url:12}'.format(
                docs_url=package.docs_url))

        # Classifiers
        if classifiers:
            echo()
            echo(u'Classifiers: ')
            for each in info.get('classifiers', []):
                echo('\t' + each)

        if license and package.license:
            echo()
            echo(u'License: ', nl=False)
            # license may be just a name, e.g. 'BSD' or the full license text
            # If a new line is found in the text, print a new line
            if package.license.find('\n') >= 0 or len(package.license) > 80:
                echo()
            echo(package.license)
        echo()
368609
def info(rq, ctx, path, interval, raw, only_queues, only_workers, by_queue,
         queues):
    ""
    return ctx.invoke(
        rq_cli.info,
        path=path,
        interval=interval,
        raw=raw,
        only_queues=only_queues,
        only_workers=only_workers,
        by_queue=by_queue,
        queues=queues or rq.queues,
        **shared_options(rq)
    )
476769
def info(file=nil)
      wc_path = self.svn_repo_working_copy
      wc_path = file if file and file.class == String

      r_info = Hash.new
      type_info = %w(
                     last_changed_author last_changed_rev
                     last_changed_date conflict_old
                     repos_root_url repos_root_URL
                     copyfrom_rev copyfrom_url conflict_wrk 
                     conflict_new has_wc_info repos_UUID
                     checksum prop_time text_time prejfile
                     schedule taguri lock rev dup url URL
                    ) # changelist depth size tree_conflict working_size

      begin
        @ctx.info(wc_path) do |path, type|
          type_info.each do |t_info|
            r_info[:"#{t_info}"] = type.method(:"#{t_info}").call
          end
        end
      #rescue Svn::Error::WcNotDirectory => e
      #       #Svn::Error::RaIllegalUrl,
      #       #Svn::Error::EntryNotFound,
      #       #Svn::Error::RaIllegalUrl,
      #       #Svn::Error::WC_NOT_DIRECTORY
      #       #Svn::Error::WcNotDirectory => e
      rescue Exception => e
        raise RepoAccessError, "cant get info: #{e.message}"
      end
      r_info
     
    end
332470
def info(model=None, markdown=False, silent=False):
    
    msg = Printer()
    if model:
        if util.is_package(model):
            model_path = util.get_package_path(model)
        else:
            model_path = util.get_data_path() / model
        meta_path = model_path / "meta.json"
        if not meta_path.is_file():
            msg.fail("Can't find model meta.json", meta_path, exits=1)
        meta = srsly.read_json(meta_path)
        if model_path.resolve() != model_path:
            meta["link"] = path2str(model_path)
            meta["source"] = path2str(model_path.resolve())
        else:
            meta["source"] = path2str(model_path)
        if not silent:
            title = "Info about model '{}'".format(model)
            model_meta = {
                k: v for k, v in meta.items() if k not in ("accuracy", "speed")
            }
            if markdown:
                print_markdown(model_meta, title=title)
            else:
                msg.table(model_meta, title=title)
        return meta
    data = {
        "spaCy version": about.__version__,
        "Location": path2str(Path(__file__).parent.parent),
        "Platform": platform.platform(),
        "Python version": platform.python_version(),
        "Models": list_models(),
    }
    if not silent:
        title = "Info about spaCy"
        if markdown:
            print_markdown(data, title=title)
        else:
            msg.table(data, title=title)
    return data
877367
def info(self, url, limit=None):
        
        return self._limit_get('api', 'info', params=dict(url=url), limit=limit)
968319
def _writePlistInfo(self):
        
        pl = Plist(
            CFBundleExecutable=self.executable,
            CFBundleGetInfoString='%s-1.0.0' % self.name,
            CFBundleIconFile=basename(self.icns),
            CFBundleIdentifier='com.%s' % self.name,
            CFBundlePackageType='APPL',
            CFBundleVersion='1.0.0',
            CFBundleShortVersionString='1.0.0',
            )
        writePlist(pl, join(self.contents_dir, 'Info.plist'))
250454
def get_info(self) -> dict:
        """"""
        with suppress_stdout():
            with youtube_dl.YoutubeDL() as ydl:
                info_dict = ydl.extract_info(self.url, download=False)
                return info_dict
643509
def info_file(self):
        
        sources = SBoGrep(self.prgnam).source().split()
        for source in sources:
            self.sbo_sources.append(source.split("/")[-1])
617898
def show_info(ulog, verbose):
    """"""
    m1, s1 = divmod(int(ulog.start_timestamp/1e6), 60)
    h1, m1 = divmod(m1, 60)
    m2, s2 = divmod(int((ulog.last_timestamp - ulog.start_timestamp)/1e6), 60)
    h2, m2 = divmod(m2, 60)
    print("Logging start time: {:d}:{:02d}:{:02d}, duration: {:d}:{:02d}:{:02d}".format(
        h1, m1, s1, h2, m2, s2))

    dropout_durations = [dropout.duration for dropout in ulog.dropouts]
    if len(dropout_durations) == 0:
        print("No Dropouts")
    else:
        print("Dropouts: count: {:}, total duration: {:.1f} s, max: {:} ms, mean: {:} ms"
              .format(len(dropout_durations), sum(dropout_durations)/1000.,
                      max(dropout_durations),
                      int(sum(dropout_durations)/len(dropout_durations))))

    version = ulog.get_version_info_str()
    if not version is None:
        print('SW Version: {}'.format(version))

    print("Info Messages:")
    for k in sorted(ulog.msg_info_dict):
        if not k.startswith('perf_') or verbose:
            print(" {0}: {1}".format(k, ulog.msg_info_dict[k]))


    if len(ulog.msg_info_multiple_dict) > 0:
        if verbose:
            print("Info Multiple Messages:")
            for k in sorted(ulog.msg_info_multiple_dict):
                print(" {0}: {1}".format(k, ulog.msg_info_multiple_dict[k]))
        else:
            print("Info Multiple Messages: {}".format(
                ", ".join(["[{}: {}]".format(k, len(ulog.msg_info_multiple_dict[k])) for k in
                           sorted(ulog.msg_info_multiple_dict)])))



    print("")
    print("{:<41} {:7}, {:10}".format("Name (multi id, message size in bytes)",
                                      "number of data points", "total bytes"))

    data_list_sorted = sorted(ulog.data_list, key=lambda d: d.name + str(d.multi_id))
    for d in data_list_sorted:
        message_size = sum([ULog.get_field_size(f.type_str) for f in d.field_data])
        num_data_points = len(d.data['timestamp'])
        name_id = "{:} ({:}, {:})".format(d.name, d.multi_id, message_size)
        print(" {:<40} {:7d} {:10d}".format(name_id, num_data_points,
                                            message_size * num_data_points))
235514
def _make_info(self, name, stat_result, namespaces):
        
        info = {
            'basic': {
                'name': name,
                'is_dir': stat.S_ISDIR(stat_result.st_mode)
            }
        }
        if 'details' in namespaces:
            info['details'] = self._make_details_from_stat(stat_result)
        if 'stat' in namespaces:
            info['stat'] = {
                k: getattr(stat_result, k)
                for k in dir(stat_result) if k.startswith('st_')
            }
        if 'access' in namespaces:
            info['access'] = self._make_access_from_stat(stat_result)
        return Info(info)