Django plug-in Enhancement (#105)

* 💄 remove double underscores on private variables. it sucks when debugging

* 📚 update change log

* This is an auto-commit, updating project meta data, such as changelog.rst, contributors.rst

Co-authored-by: chfw <chfw@users.noreply.github.com>

CHANGELOG.rst

@@ -1,7 +1,7 @@
 Change log
 ================================================================================
 
-0.6.4 - tbd
+0.6.4 - 31.10.2020
 --------------------------------------------------------------------------------
 
 **updated**

changelog.yml

@@ -6,7 +6,7 @@ releases:
     details:
     - "`#102`: skip columns from imported excel sheet."
   version: 0.6.4
-  date: tbd
+  date: 31.10.2020
 - changes:
   - action: fixed
     details:

docs/source/conf.py

@@ -26,7 +26,7 @@
 copyright = '2015-2020 Onni Software Ltd.'
 author = 'C.W.'
 # The short X.Y version
-version = '0.6.3'
+version = '0.6.4'
 # The full version, including alpha/beta/rc tags
 release = '0.6.4'
 

docs/source/index.rst

@@ -10,7 +10,6 @@
 :Source code: http://github.com/pyexcel/pyexcel-io.git
 :Issues: http://github.com/pyexcel/pyexcel-io/issues
 :License: New BSD License
-:Development: |release|
 :Released: |version|
 :Generated: |today|
 

pyexcel-io.yml

@@ -2,7 +2,7 @@ overrides: "pyexcel.yaml"
 project: "pyexcel-io"
 name: pyexcel-io
 nick_name: io
-version: 0.6.3
+version: 0.6.4
 current_version: 0.6.4
 release: 0.6.4
 copyright_year: 2015-2020

pyexcel_io/database/common.py

@@ -38,65 +38,66 @@ def __init__(self):
 
     def __init__(self, model):
         DjangoModelExportAdapter.__init__(self, model)
-        self.__column_names = self.InOutParameter()
-        self.__column_name_mapping_dict = self.InOutParameter()
-        self.__row_initializer = self.InOutParameter()
+        self._column_names = self.InOutParameter()
+        self._column_name_mapping_dict = self.InOutParameter()
+        self._row_initializer = self.InOutParameter()
         self._process_parameters()
 
     @property
     def row_initializer(self):
         """ contructor for a database table entry """
-        return self.__row_initializer.output
+        return self._row_initializer.output
 
     @property
     def column_names(self):
         """ the desginated database column names """
-        return self.__column_names.output
+        return self._column_names.output
 
     @property
     def column_name_mapping_dict(self):
         """ if not the same, a mapping dictionary is looked up"""
-        return self.__column_name_mapping_dict.output
+        return self._column_name_mapping_dict.output
 
     @row_initializer.setter
     def row_initializer(self, a_function):
         """ set the contructor """
-        self.__row_initializer.input = a_function
+        self._row_initializer.input = a_function
         self._process_parameters()
 
     @column_names.setter
     def column_names(self, column_names):
         """ set the column names """
-        self.__column_names.input = column_names
+        self._column_names.input = column_names
         self._process_parameters()
 
     @column_name_mapping_dict.setter
     def column_name_mapping_dict(self, mapping_dict):
         """ set the mapping dict """
-        self.__column_name_mapping_dict.input = mapping_dict
+        self._column_name_mapping_dict.input = mapping_dict
         self._process_parameters()
 
     def _process_parameters(self):
-        if self.__row_initializer.input is None:
-            self.__row_initializer.output = None
+        if self._row_initializer.input is None:
+            self._row_initializer.output = None
         else:
-            self.__row_initializer.output = self.__row_initializer.input
-        if isinstance(self.__column_name_mapping_dict.input, list):
-            self.__column_names.output = self.__column_name_mapping_dict.input
-            self.__column_name_mapping_dict.output = None
-        elif isinstance(self.__column_name_mapping_dict.input, dict):
-            if self.__column_names.input:
-                self.__column_names.output = []
+            self._row_initializer.output = self._row_initializer.input
+        if isinstance(self._column_name_mapping_dict.input, list):
+            self._column_names.output = self._column_name_mapping_dict.input
+            self._column_name_mapping_dict.output = None
+        elif isinstance(self._column_name_mapping_dict.input, dict):
+
+            if self._column_names.input:
+                self._column_names.output = []
                 indices = []
-                for index, name in enumerate(self.__column_names.input):
-                    if name in self.__column_name_mapping_dict.input:
-                        self.__column_names.output.append(
-                            self.__column_name_mapping_dict.input[name]
+                for index, name in enumerate(self._column_names.input):
+                    if name in self._column_name_mapping_dict.input:
+                        self._column_names.output.append(
+                            self._column_name_mapping_dict.input[name]
                         )
                         indices.append(index)
-                self.__column_name_mapping_dict.output = indices
-        if self.__column_names.output is None:
-            self.__column_names.output = self.__column_names.input
+                self._column_name_mapping_dict.output = indices
+        if self._column_names.output is None:
+            self._column_names.output = self._column_names.input
 
 
 class DjangoModelExporter(object):
@@ -114,15 +115,15 @@ class DjangoModelImporter(object):
     """ public interface for django model import """
 
     def __init__(self):
-        self.__adapters = {}
+        self._adapters = {}
 
     def append(self, import_adapter):
         """ store model parameter for more than one model """
-        self.__adapters[import_adapter.get_name()] = import_adapter
+        self._adapters[import_adapter.get_name()] = import_adapter
 
     def get(self, name):
         """ get a parameter out """
-        return self.__adapters.get(name, None)
+        return self._adapters.get(name, None)
 
 
 class SQLTableExportAdapter(DjangoModelExportAdapter):

pyexcel_io/database/importers/django.py

@@ -20,32 +20,33 @@ class DjangoModelWriter(ISheetWriter):
     """ import data into a django model """
 
     def __init__(self, importer, adapter, batch_size=None, bulk_save=True):
-        self.__batch_size = batch_size
-        self.__model = adapter.model
-        self.__column_names = adapter.column_names
-        self.__mapdict = adapter.column_name_mapping_dict
-        self.__initializer = adapter.row_initializer
-        self.__objs = []
-        self.__bulk_save = bulk_save
+        self.batch_size = batch_size
+        self.model = adapter.model
+        self.column_names = adapter.column_names
+        self.mapdict = adapter.column_name_mapping_dict
+        self.initializer = adapter.row_initializer
+        self.objs = []
+        self.bulk_save = bulk_save
+        self.adapter = adapter
 
     def write_row(self, array):
         if is_empty_array(array):
             print(constants.MESSAGE_EMPTY_ARRAY)
         else:
             new_array = swap_empty_string_for_none(array)
-            if self.__mapdict:
+            if self.mapdict:
                 another_new_array = []
                 for index, element in enumerate(new_array):
-                    if index in self.__mapdict:
+                    if index in self.mapdict:
                         another_new_array.append(element)
                 new_array = another_new_array
             model_to_be_created = new_array
-            if self.__initializer is not None:
-                model_to_be_created = self.__initializer(new_array)
+            if self.initializer is not None:
+                model_to_be_created = self.initializer(new_array)
             if model_to_be_created:
-                row = dict(zip(self.__column_names, model_to_be_created))
-                self.__objs.append(
-                    self.__model(
+                row = dict(zip(self.column_names, model_to_be_created))
+                self.objs.append(
+                    self.model(
                         **row
                     )
                 )
@@ -54,28 +55,28 @@ def write_row(self, array):
     # skip the row
 
     def close(self):
-        if self.__bulk_save:
-            self.__model.objects.bulk_create(
-                self.__objs, batch_size=self.__batch_size
+        if self.bulk_save:
+            self.model.objects.bulk_create(
+                self.objs, batch_size=self.batch_size
             )
         else:
-            for an_object in self.__objs:
+            for an_object in self.objs:
                 an_object.save()
 
 
 class DjangoBookWriter(IWriter):
     """ write data into django models """
 
     def __init__(self, exporter, _, **keywords):
-        self.__importer = exporter
+        self.importer = exporter
         self._keywords = keywords
 
     def create_sheet(self, sheet_name):
         sheet_writer = None
-        model = self.__importer.get(sheet_name)
+        model = self.importer.get(sheet_name)
         if model:
             sheet_writer = DjangoModelWriter(
-                self.__importer,
+                self.importer,
                 model,
                 batch_size=self._keywords.get("batch_size", None),
                 bulk_save=self._keywords.get("bulk_save", True),