Add files using upload-large-folder tool

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/__init__.py

@@ -0,0 +1,943 @@
+"""**Document Loaders**  are classes to load Documents.
+
+**Document Loaders** are usually used to load a lot of Documents in a single run.
+
+**Class hierarchy:**
+
+.. code-block::
+
+    BaseLoader --> <name>Loader  # Examples: TextLoader, UnstructuredFileLoader
+
+**Main helpers:**
+
+.. code-block::
+
+    Document, <name>TextSplitter
+"""
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.document_loaders.acreom import (
+        AcreomLoader,
+    )
+    from langchain_community.document_loaders.airbyte import (
+        AirbyteCDKLoader,
+        AirbyteGongLoader,
+        AirbyteHubspotLoader,
+        AirbyteSalesforceLoader,
+        AirbyteShopifyLoader,
+        AirbyteStripeLoader,
+        AirbyteTypeformLoader,
+        AirbyteZendeskSupportLoader,
+    )
+    from langchain_community.document_loaders.airbyte_json import (
+        AirbyteJSONLoader,
+    )
+    from langchain_community.document_loaders.airtable import (
+        AirtableLoader,
+    )
+    from langchain_community.document_loaders.apify_dataset import (
+        ApifyDatasetLoader,
+    )
+    from langchain_community.document_loaders.arcgis_loader import (
+        ArcGISLoader,
+    )
+    from langchain_community.document_loaders.arxiv import (
+        ArxivLoader,
+    )
+    from langchain_community.document_loaders.assemblyai import (
+        AssemblyAIAudioLoaderById,
+        AssemblyAIAudioTranscriptLoader,
+    )
+    from langchain_community.document_loaders.astradb import (
+        AstraDBLoader,
+    )
+    from langchain_community.document_loaders.async_html import (
+        AsyncHtmlLoader,
+    )
+    from langchain_community.document_loaders.athena import (
+        AthenaLoader,
+    )
+    from langchain_community.document_loaders.azlyrics import (
+        AZLyricsLoader,
+    )
+    from langchain_community.document_loaders.azure_ai_data import (
+        AzureAIDataLoader,
+    )
+    from langchain_community.document_loaders.azure_blob_storage_container import (
+        AzureBlobStorageContainerLoader,
+    )
+    from langchain_community.document_loaders.azure_blob_storage_file import (
+        AzureBlobStorageFileLoader,
+    )
+    from langchain_community.document_loaders.bibtex import (
+        BibtexLoader,
+    )
+    from langchain_community.document_loaders.bigquery import (
+        BigQueryLoader,
+    )
+    from langchain_community.document_loaders.bilibili import (
+        BiliBiliLoader,
+    )
+    from langchain_community.document_loaders.blackboard import (
+        BlackboardLoader,
+    )
+    from langchain_community.document_loaders.blob_loaders import (
+        Blob,
+        BlobLoader,
+        CloudBlobLoader,
+        FileSystemBlobLoader,
+        YoutubeAudioLoader,
+    )
+    from langchain_community.document_loaders.blockchain import (
+        BlockchainDocumentLoader,
+    )
+    from langchain_community.document_loaders.brave_search import (
+        BraveSearchLoader,
+    )
+    from langchain_community.document_loaders.browserbase import (
+        BrowserbaseLoader,
+    )
+    from langchain_community.document_loaders.browserless import (
+        BrowserlessLoader,
+    )
+    from langchain_community.document_loaders.cassandra import (
+        CassandraLoader,
+    )
+    from langchain_community.document_loaders.chatgpt import (
+        ChatGPTLoader,
+    )
+    from langchain_community.document_loaders.chm import (
+        UnstructuredCHMLoader,
+    )
+    from langchain_community.document_loaders.chromium import (
+        AsyncChromiumLoader,
+    )
+    from langchain_community.document_loaders.college_confidential import (
+        CollegeConfidentialLoader,
+    )
+    from langchain_community.document_loaders.concurrent import (
+        ConcurrentLoader,
+    )
+    from langchain_community.document_loaders.confluence import (
+        ConfluenceLoader,
+    )
+    from langchain_community.document_loaders.conllu import (
+        CoNLLULoader,
+    )
+    from langchain_community.document_loaders.couchbase import (
+        CouchbaseLoader,
+    )
+    from langchain_community.document_loaders.csv_loader import (
+        CSVLoader,
+        UnstructuredCSVLoader,
+    )
+    from langchain_community.document_loaders.cube_semantic import (
+        CubeSemanticLoader,
+    )
+    from langchain_community.document_loaders.datadog_logs import (
+        DatadogLogsLoader,
+    )
+    from langchain_community.document_loaders.dataframe import (
+        DataFrameLoader,
+    )
+    from langchain_community.document_loaders.dedoc import (
+        DedocAPIFileLoader,
+        DedocFileLoader,
+    )
+    from langchain_community.document_loaders.diffbot import (
+        DiffbotLoader,
+    )
+    from langchain_community.document_loaders.directory import (
+        DirectoryLoader,
+    )
+    from langchain_community.document_loaders.discord import (
+        DiscordChatLoader,
+    )
+    from langchain_community.document_loaders.doc_intelligence import (
+        AzureAIDocumentIntelligenceLoader,
+    )
+    from langchain_community.document_loaders.docugami import (
+        DocugamiLoader,
+    )
+    from langchain_community.document_loaders.docusaurus import (
+        DocusaurusLoader,
+    )
+    from langchain_community.document_loaders.dropbox import (
+        DropboxLoader,
+    )
+    from langchain_community.document_loaders.duckdb_loader import (
+        DuckDBLoader,
+    )
+    from langchain_community.document_loaders.email import (
+        OutlookMessageLoader,
+        UnstructuredEmailLoader,
+    )
+    from langchain_community.document_loaders.epub import (
+        UnstructuredEPubLoader,
+    )
+    from langchain_community.document_loaders.etherscan import (
+        EtherscanLoader,
+    )
+    from langchain_community.document_loaders.evernote import (
+        EverNoteLoader,
+    )
+    from langchain_community.document_loaders.excel import (
+        UnstructuredExcelLoader,
+    )
+    from langchain_community.document_loaders.facebook_chat import (
+        FacebookChatLoader,
+    )
+    from langchain_community.document_loaders.fauna import (
+        FaunaLoader,
+    )
+    from langchain_community.document_loaders.figma import (
+        FigmaFileLoader,
+    )
+    from langchain_community.document_loaders.firecrawl import (
+        FireCrawlLoader,
+    )
+    from langchain_community.document_loaders.gcs_directory import (
+        GCSDirectoryLoader,
+    )
+    from langchain_community.document_loaders.gcs_file import (
+        GCSFileLoader,
+    )
+    from langchain_community.document_loaders.geodataframe import (
+        GeoDataFrameLoader,
+    )
+    from langchain_community.document_loaders.git import (
+        GitLoader,
+    )
+    from langchain_community.document_loaders.gitbook import (
+        GitbookLoader,
+    )
+    from langchain_community.document_loaders.github import (
+        GithubFileLoader,
+        GitHubIssuesLoader,
+    )
+    from langchain_community.document_loaders.glue_catalog import (
+        GlueCatalogLoader,
+    )
+    from langchain_community.document_loaders.google_speech_to_text import (
+        GoogleSpeechToTextLoader,
+    )
+    from langchain_community.document_loaders.googledrive import (
+        GoogleDriveLoader,
+    )
+    from langchain_community.document_loaders.gutenberg import (
+        GutenbergLoader,
+    )
+    from langchain_community.document_loaders.hn import (
+        HNLoader,
+    )
+    from langchain_community.document_loaders.html import (
+        UnstructuredHTMLLoader,
+    )
+    from langchain_community.document_loaders.html_bs import (
+        BSHTMLLoader,
+    )
+    from langchain_community.document_loaders.hugging_face_dataset import (
+        HuggingFaceDatasetLoader,
+    )
+    from langchain_community.document_loaders.hugging_face_model import (
+        HuggingFaceModelLoader,
+    )
+    from langchain_community.document_loaders.ifixit import (
+        IFixitLoader,
+    )
+    from langchain_community.document_loaders.image import (
+        UnstructuredImageLoader,
+    )
+    from langchain_community.document_loaders.image_captions import (
+        ImageCaptionLoader,
+    )
+    from langchain_community.document_loaders.imsdb import (
+        IMSDbLoader,
+    )
+    from langchain_community.document_loaders.iugu import (
+        IuguLoader,
+    )
+    from langchain_community.document_loaders.joplin import (
+        JoplinLoader,
+    )
+    from langchain_community.document_loaders.json_loader import (
+        JSONLoader,
+    )
+    from langchain_community.document_loaders.kinetica_loader import KineticaLoader
+    from langchain_community.document_loaders.lakefs import (
+        LakeFSLoader,
+    )
+    from langchain_community.document_loaders.larksuite import (
+        LarkSuiteDocLoader,
+    )
+    from langchain_community.document_loaders.llmsherpa import (
+        LLMSherpaFileLoader,
+    )
+    from langchain_community.document_loaders.markdown import (
+        UnstructuredMarkdownLoader,
+    )
+    from langchain_community.document_loaders.mastodon import (
+        MastodonTootsLoader,
+    )
+    from langchain_community.document_loaders.max_compute import (
+        MaxComputeLoader,
+    )
+    from langchain_community.document_loaders.mediawikidump import (
+        MWDumpLoader,
+    )
+    from langchain_community.document_loaders.merge import (
+        MergedDataLoader,
+    )
+    from langchain_community.document_loaders.mhtml import (
+        MHTMLLoader,
+    )
+    from langchain_community.document_loaders.modern_treasury import (
+        ModernTreasuryLoader,
+    )
+    from langchain_community.document_loaders.mongodb import (
+        MongodbLoader,
+    )
+    from langchain_community.document_loaders.needle import (
+        NeedleLoader,
+    )
+    from langchain_community.document_loaders.news import (
+        NewsURLLoader,
+    )
+    from langchain_community.document_loaders.notebook import (
+        NotebookLoader,
+    )
+    from langchain_community.document_loaders.notion import (
+        NotionDirectoryLoader,
+    )
+    from langchain_community.document_loaders.notiondb import (
+        NotionDBLoader,
+    )
+    from langchain_community.document_loaders.obs_directory import (
+        OBSDirectoryLoader,
+    )
+    from langchain_community.document_loaders.obs_file import (
+        OBSFileLoader,
+    )
+    from langchain_community.document_loaders.obsidian import (
+        ObsidianLoader,
+    )
+    from langchain_community.document_loaders.odt import (
+        UnstructuredODTLoader,
+    )
+    from langchain_community.document_loaders.onedrive import (
+        OneDriveLoader,
+    )
+    from langchain_community.document_loaders.onedrive_file import (
+        OneDriveFileLoader,
+    )
+    from langchain_community.document_loaders.open_city_data import (
+        OpenCityDataLoader,
+    )
+    from langchain_community.document_loaders.oracleadb_loader import (
+        OracleAutonomousDatabaseLoader,
+    )
+    from langchain_community.document_loaders.oracleai import (
+        OracleDocLoader,
+        OracleTextSplitter,
+    )
+    from langchain_community.document_loaders.org_mode import (
+        UnstructuredOrgModeLoader,
+    )
+    from langchain_community.document_loaders.pdf import (
+        AmazonTextractPDFLoader,
+        DedocPDFLoader,
+        MathpixPDFLoader,
+        OnlinePDFLoader,
+        PagedPDFSplitter,
+        PDFMinerLoader,
+        PDFMinerPDFasHTMLLoader,
+        PDFPlumberLoader,
+        PyMuPDFLoader,
+        PyPDFDirectoryLoader,
+        PyPDFium2Loader,
+        PyPDFLoader,
+        UnstructuredPDFLoader,
+    )
+    from langchain_community.document_loaders.pebblo import (
+        PebbloSafeLoader,
+        PebbloTextLoader,
+    )
+    from langchain_community.document_loaders.polars_dataframe import (
+        PolarsDataFrameLoader,
+    )
+    from langchain_community.document_loaders.powerpoint import (
+        UnstructuredPowerPointLoader,
+    )
+    from langchain_community.document_loaders.psychic import (
+        PsychicLoader,
+    )
+    from langchain_community.document_loaders.pubmed import (
+        PubMedLoader,
+    )
+    from langchain_community.document_loaders.pyspark_dataframe import (
+        PySparkDataFrameLoader,
+    )
+    from langchain_community.document_loaders.python import (
+        PythonLoader,
+    )
+    from langchain_community.document_loaders.readthedocs import (
+        ReadTheDocsLoader,
+    )
+    from langchain_community.document_loaders.recursive_url_loader import (
+        RecursiveUrlLoader,
+    )
+    from langchain_community.document_loaders.reddit import (
+        RedditPostsLoader,
+    )
+    from langchain_community.document_loaders.roam import (
+        RoamLoader,
+    )
+    from langchain_community.document_loaders.rocksetdb import (
+        RocksetLoader,
+    )
+    from langchain_community.document_loaders.rss import (
+        RSSFeedLoader,
+    )
+    from langchain_community.document_loaders.rst import (
+        UnstructuredRSTLoader,
+    )
+    from langchain_community.document_loaders.rtf import (
+        UnstructuredRTFLoader,
+    )
+    from langchain_community.document_loaders.s3_directory import (
+        S3DirectoryLoader,
+    )
+    from langchain_community.document_loaders.s3_file import (
+        S3FileLoader,
+    )
+    from langchain_community.document_loaders.scrapfly import (
+        ScrapflyLoader,
+    )
+    from langchain_community.document_loaders.scrapingant import (
+        ScrapingAntLoader,
+    )
+    from langchain_community.document_loaders.sharepoint import (
+        SharePointLoader,
+    )
+    from langchain_community.document_loaders.sitemap import (
+        SitemapLoader,
+    )
+    from langchain_community.document_loaders.slack_directory import (
+        SlackDirectoryLoader,
+    )
+    from langchain_community.document_loaders.snowflake_loader import (
+        SnowflakeLoader,
+    )
+    from langchain_community.document_loaders.spider import (
+        SpiderLoader,
+    )
+    from langchain_community.document_loaders.spreedly import (
+        SpreedlyLoader,
+    )
+    from langchain_community.document_loaders.sql_database import (
+        SQLDatabaseLoader,
+    )
+    from langchain_community.document_loaders.srt import (
+        SRTLoader,
+    )
+    from langchain_community.document_loaders.stripe import (
+        StripeLoader,
+    )
+    from langchain_community.document_loaders.surrealdb import (
+        SurrealDBLoader,
+    )
+    from langchain_community.document_loaders.telegram import (
+        TelegramChatApiLoader,
+        TelegramChatFileLoader,
+        TelegramChatLoader,
+    )
+    from langchain_community.document_loaders.tencent_cos_directory import (
+        TencentCOSDirectoryLoader,
+    )
+    from langchain_community.document_loaders.tencent_cos_file import (
+        TencentCOSFileLoader,
+    )
+    from langchain_community.document_loaders.tensorflow_datasets import (
+        TensorflowDatasetLoader,
+    )
+    from langchain_community.document_loaders.text import (
+        TextLoader,
+    )
+    from langchain_community.document_loaders.tidb import (
+        TiDBLoader,
+    )
+    from langchain_community.document_loaders.tomarkdown import (
+        ToMarkdownLoader,
+    )
+    from langchain_community.document_loaders.toml import (
+        TomlLoader,
+    )
+    from langchain_community.document_loaders.trello import (
+        TrelloLoader,
+    )
+    from langchain_community.document_loaders.tsv import (
+        UnstructuredTSVLoader,
+    )
+    from langchain_community.document_loaders.twitter import (
+        TwitterTweetLoader,
+    )
+    from langchain_community.document_loaders.unstructured import (
+        UnstructuredAPIFileIOLoader,
+        UnstructuredAPIFileLoader,
+        UnstructuredFileIOLoader,
+        UnstructuredFileLoader,
+    )
+    from langchain_community.document_loaders.url import (
+        UnstructuredURLLoader,
+    )
+    from langchain_community.document_loaders.url_playwright import (
+        PlaywrightURLLoader,
+    )
+    from langchain_community.document_loaders.url_selenium import (
+        SeleniumURLLoader,
+    )
+    from langchain_community.document_loaders.vsdx import (
+        VsdxLoader,
+    )
+    from langchain_community.document_loaders.weather import (
+        WeatherDataLoader,
+    )
+    from langchain_community.document_loaders.web_base import (
+        WebBaseLoader,
+    )
+    from langchain_community.document_loaders.whatsapp_chat import (
+        WhatsAppChatLoader,
+    )
+    from langchain_community.document_loaders.wikipedia import (
+        WikipediaLoader,
+    )
+    from langchain_community.document_loaders.word_document import (
+        Docx2txtLoader,
+        UnstructuredWordDocumentLoader,
+    )
+    from langchain_community.document_loaders.xml import (
+        UnstructuredXMLLoader,
+    )
+    from langchain_community.document_loaders.xorbits import (
+        XorbitsLoader,
+    )
+    from langchain_community.document_loaders.youtube import (
+        GoogleApiClient,
+        GoogleApiYoutubeLoader,
+        YoutubeLoader,
+    )
+    from langchain_community.document_loaders.yuque import (
+        YuqueLoader,
+    )
+
+
+_module_lookup = {
+    "AZLyricsLoader": "langchain_community.document_loaders.azlyrics",
+    "AcreomLoader": "langchain_community.document_loaders.acreom",
+    "AirbyteCDKLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteGongLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteHubspotLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteJSONLoader": "langchain_community.document_loaders.airbyte_json",
+    "AirbyteSalesforceLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteShopifyLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteStripeLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteTypeformLoader": "langchain_community.document_loaders.airbyte",
+    "AirbyteZendeskSupportLoader": "langchain_community.document_loaders.airbyte",
+    "AirtableLoader": "langchain_community.document_loaders.airtable",
+    "AmazonTextractPDFLoader": "langchain_community.document_loaders.pdf",
+    "ApifyDatasetLoader": "langchain_community.document_loaders.apify_dataset",
+    "ArcGISLoader": "langchain_community.document_loaders.arcgis_loader",
+    "ArxivLoader": "langchain_community.document_loaders.arxiv",
+    "AssemblyAIAudioLoaderById": "langchain_community.document_loaders.assemblyai",
+    "AssemblyAIAudioTranscriptLoader": "langchain_community.document_loaders.assemblyai",  # noqa: E501
+    "AstraDBLoader": "langchain_community.document_loaders.astradb",
+    "AsyncChromiumLoader": "langchain_community.document_loaders.chromium",
+    "AsyncHtmlLoader": "langchain_community.document_loaders.async_html",
+    "AthenaLoader": "langchain_community.document_loaders.athena",
+    "AzureAIDataLoader": "langchain_community.document_loaders.azure_ai_data",
+    "AzureAIDocumentIntelligenceLoader": "langchain_community.document_loaders.doc_intelligence",  # noqa: E501
+    "AzureBlobStorageContainerLoader": "langchain_community.document_loaders.azure_blob_storage_container",  # noqa: E501
+    "AzureBlobStorageFileLoader": "langchain_community.document_loaders.azure_blob_storage_file",  # noqa: E501
+    "BSHTMLLoader": "langchain_community.document_loaders.html_bs",
+    "BibtexLoader": "langchain_community.document_loaders.bibtex",
+    "BigQueryLoader": "langchain_community.document_loaders.bigquery",
+    "BiliBiliLoader": "langchain_community.document_loaders.bilibili",
+    "BlackboardLoader": "langchain_community.document_loaders.blackboard",
+    "Blob": "langchain_community.document_loaders.blob_loaders",
+    "BlobLoader": "langchain_community.document_loaders.blob_loaders",
+    "BlockchainDocumentLoader": "langchain_community.document_loaders.blockchain",
+    "BraveSearchLoader": "langchain_community.document_loaders.brave_search",
+    "BrowserbaseLoader": "langchain_community.document_loaders.browserbase",
+    "BrowserlessLoader": "langchain_community.document_loaders.browserless",
+    "CSVLoader": "langchain_community.document_loaders.csv_loader",
+    "CassandraLoader": "langchain_community.document_loaders.cassandra",
+    "ChatGPTLoader": "langchain_community.document_loaders.chatgpt",
+    "CloudBlobLoader": "langchain_community.document_loaders.blob_loaders",
+    "CoNLLULoader": "langchain_community.document_loaders.conllu",
+    "CollegeConfidentialLoader": "langchain_community.document_loaders.college_confidential",  # noqa: E501
+    "ConcurrentLoader": "langchain_community.document_loaders.concurrent",
+    "ConfluenceLoader": "langchain_community.document_loaders.confluence",
+    "CouchbaseLoader": "langchain_community.document_loaders.couchbase",
+    "CubeSemanticLoader": "langchain_community.document_loaders.cube_semantic",
+    "DataFrameLoader": "langchain_community.document_loaders.dataframe",
+    "DatadogLogsLoader": "langchain_community.document_loaders.datadog_logs",
+    "DedocAPIFileLoader": "langchain_community.document_loaders.dedoc",
+    "DedocFileLoader": "langchain_community.document_loaders.dedoc",
+    "DedocPDFLoader": "langchain_community.document_loaders.pdf",
+    "DiffbotLoader": "langchain_community.document_loaders.diffbot",
+    "DirectoryLoader": "langchain_community.document_loaders.directory",
+    "DiscordChatLoader": "langchain_community.document_loaders.discord",
+    "DocugamiLoader": "langchain_community.document_loaders.docugami",
+    "DocusaurusLoader": "langchain_community.document_loaders.docusaurus",
+    "Docx2txtLoader": "langchain_community.document_loaders.word_document",
+    "DropboxLoader": "langchain_community.document_loaders.dropbox",
+    "DuckDBLoader": "langchain_community.document_loaders.duckdb_loader",
+    "EtherscanLoader": "langchain_community.document_loaders.etherscan",
+    "EverNoteLoader": "langchain_community.document_loaders.evernote",
+    "FacebookChatLoader": "langchain_community.document_loaders.facebook_chat",
+    "FaunaLoader": "langchain_community.document_loaders.fauna",
+    "FigmaFileLoader": "langchain_community.document_loaders.figma",
+    "FireCrawlLoader": "langchain_community.document_loaders.firecrawl",
+    "FileSystemBlobLoader": "langchain_community.document_loaders.blob_loaders",
+    "GCSDirectoryLoader": "langchain_community.document_loaders.gcs_directory",
+    "GCSFileLoader": "langchain_community.document_loaders.gcs_file",
+    "GeoDataFrameLoader": "langchain_community.document_loaders.geodataframe",
+    "GitHubIssuesLoader": "langchain_community.document_loaders.github",
+    "GitLoader": "langchain_community.document_loaders.git",
+    "GitbookLoader": "langchain_community.document_loaders.gitbook",
+    "GithubFileLoader": "langchain_community.document_loaders.github",
+    "GlueCatalogLoader": "langchain_community.document_loaders.glue_catalog",
+    "GoogleApiClient": "langchain_community.document_loaders.youtube",
+    "GoogleApiYoutubeLoader": "langchain_community.document_loaders.youtube",
+    "GoogleDriveLoader": "langchain_community.document_loaders.googledrive",
+    "GoogleSpeechToTextLoader": "langchain_community.document_loaders.google_speech_to_text",  # noqa: E501
+    "GutenbergLoader": "langchain_community.document_loaders.gutenberg",
+    "HNLoader": "langchain_community.document_loaders.hn",
+    "HuggingFaceDatasetLoader": "langchain_community.document_loaders.hugging_face_dataset",  # noqa: E501
+    "HuggingFaceModelLoader": "langchain_community.document_loaders.hugging_face_model",
+    "IFixitLoader": "langchain_community.document_loaders.ifixit",
+    "IMSDbLoader": "langchain_community.document_loaders.imsdb",
+    "ImageCaptionLoader": "langchain_community.document_loaders.image_captions",
+    "IuguLoader": "langchain_community.document_loaders.iugu",
+    "JSONLoader": "langchain_community.document_loaders.json_loader",
+    "JoplinLoader": "langchain_community.document_loaders.joplin",
+    "KineticaLoader": "langchain_community.document_loaders.kinetica_loader",
+    "LakeFSLoader": "langchain_community.document_loaders.lakefs",
+    "LarkSuiteDocLoader": "langchain_community.document_loaders.larksuite",
+    "LLMSherpaFileLoader": "langchain_community.document_loaders.llmsherpa",
+    "MHTMLLoader": "langchain_community.document_loaders.mhtml",
+    "MWDumpLoader": "langchain_community.document_loaders.mediawikidump",
+    "MastodonTootsLoader": "langchain_community.document_loaders.mastodon",
+    "MathpixPDFLoader": "langchain_community.document_loaders.pdf",
+    "MaxComputeLoader": "langchain_community.document_loaders.max_compute",
+    "MergedDataLoader": "langchain_community.document_loaders.merge",
+    "ModernTreasuryLoader": "langchain_community.document_loaders.modern_treasury",
+    "MongodbLoader": "langchain_community.document_loaders.mongodb",
+    "NeedleLoader": "langchain_community.document_loaders.needle",
+    "NewsURLLoader": "langchain_community.document_loaders.news",
+    "NotebookLoader": "langchain_community.document_loaders.notebook",
+    "NotionDBLoader": "langchain_community.document_loaders.notiondb",
+    "NotionDirectoryLoader": "langchain_community.document_loaders.notion",
+    "OBSDirectoryLoader": "langchain_community.document_loaders.obs_directory",
+    "OBSFileLoader": "langchain_community.document_loaders.obs_file",
+    "ObsidianLoader": "langchain_community.document_loaders.obsidian",
+    "OneDriveFileLoader": "langchain_community.document_loaders.onedrive_file",
+    "OneDriveLoader": "langchain_community.document_loaders.onedrive",
+    "OnlinePDFLoader": "langchain_community.document_loaders.pdf",
+    "OpenCityDataLoader": "langchain_community.document_loaders.open_city_data",
+    "OracleAutonomousDatabaseLoader": "langchain_community.document_loaders.oracleadb_loader",  # noqa: E501
+    "OracleDocLoader": "langchain_community.document_loaders.oracleai",
+    "OracleTextSplitter": "langchain_community.document_loaders.oracleai",
+    "OutlookMessageLoader": "langchain_community.document_loaders.email",
+    "PDFMinerLoader": "langchain_community.document_loaders.pdf",
+    "PDFMinerPDFasHTMLLoader": "langchain_community.document_loaders.pdf",
+    "PDFPlumberLoader": "langchain_community.document_loaders.pdf",
+    "PagedPDFSplitter": "langchain_community.document_loaders.pdf",
+    "PebbloSafeLoader": "langchain_community.document_loaders.pebblo",
+    "PebbloTextLoader": "langchain_community.document_loaders.pebblo",
+    "PlaywrightURLLoader": "langchain_community.document_loaders.url_playwright",
+    "PolarsDataFrameLoader": "langchain_community.document_loaders.polars_dataframe",
+    "PsychicLoader": "langchain_community.document_loaders.psychic",
+    "PubMedLoader": "langchain_community.document_loaders.pubmed",
+    "PyMuPDFLoader": "langchain_community.document_loaders.pdf",
+    "PyPDFDirectoryLoader": "langchain_community.document_loaders.pdf",
+    "PyPDFLoader": "langchain_community.document_loaders.pdf",
+    "PyPDFium2Loader": "langchain_community.document_loaders.pdf",
+    "PySparkDataFrameLoader": "langchain_community.document_loaders.pyspark_dataframe",
+    "PythonLoader": "langchain_community.document_loaders.python",
+    "RSSFeedLoader": "langchain_community.document_loaders.rss",
+    "ReadTheDocsLoader": "langchain_community.document_loaders.readthedocs",
+    "RecursiveUrlLoader": "langchain_community.document_loaders.recursive_url_loader",
+    "RedditPostsLoader": "langchain_community.document_loaders.reddit",
+    "RoamLoader": "langchain_community.document_loaders.roam",
+    "RocksetLoader": "langchain_community.document_loaders.rocksetdb",
+    "S3DirectoryLoader": "langchain_community.document_loaders.s3_directory",
+    "S3FileLoader": "langchain_community.document_loaders.s3_file",
+    "ScrapflyLoader": "langchain_community.document_loaders.scrapfly",
+    "ScrapingAntLoader": "langchain_community.document_loaders.scrapingant",
+    "SQLDatabaseLoader": "langchain_community.document_loaders.sql_database",
+    "SRTLoader": "langchain_community.document_loaders.srt",
+    "SeleniumURLLoader": "langchain_community.document_loaders.url_selenium",
+    "SharePointLoader": "langchain_community.document_loaders.sharepoint",
+    "SitemapLoader": "langchain_community.document_loaders.sitemap",
+    "SlackDirectoryLoader": "langchain_community.document_loaders.slack_directory",
+    "SnowflakeLoader": "langchain_community.document_loaders.snowflake_loader",
+    "SpiderLoader": "langchain_community.document_loaders.spider",
+    "SpreedlyLoader": "langchain_community.document_loaders.spreedly",
+    "StripeLoader": "langchain_community.document_loaders.stripe",
+    "SurrealDBLoader": "langchain_community.document_loaders.surrealdb",
+    "TelegramChatApiLoader": "langchain_community.document_loaders.telegram",
+    "TelegramChatFileLoader": "langchain_community.document_loaders.telegram",
+    "TelegramChatLoader": "langchain_community.document_loaders.telegram",
+    "TencentCOSDirectoryLoader": "langchain_community.document_loaders.tencent_cos_directory",  # noqa: E501
+    "TencentCOSFileLoader": "langchain_community.document_loaders.tencent_cos_file",
+    "TensorflowDatasetLoader": "langchain_community.document_loaders.tensorflow_datasets",  # noqa: E501
+    "TextLoader": "langchain_community.document_loaders.text",
+    "TiDBLoader": "langchain_community.document_loaders.tidb",
+    "ToMarkdownLoader": "langchain_community.document_loaders.tomarkdown",
+    "TomlLoader": "langchain_community.document_loaders.toml",
+    "TrelloLoader": "langchain_community.document_loaders.trello",
+    "TwitterTweetLoader": "langchain_community.document_loaders.twitter",
+    "UnstructuredAPIFileIOLoader": "langchain_community.document_loaders.unstructured",
+    "UnstructuredAPIFileLoader": "langchain_community.document_loaders.unstructured",
+    "UnstructuredCHMLoader": "langchain_community.document_loaders.chm",
+    "UnstructuredCSVLoader": "langchain_community.document_loaders.csv_loader",
+    "UnstructuredEPubLoader": "langchain_community.document_loaders.epub",
+    "UnstructuredEmailLoader": "langchain_community.document_loaders.email",
+    "UnstructuredExcelLoader": "langchain_community.document_loaders.excel",
+    "UnstructuredFileIOLoader": "langchain_community.document_loaders.unstructured",
+    "UnstructuredFileLoader": "langchain_community.document_loaders.unstructured",
+    "UnstructuredHTMLLoader": "langchain_community.document_loaders.html",
+    "UnstructuredImageLoader": "langchain_community.document_loaders.image",
+    "UnstructuredMarkdownLoader": "langchain_community.document_loaders.markdown",
+    "UnstructuredODTLoader": "langchain_community.document_loaders.odt",
+    "UnstructuredOrgModeLoader": "langchain_community.document_loaders.org_mode",
+    "UnstructuredPDFLoader": "langchain_community.document_loaders.pdf",
+    "UnstructuredPowerPointLoader": "langchain_community.document_loaders.powerpoint",
+    "UnstructuredRSTLoader": "langchain_community.document_loaders.rst",
+    "UnstructuredRTFLoader": "langchain_community.document_loaders.rtf",
+    "UnstructuredTSVLoader": "langchain_community.document_loaders.tsv",
+    "UnstructuredURLLoader": "langchain_community.document_loaders.url",
+    "UnstructuredWordDocumentLoader": "langchain_community.document_loaders.word_document",  # noqa: E501
+    "UnstructuredXMLLoader": "langchain_community.document_loaders.xml",
+    "VsdxLoader": "langchain_community.document_loaders.vsdx",
+    "WeatherDataLoader": "langchain_community.document_loaders.weather",
+    "WebBaseLoader": "langchain_community.document_loaders.web_base",
+    "WhatsAppChatLoader": "langchain_community.document_loaders.whatsapp_chat",
+    "WikipediaLoader": "langchain_community.document_loaders.wikipedia",
+    "XorbitsLoader": "langchain_community.document_loaders.xorbits",
+    "YoutubeAudioLoader": "langchain_community.document_loaders.blob_loaders",
+    "YoutubeLoader": "langchain_community.document_loaders.youtube",
+    "YuqueLoader": "langchain_community.document_loaders.yuque",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+__all__ = [
+    "AZLyricsLoader",
+    "AcreomLoader",
+    "AirbyteCDKLoader",
+    "AirbyteGongLoader",
+    "AirbyteHubspotLoader",
+    "AirbyteJSONLoader",
+    "AirbyteSalesforceLoader",
+    "AirbyteShopifyLoader",
+    "AirbyteStripeLoader",
+    "AirbyteTypeformLoader",
+    "AirbyteZendeskSupportLoader",
+    "AirtableLoader",
+    "AmazonTextractPDFLoader",
+    "ApifyDatasetLoader",
+    "ArcGISLoader",
+    "ArxivLoader",
+    "AssemblyAIAudioLoaderById",
+    "AssemblyAIAudioTranscriptLoader",
+    "AstraDBLoader",
+    "AsyncChromiumLoader",
+    "AsyncHtmlLoader",
+    "AthenaLoader",
+    "AzureAIDataLoader",
+    "AzureAIDocumentIntelligenceLoader",
+    "AzureBlobStorageContainerLoader",
+    "AzureBlobStorageFileLoader",
+    "BSHTMLLoader",
+    "BibtexLoader",
+    "BigQueryLoader",
+    "BiliBiliLoader",
+    "BlackboardLoader",
+    "Blob",
+    "BlobLoader",
+    "BlockchainDocumentLoader",
+    "BraveSearchLoader",
+    "BrowserbaseLoader",
+    "BrowserlessLoader",
+    "CSVLoader",
+    "CassandraLoader",
+    "ChatGPTLoader",
+    "CloudBlobLoader",
+    "CoNLLULoader",
+    "CollegeConfidentialLoader",
+    "ConcurrentLoader",
+    "ConfluenceLoader",
+    "CouchbaseLoader",
+    "CubeSemanticLoader",
+    "DataFrameLoader",
+    "DatadogLogsLoader",
+    "DedocAPIFileLoader",
+    "DedocFileLoader",
+    "DedocPDFLoader",
+    "DiffbotLoader",
+    "DirectoryLoader",
+    "DiscordChatLoader",
+    "DocugamiLoader",
+    "DocusaurusLoader",
+    "Docx2txtLoader",
+    "DropboxLoader",
+    "DuckDBLoader",
+    "EtherscanLoader",
+    "EverNoteLoader",
+    "FacebookChatLoader",
+    "FaunaLoader",
+    "FigmaFileLoader",
+    "FireCrawlLoader",
+    "FileSystemBlobLoader",
+    "GCSDirectoryLoader",
+    "GlueCatalogLoader",
+    "GCSFileLoader",
+    "GeoDataFrameLoader",
+    "GitHubIssuesLoader",
+    "GitLoader",
+    "GitbookLoader",
+    "GithubFileLoader",
+    "GoogleApiClient",
+    "GoogleApiYoutubeLoader",
+    "GoogleDriveLoader",
+    "GoogleSpeechToTextLoader",
+    "GutenbergLoader",
+    "HNLoader",
+    "HuggingFaceDatasetLoader",
+    "HuggingFaceModelLoader",
+    "IFixitLoader",
+    "ImageCaptionLoader",
+    "IMSDbLoader",
+    "IuguLoader",
+    "JoplinLoader",
+    "JSONLoader",
+    "KineticaLoader",
+    "LakeFSLoader",
+    "LarkSuiteDocLoader",
+    "LLMSherpaFileLoader",
+    "MastodonTootsLoader",
+    "MHTMLLoader",
+    "MWDumpLoader",
+    "MathpixPDFLoader",
+    "MaxComputeLoader",
+    "MergedDataLoader",
+    "ModernTreasuryLoader",
+    "MongodbLoader",
+    "NeedleLoader",
+    "NewsURLLoader",
+    "NotebookLoader",
+    "NotionDBLoader",
+    "NotionDirectoryLoader",
+    "OBSDirectoryLoader",
+    "OBSFileLoader",
+    "ObsidianLoader",
+    "OneDriveFileLoader",
+    "OneDriveLoader",
+    "OnlinePDFLoader",
+    "OpenCityDataLoader",
+    "OracleAutonomousDatabaseLoader",
+    "OracleDocLoader",
+    "OracleTextSplitter",
+    "OutlookMessageLoader",
+    "PDFMinerLoader",
+    "PDFMinerPDFasHTMLLoader",
+    "PDFPlumberLoader",
+    "PagedPDFSplitter",
+    "PebbloSafeLoader",
+    "PebbloTextLoader",
+    "PlaywrightURLLoader",
+    "PolarsDataFrameLoader",
+    "PsychicLoader",
+    "PubMedLoader",
+    "PyMuPDFLoader",
+    "PyPDFDirectoryLoader",
+    "PyPDFLoader",
+    "PyPDFium2Loader",
+    "PySparkDataFrameLoader",
+    "PythonLoader",
+    "RSSFeedLoader",
+    "ReadTheDocsLoader",
+    "RecursiveUrlLoader",
+    "RedditPostsLoader",
+    "RoamLoader",
+    "RocksetLoader",
+    "S3DirectoryLoader",
+    "S3FileLoader",
+    "ScrapflyLoader",
+    "ScrapingAntLoader",
+    "SQLDatabaseLoader",
+    "SRTLoader",
+    "SeleniumURLLoader",
+    "SharePointLoader",
+    "SitemapLoader",
+    "SlackDirectoryLoader",
+    "SnowflakeLoader",
+    "SpiderLoader",
+    "SpreedlyLoader",
+    "StripeLoader",
+    "SurrealDBLoader",
+    "TelegramChatApiLoader",
+    "TelegramChatFileLoader",
+    "TelegramChatLoader",
+    "TencentCOSDirectoryLoader",
+    "TencentCOSFileLoader",
+    "TensorflowDatasetLoader",
+    "TextLoader",
+    "TiDBLoader",
+    "ToMarkdownLoader",
+    "TomlLoader",
+    "TrelloLoader",
+    "TwitterTweetLoader",
+    "UnstructuredAPIFileIOLoader",
+    "UnstructuredAPIFileLoader",
+    "UnstructuredCHMLoader",
+    "UnstructuredCSVLoader",
+    "UnstructuredEPubLoader",
+    "UnstructuredEmailLoader",
+    "UnstructuredExcelLoader",
+    "UnstructuredFileIOLoader",
+    "UnstructuredFileLoader",
+    "UnstructuredHTMLLoader",
+    "UnstructuredImageLoader",
+    "UnstructuredMarkdownLoader",
+    "UnstructuredODTLoader",
+    "UnstructuredOrgModeLoader",
+    "UnstructuredPDFLoader",
+    "UnstructuredPowerPointLoader",
+    "UnstructuredRSTLoader",
+    "UnstructuredRTFLoader",
+    "UnstructuredTSVLoader",
+    "UnstructuredURLLoader",
+    "UnstructuredWordDocumentLoader",
+    "UnstructuredXMLLoader",
+    "VsdxLoader",
+    "WeatherDataLoader",
+    "WebBaseLoader",
+    "WhatsAppChatLoader",
+    "WikipediaLoader",
+    "XorbitsLoader",
+    "YoutubeAudioLoader",
+    "YoutubeLoader",
+    "YuqueLoader",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/pyspark_dataframe.py

@@ -0,0 +1,91 @@
+import itertools
+import logging
+import sys
+from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__file__)
+
+if TYPE_CHECKING:
+    from pyspark.sql import SparkSession
+
+
+class PySparkDataFrameLoader(BaseLoader):
+    """Load `PySpark` DataFrames."""
+
+    def __init__(
+        self,
+        spark_session: Optional["SparkSession"] = None,
+        df: Optional[Any] = None,
+        page_content_column: str = "text",
+        fraction_of_memory: float = 0.1,
+    ):
+        """Initialize with a Spark DataFrame object.
+
+        Args:
+            spark_session: The SparkSession object.
+            df: The Spark DataFrame object.
+            page_content_column: The name of the column containing the page content.
+             Defaults to "text".
+            fraction_of_memory: The fraction of memory to use. Defaults to 0.1.
+        """
+        try:
+            from pyspark.sql import DataFrame, SparkSession
+        except ImportError:
+            raise ImportError(
+                "pyspark is not installed. Please install it with `pip install pyspark`"
+            )
+
+        self.spark = (
+            spark_session if spark_session else SparkSession.builder.getOrCreate()
+        )
+
+        if not isinstance(df, DataFrame):
+            raise ValueError(
+                f"Expected data_frame to be a PySpark DataFrame, got {type(df)}"
+            )
+        self.df = df
+        self.page_content_column = page_content_column
+        self.fraction_of_memory = fraction_of_memory
+        self.num_rows, self.max_num_rows = self.get_num_rows()
+        self.rdd_df = self.df.rdd.map(list)
+        self.column_names = self.df.columns
+
+    def get_num_rows(self) -> Tuple[int, int]:
+        """Gets the number of "feasible" rows for the DataFrame"""
+        try:
+            import psutil
+        except ImportError as e:
+            raise ImportError(
+                "psutil not installed. Please install it with `pip install psutil`."
+            ) from e
+        row = self.df.limit(1).collect()[0]
+        estimated_row_size = sys.getsizeof(row)
+        mem_info = psutil.virtual_memory()
+        available_memory = mem_info.available
+        max_num_rows = int(
+            (available_memory / estimated_row_size) * self.fraction_of_memory
+        )
+        return min(max_num_rows, self.df.count()), max_num_rows
+
+    def lazy_load(self) -> Iterator[Document]:
+        """A lazy loader for document content."""
+        for row in self.rdd_df.toLocalIterator():
+            metadata = {self.column_names[i]: row[i] for i in range(len(row))}
+            text = metadata[self.page_content_column]
+            metadata.pop(self.page_content_column)
+            yield Document(page_content=text, metadata=metadata)
+
+    def load(self) -> List[Document]:
+        """Load from the dataframe."""
+        if self.df.count() > self.max_num_rows:
+            logger.warning(
+                f"The number of DataFrame rows is {self.df.count()}, "
+                f"but we will only include the amount "
+                f"of rows that can reasonably fit in memory: {self.num_rows}."
+            )
+        lazy_load_iterator = self.lazy_load()
+        return list(itertools.islice(lazy_load_iterator, self.num_rows))

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/python.py

@@ -0,0 +1,19 @@
+import tokenize
+from pathlib import Path
+from typing import Union
+
+from langchain_community.document_loaders.text import TextLoader
+
+
+class PythonLoader(TextLoader):
+    """Load `Python` files, respecting any non-default encoding if specified."""
+
+    def __init__(self, file_path: Union[str, Path]):
+        """Initialize with a file path.
+
+        Args:
+            file_path: The path to the file to load.
+        """
+        with open(file_path, "rb") as f:
+            encoding, _ = tokenize.detect_encoding(f.readline)
+        super().__init__(file_path=file_path, encoding=encoding)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/quip.py

@@ -0,0 +1,249 @@
+import logging
+import re
+import xml.etree.cElementTree  # OK: user-must-opt-in
+from io import BytesIO
+from typing import List, Optional, Sequence
+from xml.etree.ElementTree import ElementTree  # OK: user-must-opt-in
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__name__)
+
+_MAXIMUM_TITLE_LENGTH = 64
+
+
+class QuipLoader(BaseLoader):
+    """Load `Quip` pages.
+
+    Port of https://github.com/quip/quip-api/tree/master/samples/baqup
+    """
+
+    def __init__(
+        self,
+        api_url: str,
+        access_token: str,
+        request_timeout: Optional[int] = 60,
+        *,
+        allow_dangerous_xml_parsing: bool = False,
+    ):
+        """
+        Args:
+            api_url: https://platform.quip.com
+            access_token: token of access quip API. Please refer:
+                https://quip.com/dev/automation/documentation/current#section/Authentication/Get-Access-to-Quip's-APIs
+            request_timeout: timeout of request, default 60s.
+            allow_dangerous_xml_parsing: Allow dangerous XML parsing, defaults to False
+        """
+        try:
+            from quip_api.quip import QuipClient
+        except ImportError:
+            raise ImportError(
+                "`quip_api` package not found, please run `pip install quip_api`"
+            )
+
+        self.quip_client = QuipClient(
+            access_token=access_token, base_url=api_url, request_timeout=request_timeout
+        )
+
+        if not allow_dangerous_xml_parsing:
+            raise ValueError(
+                "The quip client uses the built-in XML parser which may cause"
+                "security issues when parsing XML data in some cases. "
+                "Please see "
+                "https://docs.python.org/3/library/xml.html#xml-vulnerabilities "
+                "For more information, set `allow_dangerous_xml_parsing` as True "
+                "if you are sure that your distribution of the standard library "
+                "is not vulnerable to XML vulnerabilities."
+            )
+
+    def load(
+        self,
+        folder_ids: Optional[List[str]] = None,
+        thread_ids: Optional[List[str]] = None,
+        max_docs: Optional[int] = 1000,
+        include_all_folders: bool = False,
+        include_comments: bool = False,
+        include_images: bool = False,
+    ) -> List[Document]:
+        """
+        Args:
+            :param folder_ids: List of specific folder IDs to load, defaults to None
+            :param thread_ids: List of specific thread IDs to load, defaults to None
+            :param max_docs: Maximum number of docs to retrieve in total, defaults 1000
+            :param include_all_folders: Include all folders that your access_token
+                   can access, but doesn't include your private folder
+            :param include_comments: Include comments, defaults to False
+            :param include_images: Include images, defaults to False
+        """
+        if not folder_ids and not thread_ids and not include_all_folders:
+            raise ValueError(
+                "Must specify at least one among `folder_ids`, `thread_ids` "
+                "or set `include_all`_folders as True"
+            )
+
+        thread_ids = thread_ids or []
+
+        if folder_ids:
+            for folder_id in folder_ids:
+                self.get_thread_ids_by_folder_id(folder_id, 0, thread_ids)
+
+        if include_all_folders:
+            user = self.quip_client.get_authenticated_user()
+            if "group_folder_ids" in user:
+                self.get_thread_ids_by_folder_id(
+                    user["group_folder_ids"], 0, thread_ids
+                )
+            if "shared_folder_ids" in user:
+                self.get_thread_ids_by_folder_id(
+                    user["shared_folder_ids"], 0, thread_ids
+                )
+
+        thread_ids = list(set(thread_ids[:max_docs]))
+        return self.process_threads(thread_ids, include_images, include_comments)
+
+    def get_thread_ids_by_folder_id(
+        self, folder_id: str, depth: int, thread_ids: List[str]
+    ) -> None:
+        """Get thread ids by folder id and update in thread_ids"""
+        from quip_api.quip import HTTPError, QuipError
+
+        try:
+            folder = self.quip_client.get_folder(folder_id)
+        except QuipError as e:
+            if e.code == 403:
+                logging.warning(
+                    f"depth {depth}, Skipped over restricted folder {folder_id}, {e}"
+                )
+            else:
+                logging.warning(
+                    f"depth {depth}, Skipped over folder {folder_id} "
+                    f"due to unknown error {e.code}"
+                )
+            return
+        except HTTPError as e:
+            logging.warning(
+                f"depth {depth}, Skipped over folder {folder_id} "
+                f"due to HTTP error {e.code}"
+            )
+            return
+
+        title = folder["folder"].get("title", "Folder %s" % folder_id)
+
+        logging.info(f"depth {depth}, Processing folder {title}")
+        for child in folder["children"]:
+            if "folder_id" in child:
+                self.get_thread_ids_by_folder_id(
+                    child["folder_id"], depth + 1, thread_ids
+                )
+            elif "thread_id" in child:
+                thread_ids.append(child["thread_id"])
+
+    def process_threads(
+        self, thread_ids: Sequence[str], include_images: bool, include_messages: bool
+    ) -> List[Document]:
+        """Process a list of thread into a list of documents."""
+        docs = []
+        for thread_id in thread_ids:
+            doc = self.process_thread(thread_id, include_images, include_messages)
+            if doc is not None:
+                docs.append(doc)
+        return docs
+
+    def process_thread(
+        self, thread_id: str, include_images: bool, include_messages: bool
+    ) -> Optional[Document]:
+        thread = self.quip_client.get_thread(thread_id)
+        thread_id = thread["thread"]["id"]
+        title = thread["thread"]["title"]
+        link = thread["thread"]["link"]
+        update_ts = thread["thread"]["updated_usec"]
+        sanitized_title = QuipLoader._sanitize_title(title)
+
+        logger.info(
+            f"processing thread {thread_id} title {sanitized_title} "
+            f"link {link} update_ts {update_ts}"
+        )
+
+        if "html" in thread:
+            # Parse the document
+            try:
+                tree = self.quip_client.parse_document_html(thread["html"])
+            except xml.etree.cElementTree.ParseError as e:
+                logger.error(f"Error parsing thread {title} {thread_id}, skipping, {e}")
+                return None
+
+            metadata = {
+                "title": sanitized_title,
+                "update_ts": update_ts,
+                "id": thread_id,
+                "source": link,
+            }
+
+            # Download each image and replace with the new URL
+            text = ""
+            if include_images:
+                text = self.process_thread_images(tree)
+
+            if include_messages:
+                text = text + "/n" + self.process_thread_messages(thread_id)
+
+            return Document(
+                page_content=thread["html"] + text,
+                metadata=metadata,
+            )
+        return None
+
+    def process_thread_images(self, tree: ElementTree) -> str:
+        text = ""
+
+        try:
+            from PIL import Image
+            from pytesseract import pytesseract
+        except ImportError:
+            raise ImportError(
+                "`Pillow or pytesseract` package not found, "
+                "please run "
+                "`pip install Pillow` or `pip install pytesseract`"
+            )
+
+        for img in tree.iter("img"):
+            src = img.get("src")
+            if not src or not src.startswith("/blob"):
+                continue
+            _, _, thread_id, blob_id = src.split("/")
+            blob_response = self.quip_client.get_blob(thread_id, blob_id)
+            try:
+                image = Image.open(BytesIO(blob_response.read()))
+                text = text + "\n" + pytesseract.image_to_string(image)
+            except OSError as e:
+                logger.error(f"failed to convert image to text, {e}")
+                raise e
+        return text
+
+    def process_thread_messages(self, thread_id: str) -> str:
+        max_created_usec = None
+        messages = []
+        while True:
+            chunk = self.quip_client.get_messages(
+                thread_id, max_created_usec=max_created_usec, count=100
+            )
+            messages.extend(chunk)
+            if chunk:
+                max_created_usec = chunk[-1]["created_usec"] - 1
+            else:
+                break
+        messages.reverse()
+
+        texts = [message["text"] for message in messages]
+
+        return "\n".join(texts)
+
+    @staticmethod
+    def _sanitize_title(title: str) -> str:
+        sanitized_title = re.sub(r"\s", " ", title)
+        sanitized_title = re.sub(r"(?u)[^- \w.]", "", sanitized_title)
+        if len(sanitized_title) > _MAXIMUM_TITLE_LENGTH:
+            sanitized_title = sanitized_title[:_MAXIMUM_TITLE_LENGTH]
+        return sanitized_title

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/readthedocs.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Sequence, Tuple, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    from bs4 import NavigableString
+    from bs4.element import Comment, Tag
+
+
+class ReadTheDocsLoader(BaseLoader):
+    """Load `ReadTheDocs` documentation directory."""
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        custom_html_tag: Optional[Tuple[str, dict]] = None,
+        patterns: Sequence[str] = ("*.htm", "*.html"),
+        exclude_links_ratio: float = 1.0,
+        **kwargs: Optional[Any],
+    ):
+        """
+        Initialize ReadTheDocsLoader
+
+        The loader loops over all files under `path` and extracts the actual content of
+        the files by retrieving main html tags. Default main html tags include
+        `<main id="main-content>`, <`div role="main>`, and `<article role="main">`. You
+        can also define your own html tags by passing custom_html_tag, e.g.
+        `("div", "class=main")`. The loader iterates html tags with the order of
+        custom html tags (if exists) and default html tags. If any of the tags is not
+        empty, the loop will break and retrieve the content out of that tag.
+
+        Args:
+            path: The location of pulled readthedocs folder.
+            encoding: The encoding with which to open the documents.
+            errors: Specify how encoding and decoding errors are to be handled—this
+                cannot be used in binary mode.
+            custom_html_tag: Optional custom html tag to retrieve the content from
+                files.
+            patterns: The file patterns to load, passed to `glob.rglob`.
+            exclude_links_ratio: The ratio of links:content to exclude pages from.
+                This is to reduce the frequency at which index pages make their
+                way into retrieved results. Recommended: 0.5
+            kwargs: named arguments passed to `bs4.BeautifulSoup`.
+        """
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            raise ImportError(
+                "Could not import python packages. "
+                "Please install it with `pip install beautifulsoup4`. "
+            )
+
+        try:
+            _ = BeautifulSoup(
+                "<html><body>Parser builder library test.</body></html>",
+                "html.parser",
+                **kwargs,
+            )
+        except Exception as e:
+            raise ValueError("Parsing kwargs do not appear valid") from e
+
+        self.file_path = Path(path)
+        self.encoding = encoding
+        self.errors = errors
+        self.custom_html_tag = custom_html_tag
+        self.patterns = patterns
+        self.bs_kwargs = kwargs
+        self.exclude_links_ratio = exclude_links_ratio
+
+    def lazy_load(self) -> Iterator[Document]:
+        """A lazy loader for Documents."""
+        for file_pattern in self.patterns:
+            for p in self.file_path.rglob(file_pattern):
+                if p.is_dir():
+                    continue
+                with open(p, encoding=self.encoding, errors=self.errors) as f:
+                    text = self._clean_data(f.read())
+                yield Document(page_content=text, metadata={"source": str(p)})
+
+    def _clean_data(self, data: str) -> str:
+        from bs4 import BeautifulSoup
+
+        soup = BeautifulSoup(data, "html.parser", **self.bs_kwargs)
+
+        # default tags
+        html_tags = [
+            ("div", {"role": "main"}),
+            ("main", {"id": "main-content"}),
+        ]
+
+        if self.custom_html_tag is not None:
+            html_tags.append(self.custom_html_tag)
+
+        element = None
+
+        # reversed order. check the custom one first
+        for tag, attrs in html_tags[::-1]:
+            element = soup.find(tag, attrs)  # type: ignore[arg-type]
+            # if found, break
+            if element is not None:
+                break
+
+        if element is not None and _get_link_ratio(element) <= self.exclude_links_ratio:
+            text = _get_clean_text(element)
+        else:
+            text = ""
+        # trim empty lines
+        return "\n".join([t for t in text.split("\n") if t])
+
+
+def _get_clean_text(element: Tag) -> str:
+    """Returns cleaned text with newlines preserved and irrelevant elements removed."""
+    elements_to_skip = [
+        "script",
+        "noscript",
+        "canvas",
+        "meta",
+        "svg",
+        "map",
+        "area",
+        "audio",
+        "source",
+        "track",
+        "video",
+        "embed",
+        "object",
+        "param",
+        "picture",
+        "iframe",
+        "frame",
+        "frameset",
+        "noframes",
+        "applet",
+        "form",
+        "button",
+        "select",
+        "base",
+        "style",
+        "img",
+    ]
+
+    newline_elements = [
+        "p",
+        "div",
+        "ul",
+        "ol",
+        "li",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "pre",
+        "table",
+        "tr",
+    ]
+
+    text = _process_element(element, elements_to_skip, newline_elements)
+    return text.strip()
+
+
+def _get_link_ratio(section: Tag) -> float:
+    links = section.find_all("a")
+    total_text = "".join(str(s) for s in section.stripped_strings)
+    if len(total_text) == 0:
+        return 0
+
+    link_text = "".join(
+        str(string.string.strip())
+        for link in links
+        for string in link.strings
+        if string
+    )
+    return len(link_text) / len(total_text)
+
+
+def _process_element(
+    element: Union[Tag, NavigableString, Comment],
+    elements_to_skip: List[str],
+    newline_elements: List[str],
+) -> str:
+    """
+    Traverse through HTML tree recursively to preserve newline and skip
+    unwanted (code/binary) elements
+    """
+    from bs4 import NavigableString
+    from bs4.element import Comment, Tag
+
+    tag_name = getattr(element, "name", None)
+    if isinstance(element, Comment) or tag_name in elements_to_skip:
+        return ""
+    elif isinstance(element, NavigableString):
+        return element
+    elif tag_name == "br":
+        return "\n"
+    elif tag_name in newline_elements:
+        return (
+            "".join(
+                _process_element(child, elements_to_skip, newline_elements)
+                for child in element.children
+                if isinstance(child, (Tag, NavigableString, Comment))
+            )
+            + "\n"
+        )
+    else:
+        return "".join(
+            _process_element(child, elements_to_skip, newline_elements)
+            for child in element.children
+            if isinstance(child, (Tag, NavigableString, Comment))
+        )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/recursive_url_loader.py

