Again, just add to metadata, and comment in install.
  
           Parameters
           ==========
           line: the line from the recipe file to parse to INSTALL
192164
def _expose(self, line):
        '''

        '''
        ports = self._setup('EXPOSE', line)
        if len(ports) > 0:
            self.ports += ports
        return self._comment("# %s" %line)
37182
def add_output(self, line):
        
        Deployment.objects.filter(pk=self.id).update(output=CF('output')+line)
634330
def build_args():
    """"""
    parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('recipe', type=str, help="The recipe file to load and run.")
    parser.add_argument('-d', '--define', action="append", default=[], help="Set a free variable in the recipe")
    parser.add_argument('-l', '--loop', default=None, help="Loop over a free variable")
    parser.add_argument('-i', '--info', action='store_true', help="Lists out all the steps of that recipe, doesn't run the recipe steps")
    parser.add_argument('-a', '--archive', help="Archive the passed yaml recipe and do not run it")
    parser.add_argument('-c', '--config', default=None, help="A YAML config file with variable definitions")

    return parser
823334
def install(self, param, author=None, constraints=None, origin=''):
        """"""
        if isinstance(param, SkillEntry):
            skill = param
        else:
            skill = self.find_skill(param, author)
        entry = build_skill_entry(skill.name, origin, skill.is_beta)
        try:
            skill.install(constraints)
            entry['installed'] = time.time()
            entry['installation'] = 'installed'
            entry['status'] = 'active'
            entry['beta'] = skill.is_beta
        except AlreadyInstalled:
            entry = None
            raise
        except MsmException as e:
            entry['installation'] = 'failed'
            entry['status'] = 'error'
            entry['failure_message'] = repr(e)
            raise
        finally:
            # Store the entry in the list
            if entry:
                self.skills_data['skills'].append(entry)
1037012
def setup!
      env = ::Librarian::Chef::Environment.new(project_path: Dir.pwd)
      @originalpath, env.config_db.local['path'] = env.config_db.local['path'], @tmpdir
      ::Librarian::Action::Resolve.new(env).run
      ::Librarian::Action::Install.new(env).run

      ::RSpec.configure { |config| config.cookbook_path = @tmpdir }
    end
1260352
def add_ppas_from_file(file_name, update=True):
    """"""

    for ppa in _read_lines_from_file(file_name):
        add_ppa(ppa, update=False)
    if update:
        update_apt_sources()
668732
def _add_instruction(self, instruction, value):
        
        if (instruction == 'LABEL' or instruction == 'ENV') and len(value) == 2:
            new_line = instruction + ' ' + '='.join(map(quote, value)) + '\n'
        else:
            new_line = '{0} {1}\n'.format(instruction, value)
        if new_line:
            lines = self.lines
            if not lines[len(lines) - 1].endswith('\n'):
                new_line = '\n' + new_line
            lines += new_line
            self.lines = lines
1130802
def add_line(self, sentences, line_number=None):
        
        self.bytes += self.line(sentences, line_number)
944378
def add_optional_param(key, value, params, call_params)
      # if there is no value in optional param spec,
      # then only add optional param that is set in call parameters
      if !value
        params[-1][key.to_sym] = call_params[key.to_sym] if call_params.key? key.to_sym
      # if value is provided in optional param spec,
      # then apply variable interpolation the same way as required param
      elsif value.class == String
        case value
        when '__FILE_PACKAGE__'
          file_path = "#{call_params[:file_path]}/#{call_params[:package_name]}-#{call_params[:package_version]}.zip"
        when '__FILE_PLAIN__'
          file_path = call_params[:file_path]
        when '__FILE_CERTIFICATE__'
          file_path = call_params[:file_path_certificate]
        when '__FILE_PRIVATE_KEY__'
          file_path = call_params[:file_path_private_key]
        end

        if !file_path.nil?
          File.open(file_path.to_s, 'r') { |file|
            params[-1][key.to_sym] = file
          }
        else
          params[-1][key.to_sym] = value % call_params
        end
      else
        params[-1][key.to_sym] = value
      end
    end
