community: Allow other than default parsers in SharePointLoader and OneDriveLoader (#27716)

## What this PR does?

### Currently `O365BaseLoader` (and consequently both derived loaders)
are limited to `pdf`, `doc`, `docx` files.
- **Solution: here we introduce _handlers_ attribute that allows for
custom handlers to be passed in. This is done in _dict_ form:**

**Example:**
```python
from langchain_community.document_loaders.parsers.documentloader_adapter import DocumentLoaderAsParser
# PR for DocumentLoaderAsParser here: https://github.com/langchain-ai/langchain/pull/27749
from langchain_community.document_loaders.excel import UnstructuredExcelLoader

xlsx_parser = DocumentLoaderAsParser(UnstructuredExcelLoader, mode="paged")

# create dictionary mapping file types to handlers (parsers)
handlers = {
    "doc": MsWordParser()
    "pdf": PDFMinerParser()
    "txt": TextParser()
    "xlsx": xlsx_parser
}
loader = SharePointLoader(document_library_id="...",
                            handlers=handlers # pass handlers to SharePointLoader
                            )
documents = loader.load()

# works the same in OneDriveLoader
loader = OneDriveLoader(document_library_id="...",
                            handlers=handlers
                            )
```
This dictionary is then passed to `MimeTypeBasedParser` same as in the
[current
implementation](5a2cfb49e0/libs/community/langchain_community/document_loaders/parsers/registry.py (L13)).


### Currently `SharePointLoader` and `OneDriveLoader` are separate
loaders that both inherit from `O365BaseLoader`
However both of these implement the same functionality. The only
differences are:
- `SharePointLoader` requires argument `document_library_id` whereas
`OneDriveLoader` requires `drive_id`. These are just different names for
the same thing.
  - `SharePointLoader` implements significantly more features.
- **Solution: `OneDriveLoader` is replaced with an empty shell just
renaming `drive_id` to `document_library_id` and inheriting from
`SharePointLoader`**

**Dependencies:** None
**Twitter handle:** @martintriska1

If no one reviews your PR within a few days, please @-mention one of
baskaryan, efriis, eyurtsev, ccurme, vbarda, hwchase17.

libs/community/langchain_community/document_loaders/onedrive.py

@@ -1,94 +1,19 @@
-"""Loads data from OneDrive"""
+from typing import Any
 
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Iterator, List, Optional, Sequence, Union
-
-from langchain_core.documents import Document
 from pydantic import Field
 
-from langchain_community.document_loaders.base_o365 import (
-    O365BaseLoader,
-    _FileType,
-)
-from langchain_community.document_loaders.parsers.registry import get_parser
-
-if TYPE_CHECKING:
-    from O365.drive import Drive, Folder
-
-logger = logging.getLogger(__name__)
+from langchain_community.document_loaders import SharePointLoader
 
 
-class OneDriveLoader(O365BaseLoader):
-    """Load from `Microsoft OneDrive`."""
+class OneDriveLoader(SharePointLoader):
+    """
+    Load documents from Microsoft OneDrive.
+    Uses `SharePointLoader` under the hood.
+    """
 
     drive_id: str = Field(...)
-    """ The ID of the OneDrive drive to load data from."""
-    folder_path: Optional[str] = None
-    """ The path to the folder to load data from."""
-    object_ids: Optional[List[str]] = None
-    """ The IDs of the objects to load data from."""
+    """The ID of the OneDrive drive to load data from."""
 
-    @property
-    def _file_types(self) -> Sequence[_FileType]:
-        """Return supported file types."""
-        return _FileType.DOC, _FileType.DOCX, _FileType.PDF
-
-    @property
-    def _scopes(self) -> List[str]:
-        """Return required scopes."""
-        return ["offline_access", "Files.Read.All"]
-
-    def _get_folder_from_path(self, drive: Drive) -> Union[Folder, Drive]:
-        """
-        Returns the folder or drive object located at the
-        specified path relative to the given drive.
-
-        Args:
-            drive (Drive): The root drive from which the folder path is relative.
-
-        Returns:
-            Union[Folder, Drive]: The folder or drive object
-            located at the specified path.
-
-        Raises:
-            FileNotFoundError: If the path does not exist.
-        """
-
-        subfolder_drive = drive
-        if self.folder_path is None:
-            return subfolder_drive
-
-        subfolders = [f for f in self.folder_path.split("/") if f != ""]
-        if len(subfolders) == 0:
-            return subfolder_drive
-
-        items = subfolder_drive.get_items()
-        for subfolder in subfolders:
-            try:
-                subfolder_drive = list(filter(lambda x: subfolder in x.name, items))[0]
-                items = subfolder_drive.get_items()
-            except (IndexError, AttributeError):
-                raise FileNotFoundError("Path {} not exist.".format(self.folder_path))
-        return subfolder_drive
-
-    def lazy_load(self) -> Iterator[Document]:
-        """Load documents lazily. Use this when working at a large scale."""
-        try:
-            from O365.drive import Drive
-        except ImportError:
-            raise ImportError(
-                "O365 package not found, please install it with `pip install o365`"
-            )
-        drive = self._auth().storage().get_drive(self.drive_id)
-        if not isinstance(drive, Drive):
-            raise ValueError(f"There isn't a Drive with id {self.drive_id}.")
-        blob_parser = get_parser("default")
-        if self.folder_path:
-            folder = self._get_folder_from_path(drive)
-            for blob in self._load_from_folder(folder):
-                yield from blob_parser.lazy_parse(blob)
-        if self.object_ids:
-            for blob in self._load_from_object_ids(drive, self.object_ids):
-                yield from blob_parser.lazy_parse(blob)
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs["document_library_id"] = kwargs["drive_id"]
+        super().__init__(**kwargs)