@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+import re
+from typing import (
+    Callable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
+from urllib.parse import urlparse
+
+import aiohttp
+import requests
+from langchain_core.documents import Document
+from langchain_core.utils.html import extract_sub_links
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__name__)
+
+
+def _metadata_extractor(
+    raw_html: str, url: str, response: Union[requests.Response, aiohttp.ClientResponse]
+) -> dict:
+    """Extract metadata from raw html using BeautifulSoup."""
+    content_type = getattr(response, "headers").get("Content-Type", "")
+    metadata = {"source": url, "content_type": content_type}
+
+    try:
+        from bs4 import BeautifulSoup
+    except ImportError:
+        logger.warning(
+            "The bs4 package is required for default metadata extraction. "
+            "Please install it with `pip install -U beautifulsoup4`."
+        )
+        return metadata
+    soup = BeautifulSoup(raw_html, "html.parser")
+    if title := soup.find("title"):
+        metadata["title"] = title.get_text()
+    if description := soup.find("meta", attrs={"name": "description"}):
+        metadata["description"] = description.get("content", None)
+    if html := soup.find("html"):
+        metadata["language"] = html.get("lang", None)
+    return metadata
+
+
+class RecursiveUrlLoader(BaseLoader):
+    """Recursively load all child links from a root URL.
+
+    **Security Note**:
+        This loader is a crawler that will start crawling
+        at a given URL and then expand to crawl child links recursively.
+
+        Web crawlers should generally NOT be deployed with network access
+        to any internal servers.
+
+        Control access to who can submit crawling requests and what network access
+        the crawler has.
+
+        While crawling, the crawler may encounter malicious URLs that would lead to a
+        server-side request forgery (SSRF) attack.
+
+        To mitigate risks, the crawler by default will only load URLs from the same
+        domain as the start URL (controlled via prevent_outside named argument).
+
+        This will mitigate the risk of SSRF attacks, but will not eliminate it.
+
+        For example, if crawling a host which hosts several sites:
+
+        https://some_host/alice_site/
+        https://some_host/bob_site/
+
+        A malicious URL on Alice's site could cause the crawler to make a malicious
+        GET request to an endpoint on Bob's site. Both sites are hosted on the
+        same host, so such a request would not be prevented by default.
+
+        See https://python.langchain.com/docs/security/
+
+    Setup:
+
+        This class has no required additional dependencies. You can optionally install
+        ``beautifulsoup4`` for richer default metadata extraction:
+
+        .. code-block:: bash
+
+            pip install -U beautifulsoup4
+
+    Instantiate:
+        .. code-block:: python
+
+            from langchain_community.document_loaders import RecursiveUrlLoader
+
+            loader = RecursiveUrlLoader(
+                "https://docs.python.org/3.9/",
+                # max_depth=2,
+                # use_async=False,
+                # extractor=None,
+                # metadata_extractor=None,
+                # exclude_dirs=(),
+                # timeout=10,
+                # check_response_status=True,
+                # continue_on_failure=True,
+                # prevent_outside=True,
+                # base_url=None,
+                # ...
+            )
+
+    Lazy load:
+        .. code-block:: python
+
+            docs = []
+            docs_lazy = loader.lazy_load()
+
+            # async variant:
+            # docs_lazy = await loader.alazy_load()
+
+            for doc in docs_lazy:
+                docs.append(doc)
+            print(docs[0].page_content[:100])
+            print(docs[0].metadata)
+
+        .. code-block:: python
+
+            <!DOCTYPE html>
+
+            <html xmlns="http://www.w3.org/1999/xhtml">
+            <head>
+                <meta charset="utf-8" /><
+            {'source': 'https://docs.python.org/3.9/', 'content_type': 'text/html', 'title': '3.9.19 Documentation', 'language': None}
+
+    Async load:
+        .. code-block:: python
+
+            docs = await loader.aload()
+            print(docs[0].page_content[:100])
+            print(docs[0].metadata)
+
+        .. code-block:: python
+
+            <!DOCTYPE html>
+
+            <html xmlns="http://www.w3.org/1999/xhtml">
+            <head>
+                <meta charset="utf-8" /><
+            {'source': 'https://docs.python.org/3.9/', 'content_type': 'text/html', 'title': '3.9.19 Documentation', 'language': None}
+
+    Content parsing / extraction:
+        By default the loader sets the raw HTML from each link as the Document page
+        content. To parse this HTML into a more human/LLM-friendly format you can pass
+        in a custom ``extractor`` method:
+
+        .. code-block:: python
+
+            # This example uses `beautifulsoup4` and `lxml`
+            import re
+            from bs4 import BeautifulSoup
+
+            def bs4_extractor(html: str) -> str:
+                soup = BeautifulSoup(html, "lxml")
+                return re.sub(r"\\n\\n+", "\\n\\n", soup.text).strip()
+
+            loader = RecursiveUrlLoader(
+                "https://docs.python.org/3.9/",
+                extractor=bs4_extractor,
+            )
+            print(loader.load()[0].page_content[:200])
+
+
+        .. code-block:: python
+
+            3.9.19 Documentation
+
+            Download
+            Download these documents
+            Docs by version
+
+            Python 3.13 (in development)
+            Python 3.12 (stable)
+            Python 3.11 (security-fixes)
+            Python 3.10 (security-fixes)
+            Python 3.9 (securit
+
+    Metadata extraction:
+        Similarly to content extraction, you can specify a metadata extraction function
+        to customize how Document metadata is extracted from the HTTP response.
+
+        .. code-block:: python
+
+            import aiohttp
+            import requests
+            from typing import Union
+
+            def simple_metadata_extractor(
+                raw_html: str, url: str, response: Union[requests.Response, aiohttp.ClientResponse]
+            ) -> dict:
+                content_type = getattr(response, "headers").get("Content-Type", "")
+                return {"source": url, "content_type": content_type}
+
+            loader = RecursiveUrlLoader(
+                "https://docs.python.org/3.9/",
+                metadata_extractor=simple_metadata_extractor,
+            )
+            loader.load()[0].metadata
+
+        .. code-block:: python
+
+            {'source': 'https://docs.python.org/3.9/', 'content_type': 'text/html'}
+
+    Filtering URLs:
+        You may not always want to pull every URL from a website. There are four parameters
+        that allow us to control what URLs we pull recursively. First, we can set the
+        ``prevent_outside`` parameter to prevent URLs outside of the ``base_url`` from
+        being pulled. Note that the ``base_url`` does not need to be the same as the URL we
+        pass in, as shown below. We can also use ``link_regex`` and ``exclude_dirs`` to be
+        more specific with the URLs that we select. In this example, we only pull websites
+        from the python docs, which contain the string "index" somewhere and are not
+        located in the FAQ section of the website.
+
+        .. code-block:: python
+
+            loader = RecursiveUrlLoader(
+                "https://docs.python.org/3.9/",
+                prevent_outside=True,
+                base_url="https://docs.python.org",
+                link_regex=r'<a\\s+(?:[^>]*?\\s+)?href="([^"]*(?=index)[^"]*)"',
+                exclude_dirs=['https://docs.python.org/3.9/faq']
+            )
+            docs = loader.load()
+
+        .. code-block:: python
+
+            ['https://docs.python.org/3.9/',
+            'https://docs.python.org/3.9/py-modindex.html',
+            'https://docs.python.org/3.9/genindex.html',
+            'https://docs.python.org/3.9/tutorial/index.html',
+            'https://docs.python.org/3.9/using/index.html',
+            'https://docs.python.org/3.9/extending/index.html',
+            'https://docs.python.org/3.9/installing/index.html',
+            'https://docs.python.org/3.9/library/index.html',
+            'https://docs.python.org/3.9/c-api/index.html',
+            'https://docs.python.org/3.9/howto/index.html',
+            'https://docs.python.org/3.9/distributing/index.html',
+            'https://docs.python.org/3.9/reference/index.html',
+            'https://docs.python.org/3.9/whatsnew/index.html']
+
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        url: str,
+        max_depth: Optional[int] = 2,
+        use_async: Optional[bool] = None,
+        extractor: Optional[Callable[[str], str]] = None,
+        metadata_extractor: Optional[_MetadataExtractorType] = None,
+        exclude_dirs: Optional[Sequence[str]] = (),
+        timeout: Optional[int] = 10,
+        prevent_outside: bool = True,
+        link_regex: Union[str, re.Pattern, None] = None,
+        headers: Optional[dict] = None,
+        check_response_status: bool = False,
+        continue_on_failure: bool = True,
+        *,
+        base_url: Optional[str] = None,
+        autoset_encoding: bool = True,
+        encoding: Optional[str] = None,
+        proxies: Optional[dict] = None,
+        ssl: bool = True,
+    ) -> None:
+        """Initialize with URL to crawl and any subdirectories to exclude.
+
+        Args:
+            url: The URL to crawl.
+            max_depth: The max depth of the recursive loading.
+            use_async: Whether to use asynchronous loading.
+                If ``True``, ``lazy_load()`` will not be lazy, but it will still work in
+                the expected way, just not lazy.
+            extractor: A function to extract document contents from raw HTML.
+                When extract function returns an empty string, the document is
+                ignored. Default returns the raw HTML.
+            metadata_extractor: A function to extract metadata from args: raw HTML, the
+                source url, and the requests.Response/aiohttp.ClientResponse object
+                (args in that order).
+
+                Default extractor will attempt to use BeautifulSoup4 to extract the
+                title, description and language of the page.
+
+                ..code-block:: python
+
+                    import requests
+                    import aiohttp
+
+                    def simple_metadata_extractor(
+                        raw_html: str, url: str, response: Union[requests.Response, aiohttp.ClientResponse]
+                    ) -> dict:
+                        content_type = getattr(response, "headers").get("Content-Type", "")
+                        return {"source": url, "content_type": content_type}
+
+            exclude_dirs: A list of subdirectories to exclude.
+            timeout: The timeout for the requests, in the unit of seconds. If ``None``
+                then connection will not timeout.
+            prevent_outside: If ``True``, prevent loading from urls which are not children
+                of the root url.
+            link_regex: Regex for extracting sub-links from the raw html of a web page.
+            headers: Default request headers to use for all requests.
+            check_response_status: If ``True``, check HTTP response status and skip
+                URLs with error responses (``400-599``).
+            continue_on_failure: If ``True``, continue if getting or parsing a link raises
+                an exception. Otherwise, raise the exception.
+            base_url: The base url to check for outside links against.
+            autoset_encoding: Whether to automatically set the encoding of the response.
+                If ``True``, the encoding of the response will be set to the apparent
+                encoding, unless the ``encoding`` argument has already been explicitly set.
+            encoding: The encoding of the response. If manually set, the encoding will be
+                set to given value, regardless of the ``autoset_encoding`` argument.
+            proxies: A dictionary mapping protocol names to the proxy URLs to be used for requests.
+                This allows the crawler to route its requests through specified proxy servers.
+                If ``None``, no proxies will be used and requests will go directly to the target URL.
+
+                Example usage:
+
+                ..code-block:: python
+
+                    proxies = {
+                        "http": "http://10.10.1.10:3128",
+                        "https": "https://10.10.1.10:1080",
+                    }
+
+            ssl: Whether to verify SSL certificates during requests.
+                By default, SSL certificate verification is enabled (``ssl=True``),
+                ensuring secure HTTPS connections. Setting this to ``False`` disables SSL
+                certificate verification, which can be useful when crawling internal
+                services, development environments, or sites with misconfigured or
+                self-signed certificates.
+
+                **Use with caution:** Disabling SSL verification exposes your crawler to
+                man-in-the-middle (MitM) attacks, data tampering, and potential
+                interception of sensitive information. This significantly compromises
+                the security and integrity of the communication. It should never be
+                used in production or when handling sensitive data.
+        """  # noqa: E501
+
+        self.url = url
+        self.max_depth = max_depth if max_depth is not None else 2
+        self.use_async = use_async if use_async is not None else False
+        self.extractor = extractor if extractor is not None else lambda x: x
+        self.ssl = ssl
+        metadata_extractor = (
+            metadata_extractor
+            if metadata_extractor is not None
+            else _metadata_extractor
+        )
+        self.autoset_encoding = autoset_encoding
+        self.encoding = encoding
+        self.metadata_extractor = _wrap_metadata_extractor(metadata_extractor)
+        self.exclude_dirs = exclude_dirs if exclude_dirs is not None else ()
+
+        if any(url.startswith(exclude_dir) for exclude_dir in self.exclude_dirs):
+            raise ValueError(
+                f"Base url is included in exclude_dirs. Received base_url: {url} and "
+                f"exclude_dirs: {self.exclude_dirs}"
+            )
+
+        self.timeout = timeout
+        self.prevent_outside = prevent_outside if prevent_outside is not None else True
+        self.link_regex = link_regex
+        self.headers = headers
+        self.check_response_status = check_response_status
+        self.continue_on_failure = continue_on_failure
+        self.base_url = base_url if base_url is not None else self._parse_base_url(url)
+        self.proxies = proxies
+
+    def _parse_base_url(self, url: str) -> str:
+        """Parse the base URL from the given URL.
+
+        Args:
+            url: The URL to parse.
+
+        Returns:
+            The base URL with scheme and netloc only, ending with a slash.
+        """
+        if not url.startswith(("http://", "https://")):
+            url = "https://" + url
+        parsed_url = urlparse(url)
+        return f"{parsed_url.scheme}://{parsed_url.netloc}/"
+
+    def _get_child_links_recursive(
+        self, url: str, visited: Set[str], *, depth: int = 0
+    ) -> Iterator[Document]:
+        """Recursively get all child links starting with the path of the input URL.
+
+        Args:
+            url: The URL to crawl.
+            visited: A set of visited URLs.
+            depth: Current depth of recursion. Stop when depth >= max_depth.
+        """
+
+        if depth >= self.max_depth:
+            return
+
+        # Get all links that can be accessed from the current URL
+        visited.add(url)
+        try:
+            response = requests.get(
+                url, timeout=self.timeout, headers=self.headers, proxies=self.proxies
+            )
+
+            if self.encoding is not None:
+                response.encoding = self.encoding
+            elif self.autoset_encoding:
+                response.encoding = response.apparent_encoding
+
+            if self.check_response_status and 400 <= response.status_code <= 599:
+                raise ValueError(f"Received HTTP status {response.status_code}")
+        except Exception as e:
+            if self.continue_on_failure:
+                logger.warning(
+                    f"Unable to load from {url}. Received error {e} of type "
+                    f"{e.__class__.__name__}"
+                )
+                return
+            else:
+                raise e
+        content = self.extractor(response.text)
+        if content:
+            yield Document(
+                page_content=content,
+                metadata=self.metadata_extractor(response.text, url, response),
+            )
+
+        # Store the visited links and recursively visit the children
+        sub_links = extract_sub_links(
+            response.text,
+            url,
+            base_url=self.base_url,
+            pattern=self.link_regex,
+            prevent_outside=self.prevent_outside,
+            exclude_prefixes=self.exclude_dirs,
+            continue_on_failure=self.continue_on_failure,
+        )
+        for link in sub_links:
+            # Check all unvisited links
+            if link not in visited:
+                yield from self._get_child_links_recursive(
+                    link, visited, depth=depth + 1
+                )
+
+    async def _async_get_child_links_recursive(
+        self,
+        url: str,
+        visited: Set[str],
+        *,
+        session: Optional[aiohttp.ClientSession] = None,
+        depth: int = 0,
+    ) -> List[Document]:
+        """Recursively get all child links starting with the path of the input URL.
+
+        Args:
+            url: The URL to crawl.
+            visited: A set of visited URLs.
+            depth: To reach the current url, how many pages have been visited.
+        """
+        if not self.use_async:
+            raise ValueError(
+                "Async functions forbidden when not initialized with `use_async`"
+            )
+
+        if depth >= self.max_depth:
+            return []
+
+        # Disable SSL verification because websites may have invalid SSL certificates,
+        # but won't cause any security issues for us.
+        close_session = session is None
+        session = (
+            session
+            if session is not None
+            else aiohttp.ClientSession(
+                connector=aiohttp.TCPConnector(ssl=self.ssl),
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+                headers=self.headers,
+            )
+        )
+        visited.add(url)
+        try:
+            async with session.get(url) as response:
+                text = await response.text()
+                if self.check_response_status and 400 <= response.status <= 599:
+                    raise ValueError(f"Received HTTP status {response.status}")
+        except (aiohttp.client_exceptions.InvalidURL, Exception) as e:
+            if close_session:
+                await session.close()
+            if self.continue_on_failure:
+                logger.warning(
+                    f"Unable to load {url}. Received error {e} of type "
+                    f"{e.__class__.__name__}"
+                )
+                return []
+            else:
+                raise e
+        results = []
+        content = self.extractor(text)
+        if content:
+            results.append(
+                Document(
+                    page_content=content,
+                    metadata=self.metadata_extractor(text, url, response),
+                )
+            )
+        if depth < self.max_depth - 1:
+            sub_links = extract_sub_links(
+                text,
+                url,
+                base_url=self.base_url,
+                pattern=self.link_regex,
+                prevent_outside=self.prevent_outside,
+                exclude_prefixes=self.exclude_dirs,
+                continue_on_failure=self.continue_on_failure,
+            )
+
+            # Recursively call the function to get the children of the children
+            sub_tasks = []
+            to_visit = set(sub_links).difference(visited)
+            for link in to_visit:
+                sub_tasks.append(
+                    self._async_get_child_links_recursive(
+                        link, visited, session=session, depth=depth + 1
+                    )
+                )
+            next_results = await asyncio.gather(*sub_tasks)
+            for sub_result in next_results:
+                if isinstance(sub_result, Exception) or sub_result is None:
+                    # We don't want to stop the whole process, so just ignore it
+                    # Not standard html format or invalid url or 404 may cause this.
+                    continue
+                # locking not fully working, temporary hack to ensure deduplication
+                results += [r for r in sub_result if r not in results]
+        if close_session:
+            await session.close()
+        return results
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load web pages.
+        When use_async is True, this function will not be lazy,
+        but it will still work in the expected way, just not lazy."""
+        visited: Set[str] = set()
+        if self.use_async:
+            results = asyncio.run(
+                self._async_get_child_links_recursive(self.url, visited)
+            )
+            return iter(results or [])
+        else:
+            return self._get_child_links_recursive(self.url, visited)
+
+
+_MetadataExtractorType1 = Callable[[str, str], dict]
+_MetadataExtractorType2 = Callable[
+    [str, str, Union[requests.Response, aiohttp.ClientResponse]], dict
+]
+_MetadataExtractorType = Union[_MetadataExtractorType1, _MetadataExtractorType2]
+
+
+def _wrap_metadata_extractor(
+    metadata_extractor: _MetadataExtractorType,
+) -> _MetadataExtractorType2:
+    if len(inspect.signature(metadata_extractor).parameters) == 3:
+        return cast(_MetadataExtractorType2, metadata_extractor)
+    else:
+
+        def _metadata_extractor_wrapper(
+            raw_html: str,
+            url: str,
+            response: Union[requests.Response, aiohttp.ClientResponse],
+        ) -> dict:
+            return cast(_MetadataExtractorType1, metadata_extractor)(raw_html, url)
+
+        return _metadata_extractor_wrapper

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/reddit.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterable, List, Optional, Sequence
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    import praw
+
+
+def _dependable_praw_import() -> praw:
+    try:
+        import praw
+    except ImportError:
+        raise ImportError(
+            "praw package not found, please install it with `pip install praw`"
+        )
+    return praw
+
+
+class RedditPostsLoader(BaseLoader):
+    """Load `Reddit` posts.
+
+    Read posts on a subreddit.
+    First, you need to go to
+    https://www.reddit.com/prefs/apps/
+    and create your application
+    """
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        user_agent: str,
+        search_queries: Sequence[str],
+        mode: str,
+        categories: Sequence[str] = ["new"],
+        number_posts: Optional[int] = 10,
+    ):
+        """
+        Initialize with client_id, client_secret, user_agent, search_queries, mode,
+            categories, number_posts.
+        Example: https://www.reddit.com/r/learnpython/
+
+        Args:
+            client_id: Reddit client id.
+            client_secret: Reddit client secret.
+            user_agent: Reddit user agent.
+            search_queries: The search queries.
+            mode: The mode.
+            categories: The categories. Default: ["new"]
+            number_posts: The number of posts. Default: 10
+        """
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.user_agent = user_agent
+        self.search_queries = search_queries
+        self.mode = mode
+        self.categories = categories
+        self.number_posts = number_posts
+
+    def load(self) -> List[Document]:
+        """Load reddits."""
+        praw = _dependable_praw_import()
+
+        reddit = praw.Reddit(
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            user_agent=self.user_agent,
+        )
+
+        results: List[Document] = []
+
+        if self.mode == "subreddit":
+            for search_query in self.search_queries:
+                for category in self.categories:
+                    docs = self._subreddit_posts_loader(
+                        search_query=search_query, category=category, reddit=reddit
+                    )
+                    results.extend(docs)
+
+        elif self.mode == "username":
+            for search_query in self.search_queries:
+                for category in self.categories:
+                    docs = self._user_posts_loader(
+                        search_query=search_query, category=category, reddit=reddit
+                    )
+                    results.extend(docs)
+
+        else:
+            raise ValueError(
+                "mode not correct, please enter 'username' or 'subreddit' as mode"
+            )
+
+        return results
+
+    def _subreddit_posts_loader(
+        self, search_query: str, category: str, reddit: praw.reddit.Reddit
+    ) -> Iterable[Document]:
+        subreddit = reddit.subreddit(search_query)
+        method = getattr(subreddit, category)
+        cat_posts = method(limit=self.number_posts)
+
+        """Format reddit posts into a string."""
+        for post in cat_posts:
+            metadata = {
+                "post_subreddit": post.subreddit_name_prefixed,
+                "post_category": category,
+                "post_title": post.title,
+                "post_score": post.score,
+                "post_id": post.id,
+                "post_url": post.url,
+                "post_author": post.author,
+            }
+            yield Document(
+                page_content=post.selftext,
+                metadata=metadata,
+            )
+
+    def _user_posts_loader(
+        self, search_query: str, category: str, reddit: praw.reddit.Reddit
+    ) -> Iterable[Document]:
+        user = reddit.redditor(search_query)
+        method = getattr(user.submissions, category)
+        cat_posts = method(limit=self.number_posts)
+
+        """Format reddit posts into a string."""
+        for post in cat_posts:
+            metadata = {
+                "post_subreddit": post.subreddit_name_prefixed,
+                "post_category": category,
+                "post_title": post.title,
+                "post_score": post.score,
+                "post_id": post.id,
+                "post_url": post.url,
+                "post_author": post.author,
+            }
+            yield Document(
+                page_content=post.selftext,
+                metadata=metadata,
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/roam.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+from typing import List, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class RoamLoader(BaseLoader):
+    """Load `Roam` files from a directory."""
+
+    def __init__(self, path: Union[str, Path]):
+        """Initialize with a path."""
+        self.file_path = path
+
+    def load(self) -> List[Document]:
+        """Load documents."""
+        ps = list(Path(self.file_path).glob("**/*.md"))
+        docs = []
+        for p in ps:
+            with open(p) as f:
+                text = f.read()
+            metadata = {"source": str(p)}
+            docs.append(Document(page_content=text, metadata=metadata))
+        return docs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/rocksetdb.py

@@ -0,0 +1,122 @@
+from typing import Any, Callable, Iterator, List, Optional, Tuple
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+def default_joiner(docs: List[Tuple[str, Any]]) -> str:
+    """Default joiner for content columns."""
+    return "\n".join([doc[1] for doc in docs])
+
+
+class ColumnNotFoundError(Exception):
+    """Column not found error."""
+
+    def __init__(self, missing_key: str, query: str):
+        super().__init__(f'Column "{missing_key}" not selected in query:\n{query}')
+
+
+class RocksetLoader(BaseLoader):
+    """Load from a `Rockset` database.
+
+    To use, you should have the `rockset` python package installed.
+
+    Example:
+        .. code-block:: python
+
+            # This code will load 3 records from the "langchain_demo"
+            # collection as Documents, with the `text` column used as
+            # the content
+
+            from langchain_community.document_loaders import RocksetLoader
+            from rockset import RocksetClient, Regions, models
+
+            loader = RocksetLoader(
+                RocksetClient(Regions.usw2a1, "<api key>"),
+                models.QueryRequestSql(
+                    query="select * from langchain_demo limit 3"
+                ),
+                ["text"]
+            )
+        )
+    """
+
+    def __init__(
+        self,
+        client: Any,
+        query: Any,
+        content_keys: List[str],
+        metadata_keys: Optional[List[str]] = None,
+        content_columns_joiner: Callable[[List[Tuple[str, Any]]], str] = default_joiner,
+    ):
+        """Initialize with Rockset client.
+
+        Args:
+            client: Rockset client object.
+            query: Rockset query object.
+            content_keys: The collection columns to be written into the `page_content`
+                of the Documents.
+            metadata_keys: The collection columns to be written into the `metadata` of
+                the Documents. By default, this is all the keys in the document.
+            content_columns_joiner: Method that joins content_keys and its values into a
+                string. It's method that takes in a List[Tuple[str, Any]]],
+                representing a list of tuples of (column name, column value).
+                By default, this is a method that joins each column value with a new
+                line. This method is only relevant if there are multiple content_keys.
+        """
+        try:
+            from rockset import QueryPaginator, RocksetClient
+            from rockset.models import QueryRequestSql
+        except ImportError:
+            raise ImportError(
+                "Could not import rockset client python package. "
+                "Please install it with `pip install rockset`."
+            )
+
+        if not isinstance(client, RocksetClient):
+            raise ValueError(
+                f"client should be an instance of rockset.RocksetClient, "
+                f"got {type(client)}"
+            )
+
+        if not isinstance(query, QueryRequestSql):
+            raise ValueError(
+                f"query should be an instance of rockset.model.QueryRequestSql, "
+                f"got {type(query)}"
+            )
+
+        self.client = client
+        self.query = query
+        self.content_keys = content_keys
+        self.content_columns_joiner = content_columns_joiner
+        self.metadata_keys = metadata_keys
+        self.paginator = QueryPaginator
+        self.request_model = QueryRequestSql
+
+        try:
+            self.client.set_application("langchain")
+        except AttributeError:
+            # ignore
+            pass
+
+    def lazy_load(self) -> Iterator[Document]:
+        query_results = self.client.Queries.query(
+            sql=self.query
+        ).results  # execute the SQL query
+        for doc in query_results:  # for each doc in the response
+            try:
+                yield Document(
+                    page_content=self.content_columns_joiner(
+                        [(col, doc[col]) for col in self.content_keys]
+                    ),
+                    metadata={col: doc[col] for col in self.metadata_keys}
+                    if self.metadata_keys is not None
+                    else doc,
+                )  # try to yield the Document
+            except (
+                KeyError
+            ) as e:  # either content_columns or metadata_columns is invalid
+                raise ColumnNotFoundError(
+                    e.args[0], self.query
+                )  # raise that the column isn't in the db schema

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/rspace.py

@@ -0,0 +1,125 @@
+import os
+from typing import Any, Dict, Iterator, List, Optional, Union
+
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_dict_or_env
+
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class RSpaceLoader(BaseLoader):
+    """Load content from RSpace notebooks, folders, documents or PDF Gallery files.
+
+    Map RSpace document <-> Langchain Document in 1-1. PDFs are imported using PyPDF.
+
+    Requirements are rspace_client (`pip install rspace_client`) and PyPDF if importing
+     PDF docs (`pip install pypdf`).
+
+    """
+
+    def __init__(
+        self, global_id: str, api_key: Optional[str] = None, url: Optional[str] = None
+    ):
+        """api_key: RSpace API key - can also be supplied as environment variable
+        'RSPACE_API_KEY'
+        url: str
+        The URL of your RSpace instance - can also be supplied as environment
+        variable 'RSPACE_URL'
+        global_id: str
+         The global ID of the resource to load,
+        e.g. 'SD12344' (a single document); 'GL12345'(A PDF file in the gallery);
+        'NB4567' (a notebook); 'FL12244' (a folder)
+        """
+        args: Dict[str, Optional[str]] = {
+            "api_key": api_key,
+            "url": url,
+            "global_id": global_id,
+        }
+        verified_args: Dict[str, str] = RSpaceLoader.validate_environment(args)
+        self.api_key = verified_args["api_key"]
+        self.url = verified_args["url"]
+        self.global_id: str = verified_args["global_id"]
+
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that API key and URL exist in environment."""
+        values["api_key"] = get_from_dict_or_env(values, "api_key", "RSPACE_API_KEY")
+        values["url"] = get_from_dict_or_env(values, "url", "RSPACE_URL")
+        if "global_id" not in values or values["global_id"] is None:
+            raise ValueError(
+                "No value supplied for global_id. Please supply an RSpace global ID"
+            )
+        return values
+
+    def _create_rspace_client(self) -> Any:
+        """Create a RSpace client."""
+        try:
+            from rspace_client.eln import eln, field_content
+
+        except ImportError:
+            raise ImportError("You must run `pip install rspace_client`")
+
+        try:
+            eln = eln.ELNClient(self.url, self.api_key)
+            eln.get_status()
+
+        except Exception:
+            raise Exception(
+                f"Unable to initialize client - is url {self.url} or api key  correct?"
+            )
+
+        return eln, field_content.FieldContent
+
+    def _get_doc(self, cli: Any, field_content: Any, d_id: Union[str, int]) -> Document:
+        content = ""
+        doc = cli.get_document(d_id)
+        content += f"<h2>{doc['name']}<h2/>"
+        for f in doc["fields"]:
+            content += f"{f['name']}\n"
+            fc = field_content(f["content"])
+            content += fc.get_text()
+            content += "\n"
+        return Document(
+            metadata={"source": f"rspace: {doc['name']}-{doc['globalId']}"},
+            page_content=content,
+        )
+
+    def _load_structured_doc(self) -> Iterator[Document]:
+        cli, field_content = self._create_rspace_client()
+        yield self._get_doc(cli, field_content, self.global_id)
+
+    def _load_folder_tree(self) -> Iterator[Document]:
+        cli, field_content = self._create_rspace_client()
+        if self.global_id:
+            docs_in_folder = cli.list_folder_tree(
+                folder_id=self.global_id[2:], typesToInclude=["document"]
+            )
+        doc_ids: List[int] = [d["id"] for d in docs_in_folder["records"]]
+        for doc_id in doc_ids:
+            yield self._get_doc(cli, field_content, doc_id)
+
+    def _load_pdf(self) -> Iterator[Document]:
+        cli, field_content = self._create_rspace_client()
+        file_info = cli.get_file_info(self.global_id)
+        _, ext = os.path.splitext(file_info["name"])
+        if ext.lower() == ".pdf":
+            outfile = f"{self.global_id}.pdf"
+            cli.download_file(self.global_id, outfile)
+            pdf_loader = PyPDFLoader(outfile)
+            for pdf in pdf_loader.lazy_load():
+                pdf.metadata["rspace_src"] = self.global_id
+                yield pdf
+
+    def lazy_load(self) -> Iterator[Document]:
+        if self.global_id and "GL" in self.global_id:
+            for d in self._load_pdf():
+                yield d
+        elif self.global_id and "SD" in self.global_id:
+            for d in self._load_structured_doc():
+                yield d
+        elif self.global_id and self.global_id[0:2] in ["FL", "NB"]:
+            for d in self._load_folder_tree():
+                yield d
+        else:
+            raise ValueError("Unknown global ID type")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/rss.py

@@ -0,0 +1,133 @@
+import logging
+from typing import Any, Iterator, List, Optional, Sequence
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.news import NewsURLLoader
+
+logger = logging.getLogger(__name__)
+
+
+class RSSFeedLoader(BaseLoader):
+    """Load news articles from `RSS` feeds using `Unstructured`.
+
+    Args:
+        urls: URLs for RSS feeds to load. Each articles in the feed is loaded into its own document.
+        opml: OPML file to load feed urls from. Only one of urls or opml should be provided.  The value
+        can be a URL string, or OPML markup contents as byte or string.
+        continue_on_failure: If True, continue loading documents even if
+            loading fails for a particular URL.
+        show_progress_bar: If True, use tqdm to show a loading progress bar. Requires
+            tqdm to be installed, ``pip install tqdm``.
+        **newsloader_kwargs: Any additional named arguments to pass to
+            NewsURLLoader.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.document_loaders import RSSFeedLoader
+
+            loader = RSSFeedLoader(
+                urls=["<url-1>", "<url-2>"],
+            )
+            docs = loader.load()
+
+    The loader uses feedparser to parse RSS feeds.  The feedparser library is not installed by default so you should
+    install it if using this loader:
+    https://pythonhosted.org/feedparser/
+
+    If you use OPML, you should also install listparser:
+    https://pythonhosted.org/listparser/
+
+    Finally, newspaper is used to process each article:
+    https://newspaper.readthedocs.io/en/latest/
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        urls: Optional[Sequence[str]] = None,
+        opml: Optional[str] = None,
+        continue_on_failure: bool = True,
+        show_progress_bar: bool = False,
+        **newsloader_kwargs: Any,
+    ) -> None:
+        """Initialize with urls or OPML."""
+        if (urls is None) == (
+            opml is None
+        ):  # This is True if both are None or neither is None
+            raise ValueError(
+                "Provide either the urls or the opml argument, but not both."
+            )
+        self.urls = urls
+        self.opml = opml
+        self.continue_on_failure = continue_on_failure
+        self.show_progress_bar = show_progress_bar
+        self.newsloader_kwargs = newsloader_kwargs
+
+    def load(self) -> List[Document]:
+        iter = self.lazy_load()
+        if self.show_progress_bar:
+            try:
+                from tqdm import tqdm
+            except ImportError as e:
+                raise ImportError(
+                    "Package tqdm must be installed if show_progress_bar=True. "
+                    "Please install with 'pip install tqdm' or set "
+                    "show_progress_bar=False."
+                ) from e
+            iter = tqdm(iter)
+        return list(iter)
+
+    @property
+    def _get_urls(self) -> Sequence[str]:
+        if self.urls:
+            return self.urls
+        try:
+            import listparser
+        except ImportError as e:
+            raise ImportError(
+                "Package listparser must be installed if the opml arg is used. "
+                "Please install with 'pip install listparser' or use the "
+                "urls arg instead."
+            ) from e
+        rss = listparser.parse(self.opml)
+        return [feed.url for feed in rss.feeds]
+
+    def lazy_load(self) -> Iterator[Document]:
+        try:
+            import feedparser
+        except ImportError:
+            raise ImportError(
+                "feedparser package not found, please install it with "
+                "`pip install feedparser`"
+            )
+
+        for url in self._get_urls:
+            try:
+                feed = feedparser.parse(url)
+                if getattr(feed, "bozo", False):
+                    raise ValueError(
+                        f"Error fetching {url}, exception: {feed.bozo_exception}"
+                    )
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error fetching {url}, exception: {e}")
+                    continue
+                else:
+                    raise e
+            try:
+                for entry in feed.entries:
+                    loader = NewsURLLoader(
+                        urls=[entry.link],
+                        **self.newsloader_kwargs,
+                    )
+                    article = loader.load()[0]
+                    article.metadata["feed"] = url
+                    yield article
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error processing entry {entry.link}, exception: {e}")
+                    continue
+                else:
+                    raise e

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/rst.py