1210599
def _add_environment_lib():
    
    # Create extra cookbook dir
    lib_path = os.path.join(env.node_work_path, cookbook_paths[0],
                            'chef_solo_envs', 'libraries')
    with hide('running', 'stdout'):
        sudo('mkdir -p {0}'.format(lib_path))
    # Add environment patch to the node's cookbooks
    put(os.path.join(basedir, 'environment.rb'),
        os.path.join(lib_path, 'environment.rb'), use_sudo=True)
1205119
def _update_libdata(self, line):
        
        ####################################################
        # parse MONA Comments line
        ####################################################
        # The mona msp files contain a "comments" line that contains lots of other information normally separated
        # into by ""
        if re.match('^Comment.*$', line, re.IGNORECASE):
            comments = re.findall('"([^"]*)"', line)
            for c in comments:
                self._parse_meta_info(c)
                self._parse_compound_info(c)

        ####################################################
        # parse meta and compound info lines
        ####################################################
        # check the current line for both general meta data
        # and compound information
        self._parse_meta_info(line)
        self._parse_compound_info(line)

        ####################################################
        # End of meta data
        ####################################################
        # Most MSP files have the a standard line of text before the spectra information begins. Here we check
        # for this line and store the relevant details for the compound and meta information to be ready for insertion
        # into the database
        if self.collect_meta and (re.match('^Num Peaks(.*)$', line, re.IGNORECASE) or re.match('^PK\$PEAK:(.*)', line,
                re.IGNORECASE) or re.match('^PK\$ANNOTATION(.*)', line, re.IGNORECASE)):

            self._store_compound_info()

            self._store_meta_info()

            # Reset the temp meta and compound information
            self.meta_info = get_blank_dict(self.meta_regex)
            self.compound_info = get_blank_dict(self.compound_regex)
            self.other_names = []
            self.collect_meta = False

        # ignore additional information in the 3rd column if using the MassBank spectra schema
        if re.match('^PK\$PEAK: m/z int\. rel\.int\.$', line, re.IGNORECASE):
            self.ignore_additional_spectra_info = True

        # Check if annnotation or spectra is to be in the next lines to be parsed
        if re.match('^Num Peaks(.*)$', line, re.IGNORECASE) or re.match('^PK\$PEAK:(.*)', line, re.IGNORECASE):
            self.start_spectra = True
            return
        elif re.match('^PK\$ANNOTATION(.*)', line, re.IGNORECASE):
            self.start_spectra_annotation = True

            match = re.match('^PK\$ANNOTATION:(.*)', line, re.IGNORECASE)
            columns = match.group(1)
            cl = columns.split()

            self.spectra_annotation_indexes = {i: cl.index(i) for i in cl}
            return

        ####################################################
        # Process annotation details
        ####################################################
        # e.g. molecular formula for each peak in the spectra
        if self.start_spectra_annotation:
            self._parse_spectra_annotation(line)

        ####################################################
        # Process spectra
        ####################################################
        if self.start_spectra:
            self._parse_spectra(line)
