Generates the long description of stored routine wrapper.
971282
private function generatePhpDocLongDescription(): void
  {
    if ($this->routine['phpdoc']['long_description']!=='')
    {
      $this->codeStore->append(' * '.$this->routine['phpdoc']['long_description'], false);
    }
  }
20402
def long_encode(input, errors='strict'):
    
    if not isinstance(input, text_type):
        input = text_type(input, sys.getdefaultencoding(), errors)
    length = len(input)
    input = unicodedata.normalize('NFKC', input)
    return input.translate(long_table), length
285990
def decorate_method(wrapped):
    
    def wrapper(self):
        lines = Lines()
        if hasattr(self.model, wrapped.__name__):
            print('            . %s' % wrapped.__name__)
            lines.add(1, method_header(wrapped.__name__, nogil=True))
            for line in wrapped(self):
                lines.add(2, line)
        return lines
    functools.update_wrapper(wrapper, wrapped)
    wrapper.__doc__ = 'Lines of model method %s.' % wrapped.__name__
    return property(wrapper)
986638
def _wrap_definition_section(source, width):
    # type: (str, int) -> str
    
    index = source.index('\n') + 1
    definitions, max_len = _get_definitions(source[index:])
    sep = '\n' + ' ' * (max_len + 4)
    lines = [source[:index].strip()]
    for arg, desc in six.iteritems(definitions):
        wrapped_desc = sep.join(textwrap.wrap(desc, width - max_len - 4))
        lines.append('  {arg:{size}}  {desc}'.format(
            arg=arg,
            size=str(max_len),
            desc=wrapped_desc
        ))
    return '\n'.join(lines)
562292
def _GenerateDescription(self):
    """"""

    manifest = {
        "description": self.description,
        "processed_files": len(self.processed_files),
        "archived_files": len(self.archived_files),
        "ignored_files": len(self.ignored_files),
        "failed_files": len(self.failed_files)
    }
    if self.ignored_files:
      manifest["ignored_files_list"] = [
          _ClientPathToString(cp, prefix="aff4:") for cp in self.ignored_files
      ]
    if self.failed_files:
      manifest["failed_files_list"] = [
          _ClientPathToString(cp, prefix="aff4:") for cp in self.failed_files
      ]

    manifest_fd = io.BytesIO()
    if self.total_files != len(self.archived_files):
      manifest_fd.write(self.FILES_SKIPPED_WARNING)
    manifest_fd.write(yaml.Dump(manifest).encode("utf-8"))

    manifest_fd.seek(0)
    st = os.stat_result(
        (0o644, 0, 0, 0, 0, 0, len(manifest_fd.getvalue()), 0, 0, 0))

    for chunk in self.archive_generator.WriteFromFD(
        manifest_fd, os.path.join(self.prefix, "MANIFEST"), st=st):
      yield chunk
980377
def description(text):
    

    def decorator(func):
        adaptor = ScriptAdaptor._get_adaptor(func)
        adaptor.description = text
        return func
    return decorator
266552
def long_description():
    
    cwd = os.path.abspath(os.path.dirname(__file__))
    readme_path = os.path.join(cwd, 'README.md')
    if not os.path.exists(readme_path):
        return pylink.__long_description__

    try:
        import pypandoc
        return pypandoc.convert(readme_path, 'rst')
    except (IOError, ImportError):
        pass

    return open(readme_path, 'r').read()
1091832
def get_long_description():
    

    description = []
    with open("README.rst") as file:
        for line in file:
            if ".. code:: python" in line and len(description) >= 2:
                blockLine = description[-2]
                if re.search(r":$", blockLine) and not re.search(r"::$", blockLine):
                    description[-2] = "::".join(blockLine.rsplit(":", 1))
                continue

            description.append(line)
    return "".join(description)
692795
def _generateDDL(self):
        """"""
        sql = []
        # Next convert each set of columns into a table structure
        for dataset_name in sorted(self.datasets.keys()):

            # SQL to drop the table if it already exists
            sql.append('''drop table if exists %s;''' % dataset_name)

            # Generate the SQL for the cols
            cols = self.datasets[dataset_name]
            col_defs = []
            for col in cols:
                sql_datatype = self.getSQLDataType(col["vartype"])
                col_defs.append("%s %s" % (col["varname"], sql_datatype,))

            stmt = 'CREATE TABLE %s (%s)' % (dataset_name, ','.join(col_defs))
            sql.append(stmt)

        return sql
