Property for accessing :class:`PluginInfoManager` instance, which is used to manage pipeline configurations.

        :rtype: yagocd.resources.plugin_info.PluginInfoManager
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
126614
protected static function getPluginTypePropertyDefinition() {
    return [
      'label' => 'Plugin type',
      'description' => "The identifier of the plugin type. This can be either the manager service name with the 'plugin.manager.' prefix removed, " .
        ' or the subdirectory name.',
      'required' => TRUE,
      'options' => function(&$property_info) {
        $mb_task_handler_report_plugins = \DrupalCodeBuilder\Factory::getTask('ReportPluginData');

        $options = $mb_task_handler_report_plugins->listPluginNamesOptions(static::$discoveryType);

        return $options;
      },
      'processing' => function($value, &$component_data, $property_name, &$property_info) {
        // Validate the plugin type, and find it if given a folder rather than
        // a type.
        $task_report_plugins = \DrupalCodeBuilder\Factory::getTask('ReportPluginData');
        $plugin_types_data = $task_report_plugins->listPluginData(static::$discoveryType);

        // Try to find the intended plugin type.
        if (isset($plugin_types_data[$value])) {
          $plugin_data = $plugin_types_data[$value];
        }
        else {
          // Convert a namespace separator into a directory separator.
          $value = str_replace('\\', '/', $value);

          $plugin_types_data_by_subdirectory = $task_report_plugins->listPluginDataBySubdirectory();
          if (isset($plugin_types_data_by_subdirectory[$value])) {
            $plugin_data = $plugin_types_data_by_subdirectory[$value];

            // Set the plugin ID in the the property.
            $component_data[$property_name] = $plugin_data['type_id'];
          }
          else {
            // Nothing found. Throw exception.
            $discovery_type = static::$discoveryType;
            throw new InvalidInputException("Plugin type {$value} not found in list of {$discovery_type} plugins.");
          }
        }

        // Set the plugin type data.
        // Bit of a cheat, as undeclared data property!
        $component_data['plugin_type_data'] = $plugin_data;

        // Set the relative qualified class name.
        // The full class name will be of the form:
        //  \Drupal\{MODULE}\Plugin\{PLUGINTYPE}\{PLUGINNAME}
        // where PLUGINNAME has any derivative prefix stripped.
        if (strpos($component_data['plugin_name'], ':') === FALSE) {
          $plugin_id = $component_data['plugin_name'];
        }
        else {
          list (, $plugin_id) = explode(':', $component_data['plugin_name']);
        }
        $plugin_id_pascal = CaseString::snake($plugin_id)->pascal();

        $component_data['plugin_name'];
        $plugin_id_without_prefix = $component_data['plugin_name'];

        $component_data['relative_class_name'] = array_merge(
          // Plugin subdirectory.
          self::pathToNamespacePieces($plugin_data['subdir']),
          // Plugin ID.
          [ $plugin_id_pascal ]
        );
      },
    ];
  }
1208703
def getDynDnsClientForConfig(config, plugins=None):
    
    initparams = {}
    if "interval" in config:
        initparams["detect_interval"] = config["interval"]

    if plugins is not None:
        initparams["plugins"] = plugins

    if "updater" in config:
        for updater_name, updater_options in config["updater"]:
            initparams["updater"] = get_updater_class(updater_name)(**updater_options)

    # find class and instantiate the detector:
    if "detector" in config:
        detector_name, detector_opts = config["detector"][-1]
        try:
            klass = get_detector_class(detector_name)
        except KeyError as exc:
            LOG.warning("Invalid change detector configuration: '%s'",
                        detector_name, exc_info=exc)
            return None
        thedetector = klass(**detector_opts)
        initparams["detector"] = thedetector

    return DynDnsClient(**initparams)
298203
def get_plugin(previous_plugin_info)
      if previous_plugin_info[:type] == :platform
        if PLUGINS.has_key?(previous_plugin_info[:name])
          @log.debug("Using #{previous_plugin_info[:name]} mapping")
          return PLUGINS[previous_plugin_info[:name]]
        else
          @log.debug("This plugin does not know what mappings to choose, so will assume default values where user values are not provided.")
        end
      end
      @log.debug("Using default domain mappings.")
      PLUGINS[:default]
    end