832872
def make(parser):
    

    version = parser.add_mutually_exclusive_group()

    # XXX deprecated in favor of release
    version.add_argument(
        '--stable',
        nargs='?',
        action=StoreVersion,
        metavar='CODENAME',
        help='[DEPRECATED] install a release known as CODENAME\
                (done by default) (default: %(default)s)',
    )

    version.add_argument(
        '--release',
        nargs='?',
        action=StoreVersion,
        metavar='CODENAME',
        help='install a release known as CODENAME\
                (done by default) (default: %(default)s)',
    )

    version.add_argument(
        '--testing',
        nargs=0,
        action=StoreVersion,
        help='install the latest development release',
    )

    version.add_argument(
        '--dev',
        nargs='?',
        action=StoreVersion,
        const='master',
        metavar='BRANCH_OR_TAG',
        help='install a bleeding edge build from Git branch\
                or tag (default: %(default)s)',
    )
    parser.add_argument(
        '--dev-commit',
        nargs='?',
        action=StoreVersion,
        metavar='COMMIT',
        help='install a bleeding edge build from Git commit (defaults to master branch)',
    )

    version.set_defaults(
        stable=None,  # XXX deprecated in favor of release
        release=None,  # Set the default release in sanitize_args()
        dev='master',
        version_kind='stable',
    )

    parser.add_argument(
        '--mon',
        dest='install_mon',
        action='store_true',
        help='install the mon component only',
    )

    parser.add_argument(
        '--mgr',
        dest='install_mgr',
        action='store_true',
        help='install the mgr component only',
    )

    parser.add_argument(
        '--mds',
        dest='install_mds',
        action='store_true',
        help='install the mds component only',
    )

    parser.add_argument(
        '--rgw',
        dest='install_rgw',
        action='store_true',
        help='install the rgw component only',
    )

    parser.add_argument(
        '--osd',
        dest='install_osd',
        action='store_true',
        help='install the osd component only',
    )

    parser.add_argument(
        '--tests',
        dest='install_tests',
        action='store_true',
        help='install the testing components',
    )

    parser.add_argument(
        '--cli', '--common',
        dest='install_common',
        action='store_true',
        help='install the common component only',
    )

    parser.add_argument(
        '--all',
        dest='install_all',
        action='store_true',
        help='install all Ceph components (mon, osd, mds, rgw) except tests. This is the default',
    )

    repo = parser.add_mutually_exclusive_group()

    repo.add_argument(
        '--adjust-repos',
        dest='adjust_repos',
        action='store_true',
        help='install packages modifying source repos',
    )

    repo.add_argument(
        '--no-adjust-repos',
        dest='adjust_repos',
        action='store_false',
        help='install packages without modifying source repos',
    )

    repo.add_argument(
        '--repo',
        action='store_true',
        help='install repo files only (skips package installation)',
    )

    repo.set_defaults(
        adjust_repos=True,
    )

    parser.add_argument(
        'host',
        metavar='HOST',
        nargs='+',
        help='hosts to install on',
    )

    parser.add_argument(
        '--local-mirror',
        nargs='?',
        const='PATH',
        default=None,
        help='Fetch packages and push them to hosts for a local repo mirror',
    )

    parser.add_argument(
        '--repo-url',
        nargs='?',
        dest='repo_url',
        help='specify a repo URL that mirrors/contains Ceph packages',
    )

    parser.add_argument(
        '--gpg-url',
        nargs='?',
        dest='gpg_url',
        help='specify a GPG key URL to be used with custom repos\
                (defaults to ceph.com)'
    )

    parser.add_argument(
        '--nogpgcheck',
        action='store_true',
        help='install packages without gpgcheck',
    )

    parser.set_defaults(
        func=install,
    )
1320145
def add(self, lines, message):
		
		error = Error(message)

		if error not in self.errors:
			self.errors[error] = []

		self.errors[error].extend(lines)
566925
def add_sources_from_file(file_name, update=True):
    

    key_regex = re.compile(r'(?P<source>[^()]*)(\s+\((?P<key>.*)\))?$')
    for line in _read_lines_from_file(file_name):
        kwargs = key_regex.match(line).groupdict()
        kwargs['update'] = False
        add_apt_source(**kwargs)
    if update:
        update_apt_sources()
328932
def prepare_metadata(self):
        # type: () -> None
        
        assert self.source_dir

        with indent_log():
            if self.use_pep517:
                self.prepare_pep517_metadata()
            else:
                self.run_egg_info()

        if not self.req:
            if isinstance(parse_version(self.metadata["Version"]), Version):
                op = "=="
            else:
                op = "==="
            self.req = Requirement(
                "".join([
                    self.metadata["Name"],
                    op,
                    self.metadata["Version"],
                ])
            )
            self._correct_build_location()
        else:
            metadata_name = canonicalize_name(self.metadata["Name"])
            if canonicalize_name(self.req.name) != metadata_name:
                logger.warning(
                    'Generating metadata for package %s '
                    'produced metadata for project name %s. Fix your '
                    '#egg=%s fragments.',
                    self.name, metadata_name, self.name
                )
                self.req = Requirement(metadata_name)
1147304
def add_comment(self, comment, metadata=""):
        
        data = {
            'comment': comment,
            'metadata': metadata
        }

        return self.post('createComment', data)
645675
def _add_cli_param(params, key, value):
    '''
    
    '''
    if value is not None:
        params.append('--{0}={1}'.format(key, value))