def setUpClass(cls): token = environ.get('KB_AUTH_TOKEN', None) config_file = environ.get('KB_DEPLOYMENT_CONFIG', None) cls.cfg = {} config = _ConfigParser() config.read(config_file) for nameval in config.items('UIService'): cls.cfg[nameval[0]] = nameval[1] # Getting username from Auth profile for token authServiceUrl = cls.cfg['auth-service-url'] auth_client = _KBaseAuth(authServiceUrl) user_id = auth_client.get_user(token) # WARNING: don't call any logging methods on the context object, # it'll result in a NoneType error cls.ctx = MethodContext(None) cls.ctx.update({ 'token': token, 'user_id': user_id, 'provenance': [{ 'service': 'UIService', 'method': 'please_never_use_it_in_production', 'method_params': [] }], 'authenticated': 1 }) cls.serviceImpl = UIService(cls.cfg) cls.scratch = cls.cfg['scratch'] cls.callback_url = os.environ['SDK_CALLBACK_URL']
def read(self, fileobj, ignore_errors=False): """ Reads the configuration from the file object. If ``ignore_errors`` is ``True`` and a section or option starts with a number, a :exc:`IOError` exception is raised. If not, these sections or options are skipped. :arg fileobj: file object :arg ignore_errors: whether to raise exception or skip invalid section(s) and option(s) """ parser = _ConfigParser() parser.read_file(fileobj) for section in parser.sections(): if section[0].isdigit(): if ignore_errors: continue raise IOError("Section name (%s) cannot start with a digit" % section) options = {} for option in parser.options(section): if option[0].isdigit(): if ignore_errors: continue raise IOError("Option name (%s) cannot start with a digit" % option) options[option] = parser.get(section, option) self.__dict__[section] = _Section(options)
def _read_inifile( file=_os.environ.get( # @ReservedAssignment "KB_DEPLOYMENT_CONFIG", _os.environ["HOME"] + "/.kbase_config")): # Another bandaid to read in the ~/.kbase_config file if one is present authdata = None if _os.path.exists(file): try: config = _ConfigParser() config.read(file) # strip down whatever we read to only what is legit authdata = { x: config.get("authentication", x) if config.has_option( "authentication", x) else None for x in ( "user_id", "token", "client_secret", "keyfile", "keyfile_passphrase", "password", ) } except Exception as e: print("Error while reading INI file %s: %s" % (file, e)) return authdata
def parse_args(self, *args, **kwargs): """Parse the arguments as usual, then add default processing.""" if _debug: ConfigArgumentParser._debug("parse_args") # pass along to the parent class result_args = ArgumentParser.parse_args(self, *args, **kwargs) # read in the configuration file config = _ConfigParser() config.read(result_args.ini) if _debug: _log.debug(" - config: %r", config) # check for BACpypes section if not config.has_section('BACpypes'): raise RuntimeError("INI file with BACpypes section required") # convert the contents to an object ini_obj = type('ini', (object,), dict(config.items('BACpypes'))) if _debug: _log.debug(" - ini_obj: %r", ini_obj) # add the object to the parsed arguments setattr(result_args, 'ini', ini_obj) # return what was parsed return result_args
def from_file(cls, fname): if not os.path.exists(fname): raise FileNotFoundError(fname) config_parser = _ConfigParser() config_parser.read(fname) sections = config_parser._sections return cls(sections)
def get_config(filepath=None): if filepath is None: filepath = _get_config_filepath() config = _ConfigParser() config.read(filepath) config_dict = {s: dict(config.items(s)) for s in config.sections()} return config_dict
def create_config_file(settings=None): filepath = _get_config_filepath() if path.isfile(filepath): return config = _ConfigParser() config['vexbot'] = {'kill_on_exit': False, 'profile': 'default'} config['vexbot_ports'] = _get_default_port_config() with open(filepath, 'w') as f: config.write(f)
def write(self, fileobj): """ Writes the configuration inside the file object. :arg fileobj: file object """ parser = _ConfigParser() # Add sections for section_name in self.__dict__: parser.add_section(section_name) # Add options for section_name, option_name, value in self: parser.set(section_name, option_name, str(value)) parser.write(fileobj)
def _read_inifile( file=_os.environ.get("KB_DEPLOYMENT_CONFIG", _os.environ["HOME"] + "/.kbase_config") # @ReservedAssignment ): # Another bandaid to read in the ~/.kbase_config file if one is present authdata = None if _os.path.exists(file): try: config = _ConfigParser() config.read(file) # strip down whatever we read to only what is legit authdata = { x: config.get("authentication", x) if config.has_option("authentication", x) else None for x in ("user_id", "token", "client_secret", "keyfile", "keyfile_passphrase", "password") } except Exception as e: print("Error while reading INI file {}: {}".format(file, e)) return authdata
def _read_inifile(file=_os.environ.get( # @ReservedAssignment 'KB_DEPLOYMENT_CONFIG', _os.environ['HOME'] + '/.kbase_config')): # Another bandaid to read in the ~/.kbase_config file if one is present authdata = None if _os.path.exists(file): try: config = _ConfigParser() config.read(file) # strip down whatever we read to only what is legit authdata = {x: config.get('authentication', x) if config.has_option('authentication', x) else None for x in ('user_id', 'token', 'client_secret', 'keyfile', 'keyfile_passphrase', 'password')} except Exception as e: print('Error while reading INI file {}: {}'.format(file, e)) return authdata
def _create_deploy_cfg(self, temp_dir, ws_temp_dir, mongo_host, mongo_db, mongo_type_db, auth_url): cp = _ConfigParser() cp['Workspace'] = { 'mongodb-host': mongo_host, 'mongodb-database': mongo_db, 'mongodb-type-database': mongo_type_db, 'backend-type': 'GridFS', 'auth-service-url': auth_url + '/api/legacy/KBase', 'auth-service-url-allow-insecure': 'true', 'auth2-service-url': auth_url + '/', # TODO WS should not be necessary 'temp-dir': str(ws_temp_dir), 'ignore-handle-service': 'true', 'auth2-ws-admin-read-only-roles': 'WS_READ_ADMIN', 'auth2-ws-admin-full-roles': 'WS_FULL_ADMIN' } f = temp_dir / 'test.cfg' with open(f, 'w') as inifile: cp.write(inifile) return f
def setUpClass(cls): configfile = os.path.abspath(os.path.dirname( os.path.abspath(__file__)) + '/../test.cfg') print('Loading test config from ' + configfile) cfg = _ConfigParser() cfg.read(configfile) authurl = cfg.get(cls.CFG_SEC, cls.AUTHURL) cls.token1 = cfg.get(cls.CFG_SEC, cls.TOKEN1) cls.token2 = cfg.get(cls.CFG_SEC, cls.TOKEN2) if not authurl: raise ValueError('Missing {} from test config'.format(cls.AUTHURL)) if not cls.token1: raise ValueError('Missing {} from test config'.format(cls.TOKEN1)) if not cls.token2: raise ValueError('Missing {} from test config'.format(cls.TOKEN2)) print('Authorization url: ' + authurl) cls.user1 = cls.get_user(authurl, cls.token1) cls.user2 = cls.get_user(authurl, cls.token2) if cls.user1 == cls.user2: raise ValueError('{} and {} users are the same: {}'.format( cls.TOKEN1, cls.TOKEN2, cls.user1)) cls.kba = KBaseAuth(authurl)
def setUpClass(cls): configfile = os.path.abspath( os.path.dirname(os.path.abspath(__file__)) + '/../test.cfg') print('Loading test config from ' + configfile) cfg = _ConfigParser() cfg.read(configfile) authurl = cfg.get(cls.CFG_SEC, cls.AUTHURL) cls.token1 = cfg.get(cls.CFG_SEC, cls.TOKEN1) cls.token2 = cfg.get(cls.CFG_SEC, cls.TOKEN2) if not authurl: raise ValueError('Missing {} from test config'.format(cls.AUTHURL)) if not cls.token1: raise ValueError('Missing {} from test config'.format(cls.TOKEN1)) if not cls.token2: raise ValueError('Missing {} from test config'.format(cls.TOKEN2)) print('Authorization url: ' + authurl) cls.user1 = cls.get_user(authurl, cls.token1) cls.user2 = cls.get_user(authurl, cls.token2) if cls.user1 == cls.user2: raise ValueError('{} and {} users are the same: {}'.format( cls.TOKEN1, cls.TOKEN2, cls.user1)) cls.kba = KBaseAuth(authurl)
def expand_args(self, result_args): """Take the result of parsing the args and interpret them.""" if _debug: ConfigArgumentParser._debug("expand_args %r", result_args) # read in the configuration file config = _ConfigParser() config.read(result_args.ini) if _debug: _log.debug(" - config: %r", config) # check for BACpypes section if not config.has_section('BACpypes'): raise RuntimeError("INI file with BACpypes section required") # convert the contents to an object ini_obj = Settings(dict(config.items('BACpypes'))) if _debug: _log.debug(" - ini_obj: %r", ini_obj) # add the object to the parsed arguments setattr(result_args, 'ini', ini_obj) # continue with normal expansion ArgumentParser.expand_args(self, result_args)
def csv_nist_import_data(pth, filename_header, filename_data, output_cls_instance=None): """ Import dataset(s) from HDF file Parameters ---------- pth : str Path filename_header : str File name of header filename_data : str File name of data output_cls_instance : crikit.data.spectrum.Spectrum (or subclass) Spectrum class (or sub) object Returns ------- Success : bool Success of import Data, Meta : list (ndarray, dict) If output_cls_instance is None and import is successful, will \ return the data from dset_list and associated meta data. """ # Join path and filename in an os-independant way pfname_header = _os.path.normpath(_os.path.join(pth, filename_header)) pfname_data = _os.path.normpath(_os.path.join(pth, filename_data)) valid_import_locs = 0 try: with open(pfname_header,'r') as _: pass except: print('Invalid header filename') else: valid_import_locs += 1 try: with open(pfname_data,'r') as _: pass except: print('Invalid data filename') else: valid_import_locs += 1 if valid_import_locs != 2: return False else: try: config = _ConfigParser() config.read(pfname_header) # Frequency calibration probe = config.getfloat('Frequency Calibration','probe(nm)') wl1 = config.getfloat('Frequency Calibration','wavelength1(nm)') wl2 = config.getfloat('Frequency Calibration','wavelength2(nm)') pixel1 = config.getint('Frequency Calibration','pixel1') pixel2 = config.getint('Frequency Calibration','pixel2') f_begin = config.getfloat('Frequency Calibration','freq index begin') f_size = config.getint('Frequency Calibration','freq index length') f_min = config.getfloat('Frequency Calibration','freq Min') f_max = config.getfloat('Frequency Calibration','freq Max') pix = _np.linspace(pixel1,pixel2,f_size) wl = _np.linspace(wl1,wl2,f_size) wn = 1e7*(1/wl - 1/probe) # Config is apparently backwards so flip order pix = _np.flipud(pix) wl = _np.flipud(wl) wn = _np.flipud(wn) # Frequency calibration stuff wl_center = wl.mean() wl_slope, wl_intercept = _np.polyfit(pix, wl,1) # Get data with open(pfname_data,'r') as csvfile: reader = _csv.reader(csvfile, delimiter='\t') data = [] for count in reader: data.append(count) data = _np.array(data).astype(float) if (data.shape[-1] == 3) | (data.shape[-1] == 2): # Spectra print('Spectra') wn = data[:,0] temp = data[:,-1] if data.shape[-1] == 3: wl = data[:,1] data = temp # Meta data attr = {} for each_section in config.sections(): #print('Section: {}'.format(each_section)) for (each_key, each_val) in config.items(each_section): k = each_section + '.' + each_key try: # int v = int(each_val) #print('Integer') except: try: # float v = float(each_val) except: # string v = str.strip(each_val,'"') #print('{}.{}: {}'.format(each_section,each_key, v)) attr.update({k:v}) # Add in frequency calibration info attr['Frequency Calibration.Slope'] = wl_slope attr['Frequency Calibration.Intercept'] = wl_intercept attr['Frequency Calibration.CenterWavelength'] = wl_center # Convert meta keys to match those of HDF5 version # Note: will not overwrite, just add-to # Note: Subject to change output_cls_instance.data = data output_cls_instance.meta = attr return True else: data = data.reshape((data.shape[0],-1,f_size)) # Spatial Info x_start = config.getfloat('X scan Parameters','X start (um)') x_steps = config.getint('X scan Parameters','X steps') x_step_size = config.getfloat('X scan Parameters','X step size (um)') x = _np.linspace(x_start, x_start + x_step_size * (x_steps-1), x_steps) try: # Exists a typo in header info in LabView program y_start = config.getfloat('Y scan Paramters','Y start (um)') y_steps = config.getint('Y scan Paramters','Y steps') y_step_size = config.getfloat('Y scan Paramters','Y step size (um)') y = _np.linspace(y_start, y_start + y_step_size * (y_steps-1), y_steps) except: # In case typo is corrected in the future y_start = config.getfloat('Y scan Parameters','Y start (um)') y_steps = config.getint('Y scan Parameters','Y steps') y_step_size = config.getfloat('Y scan Parameters','Y step size (um)') y = _np.linspace(y_start, y_start + y_step_size * (y_steps-1), y_steps) # Meta data attr = {} for each_section in config.sections(): #print('Section: {}'.format(each_section)) for (each_key, each_val) in config.items(each_section): k = each_section + '.' + each_key try: # int v = int(each_val) #print('Integer') except: try: # float v = float(each_val) except: # string v = str.strip(each_val,'"') #print('{}.{}: {}'.format(each_section,each_key, v)) attr.update({k:v}) # Add in frequency calibration info attr['Frequency Calibration.Slope'] = wl_slope attr['Frequency Calibration.Intercept'] = wl_intercept attr['Frequency Calibration.CenterWavelength'] = wl_center # Convert meta keys to match those of HDF5 version # Note: will not overwrite, just add-to # Note: Subject to change try: ax1 = attr['Image data.1st axis'] if ax1 == 0: attr['RasterScanParams.FastAxis'] = 'X' elif ax1 == 1: attr['RasterScanParams.FastAxis'] = 'Y' elif ax1 == 2: attr['RasterScanParams.FastAxis'] = 'Z' attr['RasterScanParams.FastAxisStart'] = x_start attr['RasterScanParams.FastAxisStepSize'] = x_step_size attr['RasterScanParams.FastAxisSteps'] = x_steps attr['RasterScanParams.FastAxisStop'] = x[-1] ax2 = attr['Image data.2nd axis'] if ax2 == 0: attr['RasterScanParams.SlowAxis'] = 'X' elif ax2 == 1: attr['RasterScanParams.SlowAxis'] = 'Y' elif ax2 == 2: attr['RasterScanParams.SlowAxis'] = 'Z' attr['RasterScanParams.SlowAxisStart'] = y_start attr['RasterScanParams.SlowAxisStepSize'] = y_step_size attr['RasterScanParams.SlowAxisSteps'] = y_steps attr['RasterScanParams.SlowAxisStop'] = y[-1] ax3 = attr['Image data.3rd axis'] if ax3 == 0: attr['RasterScanParams.FixedAxis'] = 'X' elif ax3 == 1: attr['RasterScanParams.FixedAxis'] = 'Y' elif ax3 == 2: attr['RasterScanParams.FixedAxis'] = 'Z' # Figure out fixed positions later except: pass else: output_cls_instance.data = data output_cls_instance.meta = attr return True except: print('Something failed in import')
def update_config(self): loglevel = self.get_log_level() logfile = self.get_log_file() self._api_log_level = -1 self._msgs_since_config_update = 0 self._time_at_config_update = time.time() # Retrieving the control API defined log level api_url = None if self._mlog_config_file and _os.path.isfile(self._mlog_config_file): cfg = _ConfigParser() cfg.read(self._mlog_config_file) cfgitems = self._get_config_items(cfg, _GLOBAL) cfgitems.update(self._get_config_items(cfg, self._subsystem)) if MLOG_LOG_LEVEL in cfgitems: try: self._config_log_level = int(cfgitems[MLOG_LOG_LEVEL]) except: _warnings.warn( 'Cannot parse log level {} from file {} to int'.format( cfgitems[MLOG_LOG_LEVEL], self._mlog_config_file) + '. Keeping current log level.') if MLOG_API_URL in cfgitems: api_url = cfgitems[MLOG_API_URL] if MLOG_LOG_FILE in cfgitems: self._config_log_file = cfgitems[MLOG_LOG_FILE] elif self._mlog_config_file: _warnings.warn('Cannot read config file ' + self._mlog_config_file) if (api_url): subsystem_api_url = api_url + "/" + self._subsystem try: data = _json.load( urllib.request.urlopen(subsystem_api_url, timeout=5)) except urllib.error.URLError as e: code_ = None if hasattr(e, 'code'): code_ = ' ' + str(e.code) _warnings.warn('Could not connect to mlog api server at ' + '{}:{} {}. Using default log level {}.'.format( subsystem_api_url, code_, str(e.reason), str(DEFAULT_LOG_LEVEL))) else: max_matching_level = -1 for constraint_set in data['log_levels']: level = constraint_set['level'] constraints = constraint_set['constraints'] if level <= max_matching_level: continue matches = 1 for constraint in constraints: if constraint not in self._log_constraints: matches = 0 elif (self._log_constraints[constraint] != constraints[constraint]): matches = 0 if matches == 1: max_matching_level = level self._api_log_level = max_matching_level if ((self.get_log_level() != loglevel or self.get_log_file() != logfile) and not self._init): self._callback()
def __init__(self): self.conf = _ConfigParser() self.conf.optionxform = str # preserve case
def csv_nist_import_data(pth, filename_header, filename_data, output_cls_instance=None): """ Import dataset(s) from HDF file Parameters ---------- pth : str Path filename_header : str File name of header filename_data : str File name of data output_cls_instance : crikit.data.spectrum.Spectrum (or subclass) Spectrum class (or sub) object Returns ------- Success : bool Success of import Data, Meta : list (ndarray, dict) If output_cls_instance is None and import is successful, will \ return the data from dset_list and associated meta data. """ # Join path and filename in an os-independant way pfname_header = _os.path.normpath(_os.path.join(pth, filename_header)) pfname_data = _os.path.normpath(_os.path.join(pth, filename_data)) valid_import_locs = 0 try: with open(pfname_header, 'r') as _: pass except: print('Invalid header filename') else: valid_import_locs += 1 try: with open(pfname_data, 'r') as _: pass except: print('Invalid data filename') else: valid_import_locs += 1 if valid_import_locs != 2: return False else: try: config = _ConfigParser() config.read(pfname_header) # Frequency calibration probe = config.getfloat('Frequency Calibration', 'probe(nm)') wl1 = config.getfloat('Frequency Calibration', 'wavelength1(nm)') wl2 = config.getfloat('Frequency Calibration', 'wavelength2(nm)') pixel1 = config.getint('Frequency Calibration', 'pixel1') pixel2 = config.getint('Frequency Calibration', 'pixel2') f_begin = config.getfloat('Frequency Calibration', 'freq index begin') f_size = config.getint('Frequency Calibration', 'freq index length') f_min = config.getfloat('Frequency Calibration', 'freq Min') f_max = config.getfloat('Frequency Calibration', 'freq Max') pix = _np.linspace(pixel1, pixel2, f_size) wl = _np.linspace(wl1, wl2, f_size) wn = 1e7 * (1 / wl - 1 / probe) # Config is apparently backwards so flip order pix = _np.flipud(pix) wl = _np.flipud(wl) wn = _np.flipud(wn) # Frequency calibration stuff wl_center = wl.mean() wl_slope, wl_intercept = _np.polyfit(pix, wl, 1) # Get data with open(pfname_data, 'r') as csvfile: reader = _csv.reader(csvfile, delimiter='\t') data = [] for count in reader: data.append(count) data = _np.array(data).astype(float) if (data.shape[-1] == 3) | (data.shape[-1] == 2): # Spectra print('Spectra') wn = data[:, 0] temp = data[:, -1] if data.shape[-1] == 3: wl = data[:, 1] data = temp # Meta data attr = {} for each_section in config.sections(): #print('Section: {}'.format(each_section)) for (each_key, each_val) in config.items(each_section): k = each_section + '.' + each_key try: # int v = int(each_val) #print('Integer') except: try: # float v = float(each_val) except: # string v = str.strip(each_val, '"') #print('{}.{}: {}'.format(each_section,each_key, v)) attr.update({k: v}) # Add in frequency calibration info attr['Frequency Calibration.Slope'] = wl_slope attr['Frequency Calibration.Intercept'] = wl_intercept attr['Frequency Calibration.CenterWavelength'] = wl_center # Convert meta keys to match those of HDF5 version # Note: will not overwrite, just add-to # Note: Subject to change output_cls_instance.data = data output_cls_instance.meta = attr return True else: data = data.reshape((data.shape[0], -1, f_size)) # Spatial Info x_start = config.getfloat('X scan Parameters', 'X start (um)') x_steps = config.getint('X scan Parameters', 'X steps') x_step_size = config.getfloat('X scan Parameters', 'X step size (um)') x = _np.linspace(x_start, x_start + x_step_size * (x_steps - 1), x_steps) try: # Exists a typo in header info in LabView program y_start = config.getfloat('Y scan Paramters', 'Y start (um)') y_steps = config.getint('Y scan Paramters', 'Y steps') y_step_size = config.getfloat('Y scan Paramters', 'Y step size (um)') y = _np.linspace(y_start, y_start + y_step_size * (y_steps - 1), y_steps) except: # In case typo is corrected in the future y_start = config.getfloat('Y scan Parameters', 'Y start (um)') y_steps = config.getint('Y scan Parameters', 'Y steps') y_step_size = config.getfloat('Y scan Parameters', 'Y step size (um)') y = _np.linspace(y_start, y_start + y_step_size * (y_steps - 1), y_steps) # Meta data attr = {} for each_section in config.sections(): #print('Section: {}'.format(each_section)) for (each_key, each_val) in config.items(each_section): k = each_section + '.' + each_key try: # int v = int(each_val) #print('Integer') except: try: # float v = float(each_val) except: # string v = str.strip(each_val, '"') #print('{}.{}: {}'.format(each_section,each_key, v)) attr.update({k: v}) # Add in frequency calibration info attr['Frequency Calibration.Slope'] = wl_slope attr['Frequency Calibration.Intercept'] = wl_intercept attr['Frequency Calibration.CenterWavelength'] = wl_center # Convert meta keys to match those of HDF5 version # Note: will not overwrite, just add-to # Note: Subject to change try: ax1 = attr['Image data.1st axis'] if ax1 == 0: attr['RasterScanParams.FastAxis'] = 'X' elif ax1 == 1: attr['RasterScanParams.FastAxis'] = 'Y' elif ax1 == 2: attr['RasterScanParams.FastAxis'] = 'Z' attr['RasterScanParams.FastAxisStart'] = x_start attr['RasterScanParams.FastAxisStepSize'] = x_step_size attr['RasterScanParams.FastAxisSteps'] = x_steps attr['RasterScanParams.FastAxisStop'] = x[-1] ax2 = attr['Image data.2nd axis'] if ax2 == 0: attr['RasterScanParams.SlowAxis'] = 'X' elif ax2 == 1: attr['RasterScanParams.SlowAxis'] = 'Y' elif ax2 == 2: attr['RasterScanParams.SlowAxis'] = 'Z' attr['RasterScanParams.SlowAxisStart'] = y_start attr['RasterScanParams.SlowAxisStepSize'] = y_step_size attr['RasterScanParams.SlowAxisSteps'] = y_steps attr['RasterScanParams.SlowAxisStop'] = y[-1] ax3 = attr['Image data.3rd axis'] if ax3 == 0: attr['RasterScanParams.FixedAxis'] = 'X' elif ax3 == 1: attr['RasterScanParams.FixedAxis'] = 'Y' elif ax3 == 2: attr['RasterScanParams.FixedAxis'] = 'Z' # Figure out fixed positions later except: pass else: output_cls_instance.data = data output_cls_instance.meta = attr return True except: print('Something failed in import')
def get_auth(filename="credentials.ini", basic=False): """ Set up NTLM authentication for the Microscopy Nexus using an account as specified from a file that lives in the package root named .credentials (or some other value provided as a parameter). Alternatively, the stored credentials can be overridden by supplying two environment variables: ``nexusLIMS_user`` and ``nexusLIMS_pass``. These variables will be queried first, and if not found, the method will attempt to use the credential file. Parameters ---------- filename : str Name relative to this file (or absolute path) of file from which to read the parameters basic : bool If True, return only username and password rather than NTLM authentication (like what is used for CDCS access rather than for NIST network resources) Returns ------- auth : ``requests_ntlm.HttpNtlmAuth`` or tuple NTLM authentication handler for ``requests`` Notes ----- The credentials file is expected to have a section named ``[nexus_credentials]`` and two values: ``username`` and ``password``. See the ``credentials.ini.example`` file included in the repository as an example. """ try: username = _os.environ['nexusLIMS_user'] passwd = _os.environ['nexusLIMS_pass'] _logger.info("Authenticating using environment variables") except KeyError: # if absolute path was provided, use that, otherwise find filename in # this directory if _os.path.isabs(filename): pass else: filename = _os.path.join(_os.path.dirname(__file__), filename) # Raise error if the configuration file is not found if not _os.path.isfile(filename): raise AuthenticationError("No credentials were specified with " "environment variables, and credential " "file {} was not found".format(filename)) config = _ConfigParser() config.read(filename) username = config.get("nexus_credentials", "username") passwd = config.get("nexus_credentials", "password") if basic: # return just username and password (for BasicAuthentication) return username, passwd domain = 'nist' path = domain + '\\' + username auth = _HttpNtlmAuth(path, passwd) return auth
from selenium.webdriver.common.keys import Keys as _Keys from selenium.webdriver.support.ui import WebDriverWait as _WebDriverWait from selenium.webdriver.support import expected_conditions as _EC from selenium.webdriver.common.by import By as _By from selenium.webdriver.chrome.options import Options as _Options #----------------------------------------------------------------------------- # Constants & Configs #----------------------------------------------------------------------------- _CONFIG_FILENAME = 'config.ini' _MONTHS = [ '', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ] _config = _ConfigParser(interpolation=_ExtendedInterpolation()) _config_result = _config.read(_CONFIG_FILENAME) if len(_config_result) == 0: raise FileNotFoundError(_errno.ENOENT, _os.strerror(_errno.ENOENT), _CONFIG_FILENAME) # Base URLs _FEED_URL_STEM = _config['base_urls']['FEED_URL_STEM'] _ARCHIVE_FEED_STEM = _config['base_urls']['ARCHIVE_FEED_STEM'] _ARCHIVE_DOWNLOAD_STEM = _config['base_urls']['ARCHIVE_DOWNLOAD_STEM'] _LOGIN_URL = _config['base_urls']['LOGIN_URL'] # Throttle times _FILE_REQUEST_WAIT = _config.getfloat('throttle_times', 'FILE_REQUEST_WAIT',
# -*- coding: utf-8 -*- """doc string""" import os as _os from configparser import ConfigParser as _ConfigParser config = _ConfigParser() config.read(_os.path.join( _os.path.dirname(__file__), r'..\..\config.ini', )) if __name__ == '__main__': print(config.get('account', 'username'))
def __init__(self, feed_id, username=None, password=None, login_cfg_path=None, show_browser_ui=False, webdriver_path=None): """ A container for Broadcastify feed archive data, and an engine for re- trieving archive entry information & downloading the corresponding mp3 files. Populates feed name, feed & archive URLs, and start & end dates on initialization. Init Parameters --------------- feed_id : str The unique feed identifier the container will represent, taken from https://www.broadcastify.com/listen/feed/[feed_id]. username : str The username for a valid Broadcastify premium account. password : str The password for a valid Broadcastify premium account. Note that getting the property value will return only "True" (if set) or "False" (if not set) to maintain confidentiality. login_cfg_path : str An absolute path to a password configuration file. Allows the user to keep their login information outside the script using the archive for privacy reasons. show_browser_ui : bool If True, scraping done during initialization and build (which use the Selenium webdriver) will be done with the "headless" option set to False, resulting in a visible browser window being open in the UI during scraping. Otherwise, scraping will be done "invisibly". Note that no browser will be shown during download, since requests.Session() is used, not Selenium. webdriver_path : str Optional absolute path to WebDriver if it's not located in a directory in the PATH environment variable Other Attributes & Properties ----------------------------- feed_url : str Full https URL for the feed's main "listen" page. archive_url : str Full https URL for the feed's archive page. entries : dictionary Container for archive entry information. uri : str [Populated at .build] The unique ID for an individual archive file page, which corresponds to a feed's transmissions over a ~30-minute period on a given date. Can be used to find the mp3 file's individual download page. This page is password protected and limited to premium account holders. start_time : datetime [Populated at .build] Beginning time of the archive entry. end_time : datetime [Populated at .build] Ending time of the archive entry. earliest_entry : datetime latest_entry : datetime The datetime of the earliest/latest archive entry currently in `entries`. start_date : datetime end_date : datetime The datetime of the earliest/latest dates on the archive's calendar. throttle : _RequestThrottle (INTERNAL USE ONLY) Throttle http requests to the Broadcastify servers. """ self.show_browser_ui = show_browser_ui if webdriver_path is None: self.webdriver_path = 'chromedriver' else: self.webdriver_path = webdriver_path self._feed_id = None self.feed_url = _FEED_URL_STEM + feed_id self.archive_url = _ARCHIVE_FEED_STEM + feed_id self.username = username self.password = password self.entries = [] self.earliest_entry = None self.latest_entry = None self.start_date = None self.end_date = None self.throttle = _RequestThrottle() # If username or password was not passed... if (username is None or password is None) and login_cfg_path is not None: # ...try to get it from the pwd.ini file _config = _ConfigParser() config_result = _config.read(login_cfg_path) if len(config_result) != 0: # Replace only if argument was not passed if not (username): self.username = _config['authentication_data']['username'] if not (password): self.password = _config['authentication_data']['password'] self.feed_id = feed_id self._get_feed_name(feed_id)
from configparser import ConfigParser as _ConfigParser from importlib import resources __version__ = "1.2.0" _cfg = _ConfigParser() with resources.path("reader", "config.cfg") as _path: _cfg.read(str(_path)) URL = _cfg.get("feed", "url")
if 3 == python_version.major: if 2 <= python_version.minor: from configparser import ( # pylint: disable=F0401 ConfigParser as _ConfigParser, ) else: from configparser import ( # pylint: disable=F0401 SafeConfigParser as _ConfigParser, ) else: from ConfigParser import ( # pylint: disable=F0401 SafeConfigParser as _ConfigParser, ) _path_to_config = _join_path( __path__[ 0 ], "version.cfg" ) _vinfo_CFG = _ConfigParser( ) if _path_to_config not in _vinfo_CFG.read( _path_to_config ): raise IOError( "Configuration file '{0}' expected but not found.".format( _path_to_config ) ) _vinfo_release_type = _vinfo_CFG.get( "control", "release_type" ) assert _vinfo_release_type in [ "bugfix", "candidate", "development" ] _vinfo_numbers_DICT = dict( _vinfo_CFG.items( "numbers" ) ) if "bugfix" == _vinfo_release_type: # Stable Bugfix Release __version__ = \ "{major}.{minor}.{bugfix}".format( **_vinfo_numbers_DICT ) elif "candidate" == _vinfo_release_type: # Release Candidate __version__ = \