246401
def _longoptl(self):
    """"""
    res = []
    for o in self.options:
      nm = o.long
      if o.argName is not None:
        nm += "="
      res.append(nm)
    return res
706414
def long_description
      text = @command.long_description
      return "" if text.nil? # empty description

      lines = text.split("\n")
      lines.map do |line|
        # In the CLI help, we use 2 spaces to designate commands
        # In Markdown we need 4 spaces.
        line.sub(/^  \b/, '    ')
      end.join("\n")
    end
802140
def get_long_description():
    """"""
    root_path = get_root_path()
    readme_path = os.path.join(root_path, "README.md")

    try:
        import pypandoc

        return pypandoc.convert(readme_path, "rst").strip()
    except ImportError:
        return "Cloudsmith CLI"
826519
def create_readme_with_long_description():
    '''
    '''
    this_dir = os.path.abspath(os.path.dirname(__file__))

    readme_md = os.path.join(this_dir, 'README.md')
    readme = os.path.join(this_dir, 'README')

    if os.path.exists(readme_md):
        # this is the case when running `python setup.py sdist`
        if os.path.exists(readme):
            os.remove(readme)

        try:
            import pypandoc
            long_description = pypandoc.convert(readme_md, 'rst', format='md')
        except(ImportError):
            with open(readme_md, encoding='utf-8') as in_:
                long_description = in_.read()

        with open(readme, 'w') as out:
            out.write(long_description)
    else:
        # this is in case of `pip install fabsetup-x.y.z.tar.gz`
        with open(readme, encoding='utf-8') as in_:
            long_description = in_.read()

    return long_description
987754
def get_long_description():
    """"""
    try:
        with open('README.md', 'r') as f:
            description = f.read()
    except OSError as e:
        if e.errno != errno.ENOENT:
            raise
        return None

    try:
        process = subprocess.Popen([
                'pandoc',
                '-f', 'markdown_github',
                '-t', 'rst',
            ],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            universal_newlines=True,
            )
    except OSError as e:
        if e.errno == errno.ENOENT:
            return None
        raise

    description, __ = process.communicate(input=description)
    if process.poll() is None:
        process.kill()
        raise Exception("pandoc did not terminate")
    if process.poll():
        raise Exception("pandoc terminated abnormally")

    return description
954393
def long_description():
    
    changes = latest_changes()
    changes[0] = "`Changes for v{}".format(changes[0][1:])
    changes[1] = '-' * len(changes[0])
    return "\n\n\n".join([
        read_file('README.rst'),
        '\n'.join(changes),
        "`Full changelog <https://{}.readthedocs.io/en/develop/changelog.html"
        "#changelog>`_.".format(PACKAGE_NAME),
    ])
633837
def _write_docstring_parameters(self, routine):
        
        if routine['pydoc']['parameters']:
            self._write_line('')

            for param in routine['pydoc']['parameters']:
                lines = param['description'].split(os.linesep)
                self._write_line(':param {0} {1}: {2}'.format(param['python_type'],
                                                              param['parameter_name'],
                                                              lines[0]))
                del lines[0]

                tmp = ':param {0} {1}:'.format(param['python_type'], param['parameter_name'])
                indent = ' ' * len(tmp)
                for line in lines:
                    self._write_line('{0} {1}'.format(indent, line))

                self._write_line('{0} {1}'.format(indent, param['data_type_descriptor']))
67603
def get_full_description(self):
        

        try:
            time_segment = self.get_time_of_day_description()
            day_of_month_desc = self.get_day_of_month_description()
            month_desc = self.get_month_description()
            day_of_week_desc = self.get_day_of_week_description()
            year_desc = self.get_year_description()

            description = "{0}{1}{2}{3}{4}".format(
                time_segment,
                day_of_month_desc,
                day_of_week_desc,
                month_desc,
                year_desc)

            description = self.transform_verbosity(
                description, self._options.verbose)
            description = self.transform_case(
                description,
                self._options.casing_type)
        except Exception:
            description = _(
                "An error occured when generating the expression description.  Check the cron expression syntax.")
            if self._options.throw_exception_on_parse_error:
                raise FormatException(description)

        return description