@@ -0,0 +1,59 @@
+"""Loads RST files."""
+
+from pathlib import Path
+from typing import Any, List, Union
+
+from langchain_community.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredRSTLoader(UnstructuredFileLoader):
+    """Load `RST` files using `Unstructured`.
+
+    You can run the loader in one of two modes: "single" and "elements".
+    If you use "single" mode, the document will be returned as a single
+    langchain Document object. If you use "elements" mode, the unstructured
+    library will split the document into elements such as Title and NarrativeText.
+    You can pass in additional unstructured kwargs after mode to apply
+    different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredRSTLoader
+
+    loader = UnstructuredRSTLoader(
+        "example.rst", mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://unstructured-io.github.io/unstructured/bricks.html#partition-rst
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        """
+        Initialize with a file path.
+
+        Args:
+            file_path: The path to the file to load.
+            mode: The mode to use for partitioning. See unstructured for details.
+                Defaults to "single".
+            **unstructured_kwargs: Additional keyword arguments to pass
+                to unstructured.
+        """
+        file_path = str(file_path)
+        validate_unstructured_version(min_unstructured_version="0.7.5")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.rst import partition_rst
+
+        return partition_rst(filename=self.file_path, **self.unstructured_kwargs)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/rtf.py

@@ -0,0 +1,59 @@
+"""Loads rich text files."""
+
+from pathlib import Path
+from typing import Any, List, Union
+
+from langchain_community.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredRTFLoader(UnstructuredFileLoader):
+    """Load `RTF` files using `Unstructured`.
+
+    You can run the loader in one of two modes: "single" and "elements".
+    If you use "single" mode, the document will be returned as a single
+    langchain Document object. If you use "elements" mode, the unstructured
+    library will split the document into elements such as Title and NarrativeText.
+    You can pass in additional unstructured kwargs after mode to apply
+    different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredRTFLoader
+
+    loader = UnstructuredRTFLoader(
+        "example.rtf", mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://unstructured-io.github.io/unstructured/bricks.html#partition-rtf
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        """
+        Initialize with a file path.
+
+        Args:
+            file_path: The path to the file to load.
+            mode: The mode to use for partitioning. See unstructured for details.
+                Defaults to "single".
+            **unstructured_kwargs: Additional keyword arguments to pass
+                to unstructured.
+        """
+        file_path = str(file_path)
+        validate_unstructured_version("0.5.12")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.rtf import partition_rtf
+
+        return partition_rtf(filename=self.file_path, **self.unstructured_kwargs)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/s3_directory.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.s3_file import S3FileLoader
+
+if TYPE_CHECKING:
+    import botocore
+
+
+class S3DirectoryLoader(BaseLoader):
+    """Load from `Amazon AWS S3` directory."""
+
+    def __init__(
+        self,
+        bucket: str,
+        prefix: str = "",
+        *,
+        region_name: Optional[str] = None,
+        api_version: Optional[str] = None,
+        use_ssl: Optional[bool] = True,
+        verify: Union[str, bool, None] = None,
+        endpoint_url: Optional[str] = None,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+        aws_session_token: Optional[str] = None,
+        boto_config: Optional[botocore.client.Config] = None,
+    ):
+        """Initialize with bucket and key name.
+
+        :param bucket: The name of the S3 bucket.
+        :param prefix: The prefix of the S3 key. Defaults to "".
+
+        :param region_name: The name of the region associated with the client.
+            A client is associated with a single region.
+
+        :param api_version: The API version to use.  By default, botocore will
+            use the latest API version when creating a client.  You only need
+            to specify this parameter if you want to use a previous API version
+            of the client.
+
+        :param use_ssl: Whether to use SSL.  By default, SSL is used.
+            Note that not all services support non-ssl connections.
+
+        :param verify: Whether to verify SSL certificates.
+            By default SSL certificates are verified.  You can provide the
+            following values:
+
+            * False - do not validate SSL certificates.  SSL will still be
+              used (unless use_ssl is False), but SSL certificates
+              will not be verified.
+            * path/to/cert/bundle.pem - A filename of the CA cert bundle to
+              uses.  You can specify this argument if you want to use a
+              different CA cert bundle than the one used by botocore.
+
+        :param endpoint_url: The complete URL to use for the constructed
+            client.  Normally, botocore will automatically construct the
+            appropriate URL to use when communicating with a service.  You can
+            specify a complete URL (including the "http/https" scheme) to
+            override this behavior.  If this value is provided, then
+            ``use_ssl`` is ignored.
+
+        :param aws_access_key_id: The access key to use when creating
+            the client.  This is entirely optional, and if not provided,
+            the credentials configured for the session will automatically
+            be used.  You only need to provide this argument if you want
+            to override the credentials used for this specific client.
+
+        :param aws_secret_access_key: The secret key to use when creating
+            the client.  Same semantics as aws_access_key_id above.
+
+        :param aws_session_token: The session token to use when creating
+            the client.  Same semantics as aws_access_key_id above.
+
+        :type boto_config: botocore.client.Config
+        :param boto_config: Advanced boto3 client configuration options. If a value
+            is specified in the client config, its value will take precedence
+            over environment variables and configuration values, but not over
+            a value passed explicitly to the method. If a default config
+            object is set on the session, the config object used when creating
+            the client will be the result of calling ``merge()`` on the
+            default config with the config provided to this call.
+        """
+        self.bucket = bucket
+        self.prefix = prefix
+        self.region_name = region_name
+        self.api_version = api_version
+        self.use_ssl = use_ssl
+        self.verify = verify
+        self.endpoint_url = endpoint_url
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_session_token = aws_session_token
+        self.boto_config = boto_config
+
+    def load(self) -> List[Document]:
+        """Load documents."""
+        try:
+            import boto3
+        except ImportError:
+            raise ImportError(
+                "Could not import boto3 python package. "
+                "Please install it with `pip install boto3`."
+            )
+        s3 = boto3.resource(
+            "s3",
+            region_name=self.region_name,
+            api_version=self.api_version,
+            use_ssl=self.use_ssl,
+            verify=self.verify,
+            endpoint_url=self.endpoint_url,
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+            aws_session_token=self.aws_session_token,
+            config=self.boto_config,
+        )
+        bucket = s3.Bucket(self.bucket)
+        docs = []
+        for obj in bucket.objects.filter(Prefix=self.prefix):
+            # Skip directories
+            if obj.size == 0 and obj.key.endswith("/"):
+                continue
+            loader = S3FileLoader(
+                self.bucket,
+                obj.key,
+                region_name=self.region_name,
+                api_version=self.api_version,
+                use_ssl=self.use_ssl,
+                verify=self.verify,
+                endpoint_url=self.endpoint_url,
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                aws_session_token=self.aws_session_token,
+                boto_config=self.boto_config,
+            )
+            docs.extend(loader.load())
+        return docs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/s3_file.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
+
+from langchain_community.document_loaders.unstructured import UnstructuredBaseLoader
+
+if TYPE_CHECKING:
+    import botocore
+
+
+class S3FileLoader(UnstructuredBaseLoader):
+    """Load from `Amazon AWS S3` file."""
+
+    def __init__(
+        self,
+        bucket: str,
+        key: str,
+        *,
+        region_name: Optional[str] = None,
+        api_version: Optional[str] = None,
+        use_ssl: Optional[bool] = True,
+        verify: Union[str, bool, None] = None,
+        endpoint_url: Optional[str] = None,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+        aws_session_token: Optional[str] = None,
+        boto_config: Optional[botocore.client.Config] = None,
+        mode: str = "single",
+        post_processors: Optional[List[Callable]] = None,
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with bucket and key name.
+
+        :param bucket: The name of the S3 bucket.
+        :param key: The key of the S3 object.
+
+        :param region_name: The name of the region associated with the client.
+            A client is associated with a single region.
+
+        :param api_version: The API version to use.  By default, botocore will
+            use the latest API version when creating a client.  You only need
+            to specify this parameter if you want to use a previous API version
+            of the client.
+
+        :param use_ssl: Whether or not to use SSL.  By default, SSL is used.
+            Note that not all services support non-ssl connections.
+
+        :param verify: Whether or not to verify SSL certificates.
+            By default SSL certificates are verified.  You can provide the
+            following values:
+
+            * False - do not validate SSL certificates.  SSL will still be
+              used (unless use_ssl is False), but SSL certificates
+              will not be verified.
+            * path/to/cert/bundle.pem - A filename of the CA cert bundle to
+              uses.  You can specify this argument if you want to use a
+              different CA cert bundle than the one used by botocore.
+
+        :param endpoint_url: The complete URL to use for the constructed
+            client.  Normally, botocore will automatically construct the
+            appropriate URL to use when communicating with a service.  You can
+            specify a complete URL (including the "http/https" scheme) to
+            override this behavior.  If this value is provided, then
+            ``use_ssl`` is ignored.
+
+        :param aws_access_key_id: The access key to use when creating
+            the client.  This is entirely optional, and if not provided,
+            the credentials configured for the session will automatically
+            be used.  You only need to provide this argument if you want
+            to override the credentials used for this specific client.
+
+        :param aws_secret_access_key: The secret key to use when creating
+            the client.  Same semantics as aws_access_key_id above.
+
+        :param aws_session_token: The session token to use when creating
+            the client.  Same semantics as aws_access_key_id above.
+
+        :type boto_config: botocore.client.Config
+        :param boto_config: Advanced boto3 client configuration options. If a value
+            is specified in the client config, its value will take precedence
+            over environment variables and configuration values, but not over
+            a value passed explicitly to the method. If a default config
+            object is set on the session, the config object used when creating
+            the client will be the result of calling ``merge()`` on the
+            default config with the config provided to this call.
+        :param mode: Mode in which to read the file. Valid options are: single,
+            paged and elements.
+        :param post_processors: Post processing functions to be applied to
+            extracted elements.
+        :param **unstructured_kwargs: Arbitrary additional kwargs to pass in when
+            calling `partition`
+        """
+        super().__init__(mode, post_processors, **unstructured_kwargs)
+        self.bucket = bucket
+        self.key = key
+        self.region_name = region_name
+        self.api_version = api_version
+        self.use_ssl = use_ssl
+        self.verify = verify
+        self.endpoint_url = endpoint_url
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_session_token = aws_session_token
+        self.boto_config = boto_config
+
+    def _get_elements(self) -> List:
+        """Get elements."""
+        from unstructured.partition.auto import partition
+
+        try:
+            import boto3
+        except ImportError:
+            raise ImportError(
+                "Could not import `boto3` python package. "
+                "Please install it with `pip install boto3`."
+            )
+        s3 = boto3.client(
+            "s3",
+            region_name=self.region_name,
+            api_version=self.api_version,
+            use_ssl=self.use_ssl,
+            verify=self.verify,
+            endpoint_url=self.endpoint_url,
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+            aws_session_token=self.aws_session_token,
+            config=self.boto_config,
+        )
+        with tempfile.TemporaryDirectory() as temp_dir:
+            file_path = f"{temp_dir}/{self.key}"
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            s3.download_file(self.bucket, self.key, file_path)
+            return partition(filename=file_path, **self.unstructured_kwargs)
+
+    def _get_metadata(self) -> dict:
+        return {"source": f"s3://{self.bucket}/{self.key}"}

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/scrapfly.py

@@ -0,0 +1,70 @@
+"""Scrapfly Web Reader."""
+
+import logging
+from typing import Iterator, List, Literal, Optional
+
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_env
+
+logger = logging.getLogger(__file__)
+
+
+class ScrapflyLoader(BaseLoader):
+    """Turn a url to llm accessible markdown with `Scrapfly.io`.
+
+    For further details, visit: https://scrapfly.io/docs/sdk/python
+    """
+
+    def __init__(
+        self,
+        urls: List[str],
+        *,
+        api_key: Optional[str] = None,
+        scrape_format: Literal["markdown", "text"] = "markdown",
+        scrape_config: Optional[dict] = None,
+        continue_on_failure: bool = True,
+    ) -> None:
+        """Initialize client.
+
+        Args:
+            urls: List of urls to scrape.
+            api_key: The Scrapfly API key. If not specified must have env var
+                SCRAPFLY_API_KEY set.
+            scrape_format: Scrape result format, one or "markdown" or "text".
+            scrape_config: Dictionary of ScrapFly scrape config object.
+            continue_on_failure: Whether to continue if scraping a url fails.
+        """
+        try:
+            from scrapfly import ScrapflyClient
+        except ImportError:
+            raise ImportError(
+                "`scrapfly` package not found, please run `pip install scrapfly-sdk`"
+            )
+        if not urls:
+            raise ValueError("URLs must be provided.")
+        api_key = api_key or get_from_env("api_key", "SCRAPFLY_API_KEY")
+        self.scrapfly = ScrapflyClient(key=api_key)
+        self.urls = urls
+        self.scrape_format = scrape_format
+        self.scrape_config = scrape_config
+        self.continue_on_failure = continue_on_failure
+
+    def lazy_load(self) -> Iterator[Document]:
+        from scrapfly import ScrapeConfig
+
+        scrape_config = self.scrape_config if self.scrape_config is not None else {}
+        for url in self.urls:
+            try:
+                response = self.scrapfly.scrape(
+                    ScrapeConfig(url, format=self.scrape_format, **scrape_config)
+                )
+                yield Document(
+                    page_content=response.scrape_result["content"],
+                    metadata={"url": url},
+                )
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error fetching data from {url}, exception: {e}")
+                else:
+                    raise e

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/scrapingant.py

@@ -0,0 +1,66 @@
+"""ScrapingAnt Web Extractor."""
+
+import logging
+from typing import Iterator, List, Optional
+
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_env
+
+logger = logging.getLogger(__file__)
+
+
+class ScrapingAntLoader(BaseLoader):
+    """Turn an url to LLM accessible markdown with `ScrapingAnt`.
+
+    For further details, visit: https://docs.scrapingant.com/python-client
+    """
+
+    def __init__(
+        self,
+        urls: List[str],
+        *,
+        api_key: Optional[str] = None,
+        scrape_config: Optional[dict] = None,
+        continue_on_failure: bool = True,
+    ) -> None:
+        """Initialize client.
+
+        Args:
+            urls: List of urls to scrape.
+            api_key: The ScrapingAnt API key. If not specified must have env var
+                SCRAPINGANT_API_KEY set.
+            scrape_config: The scraping config from ScrapingAntClient.markdown_request
+            continue_on_failure: Whether to continue if scraping an url fails.
+        """
+        try:
+            from scrapingant_client import ScrapingAntClient
+        except ImportError:
+            raise ImportError(
+                "`scrapingant-client` package not found,"
+                " run `pip install scrapingant-client`"
+            )
+        if not urls:
+            raise ValueError("URLs must be provided.")
+        api_key = api_key or get_from_env("api_key", "SCRAPINGANT_API_KEY")
+        self.client = ScrapingAntClient(token=api_key)
+        self.urls = urls
+        self.scrape_config = scrape_config
+        self.continue_on_failure = continue_on_failure
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Fetch data from ScrapingAnt."""
+
+        scrape_config = self.scrape_config if self.scrape_config is not None else {}
+        for url in self.urls:
+            try:
+                result = self.client.markdown_request(url=url, **scrape_config)
+                yield Document(
+                    page_content=result.markdown,
+                    metadata={"url": result.url},
+                )
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error fetching data from {url}, exception: {e}")
+                else:
+                    raise e

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/sharepoint.py

@@ -0,0 +1,208 @@
+"""Loader that loads data from Sharepoint Document Library"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional
+
+import requests
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+from pydantic import Field
+
+from langchain_community.document_loaders.base_o365 import (
+    O365BaseLoader,
+)
+
+
+class SharePointLoader(O365BaseLoader, BaseLoader):
+    """Load  from `SharePoint`."""
+
+    document_library_id: str = Field(...)
+    """ The ID of the SharePoint document library 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."""
+    folder_id: Optional[str] = None
+    """ The ID of the folder to load data from."""
+    load_auth: Optional[bool] = False
+    """ Whether to load authorization identities."""
+    token_path: Path = Path.home() / ".credentials" / "o365_token.txt"
+    """ The path to the token to make api calls"""
+    load_extended_metadata: Optional[bool] = False
+    """ Whether to load extended metadata. Size, Owner and full_path."""
+
+    @property
+    def _scopes(self) -> List[str]:
+        """Return required scopes.
+        Returns:
+            List[str]: A list of required scopes.
+        """
+        return ["sharepoint", "basic"]
+
+    def lazy_load(self) -> Iterator[Document]:
+        """
+        Load documents lazily. Use this when working at a large scale.
+        Yields:
+            Document: A document object representing the parsed blob.
+        """
+        try:
+            from O365.drive import Drive, Folder
+        except ImportError:
+            raise ImportError(
+                "O365 package not found, please install it with `pip install o365`"
+            )
+        drive = self._auth().storage().get_drive(self.document_library_id)
+        if not isinstance(drive, Drive):
+            raise ValueError(f"There isn't a Drive with id {self.document_library_id}.")
+        if self.folder_path:
+            target_folder = drive.get_item_by_path(self.folder_path)
+            if not isinstance(target_folder, Folder):
+                raise ValueError(f"There isn't a folder with path {self.folder_path}.")
+            for blob in self._load_from_folder(target_folder):
+                file_id = str(blob.metadata.get("id"))
+                if self.load_auth is True:
+                    auth_identities = self.authorized_identities(file_id)
+                if self.load_extended_metadata is True:
+                    extended_metadata = self.get_extended_metadata(file_id)
+                    extended_metadata.update({"source_full_url": target_folder.web_url})
+                for parsed_blob in self._blob_parser.lazy_parse(blob):
+                    if self.load_auth is True:
+                        parsed_blob.metadata["authorized_identities"] = auth_identities
+                    if self.load_extended_metadata is True:
+                        parsed_blob.metadata.update(extended_metadata)
+                    yield parsed_blob
+        if self.folder_id:
+            target_folder = drive.get_item(self.folder_id)
+            if not isinstance(target_folder, Folder):
+                raise ValueError(f"There isn't a folder with path {self.folder_path}.")
+            for blob in self._load_from_folder(target_folder):
+                file_id = str(blob.metadata.get("id"))
+                if self.load_auth is True:
+                    auth_identities = self.authorized_identities(file_id)
+                if self.load_extended_metadata is True:
+                    extended_metadata = self.get_extended_metadata(file_id)
+                    extended_metadata.update({"source_full_url": target_folder.web_url})
+                for parsed_blob in self._blob_parser.lazy_parse(blob):
+                    if self.load_auth is True:
+                        parsed_blob.metadata["authorized_identities"] = auth_identities
+                    if self.load_extended_metadata is True:
+                        parsed_blob.metadata.update(extended_metadata)
+                    yield parsed_blob
+        if self.object_ids:
+            for blob in self._load_from_object_ids(drive, self.object_ids):
+                file_id = str(blob.metadata.get("id"))
+                if self.load_auth is True:
+                    auth_identities = self.authorized_identities(file_id)
+                if self.load_extended_metadata is True:
+                    extended_metadata = self.get_extended_metadata(file_id)
+                for parsed_blob in self._blob_parser.lazy_parse(blob):
+                    if self.load_auth is True:
+                        parsed_blob.metadata["authorized_identities"] = auth_identities
+                    if self.load_extended_metadata is True:
+                        parsed_blob.metadata.update(extended_metadata)
+                    yield parsed_blob
+
+        if not (self.folder_path or self.folder_id or self.object_ids):
+            target_folder = drive.get_root_folder()
+            if not isinstance(target_folder, Folder):
+                raise ValueError("Unable to fetch root folder")
+            for blob in self._load_from_folder(target_folder):
+                file_id = str(blob.metadata.get("id"))
+                if self.load_auth is True:
+                    auth_identities = self.authorized_identities(file_id)
+                if self.load_extended_metadata is True:
+                    extended_metadata = self.get_extended_metadata(file_id)
+                for blob_part in self._blob_parser.lazy_parse(blob):
+                    blob_part.metadata.update(blob.metadata)
+                    if self.load_auth is True:
+                        blob_part.metadata["authorized_identities"] = auth_identities
+                    if self.load_extended_metadata is True:
+                        blob_part.metadata.update(extended_metadata)
+                        blob_part.metadata.update(
+                            {"source_full_url": target_folder.web_url}
+                        )
+                    yield blob_part
+
+    def authorized_identities(self, file_id: str) -> List:
+        """
+        Retrieve the access identities (user/group emails) for a given file.
+        Args:
+            file_id (str): The ID of the file.
+        Returns:
+            List: A list of group names (email addresses) that have
+                  access to the file.
+        """
+        data = self._fetch_access_token()
+        access_token = data.get("access_token")
+        url = (
+            "https://graph.microsoft.com/v1.0/drives"
+            f"/{self.document_library_id}/items/{file_id}/permissions"
+        )
+        headers = {"Authorization": f"Bearer {access_token}"}
+        response = requests.request("GET", url, headers=headers)
+        access_list = response.json()
+
+        group_names = []
+
+        for access_data in access_list.get("value"):
+            if access_data.get("grantedToV2"):
+                site_data = (
+                    (access_data.get("grantedToV2").get("siteUser"))
+                    or (access_data.get("grantedToV2").get("user"))
+                    or (access_data.get("grantedToV2").get("group"))
+                )
+                if site_data:
+                    email = site_data.get("email")
+                    if email:
+                        group_names.append(email)
+        return group_names
+
+    def _fetch_access_token(self) -> Any:
+        """
+        Fetch the access token from the token file.
+        Returns:
+            The access token as a dictionary.
+        """
+        with open(self.token_path, encoding="utf-8") as f:
+            s = f.read()
+        data = json.loads(s)
+        return data
+
+    def get_extended_metadata(self, file_id: str) -> Dict:
+        """
+        Retrieve extended metadata for a file in SharePoint.
+        As of today, following fields are supported in the extended metadata:
+        - size: size of the source file.
+        - owner: display name of the owner of the source file.
+        - full_path: pretty human readable path of the source file.
+        Args:
+            file_id (str): The ID of the file.
+        Returns:
+            `dict` containing the extended metadata of the file, including size, owner,
+                and full path.
+        """
+        data = self._fetch_access_token()
+        access_token = data.get("access_token")
+        url = (
+            "https://graph.microsoft.com/v1.0/drives/"
+            f"{self.document_library_id}/items/{file_id}"
+            "?$select=size,createdBy,parentReference,name"
+        )
+        headers = {"Authorization": f"Bearer {access_token}"}
+        response = requests.request("GET", url, headers=headers)
+        metadata = response.json()
+        staged_metadata = {
+            "size": metadata.get("size", 0),
+            "owner": metadata.get("createdBy", {})
+            .get("user", {})
+            .get("displayName", ""),
+            "full_path": metadata.get("parentReference", {})
+            .get("path", "")
+            .split(":")[-1]
+            + "/"
+            + metadata.get("name", ""),
+        }
+        return staged_metadata

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/sitemap.py

@@ -0,0 +1,236 @@
+import itertools
+import re
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+)
+from urllib.parse import urlparse
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.web_base import WebBaseLoader
+
+
+def _default_parsing_function(content: Any) -> str:
+    return str(content.get_text())
+
+
+def _default_meta_function(meta: dict, _content: Any) -> dict:
+    return {"source": meta["loc"], **meta}
+
+
+def _batch_block(iterable: Iterable, size: int) -> Generator[List[dict], None, None]:
+    it = iter(iterable)
+    while item := list(itertools.islice(it, size)):
+        yield item
+
+
+def _extract_scheme_and_domain(url: str) -> Tuple[str, str]:
+    """Extract the scheme + domain from a given URL.
+
+    Args:
+        url (str): The input URL.
+
+    Returns:
+        return a 2-tuple of scheme and domain
+    """
+    parsed_uri = urlparse(url)
+    return parsed_uri.scheme, parsed_uri.netloc
+
+
+class SitemapLoader(WebBaseLoader):
+    """Load a sitemap and its URLs.
+
+    **Security Note**: This loader can be used to load all URLs specified in a sitemap.
+        If a malicious actor gets access to the sitemap, they could force
+        the server to load URLs from other domains by modifying the sitemap.
+        This could lead to server-side request forgery (SSRF) attacks; e.g.,
+        with the attacker forcing the server to load URLs from internal
+        service endpoints that are not publicly accessible. While the attacker
+        may not immediately gain access to this data, this data could leak
+        into downstream systems (e.g., data loader is used to load data for indexing).
+
+        This loader is a crawler and web crawlers should generally NOT be deployed
+        with network access to any internal servers.
+
+        Control access to who can submit crawling requests and what network access
+        the crawler has.
+
+        By default, the loader will only load URLs from the same domain as the sitemap
+        if the site map is not a local file. This can be disabled by setting
+        restrict_to_same_domain to False (not recommended).
+
+        If the site map is a local file, no such risk mitigation is applied by default.
+
+        Use the filter URLs argument to limit which URLs can be loaded.
+
+        See https://python.langchain.com/docs/security
+    """
+
+    def __init__(
+        self,
+        web_path: str,
+        filter_urls: Optional[List[str]] = None,
+        parsing_function: Optional[Callable] = None,
+        blocksize: Optional[int] = None,
+        blocknum: int = 0,
+        meta_function: Optional[Callable] = None,
+        is_local: bool = False,
+        continue_on_failure: bool = False,
+        restrict_to_same_domain: bool = True,
+        max_depth: int = 10,
+        **kwargs: Any,
+    ):
+        """Initialize with webpage path and optional filter URLs.
+
+        Args:
+            web_path: url of the sitemap. can also be a local path
+            filter_urls: a list of regexes. If specified, only
+                URLS that match one of the filter URLs will be loaded.
+                *WARNING* The filter URLs are interpreted as regular expressions.
+                Remember to escape special characters if you do not want them to be
+                interpreted as regular expression syntax. For example, `.` appears
+                frequently in URLs and should be escaped if you want to match a literal
+                `.` rather than any character.
+                restrict_to_same_domain takes precedence over filter_urls when
+                restrict_to_same_domain is True and the sitemap is not a local file.
+            parsing_function: Function to parse bs4.Soup output
+            blocksize: number of sitemap locations per block
+            blocknum: the number of the block that should be loaded - zero indexed.
+                Default: 0
+            meta_function: Function to parse bs4.Soup output for metadata
+                remember when setting this method to also copy metadata["loc"]
+                to metadata["source"] if you are using this field
+            is_local: whether the sitemap is a local file. Default: False
+            continue_on_failure: whether to continue loading the sitemap if an error
+                occurs loading a url, emitting a warning instead of raising an
+                exception. Setting this to True makes the loader more robust, but also
+                may result in missing data. Default: False
+            restrict_to_same_domain: whether to restrict loading to URLs to the same
+                domain as the sitemap. Attention: This is only applied if the sitemap
+                is not a local file!
+            max_depth: maximum depth to follow sitemap links. Default: 10
+        """
+
+        if blocksize is not None and blocksize < 1:
+            raise ValueError("Sitemap blocksize should be at least 1")
+
+        if blocknum < 0:
+            raise ValueError("Sitemap blocknum can not be lower then 0")
+
+        try:
+            import lxml  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "lxml package not found, please install it with `pip install lxml`"
+            )
+
+        super().__init__(web_paths=[web_path], **kwargs)
+
+        # Define a list of URL patterns (interpreted as regular expressions) that
+        # will be allowed to be loaded.
+        # restrict_to_same_domain takes precedence over filter_urls when
+        # restrict_to_same_domain is True and the sitemap is not a local file.
+        self.allow_url_patterns = filter_urls
+        self.restrict_to_same_domain = restrict_to_same_domain
+        self.parsing_function = parsing_function or _default_parsing_function
+        self.meta_function = meta_function or _default_meta_function
+        self.blocksize = blocksize
+        self.blocknum = blocknum
+        self.is_local = is_local
+        self.continue_on_failure = continue_on_failure
+        self.max_depth = max_depth
+
+    def parse_sitemap(self, soup: Any, *, depth: int = 0) -> List[dict]:
+        """Parse sitemap xml and load into a list of dicts.
+
+        Args:
+            soup: BeautifulSoup object.
+            depth: current depth of the sitemap. Default: 0
+
+        Returns:
+            List of dicts.
+        """
+        if depth >= self.max_depth:
+            return []
+
+        els: List[Dict] = []
+
+        for url in soup.find_all("url"):
+            loc = url.find("loc")
+            if not loc:
+                continue
+
+            # Strip leading and trailing whitespace and newlines
+            loc_text = loc.text.strip()
+
+            if self.restrict_to_same_domain and not self.is_local:
+                if _extract_scheme_and_domain(loc_text) != _extract_scheme_and_domain(
+                    self.web_path
+                ):
+                    continue
+
+            if self.allow_url_patterns and not any(
+                re.match(regexp_pattern, loc_text)
+                for regexp_pattern in self.allow_url_patterns
+            ):
+                continue
+
+            els.append(
+                {
+                    tag: prop.text.strip()
+                    for tag in ["loc", "lastmod", "changefreq", "priority"]
+                    if (prop := url.find(tag))
+                }
+            )
+
+        for sitemap in soup.find_all("sitemap"):
+            loc = sitemap.find("loc")
+            if not loc:
+                continue
+
+            soup_child = self.scrape_all([loc.text], "xml")[0]
+            els.extend(self.parse_sitemap(soup_child, depth=depth + 1))
+        return els
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load sitemap."""
+        if self.is_local:
+            try:
+                import bs4
+            except ImportError:
+                raise ImportError(
+                    "beautifulsoup4 package not found, please install it"
+                    " with `pip install beautifulsoup4`"
+                )
+            fp = open(self.web_path)
+            soup = bs4.BeautifulSoup(fp, "xml")
+        else:
+            soup = self._scrape(self.web_path, parser="xml")
+
+        els = self.parse_sitemap(soup)
+
+        if self.blocksize is not None:
+            elblocks = list(_batch_block(els, self.blocksize))
+            blockcount = len(elblocks)
+            if blockcount - 1 < self.blocknum:
+                raise ValueError(
+                    "Selected sitemap does not contain enough blocks for given blocknum"
+                )
+            else:
+                els = elblocks[self.blocknum]
+
+        results = self.scrape_all([el["loc"].strip() for el in els if "loc" in el])
+
+        for i, result in enumerate(results):
+            yield Document(
+                page_content=self.parsing_function(result),
+                metadata=self.meta_function(els[i], result),
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/slack_directory.py

@@ -0,0 +1,107 @@
+import json
+import zipfile
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class SlackDirectoryLoader(BaseLoader):
+    """Load from a `Slack` directory dump."""
+
+    def __init__(self, zip_path: Union[str, Path], workspace_url: Optional[str] = None):
+        """Initialize the SlackDirectoryLoader.
+
+        Args:
+            zip_path (str): The path to the Slack directory dump zip file.
+            workspace_url (Optional[str]): The Slack workspace URL.
+              Including the URL will turn
+              sources into links. Defaults to None.
+        """
+        self.zip_path = Path(zip_path)
+        self.workspace_url = workspace_url
+        self.channel_id_map = self._get_channel_id_map(self.zip_path)
+
+    @staticmethod
+    def _get_channel_id_map(zip_path: Path) -> Dict[str, str]:
+        """Get a dictionary mapping channel names to their respective IDs."""
+        with zipfile.ZipFile(zip_path, "r") as zip_file:
+            try:
+                with zip_file.open("channels.json", "r") as f:
+                    channels = json.load(f)
+                return {channel["name"]: channel["id"] for channel in channels}
+            except KeyError:
+                return {}
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load and return documents from the Slack directory dump."""
+        with zipfile.ZipFile(self.zip_path, "r") as zip_file:
+            for channel_path in zip_file.namelist():
+                channel_name = Path(channel_path).parent.name
+                if not channel_name:
+                    continue
+                if channel_path.endswith(".json"):
+                    messages = self._read_json(zip_file, channel_path)
+                    for message in messages:
+                        yield self._convert_message_to_document(message, channel_name)
+
+    def _read_json(self, zip_file: zipfile.ZipFile, file_path: str) -> List[dict]:
+        """Read JSON data from a zip subfile."""
+        with zip_file.open(file_path, "r") as f:
+            data = json.load(f)
+        return data
+
+    def _convert_message_to_document(
+        self, message: dict, channel_name: str
+    ) -> Document:
+        """
+        Convert a message to a Document object.
+
+        Args:
+            message (dict): A message in the form of a dictionary.
+            channel_name (str): The name of the channel the message belongs to.
+
+        Returns:
+            Document: A Document object representing the message.
+        """
+        text = message.get("text", "")
+        metadata = self._get_message_metadata(message, channel_name)
+        return Document(
+            page_content=text,
+            metadata=metadata,
+        )
+
+    def _get_message_metadata(self, message: dict, channel_name: str) -> dict:
+        """Create and return metadata for a given message and channel."""
+        timestamp = message.get("ts", "")
+        user = message.get("user", "")
+        source = self._get_message_source(channel_name, user, timestamp)
+        return {
+            "source": source,
+            "channel": channel_name,
+            "timestamp": timestamp,
+            "user": user,
+        }
+
+    def _get_message_source(self, channel_name: str, user: str, timestamp: str) -> str:
+        """
+        Get the message source as a string.
+
+        Args:
+            channel_name (str): The name of the channel the message belongs to.
+            user (str): The user ID who sent the message.
+            timestamp (str): The timestamp of the message.
+
+        Returns:
+            str: The message source.
+        """
+        if self.workspace_url:
+            channel_id = self.channel_id_map.get(channel_name, "")
+            return (
+                f"{self.workspace_url}/archives/{channel_id}"
+                + f"/p{timestamp.replace('.', '')}"
+            )
+        else:
+            return f"{channel_name} - {user} - {timestamp}"

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/snowflake_loader.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class SnowflakeLoader(BaseLoader):
+    """Load from `Snowflake` API.
+
+    Each document represents one row of the result. The `page_content_columns`
+    are written into the `page_content` of the document. The `metadata_columns`
+    are written into the `metadata` of the document. By default, all columns
+    are written into the `page_content` and none into the `metadata`.
+
+    """
+
+    def __init__(
+        self,
+        query: str,
+        user: str,
+        password: str,
+        account: str,
+        warehouse: str,
+        role: str,
+        database: str,
+        schema: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        page_content_columns: Optional[List[str]] = None,
+        metadata_columns: Optional[List[str]] = None,
+    ):
+        """Initialize Snowflake document loader.
+
+        Args:
+            query: The query to run in Snowflake.
+            user: Snowflake user.
+            password: Snowflake password.
+            account: Snowflake account.
+            warehouse: Snowflake warehouse.
+            role: Snowflake role.
+            database: Snowflake database
+            schema: Snowflake schema
+            parameters: Optional. Parameters to pass to the query.
+            page_content_columns: Optional. Columns written to Document `page_content`.
+            metadata_columns: Optional. Columns written to Document `metadata`.
+        """
+        self.query = query
+        self.user = user
+        self.password = password
+        self.account = account
+        self.warehouse = warehouse
+        self.role = role
+        self.database = database
+        self.schema = schema
+        self.parameters = parameters
+        self.page_content_columns = (
+            page_content_columns if page_content_columns is not None else ["*"]
+        )
+        self.metadata_columns = metadata_columns if metadata_columns is not None else []
+
+    def _execute_query(self) -> List[Dict[str, Any]]:
+        try:
+            import snowflake.connector
+        except ImportError as ex:
+            raise ImportError(
+                "Could not import snowflake-connector-python package. "
+                "Please install it with `pip install snowflake-connector-python`."
+            ) from ex
+
+        conn = snowflake.connector.connect(
+            user=self.user,
+            password=self.password,
+            account=self.account,
+            warehouse=self.warehouse,
+            role=self.role,
+            database=self.database,
+            schema=self.schema,
+            parameters=self.parameters,
+        )
+        try:
+            cur = conn.cursor()
+            cur.execute("USE DATABASE " + self.database)
+            cur.execute("USE SCHEMA " + self.schema)
+            cur.execute(self.query, self.parameters)
+            query_result = cur.fetchall()
+            column_names = [column[0] for column in cur.description]
+            query_result = [dict(zip(column_names, row)) for row in query_result]
+        except Exception as e:
+            print(f"An error occurred: {e}")  # noqa: T201
+            query_result = []
+        finally:
+            cur.close()
+        return query_result
+
+    def _get_columns(
+        self, query_result: List[Dict[str, Any]]
+    ) -> Tuple[List[str], List[str]]:
+        page_content_columns = (
+            self.page_content_columns if self.page_content_columns else []
+        )
+        metadata_columns = self.metadata_columns if self.metadata_columns else []
+        if page_content_columns is None and query_result:
+            page_content_columns = list(query_result[0].keys())
+        if metadata_columns is None:
+            metadata_columns = []
+        return page_content_columns or [], metadata_columns
+
+    def lazy_load(self) -> Iterator[Document]:
+        query_result = self._execute_query()
+        if isinstance(query_result, Exception):
+            print(f"An error occurred during the query: {query_result}")  # noqa: T201
+            return []
+        page_content_columns, metadata_columns = self._get_columns(query_result)
+        if "*" in page_content_columns:
+            page_content_columns = list(query_result[0].keys())
+        for row in query_result:
+            page_content = "\n".join(
+                f"{k}: {v}" for k, v in row.items() if k in page_content_columns
+            )
+            metadata = {k: v for k, v in row.items() if k in metadata_columns}
+            doc = Document(page_content=page_content, metadata=metadata)
+            yield doc

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/spider.py

@@ -0,0 +1,94 @@
+from typing import Iterator, Literal, Optional
+
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_env
+
+
+class SpiderLoader(BaseLoader):
+    """Load web pages as Documents using Spider AI.
+
+    Must have the Python package `spider-client` installed and a Spider API key.
+    See https://spider.cloud for more.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        api_key: Optional[str] = None,
+        mode: Literal["scrape", "crawl"] = "scrape",
+        params: Optional[dict] = None,
+    ):
+        """Initialize with API key and URL.
+
+        Args:
+            url: The URL to be processed.
+            api_key: The Spider API key. If not specified, will be read from env
+            var `SPIDER_API_KEY`.
+            mode: The mode to run the loader in. Default is "scrape".
+                 Options include "scrape" (single page) and "crawl" (with deeper
+                 crawling following subpages).
+            params: Additional parameters for the Spider API.
+        """
+        if params is None:
+            params = {
+                "return_format": "markdown",
+                "metadata": True,
+            }  # Using the metadata param slightly slows down the output
+
+        try:
+            from spider import Spider
+        except ImportError:
+            raise ImportError(
+                "`spider` package not found, please run `pip install spider-client`"
+            )
+        if mode not in ("scrape", "crawl"):
+            raise ValueError(
+                f"Unrecognized mode '{mode}'. Expected one of 'scrape', 'crawl'."
+            )
+
+        # Use the environment variable if the API key isn't provided
+        api_key = api_key or get_from_env("api_key", "SPIDER_API_KEY")
+        self.spider = Spider(api_key=api_key)
+        self.url = url
+        self.mode = mode
+        self.params = params
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load documents based on the specified mode."""
+        spider_docs = []
+
+        if self.mode == "scrape":
+            # Scrape a single page
+            response = self.spider.scrape_url(self.url, params=self.params)
+            if response:
+                spider_docs.append(response)
+        elif self.mode == "crawl":
+            # Crawl multiple pages
+            response = self.spider.crawl_url(self.url, params=self.params)
+            if response:
+                spider_docs.extend(response)
+
+        for doc in spider_docs:
+            if self.mode == "scrape":
+                # Ensure page_content is also not None
+                page_content = doc[0].get("content", "")
+
+                # Ensure metadata is also not None
+                metadata = doc[0].get("metadata", {})
+
+                if page_content is not None:
+                    yield Document(page_content=page_content, metadata=metadata)
+            if self.mode == "crawl":
+                # Ensure page_content is also not None
+                page_content = doc.get("content", "")
+
+                # Ensure metadata is also not None
+                metadata = doc.get("metadata", {})
+
+                if page_content is not None:
+                    yield Document(
+                        page_content=page_content,
+                        metadata=metadata,
+                    )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/spreedly.py

@@ -0,0 +1,55 @@
+import json
+import urllib.request
+from typing import List
+
+from langchain_core.documents import Document
+from langchain_core.utils import stringify_dict
+
+from langchain_community.document_loaders.base import BaseLoader
+
+SPREEDLY_ENDPOINTS = {
+    "gateways_options": "https://core.spreedly.com/v1/gateways_options.json",
+    "gateways": "https://core.spreedly.com/v1/gateways.json",
+    "receivers_options": "https://core.spreedly.com/v1/receivers_options.json",
+    "receivers": "https://core.spreedly.com/v1/receivers.json",
+    "payment_methods": "https://core.spreedly.com/v1/payment_methods.json",
+    "certificates": "https://core.spreedly.com/v1/certificates.json",
+    "transactions": "https://core.spreedly.com/v1/transactions.json",
+    "environments": "https://core.spreedly.com/v1/environments.json",
+}
+
+
+class SpreedlyLoader(BaseLoader):
+    """Load from `Spreedly` API."""
+
+    def __init__(self, access_token: str, resource: str) -> None:
+        """Initialize with an access token and a resource.
+
+        Args:
+            access_token: The access token.
+            resource: The resource.
+        """
+        self.access_token = access_token
+        self.resource = resource
+        self.headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Accept": "application/json",
+        }
+
+    def _make_request(self, url: str) -> List[Document]:
+        request = urllib.request.Request(url, headers=self.headers)
+
+        with urllib.request.urlopen(request) as response:
+            json_data = json.loads(response.read().decode())
+            text = stringify_dict(json_data)
+            metadata = {"source": url}
+            return [Document(page_content=text, metadata=metadata)]
+
+    def _get_resource(self) -> List[Document]:
+        endpoint = SPREEDLY_ENDPOINTS.get(self.resource)
+        if endpoint is None:
+            return []
+        return self._make_request(endpoint)
+
+    def load(self) -> List[Document]:
+        return self._get_resource()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/sql_database.py

@@ -0,0 +1,137 @@
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Union
+
+from sqlalchemy.engine import RowMapping
+from sqlalchemy.sql.expression import Select
+
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.utilities.sql_database import SQLDatabase
+
+
+class SQLDatabaseLoader(BaseLoader):
+    """
+    Load documents by querying database tables supported by SQLAlchemy.
+
+    For talking to the database, the document loader uses the `SQLDatabase`
+    utility from the LangChain integration toolkit.
+
+    Each document represents one row of the result.
+    """
+
+    def __init__(
+        self,
+        query: Union[str, Select],
+        db: SQLDatabase,
+        *,
+        parameters: Optional[Dict[str, Any]] = None,
+        page_content_mapper: Optional[Callable[..., str]] = None,
+        metadata_mapper: Optional[Callable[..., Dict[str, Any]]] = None,
+        source_columns: Optional[Sequence[str]] = None,
+        include_rownum_into_metadata: bool = False,
+        include_query_into_metadata: bool = False,
+    ):
+        """
+        Args:
+            query: The query to execute.
+            db: A LangChain `SQLDatabase`, wrapping an SQLAlchemy engine.
+            sqlalchemy_kwargs: More keyword arguments for SQLAlchemy's `create_engine`.
+            parameters: Optional. Parameters to pass to the query.
+            page_content_mapper: Optional. Function to convert a row into a string
+              to use as the `page_content` of the document. By default, the loader
+              serializes the whole row into a string, including all columns.
+            metadata_mapper: Optional. Function to convert a row into a dictionary
+              to use as the `metadata` of the document. By default, no columns are
+              selected into the metadata dictionary.
+            source_columns: Optional. The names of the columns to use as the `source`
+              within the metadata dictionary.
+            include_rownum_into_metadata: Optional. Whether to include the row number
+              into the metadata dictionary. Default: False.
+            include_query_into_metadata: Optional. Whether to include the query
+              expression into the metadata dictionary. Default: False.
+        """
+        self.query = query
+        self.db: SQLDatabase = db
+        self.parameters = parameters or {}
+        self.page_content_mapper = (
+            page_content_mapper or self.page_content_default_mapper
+        )
+        self.metadata_mapper = metadata_mapper or self.metadata_default_mapper
+        self.source_columns = source_columns
+        self.include_rownum_into_metadata = include_rownum_into_metadata
+        self.include_query_into_metadata = include_query_into_metadata
+
+    def lazy_load(self) -> Iterator[Document]:
+        try:
+            import sqlalchemy as sa
+        except ImportError:
+            raise ImportError(
+                "Could not import sqlalchemy python package. "
+                "Please install it with `pip install sqlalchemy`."
+            )
+
+        # Querying in `cursor` fetch mode will return an SQLAlchemy `Result` instance.
+        result: sa.Result[Any]
+
+        # Invoke the database query.
+        if isinstance(self.query, sa.SelectBase):
+            result = self.db._execute(  # type: ignore[assignment]
+                self.query, fetch="cursor", parameters=self.parameters
+            )
+            query_sql = str(self.query.compile(bind=self.db._engine))
+        elif isinstance(self.query, str):
+            result = self.db._execute(  # type: ignore[assignment]
+                sa.text(self.query), fetch="cursor", parameters=self.parameters
+            )
+            query_sql = self.query
+        else:
+            raise TypeError(f"Unable to process query of unknown type: {self.query}")
+
+        # Iterate database result rows and generate list of documents.
+        for i, row in enumerate(result.mappings()):
+            page_content = self.page_content_mapper(row)
+            metadata = self.metadata_mapper(row)
+
+            if self.include_rownum_into_metadata:
+                metadata["row"] = i
+            if self.include_query_into_metadata:
+                metadata["query"] = query_sql
+
+            source_values = []
+            for column, value in row.items():
+                if self.source_columns and column in self.source_columns:
+                    source_values.append(value)
+            if source_values:
+                metadata["source"] = ",".join(source_values)
+
+            yield Document(page_content=page_content, metadata=metadata)
+
+    @staticmethod
+    def page_content_default_mapper(
+        row: RowMapping, column_names: Optional[List[str]] = None
+    ) -> str:
+        """
+        A reasonable default function to convert a record into a "page content" string.
+        """
+        if column_names is None:
+            column_names = list(row.keys())
+        return "\n".join(
+            f"{column}: {value}"
+            for column, value in row.items()
+            if column in column_names
+        )
+
+    @staticmethod
+    def metadata_default_mapper(
+        row: RowMapping, column_names: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        A reasonable default function to convert a record into a "metadata" dictionary.
+        """
+        if column_names is None:
+            return {}
+
+        metadata: Dict[str, Any] = {}
+        for column, value in row.items():
+            if column in column_names:
+                metadata[column] = value
+        return metadata

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/srt.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import List, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class SRTLoader(BaseLoader):
+    """Load `.srt` (subtitle) files."""
+
+    def __init__(self, file_path: Union[str, Path]):
+        """Initialize with a file path."""
+        try:
+            import pysrt  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "package `pysrt` not found, please install it with `pip install pysrt`"
+            )
+        self.file_path = str(file_path)
+
+    def load(self) -> List[Document]:
+        """Load using pysrt file."""
+        import pysrt
+
+        parsed_info = pysrt.open(self.file_path)
+        text = " ".join([t.text for t in parsed_info])
+        metadata = {"source": self.file_path}
+        return [Document(page_content=text, metadata=metadata)]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/stripe.py

@@ -0,0 +1,52 @@
+import json
+import urllib.request
+from typing import List, Optional
+
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_env, stringify_dict
+
+from langchain_community.document_loaders.base import BaseLoader
+
+STRIPE_ENDPOINTS = {
+    "balance_transactions": "https://api.stripe.com/v1/balance_transactions",
+    "charges": "https://api.stripe.com/v1/charges",
+    "customers": "https://api.stripe.com/v1/customers",
+    "events": "https://api.stripe.com/v1/events",
+    "refunds": "https://api.stripe.com/v1/refunds",
+    "disputes": "https://api.stripe.com/v1/disputes",
+}
+
+
+class StripeLoader(BaseLoader):
+    """Load from `Stripe` API."""
+
+    def __init__(self, resource: str, access_token: Optional[str] = None) -> None:
+        """Initialize with a resource and an access token.
+
+        Args:
+            resource: The resource.
+            access_token: The access token.
+        """
+        self.resource = resource
+        access_token = access_token or get_from_env(
+            "access_token", "STRIPE_ACCESS_TOKEN"
+        )
+        self.headers = {"Authorization": f"Bearer {access_token}"}
+
+    def _make_request(self, url: str) -> List[Document]:
+        request = urllib.request.Request(url, headers=self.headers)
+
+        with urllib.request.urlopen(request) as response:
+            json_data = json.loads(response.read().decode())
+            text = stringify_dict(json_data)
+            metadata = {"source": url}
+            return [Document(page_content=text, metadata=metadata)]
+
+    def _get_resource(self) -> List[Document]:
+        endpoint = STRIPE_ENDPOINTS.get(self.resource)
+        if endpoint is None:
+            return []
+        return self._make_request(endpoint)
+
+    def load(self) -> List[Document]:
+        return self._get_resource()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/surrealdb.py

@@ -0,0 +1,95 @@
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__name__)
+
+
+class SurrealDBLoader(BaseLoader):
+    """Load SurrealDB documents."""
+
+    def __init__(
+        self,
+        filter_criteria: Optional[Dict] = None,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            from surrealdb import Surreal
+        except ImportError as e:
+            raise ImportError(
+                """Cannot import from surrealdb.
+                please install with `pip install surrealdb`."""
+            ) from e
+
+        self.dburl = kwargs.pop("dburl", "ws://localhost:8000/rpc")
+
+        if self.dburl[0:2] == "ws":
+            self.sdb = Surreal(self.dburl)
+        else:
+            raise ValueError("Only websocket connections are supported at this time.")
+
+        self.filter_criteria = filter_criteria or {}
+
+        if "table" in self.filter_criteria:
+            raise ValueError(
+                "key `table` is not a valid criteria for `filter_criteria` argument."
+            )
+
+        self.ns = kwargs.pop("ns", "langchain")
+        self.db = kwargs.pop("db", "database")
+        self.table = kwargs.pop("table", "documents")
+        self.sdb = Surreal(self.dburl)
+        self.kwargs = kwargs
+
+    async def initialize(self) -> None:
+        """
+        Initialize connection to surrealdb database
+        and authenticate if credentials are provided
+        """
+        await self.sdb.connect()
+        if "db_user" in self.kwargs and "db_pass" in self.kwargs:
+            user = self.kwargs.get("db_user")
+            password = self.kwargs.get("db_pass")
+            await self.sdb.signin({"user": user, "pass": password})
+
+        await self.sdb.use(self.ns, self.db)
+
+    def load(self) -> List[Document]:
+        async def _load() -> List[Document]:
+            await self.initialize()
+            return await self.aload()
+
+        return asyncio.run(_load())
+
+    async def aload(self) -> List[Document]:
+        """Load data into Document objects."""
+
+        query = "SELECT * FROM type::table($table)"
+        if self.filter_criteria is not None and len(self.filter_criteria) > 0:
+            query += " WHERE "
+            for idx, key in enumerate(self.filter_criteria):
+                query += f""" {"AND" if idx > 0 else ""} {key} = ${key}"""
+
+        metadata = {
+            "ns": self.ns,
+            "db": self.db,
+            "table": self.table,
+        }
+        results = await self.sdb.query(
+            query, {"table": self.table, **self.filter_criteria}
+        )
+
+        return [
+            (
+                Document(
+                    page_content=json.dumps(result),
+                    metadata={"id": result["id"], **result["metadata"], **metadata},
+                )
+            )
+            for result in results[0]["result"]
+        ]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/telegram.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from telethon.hints import EntityLike
+
+
+def concatenate_rows(row: dict) -> str:
+    """Combine message information in a readable format ready to be used."""
+    date = row["date"]
+    sender = row["from"]
+    text = row["text"]
+    return f"{sender} on {date}: {text}\n\n"
+
+
+class TelegramChatFileLoader(BaseLoader):
+    """Load from `Telegram chat` dump."""
+
+    def __init__(self, path: Union[str, Path]):
+        """Initialize with a path."""
+        self.file_path = path
+
+    def load(self) -> List[Document]:
+        """Load documents."""
+        p = Path(self.file_path)
+
+        with open(p, encoding="utf8") as f:
+            d = json.load(f)
+
+        text = "".join(
+            concatenate_rows(message)
+            for message in d["messages"]
+            if message["type"] == "message" and isinstance(message["text"], str)
+        )
+        metadata = {"source": str(p)}
+
+        return [Document(page_content=text, metadata=metadata)]
+
+
+def text_to_docs(text: Union[str, List[str]]) -> List[Document]:
+    """Convert a string or list of strings to a list of Documents with metadata."""
+    from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=800,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""],
+        chunk_overlap=20,
+    )
+
+    if isinstance(text, str):
+        # Take a single string as one page
+        text = [text]
+    page_docs = [Document(page_content=page) for page in text]
+
+    # Add page numbers as metadata
+    for i, doc in enumerate(page_docs):
+        doc.metadata["page"] = i + 1
+
+    # Split pages into chunks
+    doc_chunks = []
+
+    for doc in page_docs:
+        chunks = text_splitter.split_text(doc.page_content)
+        for i, chunk in enumerate(chunks):
+            doc = Document(
+                page_content=chunk, metadata={"page": doc.metadata["page"], "chunk": i}
+            )
+            # Add sources a metadata
+            doc.metadata["source"] = f"{doc.metadata['page']}-{doc.metadata['chunk']}"
+            doc_chunks.append(doc)
+    return doc_chunks
+
+
+class TelegramChatApiLoader(BaseLoader):
+    """Load `Telegram` chat json directory dump."""
+
+    def __init__(
+        self,
+        chat_entity: Optional[EntityLike] = None,
+        api_id: Optional[int] = None,
+        api_hash: Optional[str] = None,
+        username: Optional[str] = None,
+        file_path: str = "telegram_data.json",
+    ):
+        """Initialize with API parameters.
+
+        Args:
+            chat_entity: The chat entity to fetch data from.
+            api_id: The API ID.
+            api_hash: The API hash.
+            username: The username.
+            file_path: The file path to save the data to. Defaults to
+                 "telegram_data.json".
+        """
+        self.chat_entity = chat_entity
+        self.api_id = api_id
+        self.api_hash = api_hash
+        self.username = username
+        self.file_path = file_path
+
+    async def fetch_data_from_telegram(self) -> None:
+        """Fetch data from Telegram API and save it as a JSON file."""
+        from telethon.sync import TelegramClient
+
+        data = []
+        async with TelegramClient(self.username, self.api_id, self.api_hash) as client:
+            async for message in client.iter_messages(self.chat_entity):
+                is_reply = message.reply_to is not None
+                reply_to_id = message.reply_to.reply_to_msg_id if is_reply else None
+                data.append(
+                    {
+                        "sender_id": message.sender_id,
+                        "text": message.text,
+                        "date": message.date.isoformat(),
+                        "message.id": message.id,
+                        "is_reply": is_reply,
+                        "reply_to_id": reply_to_id,
+                    }
+                )
+
+        with open(self.file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+    def _get_message_threads(self, data: pd.DataFrame) -> dict:
+        """Create a dictionary of message threads from the given data.
+
+        Args:
+            data (pd.DataFrame): A DataFrame containing the conversation \
+                data with columns:
+                - message.sender_id
+                - text
+                - date
+                - message.id
+                - is_reply
+                - reply_to_id
+
+        Returns:
+            dict: A dictionary where the key is the parent message ID and \
+                the value is a list of message IDs in ascending order.
+        """
+
+        def find_replies(parent_id: int, reply_data: pd.DataFrame) -> List[int]:
+            """
+            Recursively find all replies to a given parent message ID.
+
+            Args:
+                parent_id (int): The parent message ID.
+                reply_data (pd.DataFrame): A DataFrame containing reply messages.
+
+            Returns:
+                list: A list of message IDs that are replies to the parent message ID.
+            """
+            # Find direct replies to the parent message ID
+            direct_replies = reply_data[reply_data["reply_to_id"] == parent_id][
+                "message.id"
+            ].tolist()
+
+            # Recursively find replies to the direct replies
+            all_replies = []
+            for reply_id in direct_replies:
+                all_replies += [reply_id] + find_replies(reply_id, reply_data)
+
+            return all_replies
+
+        # Filter out parent messages
+        parent_messages = data[~data["is_reply"]]
+
+        # Filter out reply messages and drop rows with NaN in 'reply_to_id'
+        reply_messages = data[data["is_reply"]].dropna(subset=["reply_to_id"])
+
+        # Convert 'reply_to_id' to integer
+        reply_messages["reply_to_id"] = reply_messages["reply_to_id"].astype(int)
+
+        # Create a dictionary of message threads with parent message IDs as keys and \
+        # lists of reply message IDs as values
+        message_threads = {
+            parent_id: [parent_id] + find_replies(parent_id, reply_messages)
+            for parent_id in parent_messages["message.id"]
+        }
+
+        return message_threads
+
+    def _combine_message_texts(
+        self, message_threads: Dict[int, List[int]], data: pd.DataFrame
+    ) -> str:
+        """
+        Combine the message texts for each parent message ID based \
+            on the list of message threads.
+
+        Args:
+            message_threads (dict): A dictionary where the key is the parent message \
+                ID and the value is a list of message IDs in ascending order.
+            data (pd.DataFrame): A DataFrame containing the conversation data:
+                - message.sender_id
+                - text
+                - date
+                - message.id
+                - is_reply
+                - reply_to_id
+
+        Returns:
+            str: A combined string of message texts sorted by date.
+        """
+        combined_text = ""
+
+        # Iterate through sorted parent message IDs
+        for parent_id, message_ids in message_threads.items():
+            # Get the message texts for the message IDs and sort them by date
+            message_texts = (
+                data[data["message.id"].isin(message_ids)]
+                .sort_values(by="date")["text"]
+                .tolist()
+            )
+            message_texts = [str(elem) for elem in message_texts]
+
+            # Combine the message texts
+            combined_text += " ".join(message_texts) + ".\n"
+
+        return combined_text.strip()
+
+    def load(self) -> List[Document]:
+        """Load documents."""
+
+        if self.chat_entity is not None:
+            try:
+                import nest_asyncio
+
+                nest_asyncio.apply()
+                asyncio.run(self.fetch_data_from_telegram())
+            except ImportError:
+                raise ImportError(
+                    """`nest_asyncio` package not found.
+                    please install with `pip install nest_asyncio`
+                    """
+                )
+
+        p = Path(self.file_path)
+
+        with open(p, encoding="utf8") as f:
+            d = json.load(f)
+        try:
+            import pandas as pd
+        except ImportError:
+            raise ImportError(
+                """`pandas` package not found. 
+                please install with `pip install pandas`
+                """
+            )
+        normalized_messages = pd.json_normalize(d)
+        df = pd.DataFrame(normalized_messages)
+
+        message_threads = self._get_message_threads(df)
+        combined_texts = self._combine_message_texts(message_threads, df)
+
+        return text_to_docs(combined_texts)
+
+
+# For backwards compatibility
+TelegramChatLoader = TelegramChatFileLoader

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tencent_cos_directory.py

@@ -0,0 +1,47 @@
+from typing import Any, Iterator
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.tencent_cos_file import TencentCOSFileLoader
+
+
+class TencentCOSDirectoryLoader(BaseLoader):
+    """Load from `Tencent Cloud COS` directory."""
+
+    def __init__(self, conf: Any, bucket: str, prefix: str = ""):
+        """Initialize with COS config, bucket and prefix.
+        :param conf(CosConfig): COS config.
+        :param bucket(str): COS bucket.
+        :param prefix(str): prefix.
+        """
+        self.conf = conf
+        self.bucket = bucket
+        self.prefix = prefix
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load documents."""
+        try:
+            from qcloud_cos import CosS3Client
+        except ImportError:
+            raise ImportError(
+                "Could not import cos-python-sdk-v5 python package. "
+                "Please install it with `pip install cos-python-sdk-v5`."
+            )
+        client = CosS3Client(self.conf)
+        contents = []
+        marker = ""
+        while True:
+            response = client.list_objects(
+                Bucket=self.bucket, Prefix=self.prefix, Marker=marker, MaxKeys=1000
+            )
+            if "Contents" in response:
+                contents.extend(response["Contents"])
+            if response["IsTruncated"] == "false":
+                break
+            marker = response["NextMarker"]
+        for content in contents:
+            if content["Key"].endswith("/"):
+                continue
+            loader = TencentCOSFileLoader(self.conf, self.bucket, content["Key"])
+            yield loader.load()[0]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tencent_cos_file.py

@@ -0,0 +1,45 @@
+import os
+import tempfile
+from typing import Any, Iterator
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.unstructured import UnstructuredFileLoader
+
+
+class TencentCOSFileLoader(BaseLoader):
+    """Load from `Tencent Cloud COS` file."""
+
+    def __init__(self, conf: Any, bucket: str, key: str):
+        """Initialize with COS config, bucket and key name.
+        :param conf(CosConfig): COS config.
+        :param bucket(str): COS bucket.
+        :param key(str): COS file key.
+        """
+        self.conf = conf
+        self.bucket = bucket
+        self.key = key
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load documents."""
+        try:
+            from qcloud_cos import CosS3Client
+        except ImportError:
+            raise ImportError(
+                "Could not import cos-python-sdk-v5 python package. "
+                "Please install it with `pip install cos-python-sdk-v5`."
+            )
+
+        # initialize a client
+        client = CosS3Client(self.conf)
+        with tempfile.TemporaryDirectory() as temp_dir:
+            file_path = f"{temp_dir}/{self.bucket}/{self.key}"
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            # Download the file to a destination
+            client.download_file(
+                Bucket=self.bucket, Key=self.key, DestFilePath=file_path
+            )
+            loader = UnstructuredFileLoader(file_path)
+            # UnstructuredFileLoader not implement lazy_load yet
+            return iter(loader.load())

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tensorflow_datasets.py

@@ -0,0 +1,77 @@
+from typing import Callable, Dict, Iterator, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.utilities.tensorflow_datasets import TensorflowDatasets
+
+
+class TensorflowDatasetLoader(BaseLoader):
+    """Load from `TensorFlow Dataset`.
+
+    Attributes:
+        dataset_name: the name of the dataset to load
+        split_name: the name of the split to load.
+        load_max_docs: a limit to the number of loaded documents. Defaults to 100.
+        sample_to_document_function: a function that converts a dataset sample
+          into a Document
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.document_loaders import TensorflowDatasetLoader
+
+            def mlqaen_example_to_document(example: dict) -> Document:
+                return Document(
+                    page_content=decode_to_str(example["context"]),
+                    metadata={
+                        "id": decode_to_str(example["id"]),
+                        "title": decode_to_str(example["title"]),
+                        "question": decode_to_str(example["question"]),
+                        "answer": decode_to_str(example["answers"]["text"][0]),
+                    },
+                )
+
+            tsds_client = TensorflowDatasetLoader(
+                    dataset_name="mlqa/en",
+                    split_name="test",
+                    load_max_docs=100,
+                    sample_to_document_function=mlqaen_example_to_document,
+                )
+
+    """
+
+    def __init__(
+        self,
+        dataset_name: str,
+        split_name: str,
+        load_max_docs: Optional[int] = 100,
+        sample_to_document_function: Optional[Callable[[Dict], Document]] = None,
+    ):
+        """Initialize the TensorflowDatasetLoader.
+
+        Args:
+            dataset_name: the name of the dataset to load
+            split_name: the name of the split to load.
+            load_max_docs: a limit to the number of loaded documents. Defaults to 100.
+            sample_to_document_function: a function that converts a dataset sample
+                into a Document.
+        """
+        self.dataset_name: str = dataset_name
+        self.split_name: str = split_name
+        self.load_max_docs = load_max_docs
+        """The maximum number of documents to load."""
+        self.sample_to_document_function: Optional[Callable[[Dict], Document]] = (
+            sample_to_document_function
+        )
+        """Custom function that transform a dataset sample into a Document."""
+
+        self._tfds_client = TensorflowDatasets(  # type: ignore[call-arg]
+            dataset_name=self.dataset_name,
+            split_name=self.split_name,
+            load_max_docs=self.load_max_docs,  # type: ignore[arg-type]
+            sample_to_document_function=self.sample_to_document_function,
+        )
+
+    def lazy_load(self) -> Iterator[Document]:
+        yield from self._tfds_client.lazy_load()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/text.py

@@ -0,0 +1,61 @@
+import logging
+from pathlib import Path
+from typing import Iterator, Optional, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.helpers import detect_file_encodings
+
+logger = logging.getLogger(__name__)
+
+
+class TextLoader(BaseLoader):
+    """Load text file.
+
+
+    Args:
+        file_path: Path to the file to load.
+
+        encoding: File encoding to use. If `None`, the file will be loaded
+        with the default system encoding.
+
+        autodetect_encoding: Whether to try to autodetect the file encoding
+            if the specified encoding fails.
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        encoding: Optional[str] = None,
+        autodetect_encoding: bool = False,
+    ):
+        """Initialize with file path."""
+        self.file_path = file_path
+        self.encoding = encoding
+        self.autodetect_encoding = autodetect_encoding
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load from file path."""
+        text = ""
+        try:
+            with open(self.file_path, encoding=self.encoding) as f:
+                text = f.read()
+        except UnicodeDecodeError as e:
+            if self.autodetect_encoding:
+                detected_encodings = detect_file_encodings(self.file_path)
+                for encoding in detected_encodings:
+                    logger.debug(f"Trying encoding: {encoding.encoding}")
+                    try:
+                        with open(self.file_path, encoding=encoding.encoding) as f:
+                            text = f.read()
+                        break
+                    except UnicodeDecodeError:
+                        continue
+            else:
+                raise RuntimeError(f"Error loading {self.file_path}") from e
+        except Exception as e:
+            raise RuntimeError(f"Error loading {self.file_path}") from e
+
+        metadata = {"source": str(self.file_path)}
+        yield Document(page_content=text, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tidb.py

@@ -0,0 +1,67 @@
+from typing import Any, Dict, Iterator, List, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class TiDBLoader(BaseLoader):
+    """Load documents from TiDB."""
+
+    def __init__(
+        self,
+        connection_string: str,
+        query: str,
+        page_content_columns: Optional[List[str]] = None,
+        metadata_columns: Optional[List[str]] = None,
+        engine_args: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Initialize TiDB document loader.
+
+        Args:
+            connection_string (str): The connection string for the TiDB database,
+                format: "mysql+pymysql://root@127.0.0.1:4000/test".
+            query: The query to run in TiDB.
+            page_content_columns: Optional. Columns written to Document `page_content`,
+                default(None) to all columns.
+            metadata_columns: Optional. Columns written to Document `metadata`,
+                default(None) to no columns.
+            engine_args: Optional. Additional arguments to pass to sqlalchemy engine.
+        """
+        self.connection_string = connection_string
+        self.query = query
+        self.page_content_columns = page_content_columns
+        self.metadata_columns = metadata_columns if metadata_columns is not None else []
+        self.engine_args = engine_args
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load TiDB data into document objects."""
+
+        from sqlalchemy import create_engine
+        from sqlalchemy.engine import Engine
+        from sqlalchemy.sql import text
+
+        # use sqlalchemy to create db connection
+        engine: Engine = create_engine(
+            self.connection_string, **(self.engine_args or {})
+        )
+
+        # execute query
+        with engine.connect() as conn:
+            result = conn.execute(text(self.query))
+
+            # convert result to Document objects
+            column_names = list(result.keys())
+            for row in result:
+                # convert row to dict{column:value}
+                row_data = {
+                    column_names[index]: value for index, value in enumerate(row)
+                }
+                page_content = "\n".join(
+                    f"{k}: {v}"
+                    for k, v in row_data.items()
+                    if self.page_content_columns is None
+                    or k in self.page_content_columns
+                )
+                metadata = {col: row_data[col] for col in self.metadata_columns}
+                yield Document(page_content=page_content, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tomarkdown.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+import requests
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class ToMarkdownLoader(BaseLoader):
+    """Load `HTML` using `2markdown API`."""
+
+    def __init__(self, url: str, api_key: str):
+        """Initialize with url and api key."""
+        self.url = url
+        self.api_key = api_key
+
+    def lazy_load(
+        self,
+    ) -> Iterator[Document]:
+        """Lazily load the file."""
+        response = requests.post(
+            "https://api.2markdown.com/v1/url2md",
+            headers={"X-Api-Key": self.api_key},
+            json={"url": self.url},
+        )
+        text = response.json()["article"]
+        metadata = {"source": self.url}
+        yield Document(page_content=text, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/toml.py

@@ -0,0 +1,43 @@
+import json
+from pathlib import Path
+from typing import Iterator, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+class TomlLoader(BaseLoader):
+    """Load `TOML` files.
+
+    It can load a single source file or several files in a single
+    directory.
+    """
+
+    def __init__(self, source: Union[str, Path]):
+        """Initialize the TomlLoader with a source file or directory."""
+        self.source = Path(source)
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazily load the TOML documents from the source file or directory."""
+        import tomli
+
+        if self.source.is_file() and self.source.suffix == ".toml":
+            files = [self.source]
+        elif self.source.is_dir():
+            files = list(self.source.glob("**/*.toml"))
+        else:
+            raise ValueError("Invalid source path or file type")
+
+        for file_path in files:
+            with file_path.open("r", encoding="utf-8") as file:
+                content = file.read()
+                try:
+                    data = tomli.loads(content)
+                    doc = Document(
+                        page_content=json.dumps(data),
+                        metadata={"source": str(file_path)},
+                    )
+                    yield doc
+                except tomli.TOMLDecodeError as e:
+                    print(f"Error parsing TOML file {file_path}: {e}")  # noqa: T201

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/trello.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Iterator, Literal, Optional, Tuple
+
+from langchain_core.documents import Document
+from langchain_core.utils import get_from_env
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    from trello import Board, Card, TrelloClient
+
+
+class TrelloLoader(BaseLoader):
+    """Load cards from a `Trello` board."""
+
+    def __init__(
+        self,
+        client: TrelloClient,
+        board_name: str,
+        *,
+        include_card_name: bool = True,
+        include_comments: bool = True,
+        include_checklist: bool = True,
+        card_filter: Literal["closed", "open", "all"] = "all",
+        extra_metadata: Tuple[str, ...] = ("due_date", "labels", "list", "closed"),
+    ):
+        """Initialize Trello loader.
+
+        Args:
+            client: Trello API client.
+            board_name: The name of the Trello board.
+            include_card_name: Whether to include the name of the card in the document.
+            include_comments: Whether to include the comments on the card in the
+                document.
+            include_checklist: Whether to include the checklist on the card in the
+                document.
+            card_filter: Filter on card status. Valid values are "closed", "open",
+                "all".
+            extra_metadata: List of additional metadata fields to include as document
+                metadata.Valid values are "due_date", "labels", "list", "closed".
+
+        """
+        self.client = client
+        self.board_name = board_name
+        self.include_card_name = include_card_name
+        self.include_comments = include_comments
+        self.include_checklist = include_checklist
+        self.extra_metadata = extra_metadata
+        self.card_filter = card_filter
+
+    @classmethod
+    def from_credentials(
+        cls,
+        board_name: str,
+        *,
+        api_key: Optional[str] = None,
+        token: Optional[str] = None,
+        **kwargs: Any,
+    ) -> TrelloLoader:
+        """Convenience constructor that builds TrelloClient init param for you.
+
+        Args:
+            board_name: The name of the Trello board.
+            api_key: Trello API key. Can also be specified as environment variable
+                TRELLO_API_KEY.
+            token: Trello token. Can also be specified as environment variable
+                TRELLO_TOKEN.
+            include_card_name: Whether to include the name of the card in the document.
+            include_comments: Whether to include the comments on the card in the
+                document.
+            include_checklist: Whether to include the checklist on the card in the
+                document.
+            card_filter: Filter on card status. Valid values are "closed", "open",
+                "all".
+            extra_metadata: List of additional metadata fields to include as document
+                metadata.Valid values are "due_date", "labels", "list", "closed".
+        """
+
+        try:
+            from trello import TrelloClient
+        except ImportError as ex:
+            raise ImportError(
+                "Could not import trello python package. "
+                "Please install it with `pip install py-trello`."
+            ) from ex
+        api_key = api_key or get_from_env("api_key", "TRELLO_API_KEY")
+        token = token or get_from_env("token", "TRELLO_TOKEN")
+        client = TrelloClient(api_key=api_key, token=token)
+        return cls(client, board_name, **kwargs)
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Loads all cards from the specified Trello board.
+
+        You can filter the cards, metadata and text included by using the optional
+            parameters.
+
+         Returns:
+            A list of documents, one for each card in the board.
+        """
+        try:
+            from bs4 import BeautifulSoup  # noqa: F401
+        except ImportError as ex:
+            raise ImportError(
+                "`beautifulsoup4` package not found, please run"
+                " `pip install beautifulsoup4`"
+            ) from ex
+
+        board = self._get_board()
+        # Create a dictionary with the list IDs as keys and the list names as values
+        list_dict = {list_item.id: list_item.name for list_item in board.list_lists()}
+        # Get Cards on the board
+        cards = board.get_cards(card_filter=self.card_filter)
+        for card in cards:
+            yield self._card_to_doc(card, list_dict)
+
+    def _get_board(self) -> Board:
+        # Find the first board with a matching name
+        board = next(
+            (b for b in self.client.list_boards() if b.name == self.board_name), None
+        )
+        if not board:
+            raise ValueError(f"Board `{self.board_name}` not found.")
+        return board
+
+    def _card_to_doc(self, card: Card, list_dict: dict) -> Document:
+        from bs4 import BeautifulSoup
+
+        text_content = ""
+        if self.include_card_name:
+            text_content = card.name + "\n"
+        if card.description.strip():
+            text_content += BeautifulSoup(card.description, "lxml").get_text()
+        if self.include_checklist:
+            # Get all the checklist items on the card
+            for checklist in card.checklists:
+                if checklist.items:
+                    items = [
+                        f"{item['name']}:{item['state']}" for item in checklist.items
+                    ]
+                    text_content += f"\n{checklist.name}\n" + "\n".join(items)
+
+        if self.include_comments:
+            # Get all the comments on the card
+            comments = [
+                BeautifulSoup(comment["data"]["text"], "lxml").get_text()
+                for comment in card.comments
+            ]
+            text_content += "Comments:" + "\n".join(comments)
+
+        # Default metadata fields
+        metadata = {
+            "title": card.name,
+            "id": card.id,
+            "url": card.url,
+        }
+
+        # Extra metadata fields. Card object is not subscriptable.
+        if "labels" in self.extra_metadata:
+            metadata["labels"] = [label.name for label in card.labels]
+        if "list" in self.extra_metadata:
+            if card.list_id in list_dict:
+                metadata["list"] = list_dict[card.list_id]
+        if "closed" in self.extra_metadata:
+            metadata["closed"] = card.closed
+        if "due_date" in self.extra_metadata:
+            metadata["due_date"] = card.due_date
+
+        return Document(page_content=text_content, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/tsv.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import Any, List, Union
+
+from langchain_community.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredTSVLoader(UnstructuredFileLoader):
+    """Load `TSV` files using `Unstructured`.
+
+    Like other
+    Unstructured loaders, UnstructuredTSVLoader can be used in both
+    "single" and "elements" mode. If you use the loader in "elements"
+    mode, the TSV file will be a single Unstructured Table element.
+    If you use the loader in "elements" mode, an HTML representation
+    of the table will be available in the "text_as_html" key in the
+    document metadata.
+
+    Examples
+    --------
+    from langchain_community.document_loaders.tsv import UnstructuredTSVLoader
+
+    loader = UnstructuredTSVLoader("stanley-cups.tsv", mode="elements")
+    docs = loader.load()
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        file_path = str(file_path)
+        validate_unstructured_version(min_unstructured_version="0.7.6")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.tsv import partition_tsv
+
+        return partition_tsv(filename=self.file_path, **self.unstructured_kwargs)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/twitter.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Sequence, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    import tweepy
+    from tweepy import OAuth2BearerHandler, OAuthHandler
+
+
+def _dependable_tweepy_import() -> tweepy:
+    try:
+        import tweepy
+    except ImportError:
+        raise ImportError(
+            "tweepy package not found, please install it with `pip install tweepy`"
+        )
+    return tweepy
+
+
+class TwitterTweetLoader(BaseLoader):
+    """Load `Twitter` tweets.
+
+    Read tweets of the user's Twitter handle.
+
+    First you need to go to
+    `https://developer.twitter.com/en/docs/twitter-api
+    /getting-started/getting-access-to-the-twitter-api`
+    to get your token. And create a v2 version of the app.
+    """
+
+    def __init__(
+        self,
+        auth_handler: Union[OAuthHandler, OAuth2BearerHandler],
+        twitter_users: Sequence[str],
+        number_tweets: Optional[int] = 100,
+    ):
+        self.auth = auth_handler
+        self.twitter_users = twitter_users
+        self.number_tweets = number_tweets
+
+    def load(self) -> List[Document]:
+        """Load tweets."""
+        tweepy = _dependable_tweepy_import()
+        api = tweepy.API(self.auth, parser=tweepy.parsers.JSONParser())
+
+        results: List[Document] = []
+        for username in self.twitter_users:
+            tweets = api.user_timeline(screen_name=username, count=self.number_tweets)
+            user = api.get_user(screen_name=username)
+            docs = self._format_tweets(tweets, user)
+            results.extend(docs)
+        return results
+
+    def _format_tweets(
+        self, tweets: List[Dict[str, Any]], user_info: dict
+    ) -> Iterable[Document]:
+        """Format tweets into a string."""
+        for tweet in tweets:
+            metadata = {
+                "created_at": tweet["created_at"],
+                "user_info": user_info,
+            }
+            yield Document(
+                page_content=tweet["text"],
+                metadata=metadata,
+            )
+
+    @classmethod
+    def from_bearer_token(
+        cls,
+        oauth2_bearer_token: str,
+        twitter_users: Sequence[str],
+        number_tweets: Optional[int] = 100,
+    ) -> TwitterTweetLoader:
+        """Create a TwitterTweetLoader from OAuth2 bearer token."""
+        tweepy = _dependable_tweepy_import()
+        auth = tweepy.OAuth2BearerHandler(oauth2_bearer_token)
+        return cls(
+            auth_handler=auth,
+            twitter_users=twitter_users,
+            number_tweets=number_tweets,
+        )
+
+    @classmethod
+    def from_secrets(
+        cls,
+        access_token: str,
+        access_token_secret: str,
+        consumer_key: str,
+        consumer_secret: str,
+        twitter_users: Sequence[str],
+        number_tweets: Optional[int] = 100,
+    ) -> TwitterTweetLoader:
+        """Create a TwitterTweetLoader from access tokens and secrets."""
+        tweepy = _dependable_tweepy_import()
+        auth = tweepy.OAuthHandler(
+            access_token=access_token,
+            access_token_secret=access_token_secret,
+            consumer_key=consumer_key,
+            consumer_secret=consumer_secret,
+        )
+        return cls(
+            auth_handler=auth,
+            twitter_users=twitter_users,
+            number_tweets=number_tweets,
+        )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/unstructured.py

@@ -0,0 +1,509 @@
+"""Loader that uses unstructured to load files."""
+
+from __future__ import annotations
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import IO, Any, Callable, Iterator, List, Optional, Sequence, Union
+
+from langchain_core._api.deprecation import deprecated
+from langchain_core.documents import Document
+from typing_extensions import TypeAlias
+
+from langchain_community.document_loaders.base import BaseLoader
+
+Element: TypeAlias = Any
+
+logger = logging.getLogger(__file__)
+
+
+def satisfies_min_unstructured_version(min_version: str) -> bool:
+    """Check if the installed `Unstructured` version exceeds the minimum version
+    for the feature in question."""
+    from unstructured.__version__ import __version__ as __unstructured_version__
+
+    min_version_tuple = tuple([int(x) for x in min_version.split(".")])
+
+    # NOTE(MthwRobinson) - enables the loader to work when you're using pre-release
+    # versions of unstructured like 0.4.17-dev1
+    _unstructured_version = __unstructured_version__.split("-")[0]
+    unstructured_version_tuple = tuple(
+        [int(x) for x in _unstructured_version.split(".")]
+    )
+
+    return unstructured_version_tuple >= min_version_tuple
+
+
+def validate_unstructured_version(min_unstructured_version: str) -> None:
+    """Raise an error if the `Unstructured` version does not exceed the
+    specified minimum."""
+    if not satisfies_min_unstructured_version(min_unstructured_version):
+        raise ValueError(
+            f"unstructured>={min_unstructured_version} is required in this loader."
+        )
+
+
+class UnstructuredBaseLoader(BaseLoader, ABC):
+    """Base Loader that uses `Unstructured`."""
+
+    def __init__(
+        self,
+        mode: str = "single",  # deprecated
+        post_processors: Optional[List[Callable[[str], str]]] = None,
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+        try:
+            import unstructured  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "unstructured package not found, please install it with "
+                "`pip install unstructured`"
+            )
+
+        # `single` - elements are combined into one (default)
+        # `elements` - maintain individual elements
+        # `paged` - elements are combined by page
+        _valid_modes = {"single", "elements", "paged"}
+        if mode not in _valid_modes:
+            raise ValueError(
+                f"Got {mode} for `mode`, but should be one of `{_valid_modes}`"
+            )
+
+        if not satisfies_min_unstructured_version("0.5.4"):
+            if "strategy" in unstructured_kwargs:
+                unstructured_kwargs.pop("strategy")
+
+        self._check_if_both_mode_and_chunking_strategy_are_by_page(
+            mode, unstructured_kwargs
+        )
+        self.mode = mode
+        self.unstructured_kwargs = unstructured_kwargs
+        self.post_processors = post_processors or []
+
+    @abstractmethod
+    def _get_elements(self) -> List[Element]:
+        """Get elements."""
+
+    @abstractmethod
+    def _get_metadata(self) -> dict[str, Any]:
+        """Get file_path metadata if available."""
+
+    def _post_process_elements(self, elements: List[Element]) -> List[Element]:
+        """Apply post processing functions to extracted unstructured elements.
+
+        Post processing functions are str -> str callables passed
+        in using the post_processors kwarg when the loader is instantiated.
+        """
+        for element in elements:
+            for post_processor in self.post_processors:
+                element.apply(post_processor)
+        return elements
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load file."""
+        elements = self._get_elements()
+        self._post_process_elements(elements)
+        if self.mode == "elements":
+            for element in elements:
+                metadata = self._get_metadata()
+                # NOTE(MthwRobinson) - the attribute check is for backward compatibility
+                # with unstructured<0.4.9. The metadata attributed was added in 0.4.9.
+                if hasattr(element, "metadata"):
+                    metadata.update(element.metadata.to_dict())
+                if hasattr(element, "category"):
+                    metadata["category"] = element.category
+                if element.to_dict().get("element_id"):
+                    metadata["element_id"] = element.to_dict().get("element_id")
+                yield Document(page_content=str(element), metadata=metadata)
+        elif self.mode == "paged":
+            logger.warning(
+                "`mode='paged'` is deprecated in favor of the 'by_page' chunking"
+                " strategy. Learn more about chunking here:"
+                " https://docs.unstructured.io/open-source/core-functionality/chunking"
+            )
+            text_dict: dict[int, str] = {}
+            meta_dict: dict[int, dict[str, Any]] = {}
+
+            for element in elements:
+                metadata = self._get_metadata()
+                if hasattr(element, "metadata"):
+                    metadata.update(element.metadata.to_dict())
+                page_number = metadata.get("page_number", 1)
+
+                # Check if this page_number already exists in text_dict
+                if page_number not in text_dict:
+                    # If not, create new entry with initial text and metadata
+                    text_dict[page_number] = str(element) + "\n\n"
+                    meta_dict[page_number] = metadata
+                else:
+                    # If exists, append to text and update the metadata
+                    text_dict[page_number] += str(element) + "\n\n"
+                    meta_dict[page_number].update(metadata)
+
+            # Convert the dict to a list of Document objects
+            for key in text_dict.keys():
+                yield Document(page_content=text_dict[key], metadata=meta_dict[key])
+        elif self.mode == "single":
+            metadata = self._get_metadata()
+            text = "\n\n".join([str(el) for el in elements])
+            yield Document(page_content=text, metadata=metadata)
+        else:
+            raise ValueError(f"mode of {self.mode} not supported.")
+
+    def _check_if_both_mode_and_chunking_strategy_are_by_page(
+        self, mode: str, unstructured_kwargs: dict[str, Any]
+    ) -> None:
+        if (
+            mode == "paged"
+            and unstructured_kwargs.get("chunking_strategy") == "by_page"
+        ):
+            raise ValueError(
+                "Only one of `chunking_strategy='by_page'` or `mode='paged'` may be"
+                " set. `chunking_strategy` is preferred."
+            )
+
+
+@deprecated(
+    since="0.2.8",
+    removal="1.0",
+    alternative_import="langchain_unstructured.UnstructuredLoader",
+)
+class UnstructuredFileLoader(UnstructuredBaseLoader):
+    """Load files using `Unstructured`.
+
+    The file loader uses the unstructured partition function and will automatically
+    detect the file type. You can run the loader in different modes: "single",
+    "elements", and "paged". The default "single" mode will return a single langchain
+    Document object. If you use "elements" mode, the unstructured library will split
+    the document into elements such as Title and NarrativeText and return those as
+    individual langchain Document objects. In addition to these post-processing modes
+    (which are specific to the LangChain Loaders), Unstructured has its own "chunking"
+    parameters for post-processing elements into more useful chunks for uses cases such
+    as Retrieval Augmented Generation (RAG). You can pass in additional unstructured
+    kwargs to configure different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredFileLoader
+
+    loader = UnstructuredFileLoader(
+        "example.pdf", mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://docs.unstructured.io/open-source/core-functionality/partitioning
+    https://docs.unstructured.io/open-source/core-functionality/chunking
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, List[str], Path, List[Path]],
+        *,
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+        self.file_path = file_path
+
+        super().__init__(mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List[Element]:
+        from unstructured.partition.auto import partition
+
+        if isinstance(self.file_path, list):
+            elements: List[Element] = []
+            for file in self.file_path:
+                if isinstance(file, Path):
+                    file = str(file)
+                elements.extend(partition(filename=file, **self.unstructured_kwargs))
+            return elements
+        else:
+            if isinstance(self.file_path, Path):
+                self.file_path = str(self.file_path)
+            return partition(filename=self.file_path, **self.unstructured_kwargs)
+
+    def _get_metadata(self) -> dict[str, Any]:
+        return {"source": self.file_path}
+
+
+def get_elements_from_api(
+    file_path: Union[str, List[str], Path, List[Path], None] = None,
+    file: Union[IO[bytes], Sequence[IO[bytes]], None] = None,
+    api_url: str = "https://api.unstructuredapp.io/general/v0/general",
+    api_key: str = "",
+    **unstructured_kwargs: Any,
+) -> List[Element]:
+    """Retrieve a list of elements from the `Unstructured API`."""
+    if is_list := isinstance(file_path, list):
+        file_path = [str(path) for path in file_path]
+    if isinstance(file, Sequence) or is_list:
+        from unstructured.partition.api import partition_multiple_via_api
+
+        _doc_elements = partition_multiple_via_api(
+            filenames=file_path,
+            files=file,
+            api_key=api_key,
+            api_url=api_url,
+            **unstructured_kwargs,
+        )
+        elements = []
+        for _elements in _doc_elements:
+            elements.extend(_elements)
+        return elements
+    else:
+        from unstructured.partition.api import partition_via_api
+
+        return partition_via_api(
+            filename=str(file_path) if file_path is not None else None,
+            file=file,
+            api_key=api_key,
+            api_url=api_url,
+            **unstructured_kwargs,
+        )
+
+
+@deprecated(
+    since="0.2.8",
+    removal="1.0",
+    alternative_import="langchain_unstructured.UnstructuredLoader",
+)
+class UnstructuredAPIFileLoader(UnstructuredBaseLoader):
+    """Load files using `Unstructured` API.
+
+    By default, the loader makes a call to the hosted Unstructured API. If you are
+    running the unstructured API locally, you can change the API rule by passing in the
+    url parameter when you initialize the loader. The hosted Unstructured API requires
+    an API key. See the links below to learn more about our API offerings and get an
+    API key.
+
+    You can run the loader in different modes: "single", "elements", and "paged". The
+    default "single" mode will return a single langchain Document object. If you use
+    "elements" mode, the unstructured library will split the document into elements such
+    as Title and NarrativeText and return those as individual langchain Document
+    objects. In addition to these post-processing modes (which are specific to the
+    LangChain Loaders), Unstructured has its own "chunking" parameters for
+    post-processing elements into more useful chunks for uses cases such as Retrieval
+    Augmented Generation (RAG). You can pass in additional unstructured kwargs to
+    configure different unstructured settings.
+
+    Examples
+    ```python
+    from langchain_community.document_loaders import UnstructuredAPIFileLoader
+
+    loader = UnstructuredAPIFileLoader(
+        "example.pdf", mode="elements", strategy="fast", api_key="MY_API_KEY",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://docs.unstructured.io/api-reference/api-services/sdk
+    https://docs.unstructured.io/api-reference/api-services/overview
+    https://docs.unstructured.io/open-source/core-functionality/partitioning
+    https://docs.unstructured.io/open-source/core-functionality/chunking
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, List[str]],
+        *,
+        mode: str = "single",
+        url: str = "https://api.unstructuredapp.io/general/v0/general",
+        api_key: str = "",
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+        validate_unstructured_version(min_unstructured_version="0.10.15")
+
+        self.file_path = file_path
+        self.url = url
+        self.api_key = os.getenv("UNSTRUCTURED_API_KEY") or api_key
+
+        super().__init__(mode=mode, **unstructured_kwargs)
+
+    def _get_metadata(self) -> dict[str, Any]:
+        return {"source": self.file_path}
+
+    def _get_elements(self) -> List[Element]:
+        return get_elements_from_api(
+            file_path=self.file_path,
+            api_key=self.api_key,
+            api_url=self.url,
+            **self.unstructured_kwargs,
+        )
+
+    def _post_process_elements(self, elements: List[Element]) -> List[Element]:
+        """Apply post processing functions to extracted unstructured elements.
+
+        Post processing functions are str -> str callables passed
+        in using the post_processors kwarg when the loader is instantiated.
+        """
+        for element in elements:
+            for post_processor in self.post_processors:
+                element.apply(post_processor)
+        return elements
+
+
+@deprecated(
+    since="0.2.8",
+    removal="1.0",
+    alternative_import="langchain_unstructured.UnstructuredLoader",
+)
+class UnstructuredFileIOLoader(UnstructuredBaseLoader):
+    """Load file-like objects opened in read mode using `Unstructured`.
+
+    The file loader uses the unstructured partition function and will automatically
+    detect the file type. You can run the loader in different modes: "single",
+    "elements", and "paged". The default "single" mode will return a single langchain
+    Document object. If you use "elements" mode, the unstructured library will split
+    the document into elements such as Title and NarrativeText and return those as
+    individual langchain Document objects. In addition to these post-processing modes
+    (which are specific to the LangChain Loaders), Unstructured has its own "chunking"
+    parameters for post-processing elements into more useful chunks for uses cases
+    such as Retrieval Augmented Generation (RAG). You can pass in additional
+    unstructured kwargs to configure different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredFileIOLoader
+
+    with open("example.pdf", "rb") as f:
+        loader = UnstructuredFileIOLoader(
+            f, mode="elements", strategy="fast",
+        )
+        docs = loader.load()
+
+
+    References
+    ----------
+    https://docs.unstructured.io/open-source/core-functionality/partitioning
+    https://docs.unstructured.io/open-source/core-functionality/chunking
+    """
+
+    def __init__(
+        self,
+        file: IO[bytes],
+        *,
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+        self.file = file
+        super().__init__(mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List[Element]:
+        from unstructured.partition.auto import partition
+
+        return partition(file=self.file, **self.unstructured_kwargs)
+
+    def _get_metadata(self) -> dict[str, Any]:
+        return {}
+
+    def _post_process_elements(self, elements: List[Element]) -> List[Element]:
+        """Apply post processing functions to extracted unstructured elements.
+
+        Post processing functions are str -> str callables passed
+        in using the post_processors kwarg when the loader is instantiated.
+        """
+        for element in elements:
+            for post_processor in self.post_processors:
+                element.apply(post_processor)
+        return elements
+
+
+@deprecated(
+    since="0.2.8",
+    removal="1.0",
+    alternative_import="langchain_unstructured.UnstructuredLoader",
+)
+class UnstructuredAPIFileIOLoader(UnstructuredBaseLoader):
+    """Send file-like objects with `unstructured-client` sdk to the Unstructured API.
+
+    By default, the loader makes a call to the hosted Unstructured API. If you are
+    running the unstructured API locally, you can change the API rule by passing in the
+    url parameter when you initialize the loader. The hosted Unstructured API requires
+    an API key. See the links below to learn more about our API offerings and get an
+    API key.
+
+    You can run the loader in different modes: "single", "elements", and "paged". The
+    default "single" mode will return a single langchain Document object. If you use
+    "elements" mode, the unstructured library will split the document into elements
+    such as Title and NarrativeText and return those as individual langchain Document
+    objects. In addition to these post-processing modes (which are specific to the
+    LangChain Loaders), Unstructured has its own "chunking" parameters for
+    post-processing elements into more useful chunks for uses cases such as Retrieval
+    Augmented Generation (RAG). You can pass in additional unstructured kwargs to
+    configure different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredAPIFileLoader
+
+    with open("example.pdf", "rb") as f:
+        loader = UnstructuredAPIFileIOLoader(
+            f, mode="elements", strategy="fast", api_key="MY_API_KEY",
+        )
+        docs = loader.load()
+
+    References
+    ----------
+    https://docs.unstructured.io/api-reference/api-services/sdk
+    https://docs.unstructured.io/api-reference/api-services/overview
+    https://docs.unstructured.io/open-source/core-functionality/partitioning
+    https://docs.unstructured.io/open-source/core-functionality/chunking
+    """
+
+    def __init__(
+        self,
+        file: Union[IO[bytes], Sequence[IO[bytes]]],
+        *,
+        mode: str = "single",
+        url: str = "https://api.unstructuredapp.io/general/v0/general",
+        api_key: str = "",
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+
+        if isinstance(file, Sequence):
+            validate_unstructured_version(min_unstructured_version="0.6.3")
+        validate_unstructured_version(min_unstructured_version="0.6.2")
+
+        self.file = file
+        self.url = url
+        self.api_key = os.getenv("UNSTRUCTURED_API_KEY") or api_key
+
+        super().__init__(mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List[Element]:
+        if self.unstructured_kwargs.get("metadata_filename"):
+            return get_elements_from_api(
+                file=self.file,
+                file_path=self.unstructured_kwargs.pop("metadata_filename"),
+                api_key=self.api_key,
+                api_url=self.url,
+                **self.unstructured_kwargs,
+            )
+        else:
+            raise ValueError(
+                "If partitioning a file via api,"
+                " metadata_filename must be specified as well.",
+            )
+
+    def _get_metadata(self) -> dict[str, Any]:
+        return {}
+
+    def _post_process_elements(self, elements: List[Element]) -> List[Element]:
+        """Apply post processing functions to extracted unstructured elements.
+
+        Post processing functions are str -> str callables passed
+        in using the post_processors kwarg when the loader is instantiated.
+        """
+        for element in elements:
+            for post_processor in self.post_processors:
+                element.apply(post_processor)
+        return elements

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/url.py

@@ -0,0 +1,161 @@
+"""Loader that uses unstructured to load HTML files."""
+
+import logging
+from typing import Any, List
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__name__)
+
+
+class UnstructuredURLLoader(BaseLoader):
+    """Load files from remote URLs using `Unstructured`.
+
+    Use the unstructured partition function to detect the MIME type
+    and route the file to the appropriate partitioner.
+
+    You can run the loader in one of two modes: "single" and "elements".
+    If you use "single" mode, the document will be returned as a single
+    langchain Document object. If you use "elements" mode, the unstructured
+    library will split the document into elements such as Title and NarrativeText.
+    You can pass in additional unstructured kwargs after mode to apply
+    different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredURLLoader
+
+    loader = UnstructuredURLLoader(
+        urls=["<url-1>", "<url-2>"], mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://unstructured-io.github.io/unstructured/bricks.html#partition
+    """
+
+    def __init__(
+        self,
+        urls: List[str],
+        continue_on_failure: bool = True,
+        mode: str = "single",
+        show_progress_bar: bool = False,
+        **unstructured_kwargs: Any,
+    ):
+        """Initialize with file path."""
+        try:
+            import unstructured  # noqa:F401
+            from unstructured.__version__ import __version__ as __unstructured_version__
+
+            self.__version = __unstructured_version__
+        except ImportError:
+            raise ImportError(
+                "unstructured package not found, please install it with "
+                "`pip install unstructured`"
+            )
+
+        self._validate_mode(mode)
+        self.mode = mode
+
+        headers = unstructured_kwargs.pop("headers", {})
+        if len(headers.keys()) != 0:
+            warn_about_headers = False
+            if self.__is_non_html_available():
+                warn_about_headers = not self.__is_headers_available_for_non_html()
+            else:
+                warn_about_headers = not self.__is_headers_available_for_html()
+
+            if warn_about_headers:
+                logger.warning(
+                    "You are using an old version of unstructured. "
+                    "The headers parameter is ignored"
+                )
+
+        self.urls = urls
+        self.continue_on_failure = continue_on_failure
+        self.headers = headers
+        self.unstructured_kwargs = unstructured_kwargs
+        self.show_progress_bar = show_progress_bar
+
+    def _validate_mode(self, mode: str) -> None:
+        _valid_modes = {"single", "elements"}
+        if mode not in _valid_modes:
+            raise ValueError(
+                f"Got {mode} for `mode`, but should be one of `{_valid_modes}`"
+            )
+
+    def __is_headers_available_for_html(self) -> bool:
+        _unstructured_version = self.__version.split("-")[0]
+        unstructured_version = tuple([int(x) for x in _unstructured_version.split(".")])
+
+        return unstructured_version >= (0, 5, 7)
+
+    def __is_headers_available_for_non_html(self) -> bool:
+        _unstructured_version = self.__version.split("-")[0]
+        unstructured_version = tuple([int(x) for x in _unstructured_version.split(".")])
+
+        return unstructured_version >= (0, 5, 13)
+
+    def __is_non_html_available(self) -> bool:
+        _unstructured_version = self.__version.split("-")[0]
+        unstructured_version = tuple([int(x) for x in _unstructured_version.split(".")])
+
+        return unstructured_version >= (0, 5, 12)
+
+    def load(self) -> List[Document]:
+        """Load file."""
+        from unstructured.partition.auto import partition
+        from unstructured.partition.html import partition_html
+
+        docs: List[Document] = list()
+        if self.show_progress_bar:
+            try:
+                from tqdm import tqdm
+            except ImportError as e:
+                raise ImportError(
+                    "Package tqdm must be installed if show_progress_bar=True. "
+                    "Please install with 'pip install tqdm' or set "
+                    "show_progress_bar=False."
+                ) from e
+
+            urls = tqdm(self.urls)
+        else:
+            urls = self.urls
+
+        for url in urls:
+            try:
+                if self.__is_non_html_available():
+                    if self.__is_headers_available_for_non_html():
+                        elements = partition(
+                            url=url, headers=self.headers, **self.unstructured_kwargs
+                        )
+                    else:
+                        elements = partition(url=url, **self.unstructured_kwargs)
+                else:
+                    if self.__is_headers_available_for_html():
+                        elements = partition_html(
+                            url=url, headers=self.headers, **self.unstructured_kwargs
+                        )
+                    else:
+                        elements = partition_html(url=url, **self.unstructured_kwargs)
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error fetching or processing {url}, exception: {e}")
+                    continue
+                else:
+                    raise e
+
+            if self.mode == "single":
+                text = "\n\n".join([str(el) for el in elements])
+                metadata = {"source": url}
+                docs.append(Document(page_content=text, metadata=metadata))
+            elif self.mode == "elements":
+                for element in elements:
+                    metadata = element.metadata.to_dict()
+                    metadata["category"] = element.category
+                    docs.append(Document(page_content=str(element), metadata=metadata))
+
+        return docs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/url_playwright.py

@@ -0,0 +1,264 @@
+"""Loader that uses Playwright to load a page, then uses unstructured to parse html."""
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, AsyncIterator, Dict, Iterator, List, Optional, Union
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+if TYPE_CHECKING:
+    from playwright.async_api import Browser as AsyncBrowser
+    from playwright.async_api import Page as AsyncPage
+    from playwright.async_api import Response as AsyncResponse
+    from playwright.sync_api import Browser, Page, Response
+
+
+logger = logging.getLogger(__name__)
+
+
+class PlaywrightEvaluator(ABC):
+    """Abstract base class for all evaluators.
+
+    Each evaluator should take a page, a browser instance, and a response
+    object, process the page as necessary, and return the resulting text.
+    """
+
+    @abstractmethod
+    def evaluate(self, page: "Page", browser: "Browser", response: "Response") -> str:
+        """Synchronously process the page and return the resulting text.
+
+        Args:
+            page: The page to process.
+            browser: The browser instance.
+            response: The response from page.goto().
+
+        Returns:
+            text: The text content of the page.
+        """
+        pass
+
+    @abstractmethod
+    async def evaluate_async(
+        self, page: "AsyncPage", browser: "AsyncBrowser", response: "AsyncResponse"
+    ) -> str:
+        """Asynchronously process the page and return the resulting text.
+
+        Args:
+            page: The page to process.
+            browser: The browser instance.
+            response: The response from page.goto().
+
+        Returns:
+            text: The text content of the page.
+        """
+        pass
+
+
+class UnstructuredHtmlEvaluator(PlaywrightEvaluator):
+    """Evaluate the page HTML content using the `unstructured` library."""
+
+    def __init__(self, remove_selectors: Optional[List[str]] = None):
+        """Initialize UnstructuredHtmlEvaluator."""
+        try:
+            import unstructured  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "unstructured package not found, please install it with "
+                "`pip install unstructured`"
+            )
+
+        self.remove_selectors = remove_selectors
+
+    def evaluate(self, page: "Page", browser: "Browser", response: "Response") -> str:
+        """Synchronously process the HTML content of the page."""
+        from unstructured.partition.html import partition_html
+
+        for selector in self.remove_selectors or []:
+            elements = page.locator(selector).all()
+            for element in elements:
+                if element.is_visible():
+                    element.evaluate("element => element.remove()")
+
+        page_source = page.content()
+        elements = partition_html(text=page_source)
+        return "\n\n".join([str(el) for el in elements])
+
+    async def evaluate_async(
+        self, page: "AsyncPage", browser: "AsyncBrowser", response: "AsyncResponse"
+    ) -> str:
+        """Asynchronously process the HTML content of the page."""
+        from unstructured.partition.html import partition_html
+
+        for selector in self.remove_selectors or []:
+            elements = await page.locator(selector).all()
+            for element in elements:
+                if await element.is_visible():
+                    await element.evaluate("element => element.remove()")
+
+        page_source = await page.content()
+        elements = partition_html(text=page_source)
+        return "\n\n".join([str(el) for el in elements])
+
+
+class PlaywrightURLLoader(BaseLoader):
+    """Load `HTML` pages with `Playwright` and parse with `Unstructured`.
+
+    This is useful for loading pages that require javascript to render.
+
+    Attributes:
+        urls (List[str]): List of URLs to load.
+        continue_on_failure (bool): If True, continue loading other URLs on failure.
+        headless (bool): If True, the browser will run in headless mode.
+        proxy (Optional[Dict[str, str]]): If set, the browser will access URLs
+            through the specified proxy.
+        browser_session (Optional[Union[str, os.PathLike[str]]]): Path to a file with
+            browser session data that can be used to restore the browser session.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.document_loaders import PlaywrightURLLoader
+
+            urls = ["https://api.ipify.org/?format=json",]
+            proxy={
+                "server": "https://xx.xx.xx:15818", # https://<host>:<port>
+                "username": "username",
+                "password": "password"
+            }
+            loader = PlaywrightURLLoader(urls, proxy=proxy)
+            data = loader.load()
+    """
+
+    def __init__(
+        self,
+        urls: List[str],
+        continue_on_failure: bool = True,
+        headless: bool = True,
+        remove_selectors: Optional[List[str]] = None,
+        evaluator: Optional[PlaywrightEvaluator] = None,
+        proxy: Optional[Dict[str, str]] = None,
+        browser_session: Optional[Union[str, os.PathLike[str]]] = None,
+    ):
+        """Load a list of URLs using Playwright."""
+        try:
+            import playwright  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "playwright package not found, please install it with "
+                "`pip install playwright`"
+            )
+
+        self.urls = urls
+        self.continue_on_failure = continue_on_failure
+        self.headless = headless
+        self.proxy = proxy
+        self.browser_session = browser_session
+
+        if remove_selectors and evaluator:
+            raise ValueError(
+                "`remove_selectors` and `evaluator` cannot be both not None"
+            )
+
+        # Use the provided evaluator, if any, otherwise, use the default.
+        self.evaluator = evaluator or UnstructuredHtmlEvaluator(remove_selectors)
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load the specified URLs using Playwright and create Document instances.
+
+        Returns:
+            A list of Document instances with loaded content.
+        """
+        from playwright.sync_api import sync_playwright
+
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=self.headless, proxy=self.proxy)
+            context = None
+
+            if self.browser_session:
+                if os.path.exists(self.browser_session):
+                    context = browser.new_context(storage_state=self.browser_session)
+                else:
+                    logger.warning(f"Session file not found: {self.browser_session}")
+
+            if context is None:
+                context = browser.new_context()
+
+            for url in self.urls:
+                try:
+                    page = context.new_page()
+                    response = page.goto(url)
+                    if response is None:
+                        raise ValueError(f"page.goto() returned None for url {url}")
+
+                    page.wait_for_load_state("load")
+
+                    text = self.evaluator.evaluate(page, browser, response)
+                    page.close()
+                    metadata = {"source": url}
+                    yield Document(page_content=text, metadata=metadata)
+                except Exception as e:
+                    if self.continue_on_failure:
+                        logger.error(
+                            f"Error fetching or processing {url}, exception: {e}"
+                        )
+                    else:
+                        raise e
+            browser.close()
+
+    async def aload(self) -> List[Document]:
+        """Load the specified URLs with Playwright and create Documents asynchronously.
+        Use this function when in a jupyter notebook environment.
+
+        Returns:
+            A list of Document instances with loaded content.
+        """
+        return [doc async for doc in self.alazy_load()]
+
+    async def alazy_load(self) -> AsyncIterator[Document]:
+        """Load the specified URLs with Playwright and create Documents asynchronously.
+        Use this function when in a jupyter notebook environment.
+
+        Returns:
+            A list of Document instances with loaded content.
+        """
+        from playwright.async_api import async_playwright
+
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=self.headless, proxy=self.proxy)
+            context = None
+
+            if self.browser_session:
+                if os.path.exists(self.browser_session):
+                    context = await browser.new_context(
+                        storage_state=self.browser_session
+                    )
+                else:
+                    logger.warning(f"Session file not found: {self.browser_session}")
+
+            if context is None:
+                context = await browser.new_context()
+
+            for url in self.urls:
+                try:
+                    page = await context.new_page()
+                    response = await page.goto(url)
+                    if response is None:
+                        raise ValueError(f"page.goto() returned None for url {url}")
+
+                    await page.wait_for_load_state("load")
+
+                    text = await self.evaluator.evaluate_async(page, browser, response)
+                    await page.close()
+                    metadata = {"source": url}
+                    yield Document(page_content=text, metadata=metadata)
+                except Exception as e:
+                    if self.continue_on_failure:
+                        logger.error(
+                            f"Error fetching or processing {url}, exception: {e}"
+                        )
+                    else:
+                        raise e
+            await browser.close()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/url_selenium.py

@@ -0,0 +1,176 @@
+"""Loader that uses Selenium to load a page, then uses unstructured to load the html."""
+
+import logging
+from typing import TYPE_CHECKING, List, Literal, Optional, Union
+
+if TYPE_CHECKING:
+    from selenium.webdriver import Chrome, Firefox
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+logger = logging.getLogger(__name__)
+
+
+class SeleniumURLLoader(BaseLoader):
+    """Load `HTML` pages with `Selenium` and parse with `Unstructured`.
+
+    This is useful for loading pages that require javascript to render.
+
+    Attributes:
+        urls (List[str]): List of URLs to load.
+        continue_on_failure (bool): If True, continue loading other URLs on failure.
+        browser (str): The browser to use, either 'chrome' or 'firefox'.
+        binary_location (Optional[str]): The location of the browser binary.
+        executable_path (Optional[str]): The path to the browser executable.
+        headless (bool): If True, the browser will run in headless mode.
+        arguments [List[str]]: List of arguments to pass to the browser.
+    """
+
+    def __init__(
+        self,
+        urls: List[str],
+        continue_on_failure: bool = True,
+        browser: Literal["chrome", "firefox"] = "chrome",
+        binary_location: Optional[str] = None,
+        executable_path: Optional[str] = None,
+        headless: bool = True,
+        arguments: List[str] = [],
+    ):
+        """Load a list of URLs using Selenium and unstructured."""
+        try:
+            import selenium  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "selenium package not found, please install it with "
+                "`pip install selenium`"
+            )
+
+        try:
+            import unstructured  # noqa:F401
+        except ImportError:
+            raise ImportError(
+                "unstructured package not found, please install it with "
+                "`pip install unstructured`"
+            )
+
+        self.urls = urls
+        self.continue_on_failure = continue_on_failure
+        self.browser = browser
+        self.binary_location = binary_location
+        self.executable_path = executable_path
+        self.headless = headless
+        self.arguments = arguments
+
+    def _get_driver(self) -> Union["Chrome", "Firefox"]:
+        """Create and return a WebDriver instance based on the specified browser.
+
+        Raises:
+            ValueError: If an invalid browser is specified.
+
+        Returns:
+            Union[Chrome, Firefox]: A WebDriver instance for the specified browser.
+        """
+        if self.browser.lower() == "chrome":
+            from selenium.webdriver import Chrome
+            from selenium.webdriver.chrome.options import Options as ChromeOptions
+            from selenium.webdriver.chrome.service import Service
+
+            chrome_options = ChromeOptions()
+
+            for arg in self.arguments:
+                chrome_options.add_argument(arg)
+
+            if self.headless:
+                chrome_options.add_argument("--headless")
+                chrome_options.add_argument("--no-sandbox")
+            if self.binary_location is not None:
+                chrome_options.binary_location = self.binary_location
+            if self.executable_path is None:
+                return Chrome(options=chrome_options)
+            return Chrome(
+                options=chrome_options,
+                service=Service(executable_path=self.executable_path),
+            )
+        elif self.browser.lower() == "firefox":
+            from selenium.webdriver import Firefox
+            from selenium.webdriver.firefox.options import Options as FirefoxOptions
+            from selenium.webdriver.firefox.service import Service
+
+            firefox_options = FirefoxOptions()
+
+            for arg in self.arguments:
+                firefox_options.add_argument(arg)
+
+            if self.headless:
+                firefox_options.add_argument("--headless")
+            if self.binary_location is not None:
+                firefox_options.binary_location = self.binary_location
+            if self.executable_path is None:
+                return Firefox(options=firefox_options)
+            return Firefox(
+                options=firefox_options,
+                service=Service(executable_path=self.executable_path),
+            )
+        else:
+            raise ValueError("Invalid browser specified. Use 'chrome' or 'firefox'.")
+
+    def _build_metadata(self, url: str, driver: Union["Chrome", "Firefox"]) -> dict:
+        from selenium.common.exceptions import NoSuchElementException
+        from selenium.webdriver.common.by import By
+
+        """Build metadata based on the contents of the webpage"""
+        metadata = {
+            "source": url,
+            "title": "No title found.",
+            "description": "No description found.",
+            "language": "No language found.",
+        }
+        if title := driver.title:
+            metadata["title"] = title
+        try:
+            if description := driver.find_element(
+                By.XPATH, '//meta[@name="description"]'
+            ):
+                metadata["description"] = (
+                    description.get_attribute("content") or "No description found."
+                )
+        except NoSuchElementException:
+            pass
+        try:
+            if html_tag := driver.find_element(By.TAG_NAME, "html"):
+                metadata["language"] = (
+                    html_tag.get_attribute("lang") or "No language found."
+                )
+        except NoSuchElementException:
+            pass
+        return metadata
+
+    def load(self) -> List[Document]:
+        """Load the specified URLs using Selenium and create Document instances.
+
+        Returns:
+            List[Document]: A list of Document instances with loaded content.
+        """
+        from unstructured.partition.html import partition_html
+
+        docs: List[Document] = list()
+        driver = self._get_driver()
+
+        for url in self.urls:
+            try:
+                driver.get(url)
+                page_content = driver.page_source
+                elements = partition_html(text=page_content)
+                text = "\n\n".join([str(el) for el in elements])
+                metadata = self._build_metadata(url, driver)
+                docs.append(Document(page_content=text, metadata=metadata))
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.error(f"Error fetching or processing {url}, exception: {e}")
+                else:
+                    raise e
+
+        driver.quit()
+        return docs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/vsdx.py

@@ -0,0 +1,54 @@
+import os
+import tempfile
+from abc import ABC
+from pathlib import Path
+from typing import List, Union
+from urllib.parse import urlparse
+
+import requests
+
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.blob_loaders import Blob
+from langchain_community.document_loaders.parsers import VsdxParser
+
+
+class VsdxLoader(BaseLoader, ABC):
+    def __init__(self, file_path: Union[str, Path]):
+        """Initialize with file path."""
+        self.file_path = str(file_path)
+        if "~" in self.file_path:
+            self.file_path = os.path.expanduser(self.file_path)
+
+        # If the file is a web path, download it to a temporary file, and use that
+        if not os.path.isfile(self.file_path) and self._is_valid_url(self.file_path):
+            r = requests.get(self.file_path)
+
+            if r.status_code != 200:
+                raise ValueError(
+                    "Check the url of your file; returned status code %s"
+                    % r.status_code
+                )
+
+            self.web_path = self.file_path
+            self.temp_file = tempfile.NamedTemporaryFile()
+            self.temp_file.write(r.content)
+            self.file_path = self.temp_file.name
+        elif not os.path.isfile(self.file_path):
+            raise ValueError("File path %s is not a valid file or url" % self.file_path)
+
+        self.parser = VsdxParser()
+
+    def __del__(self) -> None:
+        if hasattr(self, "temp_file"):
+            self.temp_file.close()
+
+    @staticmethod
+    def _is_valid_url(url: str) -> bool:
+        """Check if the url is valid."""
+        parsed = urlparse(url)
+        return bool(parsed.netloc) and bool(parsed.scheme)
+
+    def load(self) -> List[Document]:
+        blob = Blob.from_path(self.file_path)
+        return list(self.parser.parse(blob))

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/weather.py

@@ -0,0 +1,46 @@
+"""Simple reader that reads weather data from OpenWeatherMap API"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterator, Optional, Sequence
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.utilities.openweathermap import OpenWeatherMapAPIWrapper
+
+
+class WeatherDataLoader(BaseLoader):
+    """Load weather data with `Open Weather Map` API.
+
+    Reads the forecast & current weather of any location using OpenWeatherMap's free
+    API. Checkout 'https://openweathermap.org/appid' for more on how to generate a free
+    OpenWeatherMap API.
+    """
+
+    def __init__(
+        self,
+        client: OpenWeatherMapAPIWrapper,
+        places: Sequence[str],
+    ) -> None:
+        """Initialize with parameters."""
+        super().__init__()
+        self.client = client
+        self.places = places
+
+    @classmethod
+    def from_params(
+        cls, places: Sequence[str], *, openweathermap_api_key: Optional[str] = None
+    ) -> WeatherDataLoader:
+        client = OpenWeatherMapAPIWrapper(openweathermap_api_key=openweathermap_api_key)
+        return cls(client, places)
+
+    def lazy_load(
+        self,
+    ) -> Iterator[Document]:
+        """Lazily load weather data for the given locations."""
+        for place in self.places:
+            metadata = {"queried_at": datetime.now()}
+            content = self.client.run(place)
+            yield Document(page_content=content, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/web_base.py

@@ -0,0 +1,406 @@
+"""Web base loader class."""
+
+import asyncio
+import logging
+import warnings
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Sequence, Union
+
+import aiohttp
+import requests
+from langchain_core._api import deprecated
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.utils.user_agent import get_user_agent
+
+logger = logging.getLogger(__name__)
+
+default_header_template = {
+    "User-Agent": get_user_agent(),
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*"
+    ";q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Referer": "https://www.google.com/",
+    "DNT": "1",
+    "Connection": "keep-alive",
+    "Upgrade-Insecure-Requests": "1",
+}
+
+
+def _build_metadata(soup: Any, url: str) -> dict:
+    """Build metadata from BeautifulSoup output."""
+    metadata = {"source": url}
+    if title := soup.find("title"):
+        metadata["title"] = title.get_text()
+    if description := soup.find("meta", attrs={"name": "description"}):
+        metadata["description"] = description.get("content", "No description found.")
+    if html := soup.find("html"):
+        metadata["language"] = html.get("lang", "No language found.")
+    return metadata
+
+
+class WebBaseLoader(BaseLoader):
+    """
+    WebBaseLoader document loader integration
+
+    Setup:
+        Install ``langchain_community``.
+
+        .. code-block:: bash
+
+            pip install -U langchain_community
+
+    Instantiate:
+        .. code-block:: python
+
+            from langchain_community.document_loaders import WebBaseLoader
+
+            loader = WebBaseLoader(
+                web_path = "https://www.espn.com/"
+                # header_template = None,
+                # verify_ssl = True,
+                # proxies = None,
+                # continue_on_failure = False,
+                # autoset_encoding = True,
+                # encoding = None,
+                # web_paths = (),
+                # requests_per_second = 2,
+                # default_parser = "html.parser",
+                # requests_kwargs = None,
+                # raise_for_status = False,
+                # bs_get_text_kwargs = None,
+                # bs_kwargs = None,
+                # session = None,
+                # show_progress = True,
+                # trust_env = False,
+            )
+
+    Lazy load:
+        .. code-block:: python
+
+            docs = []
+            for doc in loader.lazy_load():
+                docs.append(doc)
+            print(docs[0].page_content[:100])
+            print(docs[0].metadata)
+
+        .. code-block:: python
+
+            ESPN - Serving Sports Fans. Anytime. Anywhere.
+
+            {'source': 'https://www.espn.com/', 'title': 'ESPN - Serving Sports Fans. Anytime. Anywhere.', 'description': 'Visit ESPN for live scores, highlights and sports news. Stream exclusive games on ESPN+ and play fantasy sports.', 'language': 'en'}
+
+
+    Async load:
+        .. code-block:: python
+
+            docs = []
+            async for doc in loader.alazy_load():
+                docs.append(doc)
+            print(docs[0].page_content[:100])
+            print(docs[0].metadata)
+
+        .. code-block:: python
+
+            ESPN - Serving Sports Fans. Anytime. Anywhere.
+
+            {'source': 'https://www.espn.com/', 'title': 'ESPN - Serving Sports Fans. Anytime. Anywhere.', 'description': 'Visit ESPN for live scores, highlights and sports news. Stream exclusive games on ESPN+ and play fantasy sports.', 'language': 'en'}
+
+    .. versionchanged:: 0.3.14
+
+        Deprecated ``aload`` (which was not async) and implemented a native async
+        ``alazy_load``. Expand below for more details.
+
+        .. dropdown:: How to update ``aload``
+
+            Instead of using ``aload``, you can use ``load`` for synchronous loading or
+            ``alazy_load`` for asynchronous lazy loading.
+
+            Example using ``load`` (synchronous):
+
+            .. code-block:: python
+
+                docs: List[Document] = loader.load()
+
+            Example using ``alazy_load`` (asynchronous):
+
+            .. code-block:: python
+
+                docs: List[Document] = []
+                async for doc in loader.alazy_load():
+                    docs.append(doc)
+
+            This is in preparation for accommodating an asynchronous ``aload`` in the
+            future:
+
+            .. code-block:: python
+
+                docs: List[Document] = await loader.aload()
+
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        web_path: Union[str, Sequence[str]] = "",
+        header_template: Optional[dict] = None,
+        verify_ssl: bool = True,
+        proxies: Optional[dict] = None,
+        continue_on_failure: bool = False,
+        autoset_encoding: bool = True,
+        encoding: Optional[str] = None,
+        web_paths: Sequence[str] = (),
+        requests_per_second: int = 2,
+        default_parser: str = "html.parser",
+        requests_kwargs: Optional[Dict[str, Any]] = None,
+        raise_for_status: bool = False,
+        bs_get_text_kwargs: Optional[Dict[str, Any]] = None,
+        bs_kwargs: Optional[Dict[str, Any]] = None,
+        session: Any = None,
+        *,
+        show_progress: bool = True,
+        trust_env: bool = False,
+    ) -> None:
+        """Initialize loader.
+
+        Args:
+            web_paths: Web paths to load from.
+            requests_per_second: Max number of concurrent requests to make.
+            default_parser: Default parser to use for BeautifulSoup.
+            requests_kwargs: kwargs for requests
+            raise_for_status: Raise an exception if http status code denotes an error.
+            bs_get_text_kwargs: kwargs for beatifulsoup4 get_text
+            bs_kwargs: kwargs for beatifulsoup4 web page parsing
+            show_progress: Show progress bar when loading pages.
+            trust_env: set to True if using proxy to make web requests, for example
+                using http(s)_proxy environment variables. Defaults to False.
+        """
+        # web_path kept for backwards-compatibility.
+        if web_path and web_paths:
+            raise ValueError(
+                "Received web_path and web_paths. Only one can be specified. "
+                "web_path is deprecated, web_paths should be used."
+            )
+        if web_paths:
+            self.web_paths = list(web_paths)
+        elif isinstance(web_path, str):
+            self.web_paths = [web_path]
+        elif isinstance(web_path, Sequence):
+            self.web_paths = list(web_path)
+        else:
+            raise TypeError(
+                f"web_path must be str or Sequence[str] got ({type(web_path)}) or"
+                f" web_paths must be Sequence[str] got ({type(web_paths)})"
+            )
+        self.requests_per_second = requests_per_second
+        self.default_parser = default_parser
+        self.requests_kwargs = requests_kwargs or {}
+        self.raise_for_status = raise_for_status
+        self.show_progress = show_progress
+        self.bs_get_text_kwargs = bs_get_text_kwargs or {}
+        self.bs_kwargs = bs_kwargs or {}
+        if session:
+            self.session = session
+        else:
+            session = requests.Session()
+            header_template = header_template or default_header_template.copy()
+            if not header_template.get("User-Agent"):
+                try:
+                    from fake_useragent import UserAgent
+
+                    header_template["User-Agent"] = UserAgent().random
+                except ImportError:
+                    logger.info(
+                        "fake_useragent not found, using default user agent."
+                        "To get a realistic header for requests, "
+                        "`pip install fake_useragent`."
+                    )
+            session.headers = dict(header_template)
+            session.verify = verify_ssl
+            if proxies:
+                session.proxies.update(proxies)
+            self.session = session
+        self.continue_on_failure = continue_on_failure
+        self.autoset_encoding = autoset_encoding
+        self.encoding = encoding
+        self.trust_env = trust_env
+
+    @property
+    def web_path(self) -> str:
+        if len(self.web_paths) > 1:
+            raise ValueError("Multiple webpaths found.")
+        return self.web_paths[0]
+
+    async def _fetch(
+        self, url: str, retries: int = 3, cooldown: int = 2, backoff: float = 1.5
+    ) -> str:
+        async with aiohttp.ClientSession(trust_env=self.trust_env) as session:
+            for i in range(retries):
+                try:
+                    kwargs: Dict = dict(
+                        headers=self.session.headers,
+                        cookies=self.session.cookies.get_dict(),
+                    )
+                    if not self.session.verify:
+                        kwargs["ssl"] = False
+
+                    async with session.get(
+                        url, **(self.requests_kwargs | kwargs)
+                    ) as response:
+                        if self.raise_for_status:
+                            response.raise_for_status()
+                        return await response.text()
+                except aiohttp.ClientConnectionError as e:
+                    if i == retries - 1:
+                        raise
+                    else:
+                        logger.warning(
+                            f"Error fetching {url} with attempt "
+                            f"{i + 1}/{retries}: {e}. Retrying..."
+                        )
+                        await asyncio.sleep(cooldown * backoff**i)
+        raise ValueError("retry count exceeded")
+
+    async def _fetch_with_rate_limit(
+        self, url: str, semaphore: asyncio.Semaphore
+    ) -> str:
+        async with semaphore:
+            try:
+                return await self._fetch(url)
+            except Exception as e:
+                if self.continue_on_failure:
+                    logger.warning(
+                        f"Error fetching {url}, skipping due to"
+                        f" continue_on_failure=True"
+                    )
+                    return ""
+                logger.exception(
+                    f"Error fetching {url} and aborting, use continue_on_failure=True "
+                    "to continue loading urls after encountering an error."
+                )
+                raise e
+
+    async def fetch_all(self, urls: List[str]) -> Any:
+        """Fetch all urls concurrently with rate limiting."""
+        semaphore = asyncio.Semaphore(self.requests_per_second)
+        tasks = []
+        for url in urls:
+            task = asyncio.ensure_future(self._fetch_with_rate_limit(url, semaphore))
+            tasks.append(task)
+        try:
+            if self.show_progress:
+                from tqdm.asyncio import tqdm_asyncio
+
+                return await tqdm_asyncio.gather(
+                    *tasks, desc="Fetching pages", ascii=True, mininterval=1
+                )
+            else:
+                return await asyncio.gather(*tasks)
+        except ImportError:
+            warnings.warn("For better logging of progress, `pip install tqdm`")
+            return await asyncio.gather(*tasks)
+
+    @staticmethod
+    def _check_parser(parser: str) -> None:
+        """Check that parser is valid for bs4."""
+        valid_parsers = ["html.parser", "lxml", "xml", "lxml-xml", "html5lib"]
+        if parser not in valid_parsers:
+            raise ValueError(
+                "`parser` must be one of " + ", ".join(valid_parsers) + "."
+            )
+
+    def _unpack_fetch_results(
+        self, results: Any, urls: List[str], parser: Union[str, None] = None
+    ) -> List[Any]:
+        """Unpack fetch results into BeautifulSoup objects."""
+        from bs4 import BeautifulSoup
+
+        final_results = []
+        for i, result in enumerate(results):
+            url = urls[i]
+            if parser is None:
+                if url.endswith(".xml"):
+                    parser = "xml"
+                else:
+                    parser = self.default_parser
+                self._check_parser(parser)
+            final_results.append(BeautifulSoup(result, parser, **self.bs_kwargs))
+        return final_results
+
+    def scrape_all(self, urls: List[str], parser: Union[str, None] = None) -> List[Any]:
+        """Fetch all urls, then return soups for all results."""
+        results = asyncio.run(self.fetch_all(urls))
+        return self._unpack_fetch_results(results, urls, parser=parser)
+
+    async def ascrape_all(
+        self, urls: List[str], parser: Union[str, None] = None
+    ) -> List[Any]:
+        """Async fetch all urls, then return soups for all results."""
+        results = await self.fetch_all(urls)
+        return self._unpack_fetch_results(results, urls, parser=parser)
+
+    def _scrape(
+        self,
+        url: str,
+        parser: Union[str, None] = None,
+        bs_kwargs: Optional[dict] = None,
+    ) -> Any:
+        from bs4 import BeautifulSoup
+
+        if parser is None:
+            if url.endswith(".xml"):
+                parser = "xml"
+            else:
+                parser = self.default_parser
+
+        self._check_parser(parser)
+
+        html_doc = self.session.get(url, **self.requests_kwargs)
+        if self.raise_for_status:
+            html_doc.raise_for_status()
+
+        if self.encoding is not None:
+            html_doc.encoding = self.encoding
+        elif self.autoset_encoding:
+            html_doc.encoding = html_doc.apparent_encoding
+        return BeautifulSoup(html_doc.text, parser, **(bs_kwargs or {}))
+
+    def scrape(self, parser: Union[str, None] = None) -> Any:
+        """Scrape data from webpage and return it in BeautifulSoup format."""
+
+        return self._scrape(self.web_path, parser=parser, bs_kwargs=self.bs_kwargs)
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load text from the url(s) in web_path."""
+        for path in self.web_paths:
+            soup = self._scrape(path, bs_kwargs=self.bs_kwargs)
+            text = soup.get_text(**self.bs_get_text_kwargs)
+            metadata = _build_metadata(soup, path)
+            yield Document(page_content=text, metadata=metadata)
+
+    async def alazy_load(self) -> AsyncIterator[Document]:
+        """Async lazy load text from the url(s) in web_path."""
+        results = await self.ascrape_all(self.web_paths)
+        for path, soup in zip(self.web_paths, results):
+            text = soup.get_text(**self.bs_get_text_kwargs)
+            metadata = _build_metadata(soup, path)
+            yield Document(page_content=text, metadata=metadata)
+
+    @deprecated(
+        since="0.3.14",
+        removal="1.0",
+        message=(
+            "See API reference for updated usage: "
+            "https://python.langchain.com/api_reference/community/document_loaders/langchain_community.document_loaders.web_base.WebBaseLoader.html"  # noqa: E501
+        ),
+    )
+    def aload(self) -> List[Document]:  # type: ignore[override]
+        """Load text from the urls in web_path async into Documents."""
+
+        results = self.scrape_all(self.web_paths)
+        docs = []
+        for path, soup in zip(self.web_paths, results):
+            text = soup.get_text(**self.bs_get_text_kwargs)
+            metadata = _build_metadata(soup, path)
+            docs.append(Document(page_content=text, metadata=metadata))
+
+        return docs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/whatsapp_chat.py

@@ -0,0 +1,64 @@
+import re
+from pathlib import Path
+from typing import Iterator
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+
+
+def concatenate_rows(date: str, sender: str, text: str) -> str:
+    """Combine message information in a readable format ready to be used."""
+    return f"{sender} on {date}: {text}\n\n"
+
+
+class WhatsAppChatLoader(BaseLoader):
+    """Load `WhatsApp` messages text file."""
+
+    def __init__(self, path: str):
+        """Initialize with path."""
+        self.file_path = path
+
+    def lazy_load(self) -> Iterator[Document]:
+        p = Path(self.file_path)
+        text_content = ""
+
+        with open(p, encoding="utf8") as f:
+            lines = f.readlines()
+
+        message_line_regex = r"""
+            \[?
+            (
+                \d{1,4}
+                [\/.]
+                \d{1,2}
+                [\/.]
+                \d{1,4}
+                ,\s
+                \d{1,2}
+                :\d{2}
+                (?:
+                    :\d{2}
+                )?
+                (?:[\s_](?:AM|PM))?
+            )
+            \]?
+            [\s-]*
+            ([~\w\s]+)
+            [:]+
+            \s
+            (.+)
+        """
+        ignore_lines = ["This message was deleted", "<Media omitted>"]
+        for line in lines:
+            result = re.match(
+                message_line_regex, line.strip(), flags=re.VERBOSE | re.IGNORECASE
+            )
+            if result:
+                date, sender, text = result.groups()
+                if text not in ignore_lines:
+                    text_content += concatenate_rows(date, sender, text)
+
+        metadata = {"source": str(p)}
+
+        yield Document(page_content=text_content, metadata=metadata)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/wikipedia.py

@@ -0,0 +1,59 @@
+from typing import Iterator, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+
+
+class WikipediaLoader(BaseLoader):
+    """Load from `Wikipedia`.
+
+    The hard limit on the length of the query is 300 for now.
+
+    Each wiki page represents one Document.
+    """
+
+    def __init__(
+        self,
+        query: str,
+        lang: str = "en",
+        load_max_docs: Optional[int] = 25,
+        load_all_available_meta: Optional[bool] = False,
+        doc_content_chars_max: Optional[int] = 4000,
+    ):
+        """
+        Initializes a new instance of the WikipediaLoader class.
+
+        Args:
+            query (str): The query string to search on Wikipedia.
+            lang (str, optional): The language code for the Wikipedia language edition.
+                Defaults to "en".
+            load_max_docs (int, optional): The maximum number of documents to load.
+                Defaults to 100.
+            load_all_available_meta (bool, optional): Indicates whether to load all
+                available metadata for each document. Defaults to False.
+            doc_content_chars_max (int, optional): The maximum number of characters
+                for the document content. Defaults to 4000.
+        """
+        self.query = query
+        self.lang = lang
+        self.load_max_docs = load_max_docs
+        self.load_all_available_meta = load_all_available_meta
+        self.doc_content_chars_max = doc_content_chars_max
+
+    def lazy_load(self) -> Iterator[Document]:
+        """
+        Loads the query result from Wikipedia into a list of `Document` objects.
+
+        Returns:
+            A list of `Document` objects representing the loaded
+                Wikipedia pages.
+        """
+        client = WikipediaAPIWrapper(  # type: ignore[call-arg]
+            lang=self.lang,
+            top_k_results=self.load_max_docs,  # type: ignore[arg-type]
+            load_all_available_meta=self.load_all_available_meta,  # type: ignore[arg-type]
+            doc_content_chars_max=self.doc_content_chars_max,  # type: ignore[arg-type]
+        )
+        yield from client.load(self.query)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/word_document.py

@@ -0,0 +1,139 @@
+"""Loads word documents."""
+
+import os
+import tempfile
+from abc import ABC
+from pathlib import Path
+from typing import Any, List, Union
+from urllib.parse import urlparse
+
+import requests
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class Docx2txtLoader(BaseLoader, ABC):
+    """Load `DOCX` file using `docx2txt` and chunks at character level.
+
+    Defaults to check for local file, but if the file is a web path, it will download it
+    to a temporary file, and use that, then clean up the temporary file after completion
+    """
+
+    def __init__(self, file_path: Union[str, Path]):
+        """Initialize with file path."""
+        self.file_path = str(file_path)
+        self.original_file_path = self.file_path
+        if "~" in self.file_path:
+            self.file_path = os.path.expanduser(self.file_path)
+
+        # If the file is a web path, download it to a temporary file, and use that
+        if not os.path.isfile(self.file_path) and self._is_valid_url(self.file_path):
+            r = requests.get(self.file_path)
+
+            if r.status_code != 200:
+                raise ValueError(
+                    "Check the url of your file; returned status code %s"
+                    % r.status_code
+                )
+
+            self.web_path = self.file_path
+            self.temp_file = tempfile.NamedTemporaryFile()
+            self.temp_file.write(r.content)
+            self.file_path = self.temp_file.name
+        elif not os.path.isfile(self.file_path):
+            raise ValueError("File path %s is not a valid file or url" % self.file_path)
+
+    def __del__(self) -> None:
+        if hasattr(self, "temp_file"):
+            self.temp_file.close()
+
+    def load(self) -> List[Document]:
+        """Load given path as single page."""
+        import docx2txt
+
+        return [
+            Document(
+                page_content=docx2txt.process(self.file_path),
+                metadata={"source": self.original_file_path},
+            )
+        ]
+
+    @staticmethod
+    def _is_valid_url(url: str) -> bool:
+        """Check if the url is valid."""
+        parsed = urlparse(url)
+        return bool(parsed.netloc) and bool(parsed.scheme)
+
+
+class UnstructuredWordDocumentLoader(UnstructuredFileLoader):
+    """Load `Microsoft Word` file using `Unstructured`.
+
+    Works with both .docx and .doc files.
+    You can run the loader in one of two modes: "single" and "elements".
+    If you use "single" mode, the document will be returned as a single
+    langchain Document object. If you use "elements" mode, the unstructured
+    library will split the document into elements such as Title and NarrativeText.
+    You can pass in additional unstructured kwargs after mode to apply
+    different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredWordDocumentLoader
+
+    loader = UnstructuredWordDocumentLoader(
+        "example.docx", mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://unstructured-io.github.io/unstructured/bricks.html#partition-docx
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        """
+
+        Args:
+            file_path: The path to the Word file to load.
+            mode: The mode to use when loading the file. Can be one of "single",
+                "multi", or "all". Default is "single".
+            **unstructured_kwargs: Any kwargs to pass to the unstructured.
+        """
+        file_path = str(file_path)
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.file_utils.filetype import FileType, detect_filetype
+
+        # NOTE(MthwRobinson) - magic will raise an import error if the libmagic
+        # system dependency isn't installed. If it's not installed, we'll just
+        # check the file extension
+        try:
+            import magic  # noqa: F401
+
+            is_doc = detect_filetype(self.file_path) == FileType.DOC
+        except ImportError:
+            _, extension = os.path.splitext(str(self.file_path))
+            is_doc = extension == ".doc"
+
+        if is_doc:
+            validate_unstructured_version("0.4.11")
+
+        if is_doc:
+            from unstructured.partition.doc import partition_doc
+
+            return partition_doc(filename=self.file_path, **self.unstructured_kwargs)
+        else:
+            from unstructured.partition.docx import partition_docx
+
+            return partition_docx(filename=self.file_path, **self.unstructured_kwargs)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/document_loaders/xml.py

@@ -0,0 +1,49 @@
+"""Loads Microsoft Excel files."""
+
+from pathlib import Path
+from typing import Any, List, Union
+
+from langchain_community.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredXMLLoader(UnstructuredFileLoader):
+    """Load `XML` file using `Unstructured`.
+
+    You can run the loader in one of two modes: "single" and "elements".
+    If you use "single" mode, the document will be returned as a single
+    langchain Document object. If you use "elements" mode, the unstructured
+    library will split the document into elements such as Title and NarrativeText.
+    You can pass in additional unstructured kwargs after mode to apply
+    different unstructured settings.
+
+    Examples
+    --------
+    from langchain_community.document_loaders import UnstructuredXMLLoader
+
+    loader = UnstructuredXMLLoader(
+        "example.xml", mode="elements", strategy="fast",
+    )
+    docs = loader.load()
+
+    References
+    ----------
+    https://unstructured-io.github.io/unstructured/bricks.html#partition-xml
+    """
+
+    def __init__(
+        self,
+        file_path: Union[str, Path],
+        mode: str = "single",
+        **unstructured_kwargs: Any,
+    ):
+        file_path = str(file_path)
+        validate_unstructured_version(min_unstructured_version="0.6.7")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.xml import partition_xml
+
+        return partition_xml(filename=self.file_path, **self.unstructured_kwargs)