Mercurial Repository: p/roundup/code: roundup/configuration.py comparison

comparison roundup/configuration.py @ 6966:8733aa2a8e40

flake8 fixes.

author	John Rouillard <rouilj@ieee.org>
date	Tue, 13 Sep 2022 16:35:32 -0400
parents	9ff091537f43
children	570abc4c6548

comparison

equal deleted inserted replaced

-:98d72d4bb489
+:8733aa2a8e40
 else:
 import ConfigParser as configparser  # Python 2
 from roundup.exceptions import RoundupException
-### Exceptions
+# Exceptions
 class ConfigurationError(RoundupException):
 pass
 def create_token(size=32):
 return b2s(binascii.b2a_base64(random_.token_bytes(size)).strip())
-### Option classes
+# Option classes
 class Option:
 """Single configuration option.
 # FIXME this is the result of running:
 #    SELECT cfgname FROM pg_ts_config;
 # on a postgresql 14.1 server.
 # So the best we can do is hardcode this.
-valid_langs = [ "simple",
+valid_langs = ["simple",
 "custom1",
 "custom2",
 "custom3",
 "custom4",
 "custom5",
 "arabic",
 "armenian",
 "basque",
 "catalan",
 "danish",
 "dutch",
 "english",
 "finnish",
 "french",
 "german",
 "greek",
 "hindi",
 "hungarian",
 "indonesian",
 "irish",
 "italian",
 "lithuanian",
 "nepali",
 "norwegian",
 "portuguese",
 "romanian",
 "russian",
 "serbian",
 "spanish",
 "swedish",
 "tamil",
 "turkish",
-"yiddish" ]
+"yiddish"]
 def str2value(self, value):
 _val = value.lower()
 if _val in self.allowed:
 return _val
 raise OptionValueError(self, value, self.class_description)
 lang_avail = b2s(xapian.Stem.get_available_languages())
 languages = textwrap.fill(_("Valid languages: ") +
 lang_avail, 75,
 subsequent_indent="   ")
 raise OptionValueError(options["INDEXER_LANGUAGE"],
 lang, languages)
 if self._value == "native-fts":
 lang = options["INDEXER_LANGUAGE"]._value
 if lang not in self.valid_langs:
 import textwrap
 languages = textwrap.fill(_("Expected languages: ") +
 " ".join(self.valid_langs), 75,
 subsequent_indent="   ")
 raise OptionValueError(options["INDEXER_LANGUAGE"],
 lang, languages)
 class MailAddressOption(Option):
 """Email address
 _val = Option.get(self)
 if _val and not os.path.isabs(_val):
 _val = os.path.join(self.config["HOME"], _val)
 return _val
 class SpaceSeparatedListOption(Option):
 """List of space seperated elements.
 """
 def get(self):
 pathlist = []
 _val = Option.get(self)
 for elem in _val.split():
 pathlist.append(elem)
 if pathlist:
 return pathlist
 else:
 return None
 class OriginHeadersListOption(Option):
 """List of space seperated origin header values.
 """
 class_description = "A list of space separated case sensitive origin headers 'scheme://host'."
 def set(self, _val):
 pathlist = self._value = []
 for elem in _val.split():
 pathlist.append(elem)
 if '*' in pathlist and len(pathlist) != 1:
 raise OptionValueError(self, _val,
 "If using '*' it must be the only element.")
 def _value2str(self, value):
 return ','.join(value)
 class MultiFilePathOption(Option):
 """List of space seperated File or directory path name
 allow the config file to be stored in version control without
 storing the secret there.
 """
-class_description = \
+class_description = (
-"A string that starts with 'file://' is interpreted as a file path \n" \
+"A string that starts with 'file://' is interpreted\n"
-"relative to the tracker home. Using 'file:///' defines an absolute \n" \
+"as a file path relative to the tracker home. Using\n"
-"path. The first line of the file will be used as the value. Any \n" \
+"'file:///' defines an absolute path. The first\n"
-"string that does not start with 'file://' is used as is. It \n" \
+"line of the file will be used as the value. Any\n"
-"removes any whitespace at the end of the line, so a newline can \n" \
+"string that does not start with 'file://' is used\n"
-"be put in the file.\n"
+"as is. It removes any whitespace at the end of the\n"
+"line, so a newline can be put in the file.\n")
 def get(self):
 _val = Option.get(self)
 if isinstance(_val, str) and _val.startswith('file://'):
 filepath = _val[7:]
 # compatible version
 except EnvironmentError as e:
 if e.errno != errno.ENOENT:
 raise
 else:
-raise OptionValueError(self, _val,
+raise OptionValueError(
+self, _val,
 "Unable to read value for %s. Error opening "
 "%s: %s." % (self.name, e.filename, e.args[1]))
 return self.str2value(_val)
 def validate(self, options):
 # is set.
 try:
 self.get()
 except OptionUnsetError:
 # provide error message with link to MAIL_USERNAME
-raise OptionValueError(options["MAIL_PASSWORD"],
+raise OptionValueError(
-"not defined",
+options["MAIL_PASSWORD"],
-"Mail username is set, so this must be defined.")
+"not defined",
+"Mail username is set, so this must be defined.")
 else:
 self.get()
 class WebUrlOption(Option):
 class SecretNullableOption(NullableOption, SecretOption):
 # use get from SecretOption and rest from NullableOption
 get = SecretOption.get
 class_description = SecretOption.class_description
 class RedisUrlOption(SecretNullableOption):
 """Do required check to make sure known bad parameters are not
 put in the url.
 Should I do more URL validation? Validate schema:
 redis, rediss, unix? How many cycles to invest
 to keep users from their own mistakes?
 """
 class_description = SecretNullableOption.class_description
 def str2value(self, value):
 if value and value.find("decode_responses") != -1:
 raise OptionValueError(self, value, "URL must not include "
 "decode_responses. Please remove "
 "the option.")
 return value
 class SessiondbBackendOption(Option):
 """Make sure that sessiondb is compatile with the primary db.
 Fail with error and suggestions if they are incompatible.
 """
 # unset will choose default
 return
 redis_available = False
 try:
-import redis
+import redis                                    # noqa: F401
 redis_available = True
 except ImportError:
 if sessiondb_backend == 'redis':
 valid_session_backends = ', '.join(sorted(list(
-[ x[1] for x in self.compatibility_matrix
+[x[1] for x in self.compatibility_matrix
 if x[0] == rdbms_backend and x[1] != 'redis'])
 ))
-raise OptionValueError(self, sessiondb_backend,
+raise OptionValueError(
-"Unable to load redis module. Please install "
+self, sessiondb_backend,
-"a redis library or choose\n an alternate "
+"Unable to load redis module. Please install "
-"session db: %(valid_session_backends)s"%locals())
+"a redis library or choose\n an alternate "
+"session db: %(valid_session_backends)s" % locals())
-if ( (rdbms_backend, sessiondb_backend) not in
-self.compatibility_matrix ):
+if ((rdbms_backend, sessiondb_backend) not in
+self.compatibility_matrix):
 valid_session_backends = ', '.join(sorted(list(
-set([ x[1] for x in self.compatibility_matrix
+set([x[1] for x in self.compatibility_matrix
 if x[0] == rdbms_backend and
-( redis_available or x[1] != 'redis')])
+(redis_available or x[1] != 'redis')])
 )))
-raise OptionValueError(self, sessiondb_backend,
+raise OptionValueError(
+self, sessiondb_backend,
 "You can not use session db type: %(sessiondb_backend)s "
 "with %(rdbms_backend)s.\n  Valid session db types: "
-"%(valid_session_backends)s."%locals())
+"%(valid_session_backends)s." % locals())
 class TimezoneOption(Option):
 class_description = \
 def str2value(self, value):
 try:
 roundup.date.get_timezone(value)
 except KeyError:
-raise OptionValueError(self, value,
+raise OptionValueError(
-"Timezone name or numeric hour offset required")
+self, value,
+"Timezone name or numeric hour offset required")
 return value
 class HttpVersionOption(Option):
 """Used by roundup-server to verify http version is set to valid
 string."""
 def str2value(self, value):
 if value not in ["HTTP/1.0", "HTTP/1.1"]:
-raise OptionValueError(self, value,
+raise OptionValueError(
+self, value,
 "Valid vaues for -V or --http_version are: HTTP/1.0, HTTP/1.1")
 return value
 class RegExpOption(Option):
 value.decode("ascii")
 except UnicodeError:
 value = value.decode("utf-8")
 return re.compile(value, self.flags)
 try:
-import jinja2
+import jinja2                                           # noqa: F401
 jinja2_avail = "Available found"
 except ImportError:
 jinja2_avail = "Unavailable needs"
-### Main configuration layout.
+# Main configuration layout.
 # Config is described as a sequence of sections,
 # where each section name is followed by a sequence
 # of Option definitions.  Each Option definition
 # is a sequence containing class name and constructor
 # parameters, starting from the setting name:
 "Templating engine to use.\n"
 "Possible values are:\n"
 "   'zopetal' for the old TAL engine ported from Zope,\n"
 "   'chameleon' for Chameleon,\n"
 "   'jinja2' for jinja2 templating.\n"
-"      %s jinja2 module."%jinja2_avail),
+"      %s jinja2 module." % jinja2_avail),
 (FilePathOption, "templates", "html",
 "Path to the HTML templates directory."),
 (MultiFilePathOption, "static_files", "",
 "A list of space separated directory paths (or a single\n"
 "directory).  These directories hold additional static\n"
 "text with <br>. Set true if you want GitHub Flavored Markdown\n"
 "(GFM) handling of embedded newlines."),
 ), "Markdown rendering options."),
 )
-### Configuration classes
+# Configuration classes
 class Config:
 """Base class for configuration objects.
 self.init_logging()
 def init_logging(self):
 _file = self["LOGGING_CONFIG"]
 if _file and os.path.isfile(_file):
-logging.config.fileConfig(_file,
+logging.config.fileConfig(
-disable_existing_loggers=self["LOGGING_DISABLE_LOGGERS"])
+_file,
+disable_existing_loggers=self["LOGGING_DISABLE_LOGGERS"])
 return
 _file = self["LOGGING_FILENAME"]
 # set file & level on the roundup logger
 logger = logging.getLogger('roundup')

Mercurial > p > roundup > code

comparison roundup/configuration.py @ 6966:8733aa2a8e40