Python3, PEP8, bad init fixes

1 files changed, 87 insertions, 79 deletions

diff --git a/ishtar_common/data_importer.py b/ishtar_common/data_importer.py
index a609353e3..46b581365 100644
--- a/ishtar_common/data_importer.py
+++ b/ishtar_common/data_importer.py
@@ -192,16 +192,16 @@ class ChoiceChecker(object):
     def report_new(self, comment):
         if not self.new_keys:
             return
-        msg = u"For \"%s\" these new associations have been made:\n" % comment
+        msg = "For \"%s\" these new associations have been made:\n" % comment
         sys.stderr.write(msg.encode('utf-8'))
         for k in self.new_keys:
-            msg = u'"%s";"%s"\n' % (k, self.new_keys[k])
+            msg = '"%s";"%s"\n' % (k, self.new_keys[k])
             sys.stderr.write(msg.encode('utf-8'))
 
 
 class UnicodeFormater(Formater):
     def __init__(self, max_length=None, clean=False, re_filter=None,
-                 notnull=False, prefix=u'', db_target=None,
+                 notnull=False, prefix='', db_target=None,
                  import_instance=None, many_split=None):
         self.max_length = max_length
         self.db_target = db_target
@@ -217,15 +217,15 @@ class UnicodeFormater(Formater):
             if type(value) != str:
                 value = str(value.strip())
             vals = []
-            for v in value.split(u'\n'):
+            for v in value.split('\n'):
                 v = v.strip()
                 if v:
                     vals.append(v)
-            value = u"\n".join(vals)
+            value = "\n".join(vals)
             if self.re_filter:
                 m = self.re_filter.match(value)
                 if m:
-                    value = u"".join(m.groups())
+                    value = "".join(m.groups())
             if self.clean:
                 if value.startswith(","):
                     value = value[1:]
@@ -236,9 +236,9 @@ class UnicodeFormater(Formater):
             return
         if self.max_length and len(value) > self.max_length:
             raise ValueError(
-                _(u"\"%(value)s\" is too long. The max length is %(length)d "
-                  u"characters.") % {'value': value,
-                                     'length': self.max_length})
+                _("\"%(value)s\" is too long. The max length is %(length)d "
+                  "characters.") % {'value': value,
+                                    'length': self.max_length})
         if self.notnull and not value:
             return
         if value:
@@ -253,7 +253,7 @@ class BooleanFormater(Formater):
             return True
         if value in ('', '0', 'NON', 'FAUX', 'NO', 'FALSE'):
             return False
