Uploads data to the Blazegraph Triplestore that is stored in files
            that are in a local directory

            kwargs:
                method['local', 'data_stream']: 'local' uses the container dir
                        'data_stream': reads the file and sends it as part of
                        http request
                file_directory: a string path to the file directory to start
                        the search
                container_dir: the path that the triplestore container sees
                root_dir: root directory to be removed from the file paths
                        for example:
                              file_directory: this is as seen from python app
                                  /example/python/data/dir/to/search
                              container_dir: this is the path as seen from the
                                  triplestore
                                  /data
                              root_dir: the portion of the path to remove so
                                  both directories match
                                  /example/python/data
                file_extensions: a list of file extensions to filter
                        example ['xml', 'rdf']. If none include all files
                include_subfolders: as implied
                namespace: the Blazegraph namespace to load the data
                graph: uri of the graph to load the data. Default is None
                create_namespace: False(default) or True will create the
                        namespace if it does not exist
                use_threading(bool): Whether to use threading or not

def load_directory(self, method='data_stream', **kwargs):
        """ Uploads data to the Blazegraph Triplestore that is stored in files
            that are in a local directory

            kwargs:
                method['local', 'data_stream']: 'local' uses the container dir
                        'data_stream': reads the file and sends it as part of
                        http request
                file_directory: a string path to the file directory to start
                        the search
                container_dir: the path that the triplestore container sees
                root_dir: root directory to be removed from the file paths
                        for example:
                              file_directory: this is as seen from python app
                                  /example/python/data/dir/to/search
                              container_dir: this is the path as seen from the
                                  triplestore
                                  /data
                              root_dir: the portion of the path to remove so
                                  both directories match
                                  /example/python/data
                file_extensions: a list of file extensions to filter
                        example ['xml', 'rdf']. If none include all files
                include_subfolders: as implied
                namespace: the Blazegraph namespace to load the data
                graph: uri of the graph to load the data. Default is None
                create_namespace: False(default) or True will create the
                        namespace if it does not exist
                use_threading(bool): Whether to use threading or not
        """

        if kwargs.get('reset') == True:
            self.reset_namespace()
        namespace = kwargs.get('namespace', self.namespace)
        container_dir = kwargs.get('container_dir', self.container_dir)
        graph = kwargs.get('graph')
        time_start = datetime.datetime.now()
        include_root = kwargs.get('include_root', False)
        if method == 'data_stream':
            include_root = True
        file_directory = kwargs.get('file_directory', self.local_directory)
        file_extensions = kwargs.get('file_extensions', self.rdf_formats)
        file_list = list_files(file_directory,
                               file_extensions,
                               kwargs.get('include_subfolders', True),
                               include_root=include_root,
                               root_dir=kwargs.get('root_dir',
                                                   self.local_directory))
        log.info(" starting load of '%s' files into namespace '%s'",
                 len(file_list),
                 self.namespace)
        if kwargs.get('create_namespace') and namespace:
            if not self.has_namespace(namespace):
                self.create_namespace(namespace)
        if not self.has_namespace(namespace):
            msg = "".join(["Namespace '%s' does not exist. " % namespace,
                           "Pass kwarg 'create_namespace=True' to ",
                           "auto-create the namespace."])
            raise ValueError(msg)
        params = {}
        for file in file_list:
            if kwargs.get('use_threading') == True:
                if method == 'data_stream':
                    th = threading.Thread(name=file[1],
                                          target=self.load_data,
                                          args=(file[1],
                                                None,
                                                namespace,
                                                graph,
                                                True,))
                else:
                    th = threading.Thread(name=file[1],
                                          target=self.load_local_file,
                                          args=(file[1],
                                                namespace,
                                                graph,))
                th.start()
            else:
              if method == 'data_stream':
                  self.load_data(data=file[1],
                                 namespace=namespace,
                                 graph=graph,
                                 is_file=True)
              else:
                  self.load_local_file(file[1], namespace, graph)
        if kwargs.get('use_threading') == True:
            main_thread = threading.main_thread()
            for t in threading.enumerate():
                if t is main_thread:
                    continue
                t.join()
        log.info("%s file(s) loaded in: %s",
                 len(file_list),
                 datetime.datetime.now() - time_start)