Returns the set of all options used in all export entries
321559
def all_options(self):
        """"""
        items = chain.from_iterable(hosts.values() for hosts in self.data.values())
        return set(chain.from_iterable(items))
937230
def compute_exports(exports):
    """"""

    loc, glob = get_calling_namespaces()

    retval = {}
    try:
        for export in exports:
            if SCons.Util.is_Dict(export):
                retval.update(export)
            else:
                try:
                    retval[export] = loc[export]
                except KeyError:
                    retval[export] = glob[export]
    except KeyError as x:
        raise SCons.Errors.UserError("Export of non-existent variable '%s'"%x)

    return retval
254570
def export(self):
        
        data = {}
        for key, value in self.items():
            data[key] = value

        return data
540870
def export_capacities(self):
        
        return [export for cls in getmro(type(self)) if hasattr(cls, "EXPORT_TO") for export in cls.EXPORT_TO]
583592
def _export_all_fixed(self):
        
        array_ts = []
        array_ps = []
        for array_t, array_p in it.product(self.metadata["t_array"][0],
                                           self.metadata["p_array"][0]):
            array_ts.append(array_t)
            array_ps.append(array_p/1e5)

        array_ts_tot = [array_ts for t in self.data.index]
        array_ps_tot = [array_ps for t in self.data.index]
        values = []
        for idx in self.data.index:
            values.append(self._partial_extraction_fixed(idx+1))
        self.data["Temperature"] = array_ts_tot
        self.data["Pressure"] = array_ps_tot
        self.data["values"] = values
321253
def get_options():
    """"""
    options = collections.defaultdict(list)
    for opt_class in config_factory.get_options():
        if not issubclass(opt_class, config_base.Options):
            continue
        config_options = opt_class(None)
        options[config_options.group_name].extend(config_options.list())
    return [(key, value) for key, value in options.items()]
1337254
def get_create_options(self):
        """"""

        package = self._get_package()

        # Locations
        locations = []
        for region in package['regions']:
            locations.append({
                'name': region['location']['location']['longName'],
                'key': region['location']['location']['name'],
            })

        # Sizes
        sizes = []
        for preset in package['activePresets'] + package['accountRestrictedActivePresets']:
            sizes.append({
                'name': preset['description'],
                'key': preset['keyName']
            })

        # Operating systems
        operating_systems = []
        for item in package['items']:
            if item['itemCategory']['categoryCode'] == 'os':
                operating_systems.append({
                    'name': item['softwareDescription']['longDescription'],
                    'key': item['softwareDescription']['referenceCode'],
                })

        # Port speeds
        port_speeds = []
        for item in package['items']:
            if all([item['itemCategory']['categoryCode'] == 'port_speed',
                    # Hide private options
                    not _is_private_port_speed_item(item),
                    # Hide unbonded options
                    _is_bonded(item)]):
                port_speeds.append({
                    'name': item['description'],
                    'key': item['capacity'],
                })

        # Extras
        extras = []
        for item in package['items']:
            if item['itemCategory']['categoryCode'] in EXTRA_CATEGORIES:
                extras.append({
                    'name': item['description'],
                    'key': item['keyName']
                })

        return {
            'locations': locations,
            'sizes': sizes,
            'operating_systems': operating_systems,
            'port_speeds': port_speeds,
            'extras': extras,
        }
262159
function getBuildingConfigs (target) {
  return target.map(({ dirname, name, version, entry, outDir, styleFilename }) => {
    return formats.map(format => {
      return {
        inputOptions: getInputOptions({ entry, outDir, styleFilename }),
        outputOptions: getOutputOptions({ outDir, name, version, format })
      }
    })
  }).reduce((prev, next) => prev.concat(next))
}
570006
def _get_options(ret=None):
    '''
    
    '''
    attrs = {'host': 'host',
             'port': 'port',
             'unix_socket_path': 'unix_socket_path',
             'db': 'db',
             'password': 'password',
             'cluster_mode': 'cluster_mode',
             'startup_nodes': 'cluster.startup_nodes',
             'skip_full_coverage_check': 'cluster.skip_full_coverage_check',
             }

    if salt.utils.platform.is_proxy():
        return {
            'host': __opts__.get('redis.host', 'salt'),
            'port': __opts__.get('redis.port', 6379),
            'unix_socket_path': __opts__.get('redis.unix_socket_path', None),
            'db': __opts__.get('redis.db', '0'),
            'password': __opts__.get('redis.password', ''),
            'cluster_mode': __opts__.get('redis.cluster_mode', False),
            'startup_nodes': __opts__.get('redis.cluster.startup_nodes', {}),
            'skip_full_coverage_check': __opts__.get('redis.cluster.skip_full_coverage_check', False)
        }

    _options = salt.returners.get_returner_options(__virtualname__,
                                                   ret,
                                                   attrs,
                                                   __salt__=__salt__,
                                                   __opts__=__opts__)
    return _options
462509
def get_options(self):
        
        return reduce(
            list.__add__,
            [list(option_list) for option_list in self.get_option_lists()],
            [])