-        raise ValueError(_(u"\"%(value)s\" not equal to yes or no") % {
+        raise ValueError(_("\"%(value)s\" not equal to yes or no") % {
             'value': value})
 
 
@@ -266,7 +266,7 @@ class FloatFormater(Formater):
         try:
             return float(value)
         except ValueError:
-            raise ValueError(_(u"\"%(value)s\" is not a float") % {
+            raise ValueError(_("\"%(value)s\" is not a float") % {
                 'value': value})
 
 
@@ -276,7 +276,7 @@ class InseeFormater(Formater):
     The syntax "CodeINSEE-Year" is accepted (Ishtar trick) in order to manage
     old INSEE (year is the date of creation)
     """
-    ERROR = _(u"\"{value}\" is not an appropriate INSEE code")
+    ERROR = _("\"{value}\" is not an appropriate INSEE code")
 
     def format(self, value):
         value = value.strip()
@@ -296,7 +296,7 @@ class InseeFormater(Formater):
             datetime.datetime.strptime(exp[1], '%Y')
         except ValueError:
             raise ValueError(str(self.ERROR).format(value))
-        return code + u"-" + exp[1]
+        return code + "-" + exp[1]
 
 
 class YearFormater(Formater):
@@ -308,7 +308,7 @@ class YearFormater(Formater):
             value = int(value)
             assert value > 0 and value < (datetime.date.today().year + 30)
         except (ValueError, AssertionError):
-            raise ValueError(_(u"\"%(value)s\" is not a valid date") % {
+            raise ValueError(_("\"%(value)s\" is not a valid date") % {
                 'value': value})
         return value
 
@@ -320,9 +320,9 @@ class YearNoFuturFormater(Formater):
             return
         try:
             value = int(value)
-            assert value > 0 and value < (datetime.date.today().year)
+            assert value > 0 and value < datetime.date.today().year
         except (ValueError, AssertionError):
-            raise ValueError(_(u"\"%(value)s\" is not a valid date") % {
+            raise ValueError(_("\"%(value)s\" is not a valid date") % {
                 'value': value})
         return value
 
@@ -336,14 +336,16 @@ class IntegerFormater(Formater):
         try:
             return int(value)
         except ValueError:
-            raise ValueError(_(u"\"%(value)s\" is not an integer") % {
+            raise ValueError(_("\"%(value)s\" is not an integer") % {
                 'value': value})
 
 
 class StrChoiceFormater(Formater, ChoiceChecker):
-    def __init__(self, choices, strict=False, equiv_dict={}, model=None,
+    def __init__(self, choices, strict=False, equiv_dict=None, model=None,
                  cli=False, many_split='', db_target=None,
                  import_instance=None):
+        if not equiv_dict:
+            equiv_dict = {}
         self.choices = list(choices)
         self.strict = strict
         self.equiv_dict = copy.deepcopy(equiv_dict)
@@ -394,18 +396,18 @@ class StrChoiceFormater(Formater, ChoiceChecker):
         return str(value).strip()
 
     def _get_choices(self, comment=''):
-        msgstr = comment + u" - "
-        msgstr += str(_(u"Choice for \"%s\" is not available. "
-                            u"Which one is relevant?\n"))
+        msgstr = comment + " - "
+        msgstr += str(_("Choice for \"%s\" is not available. "
+                        "Which one is relevant?\n"))
         idx = -1
         for idx, choice in enumerate(self.choices):
-            msgstr += u"%d. %s\n" % (idx + 1, choice[1])
+            msgstr += "%d. %s\n" % (idx + 1, choice[1])
         idx += 2
         if self.create:
-            msgstr += str(_(u"%d. None of the above - create new")) % idx \
-                + u"\n"
+            msgstr += str(_("%d. None of the above - create new")) % idx \
+                + "\n"
             idx += 1
-        msgstr += str(_(u"%d. None of the above - skip")) % idx + u"\n"
+        msgstr += str(_("%d. None of the above - skip")) % idx + "\n"
         return msgstr, idx
 
     def check(self, values, output=None, comment='', choose_default=False,
@@ -528,8 +530,10 @@ class StrChoiceFormater(Formater, ChoiceChecker):
 
 
 class TypeFormater(StrChoiceFormater):
-    def __init__(self, model, cli=False, defaults={}, many_split=False,
+    def __init__(self, model, cli=False, defaults=None, many_split=False,
                  db_target=None, import_instance=None):
+        if not defaults:
+            defaults = {}
         self.create = True
         self.strict = False
         self.model = model
@@ -567,8 +571,10 @@ class TypeFormater(StrChoiceFormater):
 
 
 class DateFormater(Formater):
-    def __init__(self, date_formats=["%d/%m/%Y"], db_target=None,
+    def __init__(self, date_formats=None, db_target=None,
                  import_instance=None):
+        if not date_formats:
+            date_formats = ["%d/%m/%Y"]
         self.date_formats = date_formats
         if type(date_formats) not in (list, tuple):
             self.date_formats = [self.date_formats]
@@ -584,7 +590,7 @@ class DateFormater(Formater):
                 return datetime.datetime.strptime(value, date_format).date()
             except:
                 continue
-        raise ValueError(_(u"\"%(value)s\" is not a valid date") % {
+        raise ValueError(_("\"%(value)s\" is not a valid date") % {
             'value': value})
 
 
@@ -596,13 +602,13 @@ class FileFormater(Formater):
         if not value:
             return
         zp = zipfile.ZipFile(archive)
-        value = value.strip().replace(u'\\', u'/')
-        items = value.replace(u'/', u'_').split(u'.')
+        value = value.strip().replace('\\', '/')
+        items = value.replace('/', '_').split('.')
         base_dir = settings.MEDIA_ROOT + 'imported'
         if not os.path.isdir(base_dir):
             os.mkdir(base_dir)
         filename = base_dir + os.sep + \
-            u".".join(items[:-1]) + u'.' + items[-1]
+            ".".join(items[:-1]) + '.' + items[-1]
 
         try:
             with open(filename, 'wb') as f:
@@ -614,13 +620,15 @@ class FileFormater(Formater):
             my_file.size = os.stat(filename).st_size
             return my_file
         except KeyError:
-            raise ValueError(_(u"\"%(value)s\" is not a valid path for the "
-                               u"given archive") % {'value': value})
+            raise ValueError(_("\"%(value)s\" is not a valid path for the "
+                               "given archive") % {'value': value})
 
 
 class StrToBoolean(Formater, ChoiceChecker):
-    def __init__(self, choices={}, cli=False, strict=False, db_target=None,
+    def __init__(self, choices=None, cli=False, strict=False, db_target=None,
                  import_instance=None):
+        if not choices:
+            choices = {}
         self.dct = copy.copy(choices)
         self.cli = cli
         self.strict = strict
@@ -652,13 +660,13 @@ class StrToBoolean(Formater, ChoiceChecker):
               import_instance=None, user=None):
         if (not output or output == 'silent') and not choose_default:
             return
-        msgstr = comment + u" - "
+        msgstr = comment + " - "
         msgstr += str(_(
             "Choice for \"%s\" is not available. "
             "Which one is relevant?\n"))
-        msgstr += u"1. True\n"
-        msgstr += u"2. False\n"
-        msgstr += u"3. Empty\n"
+        msgstr += "1. True\n"
+        msgstr += "2. False\n"
+        msgstr += "3. Empty\n"
         for value in values:
             value = self.prepare(value)
             if value in self.dct:
@@ -730,21 +738,21 @@ class Importer(object):
     DEFAULTS = {}
     ERRORS = {
         'header_check': _(
-            u"The given file is not correct. Check the file "
-            u"format. If you use a CSV file: check that column separator "
-            u"and encoding are similar to the ones used by the reference "
-            u"file."),
-        'too_many_cols': _(u"Too many cols (%(user_col)d) when "
-                           u"maximum is %(ref_col)d"),
-        'no_data': _(u"No data provided"),
-        'value_required': _(u"Value is required"),
-        'not_enough_cols': _(u"At least %d columns must be filled"),
-        'regex_not_match': _(u"The regexp doesn't match."),
+            "The given file is not correct. Check the file "
+            "format. If you use a CSV file: check that column separator "
+            "and encoding are similar to the ones used by the reference "
+            "file."),
+        'too_many_cols': _("Too many cols (%(user_col)d) when "
+                           "maximum is %(ref_col)d"),
+        'no_data': _("No data provided"),
+        'value_required': _("Value is required"),
+        'not_enough_cols': _("At least %d columns must be filled"),
+        'regex_not_match': _("The regexp doesn't match."),
         'improperly_configured': _(
-            u"Forced creation is set for model {} but this model is not in the "
-            u"list of models allowed to be created."),
-        'does_not_exist_in_db': _(u"{} with values {} doesn't exist in the "
-          u"database. Create it first or fix your source file."),
+            "Forced creation is set for model {} but this model is not in the "
+            "list of models allowed to be created."),
+        'does_not_exist_in_db': _("{} with values {} doesn't exist in the "
+          "database. Create it first or fix your source file."),
     }
 
     def _create_models(self, force=False):
@@ -805,8 +813,8 @@ class Importer(object):
             formaters = line.formater
             if type(formaters) not in (list, tuple):
                 formaters = [formaters]
-            for idx, target in enumerate(targets):
-                formater = formaters[idx]
+            for idx_target, target in enumerate(targets):
+                formater = formaters[idx_target]
                 formater_name = formater.__class__.__name__
                 if formater_name not in models.IMPORTER_TYPES_DCT:
                     formater_name = 'UnknowType'
@@ -852,8 +860,8 @@ class Importer(object):
         q = ImporterModel.objects.filter(klass=cls_name)
         if q.count():
             cls_name = q.all()[0].name
-        values = u", ".join(
-            [u"{}: {}".format(k, data[k]) for k in data]
+        values = ", ".join(
+            ["{}: {}".format(k, data[k]) for k in data]
         )
         raise ImporterError(
             str(self.ERRORS['does_not_exist_in_db']).format(cls_name, values))
@@ -1099,9 +1107,9 @@ class Importer(object):
                     time_by_item = ellapsed / idx_line
                     if time_by_item:
                         left = ((total - idx_line) * time_by_item).seconds
-                txt = u"\r* %d/%d" % (idx_line + 1, total)
+                txt = "\r* %d/%d" % (idx_line + 1, total)
                 if left:
-                    txt += u" (%d seconds left)" % left
+                    txt += " (%d seconds left)" % left
                 sys.stdout.write(txt.encode('utf-8'))
                 sys.stdout.flush()
             try:
@@ -1284,7 +1292,7 @@ class Importer(object):
             val_group = []
             for g in formater.regexp.findall(val):
                 if isinstance(g, (tuple, list)):
-                    g = u"".join(g)
+                    g = "".join(g)
                 val_group.append(
                     g.replace(NEW_LINE_BREAK, '\n') if g else ''
                 )
@@ -1404,9 +1412,9 @@ class Importer(object):
             if formater.through:
                 self._throughs.append((formater, value))
             else:
-                for idx, field_name in enumerate(field_names):
+                for idx, f_name in enumerate(field_names):
                     self._field_name_to_data_dict(
-                        field_name, value, data, formater.force_value,
+                        f_name, value, data, formater.force_value,
                         force_new=force_news[idx], concat=concats[idx],
                         concat_str=concat_str[idx])
         c_row.append(" ; ".join([v for v in c_values]))
@@ -1500,8 +1508,8 @@ class Importer(object):
                                    new_created)
                 if '__force_new' in v:
                     created = v.pop('__force_new')
-                    key = u";".join([u"{}-{}".format(k, v[k])
-                                     for k in sorted(v.keys())])
+                    key = ";".join(["{}-{}".format(k, v[k])
+                                    for k in sorted(v.keys())])
                     # only one forced creation
                     if attribute in new_created \
                             and key in new_created[attribute]:
@@ -1536,7 +1544,7 @@ class Importer(object):
                             extra_fields[k] = v.pop(k)
                     created = False
                     if not self.MODEL_CREATION_LIMIT or \
-                                    model in self.MODEL_CREATION_LIMIT:
+                            model in self.MODEL_CREATION_LIMIT:
                         try:
                             v, created = model.objects.get_or_create(
                                 **v)
@@ -1734,7 +1742,7 @@ class Importer(object):
             # filter unnecessary default values but not the json field
             if isinstance(create_dict[k], dict) and k != 'data':
                 if self.simulate:
-                    create_dict[k] = _(u"* created *")
+                    create_dict[k] = _("* created *")
                 else:
                     create_dict.pop(k)
             # File doesn't like deepcopy
@@ -1805,7 +1813,7 @@ class Importer(object):
                                 self.not_find_objects.append(
                                     (path, cls, dct)
                                 )
-                                return _(u"* match not find *"), False
+                                return _("* match not find *"), False
                             dct.update(defaults)
                             self.new_objects.append([path, cls, dct])
                             created = True
@@ -1814,10 +1822,10 @@ class Importer(object):
                                 (path, list(q.all()), dct)
                             )
                             if q.count() > 10:
-                                return _(u"* the query match more than 10 "
-                                         u"results*"), False
+                                return _("* the query match more than 10 "
+                                         "results*"), False
                             else:
-                                return str(_(u" or ")).join(
+                                return str(_(" or ")).join(
                                     [str(item) for item in q.all()]
                                 ), False
                         else:
@@ -1853,7 +1861,7 @@ class Importer(object):
                                 elif k in self.concats \
                                         and type(val) == str \
                                         and type(new_val) == str:
-                                    updated_dct[k] = val + u"\n" + new_val
+                                    updated_dct[k] = val + "\n" + new_val
                         else:
                             for k in dct['defaults']:
                                 new_val = dct['defaults'][k]
@@ -1961,17 +1969,17 @@ class Importer(object):
             except UnicodeDecodeError:
                 data = ''
             raise ImporterError(
-                u"Erreur d'import %s %s, contexte : %s, erreur : %s"
+                "Erreur d'import %s %s, contexte : %s, erreur : %s"
                 % (str(cls), str("__".join(path)),
                    str(data), message))
         return obj, created
 
-    def _format_csv_line(self, values, empty=u"-"):
-        return u'"' + u'","'.join(
+    def _format_csv_line(self, values, empty="-"):
+        return '"' + '","'.join(
             [(v and str(v).replace('"', '""')) or empty
-             for v in values]) + u'"'
+             for v in values]) + '"'
 
-    def _get_csv(self, rows, header=None, empty=u"-"):
+    def _get_csv(self, rows, header=None, empty="-"):
         if not rows:
             return ""
         if not header:
@@ -1981,7 +1989,7 @@ class Importer(object):
             csv_v.append(self._format_csv_line(header, empty=empty))
         for values in rows:
             csv_v.append(self._format_csv_line(values, empty=empty))
-        return u"\n".join(csv_v)
+        return "\n".join(csv_v)
 
     def get_csv_errors(self):
         return self._get_csv(
@@ -2007,10 +2015,10 @@ class Importer(object):
                 return
             if value not in choices_dct.values():
                 raise ValueError(
-                    _(u"\"%(value)s\" not in %(values)s") % {
+                    _("\"%(value)s\" not in %(values)s") % {
                         'value': value,
-                        'values': u", ".join([val
-                                              for val in choices_dct.values()])
+                        'values': ", ".join(
+                            [val for val in choices_dct.values()])
                     })
             return value
         return function