1283277
def initialize_plugin(plugin, plugin_info, options = {})
      options = {
        :log => @log
      }.merge(options)

      unless @plugin_chain.empty?
        options.merge!(:previous_plugin => @plugin_chain.last[:plugin])
      end

      plugin.init(@config, @appliance_config, plugin_info, options)

      # Execute callbacks if implemented
      #
      # Order is very important
      [:after_init, :validate, :after_validate].each do |callback|
        plugin.send(callback) if plugin.respond_to?(callback)
      end

      param = nil

      # For operating system plugins we need to inject appliance definition.
      if plugin_info[:type] == :os
        param = @appliance_definition
      end

      @plugin_chain << {:plugin => plugin, :param => param}
    end
443950
protected function init_pluginsinfo_property() {
        if (is_array($this->pluginsinfo)) {
            return;
        }
        $this->pluginsinfo = array();

        $plugintypes = $this->get_plugin_types();

        foreach ($plugintypes as $plugintype => $plugintyperootdir) {
            $this->pluginsinfo[$plugintype] = null;
        }

        // Add orphaned subplugin types.
        $this->load_installed_plugins();
        foreach ($this->installedplugins as $plugintype => $unused) {
            if (!isset($plugintypes[$plugintype])) {
                $this->pluginsinfo[$plugintype] = null;
            }
        }
    }
518608
def get_info(self, version):
        
        ret = super(PandasStore, self).get_info(version)
        ret['col_names'] = version['dtype_metadata']
        ret['handler'] = self.__class__.__name__
        ret['dtype'] = ast.literal_eval(version['dtype'])
        return ret
806253
def pluginRegisterType(cls):
        
        default = Plugin.Type.Module
        default |= Plugin.Type.Package
        default |= Plugin.Type.RegistryFile

        return getattr(cls, '_%s__pluginRegisterType', default)
943134
def initialize_plugin(self):
        
        # TODO: should retrieving the plugin's config be part of the base class?
        try:
            config = self.configuration["filter_regex"]["releases"]
        except KeyError:
            return
        else:
            if not self.patterns:
                pattern_strings = [pattern for pattern in config.split("\n") if pattern]
                self.patterns = [
                    re.compile(pattern_string) for pattern_string in pattern_strings
                ]

                logger.info(f"Initialized regex release plugin with {self.patterns}")
1139645
def plugin_info_by_id(plugin_id, opts={})
      found = all_plugins.find {|pe|
        pe.respond_to?(:plugin_id) && pe.plugin_id.to_s == plugin_id
      }
      if found
        get_monitor_info(found, opts)
      else
        nil
      end
    end
432924
def get_info(self):
        
        info = {
            "name":     self.name,
            "mode":     self.mode & 0o7777,
            "uid":      self.uid,
            "gid":      self.gid,
            "size":     self.size,
            "mtime":    self.mtime,
            "chksum":   self.chksum,
            "type":     self.type,
            "linkname": self.linkname,
            "uname":    self.uname,
            "gname":    self.gname,
            "devmajor": self.devmajor,
            "devminor": self.devminor
        }

        if info["type"] == DIRTYPE and not info["name"].endswith("/"):
            info["name"] += "/"

        return info
255894
def get_config(self, ):
        
        # get the module of the plugin class
        mod = sys.modules[self.__module__]
        # get the file from where it was imported
        modfile = mod.__file__
        # get the module directory
        specdir = os.path.dirname(modfile)
        # get the classname
        cname = self.__class__.__name__
        # add the extension
        confname = os.extsep.join((cname, CONFIG_EXT))

        specpath = os.path.join(specdir, confname)
        if not os.path.exists(specpath):
            return None
        confpath = os.path.join(PLUGIN_CONFIG_DIR, confname)
        return load_config(confpath, specpath)
527601
def properties(self):
        
        if self._property_manager is None:
            self._property_manager = PropertyManager(session=self._session)
        return self._property_manager
292071
def GetPluginObjectByName(cls, plugin_name):
    
    plugin_class = cls._plugin_classes.get(plugin_name, None)
    if plugin_class:
      return plugin_class()

    return None
1203301
def search_manager_from_config(config, **default_init):
    
    manager_cls = import_name(config['class'], default_ns='birding.search')
    init = {}
    init.update(default_init)
    init.update(config['init'])
    manager = manager_cls(**init)
    return manager
1104385
def _init_pluginmanager(self):
        
        self.pluginmanager = PluginManager(logger=self.logger)
        self.logger.debug("Registering execution wide plugins:")
        self.pluginmanager.load_default_run_plugins()
        self.pluginmanager.load_custom_run_plugins(self.args.plugin_path)
        self.logger.debug("Execution wide plugins loaded and registered.")
374849
def get_plugin_class(self, plugin_type, plugin_name):
        """"""
        plugin = self._get_plugin_type(plugin_type)
        return plugin.get_plugin_class(plugin_name)