680202
def getAllPlatformObjects(mode = None):
    

    listAll = []

    ############################################################################
    ############################################################################

    # --------------------------------------------------------------------------
    # Dinamically collecting all the "official" modules
    # --------------------------------------------------------------------------

    # A list that will contain all of the module names
    all_modules = []

    # Grabbing all the module names
    for _, name, _ in pkgutil.iter_modules(osrframework.wrappers.__path__):
        all_modules.append("osrframework.wrappers." + name)

    # Iterating through all the module names to grab them
    for moduleName in all_modules:
        # Importing the module
        my_module = importlib.import_module(moduleName)

        # Getting all the classNames.
        classNames = [m[0] for m in inspect.getmembers(my_module, inspect.isclass) if m[1].__module__ == moduleName]

        # Dinamically grabbing the first class of the module. IT SHOULD BE ALONE!
        MyClass = getattr(my_module, classNames[0])

        # Instantiating the object
        newInstance = MyClass()

        # Adding to the list!
        listAll.append(newInstance)

    # --------------------------------------------------------------------------
    # Loading user-defined wrappers under [OSRFrameworkHOME]/plugins/wrappers/
    # --------------------------------------------------------------------------

    # Creating the application paths
    paths = configuration.getConfigPath()

    newPath = os.path.abspath(paths["appPathWrappers"])

    # Inserting in the System Path
    if not newPath in sys.path:
        sys.path.append(newPath)

    userImportedModules = {}

    for module in os.listdir(newPath):
        if module[-3:] == '.py':
            current = module.replace('.py', '')
            userImportedModules[current] = __import__(current)

    del newPath

    userClasses = []

    # Iterating through all the files
    for userModule in userImportedModules.keys():

        my_module = userImportedModules[userModule]
        # Getting all the classNames.
        classNames = [m[0] for m in inspect.getmembers(my_module, inspect.isclass) if m[1].__module__ == userModule]

        # Dinamically grabbing the first class of the module. IT SHOULD BE ALONE!
        MyClass = getattr(my_module, classNames[0])

        # Instantiating the object
        newInstance = MyClass()

        # Adding to the list!
        userClasses.append(newInstance)

    # --------------------------------------------------------------------------
    # Overwriting original modules with the user plugins
    # --------------------------------------------------------------------------
    listToAdd = []
    for userClass in userClasses:
        overwritten = False
        for i, officialClass in enumerate(listAll):
            # Checking if the name is the same
            if str(userClass) == str(officialClass):
                # Replacing the official module if a user module exists for it
                listAll[i] = userClass
                # We stop iterating this loop
                overwritten = True
                break
        if not overwritten:
            # Appending the new class
            listToAdd.append(userClass)

    # Merging listAll and listToAdd
    listAll = listAll + listToAdd
    ############################################################################
    ############################################################################

    creds = credentials.getCredentials()

    for p in listAll:
        # Verify if there are credentials to be loaded
        if p.platformName.lower() in creds.keys():
            p.setCredentials(creds[p.platformName.lower()])

    if mode == None:
        return listAll
    else:
        # We are returning only those platforms which are required by the mode.
        selected = []
        for p in listAll:
            try:
                if p.isValidMode[mode]:
                    selected.append(p)
            except:
                pass
        return selected
345147
def get_outkey(dskey, export_types):
    
    for exptype in export_types:
        if (dskey, exptype) in export:
            return (dskey, exptype)
1076156
def document_options(self):
        
        k1 = max([len(_) for _ in self.gc['k1']]) + 4
        k1 = max([k1, len('Option Class')])
        k2 = max([len(_) for _ in self.gc['k2']]) + 4
        k2 = max([k2, len('Option ID')])

        separators = "  ".join(["".join(["=", ] * k1),
                                "".join(["=", ] * k2),
                                "".join(["=", ] * 11)])
        line = ("{0:>"+str(k1)+"}  {1:>"+str(k2)+"}  {2}")

        data = []
        data.append(separators)
        data.append(line.format('Option Class', 'Option ID', 'Description'))
        data.append(separators)
        for _, row in self.gc.iterrows():
            data.append(line.format("**" + row['k1'] + "**",
                                    "**" + row['k2'] + "**",
                                    row['description']))
        data.append(separators)
        return "\n".join(data)
718420
def _export_all_keyword(self):
        
        data = {}
        for fluid_idx, fluid in enumerate(self.metadata["fluids"]):
            data[fluid] = {}
            with open(self.abspath) as fobj:
                text = fobj.read()
                try:
                    text = text.split("!Phase properties")[1+fluid_idx]
                except IndexError:
                    text = text.split("COLUMNS")[1+fluid_idx]
                try:
                    text = text.split("LABEL")[0]
                except IndexError:
                    pass
                values = re.findall(r"[\.\d\-]+[\.\deE\+\-]+", text)
            nprops = len(self.metadata["properties"])
            for idx, prop in enumerate(self.metadata["properties"]):
                data[fluid][prop] = [float(x) for x in values[idx::nprops]]
        self.data = pd.DataFrame(data)
20547
function getOptions(merge) {
	var options = {
		root: null,
		schemas: {},
		add: [],
		formats: {},
		fresh: false,
		multi: false,
		timeout: 5000,
		checkRecursive: false,
		banUnknownProperties: false,
		languages: {},
		language: null
	};
	return copyProps(options, merge);
}
719147
def export_configuration(self):
        
        if self._export_configuration is None:
            self._export_configuration = ExportConfigurationList(self)
        return self._export_configuration
527443
def export_dict(self):
        ""
        return {k: v.export_dict() if isinstance(v, self.__class__) else v
                for k, v in self.items()}