├── .coveragerc
├── .github
    ├── CODEOWNERS
    ├── CONTRIBUTING.md
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   ├── feature_request.md
    │   └── support_request.md
    ├── PULL_REQUEST_TEMPLATE.md
    ├── blunderbuss.yml
    ├── header-checker-lint.yml
    ├── release-please.yml
    ├── release-trigger.yml
    ├── renovate.json5
    ├── sync-repo-settings.yaml
    ├── trusted-contribution.yml
    └── workflows
    │   ├── docs.yml
    │   ├── lint.yml
    │   └── lint_fallback.yml
├── .gitignore
├── .kokoro
    ├── build.sh
    ├── docker
    │   └── docs
    │   │   ├── Dockerfile
    │   │   ├── requirements.in
    │   │   └── requirements.txt
    ├── docs
    │   ├── common.cfg
    │   ├── docs-presubmit.cfg
    │   └── docs.cfg
    ├── populate-secrets.sh
    ├── publish-docs.sh
    ├── release.sh
    ├── release
    │   ├── common.cfg
    │   └── release.cfg
    ├── requirements.in
    ├── requirements.txt
    ├── trampoline.sh
    └── trampoline_v2.sh
├── .repo-metadata.json
├── .trampolinerc
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DEVELOPER.md
├── LICENSE
├── README.rst
├── SECURITY.md
├── docs
    ├── README.rst
    ├── _static
    │   └── custom.css
    ├── changelog.md
    ├── chat_message_history.ipynb
    ├── conf.py
    ├── document_loader.ipynb
    ├── index.rst
    ├── langchain_google_firestore
    │   ├── history.rst
    │   ├── loader.rst
    │   └── vectorstore.rst
    ├── templates
    │   └── layout.html
    └── vectorstores.ipynb
├── integration.cloudbuild.yaml
├── noxfile.py
├── pyproject.toml
├── requirements.txt
├── src
    └── langchain_google_firestore
    │   ├── __init__.py
    │   ├── chat_message_history.py
    │   ├── common.py
    │   ├── document_converter.py
    │   ├── document_loader.py
    │   ├── py.typed
    │   ├── vectorstores.py
    │   └── version.py
└── tests
    ├── fake.py
    ├── test_chat_message_history.py
    ├── test_document_converter.py
    ├── test_document_loader.py
    └── test_vectorstores.py


/.coveragerc:
--------------------------------------------------------------------------------
1 | [run]
2 | branch = true
3 | omit =
4 |     */__init__.py
5 | 
6 | [report]
7 | show_missing = true
8 | fail_under = 90


--------------------------------------------------------------------------------
/.github/CODEOWNERS:
--------------------------------------------------------------------------------
1 | # This file controls who is tagged for review for any given pull request.
2 | #
3 | # For syntax help see:
4 | # https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
5 | 
6 | *   @googleapis/senseai-eco @googleapis/langchain-firestore


--------------------------------------------------------------------------------
/.github/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to Contribute
 2 | 
 3 | We'd love to accept your patches and contributions to this project. There are
 4 | just a few small guidelines you need to follow.
 5 | 
 6 | ## Contributor License Agreement
 7 | 
 8 | Contributions to this project must be accompanied by a Contributor License
 9 | Agreement. You (or your employer) retain the copyright to your contribution;
10 | this simply gives us permission to use and redistribute your contributions as
11 | part of the project. Head over to <https://cla.developers.google.com/> to see
12 | your current agreements on file or to sign a new one.
13 | 
14 | You generally only need to submit a CLA once, so if you've already submitted one
15 | (even if it was for a different project), you probably don't need to do it
16 | again.
17 | 
18 | ## Code reviews
19 | 
20 | All submissions, including submissions by project members, require review. We
21 | use GitHub pull requests for this purpose. Consult
22 | [GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
23 | information on using pull requests.
24 | 
25 | ## Community Guidelines
26 | 
27 | This project follows [Google's Open Source Community
28 | Guidelines](https://opensource.google.com/conduct/).
29 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | 
 5 | ---
 6 | 
 7 | Thanks for stopping by to let us know something could be better!
 8 | 
 9 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
10 | 
11 | Please run down the following list and make sure you've tried the usual "quick fixes":
12 | 
13 |   - Search the issues already opened: https://github.com/googleapis/langchain-google-firestore-python/issues
14 |   - Search StackOverflow: https://stackoverflow.com/questions/tagged/google-cloud-platform+python
15 | 
16 | If you are still having issues, please be sure to include as much information as possible:
17 | 
18 | #### Environment details
19 | 
20 |   - OS type and version:
21 |   - Python version: `python --version`
22 |   - pip version: `pip --version`
23 |   - `langchain-google-firestore` version: `pip show langchain-google-firestore`
24 | 
25 | #### Steps to reproduce
26 | 
27 |   1. ?
28 |   2. ?
29 | 
30 | #### Code example
31 | 
32 | ```python
33 | # example
34 | ```
35 | 
36 | #### Stack trace
37 | ```
38 | # example
39 | ```
40 | 
41 | Making sure to follow these steps will guarantee the quickest resolution possible.
42 | 
43 | Thanks!
44 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this library
 4 | 
 5 | ---
 6 | 
 7 | Thanks for stopping by to let us know something could be better!
 8 | 
 9 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
10 | 
11 |  **Is your feature request related to a problem? Please describe.**
12 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
13 |  **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 |  **Describe alternatives you've considered**
16 | A clear and concise description of any alternative solutions or features you've considered.
17 |  **Additional context**
18 | Add any other context or screenshots about the feature request here.
19 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/support_request.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Support request
3 | about: If you have a support contract with Google, please create an issue in the Google Cloud Support console.
4 | 
5 | ---
6 | 
7 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
8 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | Thank you for opening a Pull Request! Before submitting your PR, there are a few things you can do to make sure it goes smoothly:
2 | - [ ] Make sure to open an issue as a [bug/issue](https://github.com/googleapis/langchain-google-firestore-python/issues/new/choose) before writing your code!  That way we can discuss the change, evaluate designs, and agree on the general idea
3 | - [ ] Ensure the tests and linter pass
4 | - [ ] Code coverage does not decrease (if any source code was changed)
5 | - [ ] Appropriate docs were updated (if necessary)
6 | 
7 | Fixes #<issue_number_goes_here> 🦕
8 | 


--------------------------------------------------------------------------------
/.github/blunderbuss.yml:
--------------------------------------------------------------------------------
1 | assign_issues:
2 |   - googleapis/langchain-firestore
3 | assign_prs:
4 |   - googleapis/langchain-firestore
5 | 


--------------------------------------------------------------------------------
/.github/header-checker-lint.yml:
--------------------------------------------------------------------------------
 1 | allowedCopyrightHolders:
 2 |   - "Google LLC"
 3 | allowedLicenses:
 4 |   - "Apache-2.0"
 5 | sourceFileExtensions:
 6 |   - "yaml"
 7 |   - "yml"
 8 |   - "sh"
 9 |   - "proto"
10 |   - "Dockerfile"
11 |   - "py"
12 |   - "text"
13 | ignoreFiles:
14 |   - ".github/blunderbuss.yml"
15 |   - ".github/release-please.yml"
16 |   - ".github/release-trigger.yml"
17 |   - ".github/header-checker-lint.yml"
18 |   - ".github/sync-repo-settings.yaml"
19 |   - ".github/workflows/docs.yml"
20 |   - ".kokoro/**"
21 |   - "**/requirements.txt"
22 |   - "**/requirements-test.txt"
23 | 


--------------------------------------------------------------------------------
/.github/release-please.yml:
--------------------------------------------------------------------------------
1 | releaseType: python
2 | handleGHRelease: true
3 | 


--------------------------------------------------------------------------------
/.github/release-trigger.yml:
--------------------------------------------------------------------------------
1 | enabled: true
2 | 


--------------------------------------------------------------------------------
/.github/renovate.json5:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": [
 3 |     "config:base", // https://docs.renovatebot.com/presets-config/#configbase
 4 |     ":semanticCommitTypeAll(chore)", // https://docs.renovatebot.com/presets-default/#semanticcommittypeallarg0
 5 |     ":ignoreUnstable", // https://docs.renovatebot.com/presets-default/#ignoreunstable
 6 |     "group:allNonMajor", // https://docs.renovatebot.com/presets-group/#groupallnonmajor
 7 |     ":separateMajorReleases", // https://docs.renovatebot.com/presets-default/#separatemajorreleases
 8 |     ":prConcurrentLimitNone", // View complete backlog as PRs. https://docs.renovatebot.com/presets-default/#prconcurrentlimitnone
 9 |     ":prHourlyLimitNone", // https://docs.renovatebot.com/presets-default/#prhourlylimitnone
10 |     ":preserveSemverRanges",
11 |   ],
12 |   "ignorePaths": [".kokoro/**"],
13 | 
14 |   // Give ecosystem time to catch up.
15 |   // npm allows maintainers to unpublish a release up to 3 days later.
16 |   // https://docs.renovatebot.com/configuration-options/#minimumreleaseage
17 |   "minimumReleaseAge": "3",
18 | 
19 |   // Create PRs, but do not update them without manual action.
20 |   // Reduces spurious retesting in repositories that have many PRs at a time.
21 |   // https://docs.renovatebot.com/configuration-options/#rebasewhen
22 |   "rebaseWhen": "never",
23 | 
24 |   // Organizational processes.
25 |   // https://docs.renovatebot.com/configuration-options/#dependencydashboardlabels
26 |   "dependencyDashboardLabels": [
27 |     "type: process",
28 |   ],
29 |   "packageRules": [
30 | 
31 |     {
32 |        "groupName": "GitHub Actions",
33 |        "matchManagers": ["github-actions"],
34 |        "pinDigests": true,
35 |     },
36 | 
37 |     // Python Specific
38 |     {
39 |       "matchPackageNames": ["pytest"],
40 |       "matchUpdateTypes": ["minor", "major"]
41 |     },
42 |     {
43 |       "groupName": "python-nonmajor",
44 |       "matchLanguages": ["python"],
45 |       "matchUpdateTypes": ["minor", "patch"],
46 |     },
47 | 
48 |   ],
49 | }
50 | 


--------------------------------------------------------------------------------
/.github/sync-repo-settings.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | # Synchronize repository settings from a centralized config
16 | # https://github.com/googleapis/repo-automation-bots/tree/main/packages/sync-repo-settings
17 | # Install: https://github.com/apps/sync-repo-settings
18 | 
19 | # Disable merge commits
20 | rebaseMergeAllowed: true
21 | squashMergeAllowed: true
22 | mergeCommitAllowed: false
23 | # Enable branch protection
24 | branchProtectionRules:
25 |   - pattern: main
26 |     isAdminEnforced: true
27 |     requiredStatusCheckContexts:
28 |       - "cla/google"
29 |       - "lint"
30 |       - "integration-test-pr-py39 (langchain-firestore-testing)"
31 |       - "integration-test-pr-py310 (langchain-firestore-testing)"
32 |       - "integration-test-pr-py311 (langchain-firestore-testing)"
33 |       - "integration-test-pr-py312 (langchain-firestore-testing)"
34 |       - "conventionalcommits.org"
35 |       - "header-check"
36 |     # - Add required status checks like presubmit tests
37 |     requiredApprovingReviewCount: 1
38 |     requiresCodeOwnerReviews: true
39 |     requiresStrictStatusChecks: true
40 | 
41 | # Set team access
42 | permissionRules:
43 |   - team: senseai-eco
44 |     permission: admin
45 |   - team: langchain-firestore
46 |     permission: push
47 | 


--------------------------------------------------------------------------------
/.github/trusted-contribution.yml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | # Trigger presubmit tests for trusted contributors
16 | # https://github.com/googleapis/repo-automation-bots/tree/main/packages/trusted-contribution
17 | # Install: https://github.com/apps/trusted-contributions-gcf
18 | 
19 | trustedContributors:
20 |   - "dependabot[bot]"
21 |   - "renovate-bot"
22 |   - "renovate[bot]"
23 |   - "forking-renovate[bot]"
24 |   - "release-please[bot]"
25 | annotations:
26 |   # Trigger Cloud Build tests
27 |   - type: comment
28 |     text: "/gcbrun"
29 | 


--------------------------------------------------------------------------------
/.github/workflows/docs.yml:
--------------------------------------------------------------------------------
 1 | on:
 2 |   pull_request:
 3 |     branches:
 4 |       - main
 5 | name: docs
 6 | permissions:
 7 |   contents: read # This applies to all jobs
 8 | jobs:
 9 |   docs:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |     - name: Checkout
13 |       uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
14 |     - name: Setup Python
15 |       uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5
16 |       with:
17 |         python-version: "3.10"
18 |     - name: Install nox
19 |       run: |
20 |         python -m pip install --upgrade setuptools pip wheel
21 |         python -m pip install nox
22 |     - name: Run docs
23 |       run: |
24 |         nox -s docs
25 |   docfx:
26 |     runs-on: ubuntu-latest
27 |     steps:
28 |     - name: Checkout
29 |       uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
30 |     - name: Setup Python
31 |       uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5
32 |       with:
33 |         python-version: "3.10"
34 |     - name: Install nox
35 |       run: |
36 |         python -m pip install --upgrade setuptools pip wheel
37 |         python -m pip install nox
38 |     - name: Run docfx
39 |       run: |
40 |         nox -s docfx
41 | 


--------------------------------------------------------------------------------
/.github/workflows/lint.yml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | name: Lint
16 | on:
17 |   pull_request:
18 |     paths-ignore: # Changes to the paths list need to be reflected in lint_fallback.yml
19 |       - "*.md"
20 |       - ".kokoro/**"
21 |       - ".github/**"
22 | 
23 | jobs:
24 |   lint:
25 |     runs-on: ubuntu-latest
26 |     permissions:
27 |       contents: read
28 |     concurrency:
29 |       group: ${{ github.workflow }}-${{ github.ref }}
30 |       cancel-in-progress: true
31 | 
32 |     steps:
33 |       - name: Checkout Repository
34 |         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
35 | 
36 |       - name: Setup Python
37 |         uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # v5.1.0
38 |         with:
39 |           python-version: "3.11"
40 | 
41 |       - name: Install requirements
42 |         run: pip install -r requirements.txt
43 | 
44 |       - name: Install module (and test requirements)
45 |         run: pip install -e .[test]
46 | 
47 |       - name: Run linters
48 |         run: |
49 |           black --check .
50 |           isort --check .
51 | 
52 |       - name: Run type-check
53 |         run: mypy --install-types --non-interactive .
54 | 


--------------------------------------------------------------------------------
/.github/workflows/lint_fallback.yml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | name: Lint
16 | on:
17 |   pull_request:
18 |     paths: # These paths are the inverse of lint.yml
19 |       - "*.md"
20 |       - ".kokoro/**"
21 |       - ".github/**"
22 | 
23 | jobs:
24 |   lint:
25 |     runs-on: ubuntu-latest
26 |     permissions:
27 |       contents: none
28 | 
29 |     steps:
30 |       - run: echo "No tests required."
31 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.py[cod]
 2 | *.sw[op]
 3 | 
 4 | # C extensions
 5 | *.so
 6 | 
 7 | # Packages
 8 | *.egg
 9 | *.egg-info
10 | dist
11 | build
12 | eggs
13 | .eggs
14 | parts
15 | bin
16 | var
17 | sdist
18 | develop-eggs
19 | .installed.cfg
20 | lib
21 | lib64
22 | __pycache__
23 | 
24 | # Installer logs
25 | pip-log.txt
26 | 
27 | # Unit test / coverage reports
28 | .coverage
29 | .nox
30 | .cache
31 | .pytest_cache
32 | 
33 | 
34 | # Mac
35 | .DS_Store
36 | 
37 | # JetBrains
38 | .idea
39 | 
40 | # VS Code
41 | .vscode
42 | 
43 | # emacs
44 | *~
45 | 
46 | # Built documentation
47 | docs/_build
48 | bigquery/docs/generated
49 | docs.metadata
50 | 
51 | # Virtual environment
52 | env/
53 | venv/
54 | .python-version
55 | 
56 | # Test logs
57 | coverage.xml
58 | *sponge_log.xml
59 | 
60 | # System test environment variables.
61 | system_tests/local_test_setup
62 | 
63 | # Make sure a generated file isn't accidentally committed.
64 | pylintrc
65 | pylintrc.test
66 | 


--------------------------------------------------------------------------------
/.kokoro/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | if [[ -z "${PROJECT_ROOT:-}" ]]; then
19 |     PROJECT_ROOT="github/langchain-google-firestore-python"
20 | fi
21 | 
22 | cd "${PROJECT_ROOT}"
23 | 
24 | # Disable buffering, so that the logs stream through.
25 | export PYTHONUNBUFFERED=1
26 | 
27 | # Debug: show build environment
28 | env | grep KOKORO
29 | 
30 | # Setup service account credentials.
31 | export GOOGLE_APPLICATION_CREDENTIALS=${KOKORO_GFILE_DIR}/service-account.json
32 | 
33 | # Setup project id.
34 | export PROJECT_ID=$(cat "${KOKORO_GFILE_DIR}/project-id.json")
35 | 
36 | # Remove old nox
37 | python3 -m pip uninstall --yes --quiet nox-automation
38 | 
39 | # Install nox
40 | python3 -m pip install --upgrade --quiet nox
41 | python3 -m nox --version
42 | 
43 | # If this is a continuous build, send the test log to the FlakyBot.
44 | # See https://github.com/googleapis/repo-automation-bots/tree/main/packages/flakybot.
45 | if [[ $KOKORO_BUILD_ARTIFACTS_SUBDIR = *"continuous"* ]]; then
46 |   cleanup() {
47 |     chmod +x $KOKORO_GFILE_DIR/linux_amd64/flakybot
48 |     $KOKORO_GFILE_DIR/linux_amd64/flakybot
49 |   }
50 |   trap cleanup EXIT HUP
51 | fi
52 | 
53 | # If NOX_SESSION is set, it only runs the specified session,
54 | # otherwise run all the sessions.
55 | if [[ -n "${NOX_SESSION:-}" ]]; then
56 |     python3 -m nox -s ${NOX_SESSION:-}
57 | else
58 |     python3 -m nox
59 | fi
60 | 


--------------------------------------------------------------------------------
/.kokoro/docker/docs/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | from ubuntu:22.04
16 | 
17 | ENV DEBIAN_FRONTEND noninteractive
18 | 
19 | # Ensure local Python is preferred over distribution Python.
20 | ENV PATH /usr/local/bin:$PATH
21 | 
22 | # Install dependencies.
23 | RUN apt-get update \
24 |   && apt-get install -y --no-install-recommends \
25 |     apt-transport-https \
26 |     build-essential \
27 |     ca-certificates \
28 |     curl \
29 |     dirmngr \
30 |     git \
31 |     gpg-agent \
32 |     graphviz \
33 |     libbz2-dev \
34 |     libdb5.3-dev \
35 |     libexpat1-dev \
36 |     libffi-dev \
37 |     liblzma-dev \
38 |     libreadline-dev \
39 |     libsnappy-dev \
40 |     libssl-dev \
41 |     libsqlite3-dev \
42 |     portaudio19-dev \
43 |     python3-distutils \
44 |     redis-server \
45 |     software-properties-common \
46 |     ssh \
47 |     sudo \
48 |     tcl \
49 |     tcl-dev \
50 |     tk \
51 |     tk-dev \
52 |     uuid-dev \
53 |     wget \
54 |     zlib1g-dev \
55 |   && add-apt-repository universe \
56 |   && apt-get update \
57 |   && apt-get -y install jq \
58 |   && apt-get clean autoclean \
59 |   && apt-get autoremove -y \
60 |   && rm -rf /var/lib/apt/lists/* \
61 |   && rm -f /var/cache/apt/archives/*.deb
62 | 
63 | ENV VERSION v4.2.0
64 | ENV BINARY yq_linux_amd64
65 | RUN wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY} -O /usr/bin/yq && \
66 |     chmod +x /usr/bin/yq
67 | 
68 | ###################### Install python 3.9.13
69 | 
70 | # Download python 3.9.13
71 | RUN wget https://www.python.org/ftp/python/3.9.13/Python-3.9.13.tgz
72 | 
73 | # Extract files
74 | RUN tar -xvf Python-3.9.13.tgz
75 | 
76 | # Install python 3.9.13
77 | RUN ./Python-3.9.13/configure --enable-optimizations
78 | RUN make altinstall
79 | 
80 | ###################### Install pip
81 | RUN wget -O /tmp/get-pip.py 'https://bootstrap.pypa.io/get-pip.py' \
82 |   && python3 /tmp/get-pip.py \
83 |   && rm /tmp/get-pip.py
84 | 
85 | # Test pip
86 | RUN python3 -m pip
87 | 
88 | CMD ["python3.8"]
89 | 


--------------------------------------------------------------------------------
/.kokoro/docker/docs/requirements.in:
--------------------------------------------------------------------------------
1 | nox
2 | 


--------------------------------------------------------------------------------
/.kokoro/docker/docs/requirements.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # This file is autogenerated by pip-compile with Python 3.11
 3 | # by the following command:
 4 | #
 5 | #    pip-compile --allow-unsafe --generate-hashes requirements.in
 6 | #
 7 | argcomplete==3.3.0 \
 8 |     --hash=sha256:c168c3723482c031df3c207d4ba8fa702717ccb9fc0bfe4117166c1f537b4a54 \
 9 |     --hash=sha256:fd03ff4a5b9e6580569d34b273f741e85cd9e072f3feeeee3eba4891c70eda62
10 |     # via nox
11 | colorlog==6.8.2 \
12 |     --hash=sha256:3e3e079a41feb5a1b64f978b5ea4f46040a94f11f0e8bbb8261e3dbbeca64d44 \
13 |     --hash=sha256:4dcbb62368e2800cb3c5abd348da7e53f6c362dda502ec27c560b2e58a66bd33
14 |     # via nox
15 | distlib==0.3.8 \
16 |     --hash=sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784 \
17 |     --hash=sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64
18 |     # via virtualenv
19 | filelock==3.14.0 \
20 |     --hash=sha256:43339835842f110ca7ae60f1e1c160714c5a6afd15a2873419ab185334975c0f \
21 |     --hash=sha256:6ea72da3be9b8c82afd3edcf99f2fffbb5076335a5ae4d03248bb5b6c3eae78a
22 |     # via virtualenv
23 | nox==2024.4.15 \
24 |     --hash=sha256:6492236efa15a460ecb98e7b67562a28b70da006ab0be164e8821177577c0565 \
25 |     --hash=sha256:ecf6700199cdfa9e5ea0a41ff5e6ef4641d09508eda6edb89d9987864115817f
26 |     # via -r requirements.in
27 | packaging==24.0 \
28 |     --hash=sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5 \
29 |     --hash=sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9
30 |     # via nox
31 | platformdirs==4.2.1 \
32 |     --hash=sha256:031cd18d4ec63ec53e82dceaac0417d218a6863f7745dfcc9efe7793b7039bdf \
33 |     --hash=sha256:17d5a1161b3fd67b390023cb2d3b026bbd40abde6fdb052dfbd3a29c3ba22ee1
34 |     # via virtualenv
35 | virtualenv==20.26.6 \
36 |     --hash=sha256:280aede09a2a5c317e409a00102e7077c6432c5a38f0ef938e643805a7ad2c48 \
37 |     --hash=sha256:7345cc5b25405607a624d8418154577459c3e0277f5466dd79c49d5e492995f2
38 |     # via nox
39 | 


--------------------------------------------------------------------------------
/.kokoro/docs/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Download trampoline resources.
11 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
12 | 
13 | # Use the trampoline script to run in docker.
14 | build_file: "langchain-google-firestore-python/.kokoro/trampoline_v2.sh"
15 | 
16 | # Configure the docker image for kokoro-trampoline.
17 | env_vars: {
18 |     key: "TRAMPOLINE_IMAGE"
19 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-lib-docs"
20 | }
21 | env_vars: {
22 |     key: "TRAMPOLINE_BUILD_FILE"
23 |     value: "github/langchain-google-firestore-python/.kokoro/publish-docs.sh"
24 | }
25 | 
26 | env_vars: {
27 |     key: "STAGING_BUCKET"
28 |     value: "docs-staging"
29 | }
30 | 
31 | env_vars: {
32 |     key: "V2_STAGING_BUCKET"
33 |     # Push non-cloud library docs to `docs-staging-v2` instead of the
34 |     # Cloud RAD bucket `docs-staging-v2`
35 |     value: "docs-staging-v2"
36 | }
37 | 
38 | # It will upload the docker image after successful builds.
39 | env_vars: {
40 |     key: "TRAMPOLINE_IMAGE_UPLOAD"
41 |     value: "true"
42 | }
43 | 
44 | # It will always build the docker image.
45 | env_vars: {
46 |     key: "TRAMPOLINE_DOCKERFILE"
47 |     value: ".kokoro/docker/docs/Dockerfile"
48 | }
49 | 
50 | # Fetch the token needed for reporting release status to GitHub
51 | before_action {
52 |   fetch_keystore {
53 |     keystore_resource {
54 |       keystore_config_id: 73713
55 |       keyname: "yoshi-automation-github-key"
56 |     }
57 |   }
58 | }
59 | 
60 | before_action {
61 |   fetch_keystore {
62 |     keystore_resource {
63 |       keystore_config_id: 73713
64 |       keyname: "docuploader_service_account"
65 |     }
66 |   }
67 | }


--------------------------------------------------------------------------------
/.kokoro/docs/docs-presubmit.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "STAGING_BUCKET"
 5 |     value: "gcloud-python-test"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "V2_STAGING_BUCKET"
10 |     value: "gcloud-python-test"
11 | }
12 | 
13 | # We only upload the image in the main `docs` build.
14 | env_vars: {
15 |     key: "TRAMPOLINE_IMAGE_UPLOAD"
16 |     value: "false"
17 | }
18 | 
19 | env_vars: {
20 |     key: "TRAMPOLINE_BUILD_FILE"
21 |     value: "github/langchain-google-firestore-python/.kokoro/build.sh"
22 | }
23 | 
24 | # Only run this nox session.
25 | env_vars: {
26 |     key: "NOX_SESSION"
27 |     value: "docs docfx"
28 | }
29 | 


--------------------------------------------------------------------------------
/.kokoro/docs/docs.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto


--------------------------------------------------------------------------------
/.kokoro/populate-secrets.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC.
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #      http://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | function now { date +"%Y-%m-%d %H:%M:%S" | tr -d '\n' ;}
19 | function msg { println "$*" >&2 ;}
20 | function println { printf '%s\n' "$(now) $*" ;}
21 | 
22 | 
23 | # Populates requested secrets set in SECRET_MANAGER_KEYS from service account:
24 | # kokoro-trampoline@cloud-devrel-kokoro-resources.iam.gserviceaccount.com
25 | SECRET_LOCATION="${KOKORO_GFILE_DIR}/secret_manager"
26 | msg "Creating folder on disk for secrets: ${SECRET_LOCATION}"
27 | mkdir -p ${SECRET_LOCATION}
28 | for key in $(echo ${SECRET_MANAGER_KEYS} | sed "s/,/ /g")
29 | do
30 |   msg "Retrieving secret ${key}"
31 |   docker run --entrypoint=gcloud \
32 |     --volume=${KOKORO_GFILE_DIR}:${KOKORO_GFILE_DIR} \
33 |     gcr.io/google.com/cloudsdktool/cloud-sdk \
34 |     secrets versions access latest \
35 |     --project cloud-devrel-kokoro-resources \
36 |     --secret ${key} > \
37 |     "${SECRET_LOCATION}/${key}"
38 |   if [[ $? == 0 ]]; then
39 |     msg "Secret written to ${SECRET_LOCATION}/${key}"
40 |   else
41 |     msg "Error retrieving secret ${key}"
42 |   fi
43 | done
44 | 


--------------------------------------------------------------------------------
/.kokoro/publish-docs.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | # Disable buffering, so that the logs stream through.
19 | export PYTHONUNBUFFERED=1
20 | 
21 | export PATH="${HOME}/.local/bin:${PATH}"
22 | 
23 | # Install nox
24 | python3 -m pip install --require-hashes -r .kokoro/requirements.txt
25 | python3 -m nox --version
26 | 
27 | # build docs
28 | nox -s docs
29 | 
30 | python3 -m pip install .
31 | VERSION=$(python3 -c "import langchain_google_firestore;print(langchain_google_firestore.__version__)")
32 | 
33 | # create metadata
34 | python3 -m docuploader create-metadata \
35 |   --name=$(jq --raw-output '.name // empty' .repo-metadata.json) \
36 |   --version=$VERSION \
37 |   --language=$(jq --raw-output '.language // empty' .repo-metadata.json) \
38 |   --distribution-name=$(jq --raw-output '.distribution_name // empty' .repo-metadata.json) \
39 |   --product-page=$(jq --raw-output '.product_documentation // empty' .repo-metadata.json) \
40 |   --github-repository=$(jq --raw-output '.repo // empty' .repo-metadata.json) \
41 |   --issue-tracker=$(jq --raw-output '.issue_tracker // empty' .repo-metadata.json)
42 | 
43 | cat docs.metadata
44 | 
45 | # upload docs
46 | python3 -m docuploader upload docs/_build/html --metadata-file docs.metadata --staging-bucket "${STAGING_BUCKET}"
47 | 
48 | 
49 | # docfx yaml files
50 | nox -s docfx
51 | 
52 | # create metadata.
53 | python3 -m docuploader create-metadata \
54 |   --name=$(jq --raw-output '.name // empty' .repo-metadata.json) \
55 |   --version=$VERSION \
56 |   --language=$(jq --raw-output '.language // empty' .repo-metadata.json) \
57 |   --distribution-name=$(jq --raw-output '.distribution_name // empty' .repo-metadata.json) \
58 |   --product-page=$(jq --raw-output '.product_documentation // empty' .repo-metadata.json) \
59 |   --github-repository=$(jq --raw-output '.repo // empty' .repo-metadata.json) \
60 |   --issue-tracker=$(jq --raw-output '.issue_tracker // empty' .repo-metadata.json)
61 | 
62 | cat docs.metadata
63 | 
64 | # upload docs
65 | python3 -m docuploader upload docs/_build/html/docfx_yaml --metadata-file docs.metadata --destination-prefix docfx --staging-bucket "${V2_STAGING_BUCKET}"
66 | 


--------------------------------------------------------------------------------
/.kokoro/release.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | # Start the releasetool reporter
19 | python3 -m pip install --require-hashes -r github/langchain-google-firestore-python/.kokoro/requirements.txt
20 | python3 -m releasetool publish-reporter-script > /tmp/publisher-script; source /tmp/publisher-script
21 | 
22 | # Disable buffering, so that the logs stream through.
23 | export PYTHONUNBUFFERED=1
24 | 
25 | # Move into the package, build the distribution and upload.
26 | TWINE_PASSWORD=$(cat "${KOKORO_KEYSTORE_DIR}/73713_google-cloud-pypi-token-keystore-3")
27 | cd github/langchain-google-firestore-python
28 | python3 -m build --wheel
29 | twine upload --username __token__ --password "${TWINE_PASSWORD}" dist/*
30 | 


--------------------------------------------------------------------------------
/.kokoro/release/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Download trampoline resources.
11 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
12 | 
13 | # Use the trampoline script to run in docker.
14 | build_file: "langchain-google-firestore-python/.kokoro/trampoline.sh"
15 | 
16 | # Configure the docker image for kokoro-trampoline.
17 | env_vars: {
18 |     key: "TRAMPOLINE_IMAGE"
19 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-multi"
20 | }
21 | env_vars: {
22 |     key: "TRAMPOLINE_BUILD_FILE"
23 |     value: "github/langchain-google-firestore-python/.kokoro/release.sh"
24 | }
25 | 
26 | # Fetch PyPI password
27 | before_action {
28 |   fetch_keystore {
29 |     keystore_resource {
30 |       keystore_config_id: 73713
31 |       keyname: "google-cloud-pypi-token-keystore-3"
32 |     }
33 |   }
34 | }
35 | 
36 | # Tokens needed to report release status back to GitHub
37 | env_vars: {
38 |   key: "SECRET_MANAGER_KEYS"
39 |   value: "releasetool-publish-reporter-app,releasetool-publish-reporter-googleapis-installation,releasetool-publish-reporter-pem"
40 | }
41 | 
42 | # Store the packages we uploaded to PyPI.  That way, we have a record of exactly
43 | # what we published, which we can use to generate SBOMs and attestations.
44 | action {
45 |   define_artifacts {
46 |     regex: "github/langchain-google-firestore-python/**/*.tar.gz"
47 |     strip_prefix: "github/langchain-google-firestore-python"
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/.kokoro/release/release.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto


--------------------------------------------------------------------------------
/.kokoro/requirements.in:
--------------------------------------------------------------------------------
 1 | gcp-docuploader
 2 | gcp-releasetool>=1.17.0 # required for compatibility with cryptography>=39.x
 3 | importlib-metadata
 4 | typing-extensions
 5 | twine
 6 | wheel
 7 | setuptools
 8 | nox>=2022.11.21 # required to remove dependency on py
 9 | charset-normalizer<3
10 | click<8.1.0
11 | build
12 | tomli
13 | secretstorage


--------------------------------------------------------------------------------
/.kokoro/trampoline.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #      http://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | # Always run the cleanup script, regardless of the success of bouncing into
19 | # the container.
20 | function cleanup() {
21 |     chmod +x ${KOKORO_GFILE_DIR}/trampoline_cleanup.sh
22 |     ${KOKORO_GFILE_DIR}/trampoline_cleanup.sh
23 |     echo "cleanup";
24 | }
25 | trap cleanup EXIT
26 | 
27 | $(dirname $0)/populate-secrets.sh # Secret Manager secrets.
28 | python3 "${KOKORO_GFILE_DIR}/trampoline_v1.py"


--------------------------------------------------------------------------------
/.kokoro/trampoline_v2.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | # Copyright 2024 Google LLC
  3 | #
  4 | # Licensed under the Apache License, Version 2.0 (the "License");
  5 | # you may not use this file except in compliance with the License.
  6 | # You may obtain a copy of the License at
  7 | #
  8 | #      http://www.apache.org/licenses/LICENSE-2.0
  9 | #
 10 | # Unless required by applicable law or agreed to in writing, software
 11 | # distributed under the License is distributed on an "AS IS" BASIS,
 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | # See the License for the specific language governing permissions and
 14 | # limitations under the License.
 15 | 
 16 | # trampoline_v2.sh
 17 | #
 18 | # This script does 3 things.
 19 | #
 20 | # 1. Prepare the Docker image for the test
 21 | # 2. Run the Docker with appropriate flags to run the test
 22 | # 3. Upload the newly built Docker image
 23 | #
 24 | # in a way that is somewhat compatible with trampoline_v1.
 25 | #
 26 | # To run this script, first download few files from gcs to /dev/shm.
 27 | # (/dev/shm is passed into the container as KOKORO_GFILE_DIR).
 28 | #
 29 | # gsutil cp gs://cloud-devrel-kokoro-resources/python-docs-samples/secrets_viewer_service_account.json /dev/shm
 30 | # gsutil cp gs://cloud-devrel-kokoro-resources/python-docs-samples/automl_secrets.txt /dev/shm
 31 | #
 32 | # Then run the script.
 33 | # .kokoro/trampoline_v2.sh
 34 | #
 35 | # These environment variables are required:
 36 | # TRAMPOLINE_IMAGE: The docker image to use.
 37 | # TRAMPOLINE_DOCKERFILE: The location of the Dockerfile.
 38 | #
 39 | # You can optionally change these environment variables:
 40 | # TRAMPOLINE_IMAGE_UPLOAD:
 41 | #     (true|false): Whether to upload the Docker image after the
 42 | #                   successful builds.
 43 | # TRAMPOLINE_BUILD_FILE: The script to run in the docker container.
 44 | # TRAMPOLINE_WORKSPACE: The workspace path in the docker container.
 45 | #                       Defaults to /workspace.
 46 | # Potentially there are some repo specific envvars in .trampolinerc in
 47 | # the project root.
 48 | 
 49 | 
 50 | set -euo pipefail
 51 | 
 52 | TRAMPOLINE_VERSION="2.0.5"
 53 | 
 54 | if command -v tput >/dev/null && [[ -n "${TERM:-}" ]]; then
 55 |   readonly IO_COLOR_RED="$(tput setaf 1)"
 56 |   readonly IO_COLOR_GREEN="$(tput setaf 2)"
 57 |   readonly IO_COLOR_YELLOW="$(tput setaf 3)"
 58 |   readonly IO_COLOR_RESET="$(tput sgr0)"
 59 | else
 60 |   readonly IO_COLOR_RED=""
 61 |   readonly IO_COLOR_GREEN=""
 62 |   readonly IO_COLOR_YELLOW=""
 63 |   readonly IO_COLOR_RESET=""
 64 | fi
 65 | 
 66 | function function_exists {
 67 |     [ $(LC_ALL=C type -t $1)"" == "function" ]
 68 | }
 69 | 
 70 | # Logs a message using the given color. The first argument must be one
 71 | # of the IO_COLOR_* variables defined above, such as
 72 | # "${IO_COLOR_YELLOW}". The remaining arguments will be logged in the
 73 | # given color. The log message will also have an RFC-3339 timestamp
 74 | # prepended (in UTC). You can disable the color output by setting
 75 | # TERM=vt100.
 76 | function log_impl() {
 77 |     local color="$1"
 78 |     shift
 79 |     local timestamp="$(date -u "+%Y-%m-%dT%H:%M:%SZ")"
 80 |     echo "================================================================"
 81 |     echo "${color}${timestamp}:" "$@" "${IO_COLOR_RESET}"
 82 |     echo "================================================================"
 83 | }
 84 | 
 85 | # Logs the given message with normal coloring and a timestamp.
 86 | function log() {
 87 |   log_impl "${IO_COLOR_RESET}" "$@"
 88 | }
 89 | 
 90 | # Logs the given message in green with a timestamp.
 91 | function log_green() {
 92 |   log_impl "${IO_COLOR_GREEN}" "$@"
 93 | }
 94 | 
 95 | # Logs the given message in yellow with a timestamp.
 96 | function log_yellow() {
 97 |   log_impl "${IO_COLOR_YELLOW}" "$@"
 98 | }
 99 | 
100 | # Logs the given message in red with a timestamp.
101 | function log_red() {
102 |   log_impl "${IO_COLOR_RED}" "$@"
103 | }
104 | 
105 | readonly tmpdir=$(mktemp -d -t ci-XXXXXXXX)
106 | readonly tmphome="${tmpdir}/h"
107 | mkdir -p "${tmphome}"
108 | 
109 | function cleanup() {
110 |     rm -rf "${tmpdir}"
111 | }
112 | trap cleanup EXIT
113 | 
114 | RUNNING_IN_CI="${RUNNING_IN_CI:-false}"
115 | 
116 | # The workspace in the container, defaults to /workspace.
117 | TRAMPOLINE_WORKSPACE="${TRAMPOLINE_WORKSPACE:-/workspace}"
118 | 
119 | pass_down_envvars=(
120 |     # TRAMPOLINE_V2 variables.
121 |     # Tells scripts whether they are running as part of CI or not.
122 |     "RUNNING_IN_CI"
123 |     # Indicates which CI system we're in.
124 |     "TRAMPOLINE_CI"
125 |     # Indicates the version of the script.
126 |     "TRAMPOLINE_VERSION"
127 | )
128 | 
129 | log_yellow "Building with Trampoline ${TRAMPOLINE_VERSION}"
130 | 
131 | # Detect which CI systems we're in. If we're in any of the CI systems
132 | # we support, `RUNNING_IN_CI` will be true and `TRAMPOLINE_CI` will be
133 | # the name of the CI system. Both envvars will be passing down to the
134 | # container for telling which CI system we're in.
135 | if [[ -n "${KOKORO_BUILD_ID:-}" ]]; then
136 |     # descriptive env var for indicating it's on CI.
137 |     RUNNING_IN_CI="true"
138 |     TRAMPOLINE_CI="kokoro"
139 |     if [[ "${TRAMPOLINE_USE_LEGACY_SERVICE_ACCOUNT:-}" == "true" ]]; then
140 | 	if [[ ! -f "${KOKORO_GFILE_DIR}/kokoro-trampoline.service-account.json" ]]; then
141 | 	    log_red "${KOKORO_GFILE_DIR}/kokoro-trampoline.service-account.json does not exist. Did you forget to mount cloud-devrel-kokoro-resources/trampoline? Aborting."
142 | 	    exit 1
143 | 	fi
144 | 	# This service account will be activated later.
145 | 	TRAMPOLINE_SERVICE_ACCOUNT="${KOKORO_GFILE_DIR}/kokoro-trampoline.service-account.json"
146 |     else
147 | 	if [[ "${TRAMPOLINE_VERBOSE:-}" == "true" ]]; then
148 | 	    gcloud auth list
149 | 	fi
150 | 	log_yellow "Configuring Container Registry access"
151 | 	gcloud auth configure-docker --quiet
152 |     fi
153 |     pass_down_envvars+=(
154 | 	# KOKORO dynamic variables.
155 | 	"KOKORO_BUILD_NUMBER"
156 | 	"KOKORO_BUILD_ID"
157 | 	"KOKORO_JOB_NAME"
158 | 	"KOKORO_GIT_COMMIT"
159 | 	"KOKORO_GITHUB_COMMIT"
160 | 	"KOKORO_GITHUB_PULL_REQUEST_NUMBER"
161 | 	"KOKORO_GITHUB_PULL_REQUEST_COMMIT"
162 | 	# For FlakyBot
163 | 	"KOKORO_GITHUB_COMMIT_URL"
164 | 	"KOKORO_GITHUB_PULL_REQUEST_URL"
165 |     )
166 | elif [[ "${TRAVIS:-}" == "true" ]]; then
167 |     RUNNING_IN_CI="true"
168 |     TRAMPOLINE_CI="travis"
169 |     pass_down_envvars+=(
170 | 	"TRAVIS_BRANCH"
171 | 	"TRAVIS_BUILD_ID"
172 | 	"TRAVIS_BUILD_NUMBER"
173 | 	"TRAVIS_BUILD_WEB_URL"
174 | 	"TRAVIS_COMMIT"
175 | 	"TRAVIS_COMMIT_MESSAGE"
176 | 	"TRAVIS_COMMIT_RANGE"
177 | 	"TRAVIS_JOB_NAME"
178 | 	"TRAVIS_JOB_NUMBER"
179 | 	"TRAVIS_JOB_WEB_URL"
180 | 	"TRAVIS_PULL_REQUEST"
181 | 	"TRAVIS_PULL_REQUEST_BRANCH"
182 | 	"TRAVIS_PULL_REQUEST_SHA"
183 | 	"TRAVIS_PULL_REQUEST_SLUG"
184 | 	"TRAVIS_REPO_SLUG"
185 | 	"TRAVIS_SECURE_ENV_VARS"
186 | 	"TRAVIS_TAG"
187 |     )
188 | elif [[ -n "${GITHUB_RUN_ID:-}" ]]; then
189 |     RUNNING_IN_CI="true"
190 |     TRAMPOLINE_CI="github-workflow"
191 |     pass_down_envvars+=(
192 | 	"GITHUB_WORKFLOW"
193 | 	"GITHUB_RUN_ID"
194 | 	"GITHUB_RUN_NUMBER"
195 | 	"GITHUB_ACTION"
196 | 	"GITHUB_ACTIONS"
197 | 	"GITHUB_ACTOR"
198 | 	"GITHUB_REPOSITORY"
199 | 	"GITHUB_EVENT_NAME"
200 | 	"GITHUB_EVENT_PATH"
201 | 	"GITHUB_SHA"
202 | 	"GITHUB_REF"
203 | 	"GITHUB_HEAD_REF"
204 | 	"GITHUB_BASE_REF"
205 |     )
206 | elif [[ "${CIRCLECI:-}" == "true" ]]; then
207 |     RUNNING_IN_CI="true"
208 |     TRAMPOLINE_CI="circleci"
209 |     pass_down_envvars+=(
210 | 	"CIRCLE_BRANCH"
211 | 	"CIRCLE_BUILD_NUM"
212 | 	"CIRCLE_BUILD_URL"
213 | 	"CIRCLE_COMPARE_URL"
214 | 	"CIRCLE_JOB"
215 | 	"CIRCLE_NODE_INDEX"
216 | 	"CIRCLE_NODE_TOTAL"
217 | 	"CIRCLE_PREVIOUS_BUILD_NUM"
218 | 	"CIRCLE_PROJECT_REPONAME"
219 | 	"CIRCLE_PROJECT_USERNAME"
220 | 	"CIRCLE_REPOSITORY_URL"
221 | 	"CIRCLE_SHA1"
222 | 	"CIRCLE_STAGE"
223 | 	"CIRCLE_USERNAME"
224 | 	"CIRCLE_WORKFLOW_ID"
225 | 	"CIRCLE_WORKFLOW_JOB_ID"
226 | 	"CIRCLE_WORKFLOW_UPSTREAM_JOB_IDS"
227 | 	"CIRCLE_WORKFLOW_WORKSPACE_ID"
228 |     )
229 | fi
230 | 
231 | # Configure the service account for pulling the docker image.
232 | function repo_root() {
233 |     local dir="$1"
234 |     while [[ ! -d "${dir}/.git" ]]; do
235 | 	dir="$(dirname "$dir")"
236 |     done
237 |     echo "${dir}"
238 | }
239 | 
240 | # Detect the project root. In CI builds, we assume the script is in
241 | # the git tree and traverse from there, otherwise, traverse from `pwd`
242 | # to find `.git` directory.
243 | if [[ "${RUNNING_IN_CI:-}" == "true" ]]; then
244 |     PROGRAM_PATH="$(realpath "$0")"
245 |     PROGRAM_DIR="$(dirname "${PROGRAM_PATH}")"
246 |     PROJECT_ROOT="$(repo_root "${PROGRAM_DIR}")"
247 | else
248 |     PROJECT_ROOT="$(repo_root $(pwd))"
249 | fi
250 | 
251 | log_yellow "Changing to the project root: ${PROJECT_ROOT}."
252 | cd "${PROJECT_ROOT}"
253 | 
254 | # To support relative path for `TRAMPOLINE_SERVICE_ACCOUNT`, we need
255 | # to use this environment variable in `PROJECT_ROOT`.
256 | if [[ -n "${TRAMPOLINE_SERVICE_ACCOUNT:-}" ]]; then
257 | 
258 |     mkdir -p "${tmpdir}/gcloud"
259 |     gcloud_config_dir="${tmpdir}/gcloud"
260 | 
261 |     log_yellow "Using isolated gcloud config: ${gcloud_config_dir}."
262 |     export CLOUDSDK_CONFIG="${gcloud_config_dir}"
263 | 
264 |     log_yellow "Using ${TRAMPOLINE_SERVICE_ACCOUNT} for authentication."
265 |     gcloud auth activate-service-account \
266 | 	   --key-file "${TRAMPOLINE_SERVICE_ACCOUNT}"
267 |     log_yellow "Configuring Container Registry access"
268 |     gcloud auth configure-docker --quiet
269 | fi
270 | 
271 | required_envvars=(
272 |     # The basic trampoline configurations.
273 |     "TRAMPOLINE_IMAGE"
274 |     "TRAMPOLINE_BUILD_FILE"
275 | )
276 | 
277 | if [[ -f "${PROJECT_ROOT}/.trampolinerc" ]]; then
278 |     source "${PROJECT_ROOT}/.trampolinerc"
279 | fi
280 | 
281 | log_yellow "Checking environment variables."
282 | for e in "${required_envvars[@]}"
283 | do
284 |     if [[ -z "${!e:-}" ]]; then
285 | 	log "Missing ${e} env var. Aborting."
286 | 	exit 1
287 |     fi
288 | done
289 | 
290 | # We want to support legacy style TRAMPOLINE_BUILD_FILE used with V1
291 | # script: e.g. "github/repo-name/.kokoro/run_tests.sh"
292 | TRAMPOLINE_BUILD_FILE="${TRAMPOLINE_BUILD_FILE#github/*/}"
293 | log_yellow "Using TRAMPOLINE_BUILD_FILE: ${TRAMPOLINE_BUILD_FILE}"
294 | 
295 | # ignore error on docker operations and test execution
296 | set +e
297 | 
298 | log_yellow "Preparing Docker image."
299 | # We only download the docker image in CI builds.
300 | if [[ "${RUNNING_IN_CI:-}" == "true" ]]; then
301 |     # Download the docker image specified by `TRAMPOLINE_IMAGE`
302 | 
303 |     # We may want to add --max-concurrent-downloads flag.
304 | 
305 |     log_yellow "Start pulling the Docker image: ${TRAMPOLINE_IMAGE}."
306 |     if docker pull "${TRAMPOLINE_IMAGE}"; then
307 | 	log_green "Finished pulling the Docker image: ${TRAMPOLINE_IMAGE}."
308 | 	has_image="true"
309 |     else
310 | 	log_red "Failed pulling the Docker image: ${TRAMPOLINE_IMAGE}."
311 | 	has_image="false"
312 |     fi
313 | else
314 |     # For local run, check if we have the image.
315 |     if docker images "${TRAMPOLINE_IMAGE}:latest" | grep "${TRAMPOLINE_IMAGE}"; then
316 | 	has_image="true"
317 |     else
318 | 	has_image="false"
319 |     fi
320 | fi
321 | 
322 | 
323 | # The default user for a Docker container has uid 0 (root). To avoid
324 | # creating root-owned files in the build directory we tell docker to
325 | # use the current user ID.
326 | user_uid="$(id -u)"
327 | user_gid="$(id -g)"
328 | user_name="$(id -un)"
329 | 
330 | # To allow docker in docker, we add the user to the docker group in
331 | # the host os.
332 | docker_gid=$(cut -d: -f3 < <(getent group docker))
333 | 
334 | update_cache="false"
335 | if [[ "${TRAMPOLINE_DOCKERFILE:-none}" != "none" ]]; then
336 |     # Build the Docker image from the source.
337 |     context_dir=$(dirname "${TRAMPOLINE_DOCKERFILE}")
338 |     docker_build_flags=(
339 | 	"-f" "${TRAMPOLINE_DOCKERFILE}"
340 | 	"-t" "${TRAMPOLINE_IMAGE}"
341 | 	"--build-arg" "UID=${user_uid}"
342 | 	"--build-arg" "USERNAME=${user_name}"
343 |     )
344 |     if [[ "${has_image}" == "true" ]]; then
345 | 	docker_build_flags+=("--cache-from" "${TRAMPOLINE_IMAGE}")
346 |     fi
347 | 
348 |     log_yellow "Start building the docker image."
349 |     if [[ "${TRAMPOLINE_VERBOSE:-false}" == "true" ]]; then
350 | 	echo "docker build" "${docker_build_flags[@]}" "${context_dir}"
351 |     fi
352 | 
353 |     # ON CI systems, we want to suppress docker build logs, only
354 |     # output the logs when it fails.
355 |     if [[ "${RUNNING_IN_CI:-}" == "true" ]]; then
356 | 	if docker build "${docker_build_flags[@]}" "${context_dir}" \
357 | 		  > "${tmpdir}/docker_build.log" 2>&1; then
358 | 	    if [[ "${TRAMPOLINE_VERBOSE:-}" == "true" ]]; then
359 | 		cat "${tmpdir}/docker_build.log"
360 | 	    fi
361 | 
362 | 	    log_green "Finished building the docker image."
363 | 	    update_cache="true"
364 | 	else
365 | 	    log_red "Failed to build the Docker image, aborting."
366 | 	    log_yellow "Dumping the build logs:"
367 | 	    cat "${tmpdir}/docker_build.log"
368 | 	    exit 1
369 | 	fi
370 |     else
371 | 	if docker build "${docker_build_flags[@]}" "${context_dir}"; then
372 | 	    log_green "Finished building the docker image."
373 | 	    update_cache="true"
374 | 	else
375 | 	    log_red "Failed to build the Docker image, aborting."
376 | 	    exit 1
377 | 	fi
378 |     fi
379 | else
380 |     if [[ "${has_image}" != "true" ]]; then
381 | 	log_red "We do not have ${TRAMPOLINE_IMAGE} locally, aborting."
382 | 	exit 1
383 |     fi
384 | fi
385 | 
386 | # We use an array for the flags so they are easier to document.
387 | docker_flags=(
388 |     # Remove the container after it exists.
389 |     "--rm"
390 | 
391 |     # Use the host network.
392 |     "--network=host"
393 | 
394 |     # Run in priviledged mode. We are not using docker for sandboxing or
395 |     # isolation, just for packaging our dev tools.
396 |     "--privileged"
397 | 
398 |     # Run the docker script with the user id. Because the docker image gets to
399 |     # write in ${PWD} you typically want this to be your user id.
400 |     # To allow docker in docker, we need to use docker gid on the host.
401 |     "--user" "${user_uid}:${docker_gid}"
402 | 
403 |     # Pass down the USER.
404 |     "--env" "USER=${user_name}"
405 | 
406 |     # Mount the project directory inside the Docker container.
407 |     "--volume" "${PROJECT_ROOT}:${TRAMPOLINE_WORKSPACE}"
408 |     "--workdir" "${TRAMPOLINE_WORKSPACE}"
409 |     "--env" "PROJECT_ROOT=${TRAMPOLINE_WORKSPACE}"
410 | 
411 |     # Mount the temporary home directory.
412 |     "--volume" "${tmphome}:/h"
413 |     "--env" "HOME=/h"
414 | 
415 |     # Allow docker in docker.
416 |     "--volume" "/var/run/docker.sock:/var/run/docker.sock"
417 | 
418 |     # Mount the /tmp so that docker in docker can mount the files
419 |     # there correctly.
420 |     "--volume" "/tmp:/tmp"
421 |     # Pass down the KOKORO_GFILE_DIR and KOKORO_KEYSTORE_DIR
422 |     # TODO(tmatsuo): This part is not portable.
423 |     "--env" "TRAMPOLINE_SECRET_DIR=/secrets"
424 |     "--volume" "${KOKORO_GFILE_DIR:-/dev/shm}:/secrets/gfile"
425 |     "--env" "KOKORO_GFILE_DIR=/secrets/gfile"
426 |     "--volume" "${KOKORO_KEYSTORE_DIR:-/dev/shm}:/secrets/keystore"
427 |     "--env" "KOKORO_KEYSTORE_DIR=/secrets/keystore"
428 | )
429 | 
430 | # Add an option for nicer output if the build gets a tty.
431 | if [[ -t 0 ]]; then
432 |     docker_flags+=("-it")
433 | fi
434 | 
435 | # Passing down env vars
436 | for e in "${pass_down_envvars[@]}"
437 | do
438 |     if [[ -n "${!e:-}" ]]; then
439 | 	docker_flags+=("--env" "${e}=${!e}")
440 |     fi
441 | done
442 | 
443 | # If arguments are given, all arguments will become the commands run
444 | # in the container, otherwise run TRAMPOLINE_BUILD_FILE.
445 | if [[ $# -ge 1 ]]; then
446 |     log_yellow "Running the given commands '" "${@:1}" "' in the container."
447 |     readonly commands=("${@:1}")
448 |     if [[ "${TRAMPOLINE_VERBOSE:-}" == "true" ]]; then
449 | 	echo docker run "${docker_flags[@]}" "${TRAMPOLINE_IMAGE}" "${commands[@]}"
450 |     fi
451 |     docker run "${docker_flags[@]}" "${TRAMPOLINE_IMAGE}" "${commands[@]}"
452 | else
453 |     log_yellow "Running the tests in a Docker container."
454 |     docker_flags+=("--entrypoint=${TRAMPOLINE_BUILD_FILE}")
455 |     if [[ "${TRAMPOLINE_VERBOSE:-}" == "true" ]]; then
456 | 	echo docker run "${docker_flags[@]}" "${TRAMPOLINE_IMAGE}"
457 |     fi
458 |     docker run "${docker_flags[@]}" "${TRAMPOLINE_IMAGE}"
459 | fi
460 | 
461 | 
462 | test_retval=$?
463 | 
464 | if [[ ${test_retval} -eq 0 ]]; then
465 |     log_green "Build finished with ${test_retval}"
466 | else
467 |     log_red "Build finished with ${test_retval}"
468 | fi
469 | 
470 | # Only upload it when the test passes.
471 | if [[ "${update_cache}" == "true" ]] && \
472 |        [[ $test_retval == 0 ]] && \
473 |        [[ "${TRAMPOLINE_IMAGE_UPLOAD:-false}" == "true" ]]; then
474 |     log_yellow "Uploading the Docker image."
475 |     if docker push "${TRAMPOLINE_IMAGE}"; then
476 | 	log_green "Finished uploading the Docker image."
477 |     else
478 | 	log_red "Failed uploading the Docker image."
479 |     fi
480 |     # Call trampoline_after_upload_hook if it's defined.
481 |     if function_exists trampoline_after_upload_hook; then
482 | 	trampoline_after_upload_hook
483 |     fi
484 | 
485 | fi
486 | 
487 | exit "${test_retval}"
488 | 


--------------------------------------------------------------------------------
/.repo-metadata.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "langchain-google-firestore",
 3 |     "name_pretty": "LangChain Google Firestore - Python",
 4 |     "issue_tracker": "https://github.com/googleapis/langchain-google-firestore-python/issues",
 5 |     "client_documentation": "https://github.com/googleapis/langchain-google-firestore-python/tree/main/docs",
 6 |     "release_level": "preview",
 7 |     "language": "python",
 8 |     "library_type": "OTHER",
 9 |     "repo": "googleapis/langchain-google-firestore-python",
10 |     "distribution_name": "langchain-google-firestore",
11 |     "requires_billing": true,
12 |     "codeowner_team": "@googleapis/senseai-eco"
13 | }
14 | 


--------------------------------------------------------------------------------
/.trampolinerc:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | # Add required env vars here.
16 | required_envvars+=(
17 | )
18 | 
19 | # Add env vars which are passed down into the container here.
20 | pass_down_envvars+=(
21 |     "NOX_SESSION"
22 |     ###############
23 |     # Docs builds
24 |     ###############
25 |     "STAGING_BUCKET"
26 |     "V2_STAGING_BUCKET"
27 |     ##################
28 |     # Samples builds
29 |     ##################
30 |     "INSTALL_LIBRARY_FROM_SOURCE"
31 |     "RUN_TESTS_SESSION"
32 |     "BUILD_SPECIFIC_GCLOUD_PROJECT"
33 |     # Target directories.
34 |     "RUN_TESTS_DIRS"
35 |     # The nox session to run.
36 |     "RUN_TESTS_SESSION"
37 | )
38 | 
39 | # Prevent unintentional override on the default image.
40 | if [[ "${TRAMPOLINE_IMAGE_UPLOAD:-false}" == "true" ]] && \
41 |    [[ -z "${TRAMPOLINE_IMAGE:-}" ]]; then
42 |    echo "Please set TRAMPOLINE_IMAGE if you want to upload the Docker image."
43 |    exit 1
44 | fi
45 | 
46 | # Define the default value if it makes sense.
47 | if [[ -z "${TRAMPOLINE_IMAGE_UPLOAD:-}" ]]; then
48 |     TRAMPOLINE_IMAGE_UPLOAD=""
49 | fi
50 | 
51 | if [[ -z "${TRAMPOLINE_IMAGE:-}" ]]; then
52 |     TRAMPOLINE_IMAGE=""
53 | fi
54 | 
55 | if [[ -z "${TRAMPOLINE_DOCKERFILE:-}" ]]; then
56 |     TRAMPOLINE_DOCKERFILE=""
57 | fi
58 | 
59 | if [[ -z "${TRAMPOLINE_BUILD_FILE:-}" ]]; then
60 |     TRAMPOLINE_BUILD_FILE=""
61 | fi


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | ## [0.5.0](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.4.0...v0.5.0) (2024-10-29)
 4 | 
 5 | 
 6 | ### ⚠ BREAKING CHANGES
 7 | 
 8 | * Change store_encodings flag to False in add_images method [#108](https://github.com/googleapis/langchain-google-firestore-python/issues/108) ([#109](https://github.com/googleapis/langchain-google-firestore-python/issues/109)) ([d76c1d2](https://github.com/googleapis/langchain-google-firestore-python/commit/d76c1d291636492070d10c9b6208cf4baede4149))
 9 | 
10 | ### Features
11 | 
12 | * Remove support for Python 3.8 ([#107](https://github.com/googleapis/langchain-google-firestore-python/issues/107)) ([9b53093](https://github.com/googleapis/langchain-google-firestore-python/commit/9b5309385486ce44fa14431851508cfc20b144ba))
13 | 
14 | 
15 | ### Documentation
16 | 
17 | * Add documentation on add_images method ([79c1937](https://github.com/googleapis/langchain-google-firestore-python/commit/79c19379985f7474b92766ee7f22386e772c2747))
18 | 
19 | ## [0.4.0](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.3.0...v0.4.0) (2024-09-27)
20 | 
21 | 
22 | ### Features
23 | 
24 | * Added image support to FirestoreVectorStore along with basic tests ([#97](https://github.com/googleapis/langchain-google-firestore-python/issues/97)) ([b8fc685](https://github.com/googleapis/langchain-google-firestore-python/commit/b8fc6853201b17523f78e3491073293df9127a38))
25 | 
26 | 
27 | ### Bug Fixes
28 | 
29 | * Vectorstore user agent ([#98](https://github.com/googleapis/langchain-google-firestore-python/issues/98)) ([765232c](https://github.com/googleapis/langchain-google-firestore-python/commit/765232cb5278079bf106e570b40b889931429193))
30 | 
31 | 
32 | ### Documentation
33 | 
34 | * Update README.rst title size ([#88](https://github.com/googleapis/langchain-google-firestore-python/issues/88)) ([36ed233](https://github.com/googleapis/langchain-google-firestore-python/commit/36ed2339130c247159d8b88e4b4aabbe775021b8))
35 | 
36 | ## [0.3.0](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.2.1...v0.3.0) (2024-05-16)
37 | 
38 | 
39 | ### Features
40 | 
41 | * Optional message encoding. ([#65](https://github.com/googleapis/langchain-google-firestore-python/issues/65)) ([9b10d7a](https://github.com/googleapis/langchain-google-firestore-python/commit/9b10d7abb0d6009ca9997ce25a162d7a42065188))
42 | 
43 | 
44 | ### Bug Fixes
45 | 
46 | * Fix broken link in README.rst ([#63](https://github.com/googleapis/langchain-google-firestore-python/issues/63)) ([27c361c](https://github.com/googleapis/langchain-google-firestore-python/commit/27c361c2551479f7def81cb182c7fe29534c07a7))
47 | 
48 | ## [0.2.1](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.2.0...v0.2.1) (2024-05-01)
49 | 
50 | 
51 | ### Documentation
52 | 
53 | * Add API reference docs ([#61](https://github.com/googleapis/langchain-google-firestore-python/issues/61)) ([93d63d9](https://github.com/googleapis/langchain-google-firestore-python/commit/93d63d928c265b466a3feaf78c55a485cd472365))
54 | * Add FirestoreVectorStore usage to README ([#48](https://github.com/googleapis/langchain-google-firestore-python/issues/48)) ([0cbe8ee](https://github.com/googleapis/langchain-google-firestore-python/commit/0cbe8ee9b767435cac805ca644b97c678dbe54b4))
55 | 
56 | ## [0.2.0](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.1.2...v0.2.0) (2024-04-03)
57 | 
58 | 
59 | ### Features
60 | 
61 | * **ci:** Test against multiple versions ([#35](https://github.com/googleapis/langchain-google-firestore-python/issues/35)) ([1639f3a](https://github.com/googleapis/langchain-google-firestore-python/commit/1639f3a839f7608fba86e7aee9e7733a4b00df55))
62 | * Firestore Vector Store ([#7](https://github.com/googleapis/langchain-google-firestore-python/issues/7)) ([2845e97](https://github.com/googleapis/langchain-google-firestore-python/commit/2845e9700cf8904926898e972cfa94346ac7c626))
63 | 
64 | 
65 | ### Bug Fixes
66 | 
67 | * Update common.py ([#43](https://github.com/googleapis/langchain-google-firestore-python/issues/43)) ([96028f9](https://github.com/googleapis/langchain-google-firestore-python/commit/96028f94504841977a22f0297083507a949825c4))
68 | 
69 | ## [0.1.2](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.1.1...v0.1.2) (2024-03-25)
70 | 
71 | 
72 | ### Bug Fixes
73 | 
74 | * Update user agent ([#37](https://github.com/googleapis/langchain-google-firestore-python/issues/37)) ([f61fd80](https://github.com/googleapis/langchain-google-firestore-python/commit/f61fd80d56669ac4f33e56f1c47c83e8c02b6a63))
75 | 
76 | 
77 | ### Documentation
78 | 
79 | * Add github links ([#28](https://github.com/googleapis/langchain-google-firestore-python/issues/28)) ([b403206](https://github.com/googleapis/langchain-google-firestore-python/commit/b403206ee2b16ac1e3b467ab2cd9de887fb71e38))
80 | * Fix install command ([#36](https://github.com/googleapis/langchain-google-firestore-python/issues/36)) ([b2d5850](https://github.com/googleapis/langchain-google-firestore-python/commit/b2d58500e7f2e7493cedb6fc38d3af6f226aff41))
81 | 
82 | ## [0.1.1](https://github.com/googleapis/langchain-google-firestore-python/compare/v0.1.0...v0.1.1) (2024-03-06)
83 | 
84 | 
85 | ### Bug Fixes
86 | 
87 | * Update user agent ([#26](https://github.com/googleapis/langchain-google-firestore-python/issues/26)) ([b96117b](https://github.com/googleapis/langchain-google-firestore-python/commit/b96117b3a78679a481565934a80a7c812ae48340))
88 | 
89 | ## 0.1.0 (2024-02-26)
90 | 
91 | 
92 | ### Features
93 | 
94 | * Add Chat Message History for Firestore. ([#10](https://github.com/googleapis/langchain-google-firestore-python/issues/10)) ([8cc242f](https://github.com/googleapis/langchain-google-firestore-python/commit/8cc242f5fba383704f9cb6bd991db19ce6ad6308))
95 | * Document Loader and Saver for Firestore ([#9](https://github.com/googleapis/langchain-google-firestore-python/issues/9)) ([791fcf6](https://github.com/googleapis/langchain-google-firestore-python/commit/791fcf6ec983e57e06f33e91f148846a1f9df287))
96 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | <!-- # Generated by synthtool. DO NOT EDIT! !-->
 2 | # Code of Conduct
 3 | 
 4 | ## Our Pledge
 5 | 
 6 | In the interest of fostering an open and welcoming environment, we as
 7 | contributors and maintainers pledge to making participation in our project and
 8 | our community a harassment-free experience for everyone, regardless of age, body
 9 | size, disability, ethnicity, gender identity and expression, level of
10 | experience, education, socio-economic status, nationality, personal appearance,
11 | race, religion, or sexual identity and orientation.
12 | 
13 | ## Our Standards
14 | 
15 | Examples of behavior that contributes to creating a positive environment
16 | include:
17 | 
18 | *   Using welcoming and inclusive language
19 | *   Being respectful of differing viewpoints and experiences
20 | *   Gracefully accepting constructive criticism
21 | *   Focusing on what is best for the community
22 | *   Showing empathy towards other community members
23 | 
24 | Examples of unacceptable behavior by participants include:
25 | 
26 | *   The use of sexualized language or imagery and unwelcome sexual attention or
27 |     advances
28 | *   Trolling, insulting/derogatory comments, and personal or political attacks
29 | *   Public or private harassment
30 | *   Publishing others' private information, such as a physical or electronic
31 |     address, without explicit permission
32 | *   Other conduct which could reasonably be considered inappropriate in a
33 |     professional setting
34 | 
35 | ## Our Responsibilities
36 | 
37 | Project maintainers are responsible for clarifying the standards of acceptable
38 | behavior and are expected to take appropriate and fair corrective action in
39 | response to any instances of unacceptable behavior.
40 | 
41 | Project maintainers have the right and responsibility to remove, edit, or reject
42 | comments, commits, code, wiki edits, issues, and other contributions that are
43 | not aligned to this Code of Conduct, or to ban temporarily or permanently any
44 | contributor for other behaviors that they deem inappropriate, threatening,
45 | offensive, or harmful.
46 | 
47 | ## Scope
48 | 
49 | This Code of Conduct applies both within project spaces and in public spaces
50 | when an individual is representing the project or its community. Examples of
51 | representing a project or community include using an official project e-mail
52 | address, posting via an official social media account, or acting as an appointed
53 | representative at an online or offline event. Representation of a project may be
54 | further defined and clarified by project maintainers.
55 | 
56 | This Code of Conduct also applies outside the project spaces when the Project
57 | Steward has a reasonable belief that an individual's behavior may have a
58 | negative impact on the project or its community.
59 | 
60 | ## Conflict Resolution
61 | 
62 | We do not believe that all conflict is bad; healthy debate and disagreement
63 | often yield positive results. However, it is never okay to be disrespectful or
64 | to engage in behavior that violates the project’s code of conduct.
65 | 
66 | If you see someone violating the code of conduct, you are encouraged to address
67 | the behavior directly with those involved. Many issues can be resolved quickly
68 | and easily, and this gives people more control over the outcome of their
69 | dispute. If you are unable to resolve the matter for any reason, or if the
70 | behavior is threatening or harassing, report it. We are dedicated to providing
71 | an environment where participants feel welcome and safe.
72 | 
73 | Reports should be directed to *cloud-database-oss-stewards@google.com*, the
74 | Project Steward(s) for this client library. It is the Project Steward’s duty to
75 | receive and address reported violations of the code of conduct. They will then
76 | work with a committee consisting of representatives from the Open Source
77 | Programs Office and the Google Open Source Strategy team. If for any reason you
78 | are uncomfortable reaching out to the Project Steward, please email
79 | opensource@google.com.
80 | 
81 | We will investigate every complaint, but you may not receive a direct response.
82 | We will use our discretion in determining when and how to follow up on reported
83 | incidents, which may range from not taking action to permanent expulsion from
84 | the project and project-sponsored spaces. We will notify the accused of the
85 | report and provide them an opportunity to discuss it before any action is taken.
86 | The identity of the reporter will be omitted from the details of the report
87 | supplied to the accused. In potentially harmful situations, such as ongoing
88 | harassment or threats to anyone's safety, we may take action without notice.
89 | 
90 | ## Attribution
91 | 
92 | This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
93 | available at
94 | https://www.contributor-covenant.org/version/1/4/code-of-conduct.html


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to Contribute
 2 | 
 3 | We'd love to accept your patches and contributions to this project. There are
 4 | just a few small guidelines you need to follow.
 5 | 
 6 | ## Contributor License Agreement
 7 | 
 8 | Contributions to this project must be accompanied by a Contributor License
 9 | Agreement (CLA). You (or your employer) retain the copyright to your
10 | contribution; this simply gives us permission to use and redistribute your
11 | contributions as part of the project. Head over to
12 | <https://cla.developers.google.com/> to see your current agreements on file or
13 | to sign a new one.
14 | 
15 | You generally only need to submit a CLA once, so if you've already submitted one
16 | (even if it was for a different project), you probably don't need to do it
17 | again.
18 | 
19 | ## Code Reviews
20 | 
21 | All submissions, including submissions by project members, require review. We
22 | use GitHub pull requests for this purpose. Consult
23 | [GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
24 | information on using pull requests.
25 | 
26 | ## Community Guidelines
27 | 
28 | This project follows
29 | [Google's Open Source Community Guidelines](https://opensource.google/conduct/).


--------------------------------------------------------------------------------
/DEVELOPER.md:
--------------------------------------------------------------------------------
 1 | # DEVELOPER.md
 2 | 
 3 | ## Versioning
 4 | 
 5 | This library follows [Semantic Versioning](http://semver.org/).
 6 | 
 7 | ## Processes
 8 | 
 9 | ### Conventional Commit messages
10 | 
11 | This repository uses tool [Release Please](https://github.com/googleapis/release-please) to create GitHub and PyPi releases. It does so by parsing your
12 | git history, looking for [Conventional Commit messages](https://www.conventionalcommits.org/),
13 | and creating release PRs.
14 | 
15 | Learn more by reading [How should I write my commits?](https://github.com/googleapis/release-please?tab=readme-ov-file#how-should-i-write-my-commits)
16 | 
17 | ## Testing
18 | 
19 | ### Run tests locally
20 | 
21 | 1. Before running tests, install `langchain_google_firestore` locally:
22 | 
23 |     ```bash
24 |     pip install -e .
25 |     ```
26 | 
27 | 2. Run pytest to automatically run all tests:
28 | 
29 |     ```bash
30 |     pytest
31 |     ```
32 | 
33 | ### CI Platform Setup
34 | 
35 | Cloud Build is used to run tests against Google Cloud resources in test project: langchain-firestore-testing.
36 | Each test has a corresponding Cloud Build trigger, see [all triggers][triggers].
37 | These tests are registered as required tests in `.github/sync-repo-settings.yaml`.
38 | 
39 | #### Trigger Setup
40 | 
41 | Cloud Build triggers (for Python versions 3.8 to 3.11) were created with the following specs:
42 | 
43 | ```YAML
44 | name: integration-test-pr-py39
45 | description: Run integration tests on PR for Python 3.9
46 | filename: integration.cloudbuild.yaml
47 | github:
48 |   name: langchain-google-firestore-python
49 |   owner: googleapis
50 |   pullRequest:
51 |     branch: .*
52 |     commentControl: COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY
53 | ignoredFiles:
54 |   - docs/**
55 |   - .kokoro/**
56 |   - .github/**
57 |   - "*.md"
58 | substitutions:
59 |   _VERSION: "3.9"
60 | ```
61 | 
62 | Use `gcloud builds triggers import --source=trigger.yaml` to create triggers via the command line
63 | 
64 | #### Project Setup
65 | 
66 | 1. Create an Firestore cluster, instance, and database
67 | 1. Setup Cloud Build triggers (above)
68 | 
69 | #### Run tests with Cloud Build
70 | 
71 | * Run integration test:
72 | 
73 |     ```bash
74 |     gcloud builds submit --config integration.cloudbuild.yaml --region us-central1
75 |     ```
76 | 
77 | #### Trigger
78 | 
79 | To run Cloud Build tests on GitHub from external contributors, ie RenovateBot, comment: `/gcbrun`.
80 | 
81 | #### Code Coverage
82 | Please make sure your code is fully tested. The Cloud Build integration tests are run with the `pytest-cov` code coverage plugin. They fail for PRs with a code coverage less than the threshold specified in `.coveragerc`.  If your file is inside the main module and should be ignored by code coverage check, add it to the `omit` section of `.coveragerc`.
83 | 
84 | Check for code coverage report in any Cloud Build integration test log.
85 | Here is a breakdown of the report:
86 | - `Stmts`:  lines of executable code (statements).
87 | - `Miss`: number of lines not covered by tests.
88 | - `Branch`: branches of executable code (e.g an if-else clause may count as 1 statement but 2 branches; test for both conditions to have both branches covered).
89 | - `BrPart`: number of branches not covered by tests.
90 | - `Cover`: average coverage of files.
91 | - `Missing`: lines that are not covered by tests.
92 | 
93 | 
94 | [triggers]: https://console.cloud.google.com/cloud-build/triggers?e=13802955&project=langchain-firestore-testing
95 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | Firestore for LangChain
  2 | =======================
  3 | 
  4 | |preview| |pypi| |versions|
  5 | 
  6 | - `Client Library Documentation`_
  7 | - `Product Documentation`_
  8 | 
  9 | .. |preview| image:: https://img.shields.io/badge/support-preview-orange.svg
 10 |    :target: https://cloud.google.com/products#product-launch-stages
 11 | .. |pypi| image:: https://img.shields.io/pypi/v/langchain-google-firestore.svg
 12 |    :target: https://pypi.org/project/langchain-google-firestore/
 13 | .. |versions| image:: https://img.shields.io/pypi/pyversions/langchain-google-firestore.svg
 14 |    :target: https://pypi.org/project/langchain-google-firestore/
 15 | .. _Client Library Documentation: https://cloud.google.com/python/docs/reference/langchain-google-firestore/latest
 16 | .. _Product Documentation: https://cloud.google.com/firestore
 17 | 
 18 | Quick Start
 19 | -----------
 20 | 
 21 | In order to use this library, you first need to go through the following
 22 | steps:
 23 | 
 24 | 1. `Select or create a Cloud Platform project.`_
 25 | 2. `Enable billing for your project.`_
 26 | 3. `Enable the Google Cloud Firestore API.`_
 27 | 4. `Setup Authentication.`_
 28 | 
 29 | .. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project
 30 | .. _Enable billing for your project.: https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project
 31 | .. _Enable the Google Cloud Firestore API.: https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com
 32 | .. _Setup Authentication.: https://googleapis.dev/python/google-api-core/latest/auth.html
 33 | 
 34 | Installation
 35 | ~~~~~~~~~~~~
 36 | 
 37 | Install this library in a `virtualenv`_ using pip. `virtualenv`_ is a tool to create isolated Python environments. The basic problem it addresses is
 38 | one of dependencies and versions, and indirectly permissions.
 39 | 
 40 | With `virtualenv`_, it’s possible to install this library without needing system install permissions, and without clashing with the installed system dependencies.
 41 | 
 42 | .. _`virtualenv`: https://virtualenv.pypa.io/en/latest/
 43 | 
 44 | Supported Python Versions
 45 | ^^^^^^^^^^^^^^^^^^^^^^^^^
 46 | 
 47 | Python >= 3.9
 48 | 
 49 | Mac/Linux
 50 | ^^^^^^^^^
 51 | 
 52 | .. code-block:: console
 53 | 
 54 |    pip install virtualenv
 55 |    virtualenv <your-env>
 56 |    source <your-env>/bin/activate
 57 |    <your-env>/bin/pip install langchain-google-firestore
 58 | 
 59 | Windows
 60 | ^^^^^^^
 61 | 
 62 | .. code-block:: console
 63 | 
 64 |    pip install virtualenv
 65 |    virtualenv <your-env>
 66 |    <your-env>\Scripts\activate
 67 |    <your-env>\Scripts\pip.exe install langchain-google-firestore
 68 | 
 69 | Vector Store Usage
 70 | ~~~~~~~~~~~~~~~~~~~
 71 | 
 72 | Use a vector store to store embedded data and perform vector search.
 73 | 
 74 | .. code-block:: python
 75 |     
 76 |     from langchain_google_firestore import FirestoreVectorStore
 77 |     from langchain_google_vertexai import VertexAIEmbeddings
 78 | 
 79 | 
 80 |     embedding = VertexAIEmbeddings(model_name="textembedding-gecko@003")
 81 |     store = FirestoreVectorStore(
 82 |         collection="VectorStore",
 83 |         embedding=embedding
 84 |     )
 85 | 
 86 | See the full `Vector Store`_ tutorial.
 87 | 
 88 | .. _`Vector Store`: https://github.com/googleapis/langchain-google-firestore-python/blob/main/docs/vectorstores.ipynb
 89 | 
 90 | Document Loader Usage
 91 | ~~~~~~~~~~~~~~~~~~~~~
 92 | 
 93 | Use a document loader to load data as LangChain ``Document``\ s.
 94 | 
 95 | .. code-block:: python
 96 | 
 97 |     from langchain_google_firestore import FirestoreLoader
 98 | 
 99 |     loader = FirestoreLoader("Collection")
100 |     docs = loader.lazy_load()
101 | 
102 | See the full `Document Loader`_ tutorial.
103 | 
104 | .. _`Document Loader`: https://github.com/googleapis/langchain-google-firestore-python/blob/main/docs/document_loader.ipynb
105 | 
106 | Chat Message History Usage
107 | ~~~~~~~~~~~~~~~~~~~~~~~~~~
108 | 
109 | Use ``ChatMessageHistory`` to store messages and provide conversation
110 | history to LLMs.
111 | 
112 | .. code:: python
113 |     
114 |     from langchain_google_firestore import FirestoreChatMessageHistory
115 | 
116 |     history = FirestoreChatMessageHistory(
117 |         session_id="my-session-id",
118 |         collection="HistoryMessages"
119 |     )
120 | 
121 | See the full `Chat Message History`_ tutorial.
122 | 
123 | .. _`Chat Message History`: https://github.com/googleapis/langchain-google-firestore-python/blob/main/docs/chat_message_history.ipynb
124 | 
125 | Contributions
126 | ~~~~~~~~~~~~~
127 | 
128 | Contributions to this library are always welcome and highly encouraged.
129 | 
130 | See `CONTRIBUTING`_ for more information how to get started.
131 | 
132 | Please note that this project is released with a Contributor Code of Conduct. By participating in
133 | this project you agree to abide by its terms. See `Code of Conduct`_ for more
134 | information.
135 | 
136 | .. _`CONTRIBUTING`: https://github.com/googleapis/langchain-google-firestore-python/blob/main/CONTRIBUTING.md
137 | .. _`Code of Conduct`: https://github.com/googleapis/langchain-google-firestore-python/blob/main/CODE_OF_CONDUCT.md
138 | 
139 | 
140 | License
141 | -------
142 | 
143 | Apache 2.0 - See
144 | `LICENSE <https://github.com/googleapis/langchain-google-firestore-python/blob/main/LICENSE>`_
145 | for more information.
146 | 
147 | Disclaimer
148 | ----------
149 | 
150 | This is not an officially supported Google product.
151 | 
152 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
1 | # Security Policy
2 | 
3 | To report a security issue, please use [g.co/vulnz](https://g.co/vulnz).
4 | 
5 | The Google Security Team will respond within 5 working days of your report on g.co/vulnz.
6 | 
7 | We use g.co/vulnz for our intake, and do coordination and disclosure here using GitHub Security Advisory to privately discuss and fix the issue.
8 | 


--------------------------------------------------------------------------------
/docs/README.rst:
--------------------------------------------------------------------------------
1 | ../README.rst


--------------------------------------------------------------------------------
/docs/_static/custom.css:
--------------------------------------------------------------------------------
 1 | div#python2-eol {
 2 | 	border-color: red;
 3 | 	border-width: medium;
 4 | }
 5 | 
 6 | /* Ensure minimum width for 'Parameters' / 'Returns' column */
 7 | dl.field-list > dt {
 8 |     min-width: 100px
 9 | }
10 | 
11 | /* Insert space between methods for readability */
12 | dl.method {
13 | 	padding-top: 10px;
14 | 	padding-bottom: 10px
15 | }
16 | 
17 | /* Insert empty space between classes */
18 | dl.class {
19 | 	padding-bottom: 50px
20 | }


--------------------------------------------------------------------------------
/docs/changelog.md:
--------------------------------------------------------------------------------
1 | ../CHANGELOG.md


--------------------------------------------------------------------------------
/docs/chat_message_history.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Google Firestore (Native Mode)\n",
  8 |     "\n",
  9 |     "> [Firestore](https://cloud.google.com/firestore) is a serverless document-oriented database that scales to meet any demand. Extend your database application to build AI-powered experiences leveraging Firestore's Langchain integrations.\n",
 10 |     "\n",
 11 |     "This notebook goes over how to use [Firestore](https://cloud.google.com/firestore) to to store chat message history with the `FirestoreChatMessageHistory` class.\n",
 12 |     "\n",
 13 |     "Learn more about the package on [GitHub](https://github.com/googleapis/langchain-google-firestore-python/).\n",
 14 |     "\n",
 15 |     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googleapis/langchain-google-firestore-python/blob/main/docs/chat_message_history.ipynb)"
 16 |    ]
 17 |   },
 18 |   {
 19 |    "cell_type": "markdown",
 20 |    "metadata": {},
 21 |    "source": [
 22 |     "## Before You Begin\n",
 23 |     "\n",
 24 |     "To run this notebook, you will need to do the following:\n",
 25 |     "\n",
 26 |     "* [Create a Google Cloud Project](https://developers.google.com/workspace/guides/create-project)\n",
 27 |     "* [Enable the Firestore API](https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com)\n",
 28 |     "* [Create a Firestore database](https://cloud.google.com/firestore/docs/manage-databases)\n",
 29 |     "\n",
 30 |     "After confirmed access to database in the runtime environment of this notebook, filling the following values and run the cell before running example scripts."
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "markdown",
 35 |    "metadata": {},
 36 |    "source": [
 37 |     "### 🦜🔗 Library Installation\n",
 38 |     "\n",
 39 |     "The integration lives in its own `langchain-google-firestore` package, so we need to install it."
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": null,
 45 |    "metadata": {
 46 |     "tags": []
 47 |    },
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "%pip install --upgrade --quiet langchain-google-firestore"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "markdown",
 55 |    "metadata": {},
 56 |    "source": [
 57 |     "**Colab only**: Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": null,
 63 |    "metadata": {},
 64 |    "outputs": [],
 65 |    "source": [
 66 |     "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
 67 |     "# import IPython\n",
 68 |     "\n",
 69 |     "# app = IPython.Application.instance()\n",
 70 |     "# app.kernel.do_shutdown(True)"
 71 |    ]
 72 |   },
 73 |   {
 74 |    "cell_type": "markdown",
 75 |    "metadata": {},
 76 |    "source": [
 77 |     "### ☁ Set Your Google Cloud Project\n",
 78 |     "Set your Google Cloud project so that you can leverage Google Cloud resources within this notebook.\n",
 79 |     "\n",
 80 |     "If you don't know your project ID, try the following:\n",
 81 |     "\n",
 82 |     "* Run `gcloud config list`.\n",
 83 |     "* Run `gcloud projects list`.\n",
 84 |     "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)."
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": null,
 90 |    "metadata": {},
 91 |    "outputs": [],
 92 |    "source": [
 93 |     "# @markdown Please fill in the value below with your Google Cloud project ID and then run the cell.\n",
 94 |     "\n",
 95 |     "PROJECT_ID = \"my-project-id\"  # @param {type:\"string\"}\n",
 96 |     "\n",
 97 |     "# Set the project id\n",
 98 |     "!gcloud config set project {PROJECT_ID}"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "markdown",
103 |    "metadata": {},
104 |    "source": [
105 |     "### 🔐 Authentication\n",
106 |     "\n",
107 |     "Authenticate to Google Cloud as the IAM user logged into this notebook in order to access your Google Cloud Project.\n",
108 |     "\n",
109 |     "- If you are using Colab to run this notebook, use the cell below and continue.\n",
110 |     "- If you are using Vertex AI Workbench, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
111 |    ]
112 |   },
113 |   {
114 |    "cell_type": "code",
115 |    "execution_count": null,
116 |    "metadata": {},
117 |    "outputs": [],
118 |    "source": [
119 |     "from google.colab import auth\n",
120 |     "\n",
121 |     "auth.authenticate_user()"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "markdown",
126 |    "metadata": {},
127 |    "source": [
128 |     "## Basic Usage"
129 |    ]
130 |   },
131 |   {
132 |    "cell_type": "markdown",
133 |    "metadata": {},
134 |    "source": [
135 |     "### FirestoreChatMessageHistory\n",
136 |     "\n",
137 |     "To initialize the `FirestoreChatMessageHistory` class you need to provide only 3 things:\n",
138 |     "\n",
139 |     "1. `session_id` - A unique identifier string that specifies an id for the session.\n",
140 |     "1. `collection` : The single `/`-delimited path to a Firestore collection."
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "code",
145 |    "execution_count": null,
146 |    "metadata": {},
147 |    "outputs": [],
148 |    "source": [
149 |     "from langchain_google_firestore import FirestoreChatMessageHistory\n",
150 |     "\n",
151 |     "chat_history = FirestoreChatMessageHistory(\n",
152 |     "    session_id=\"user-session-id\", collection=\"HistoryMessages\"\n",
153 |     ")\n",
154 |     "\n",
155 |     "chat_history.add_user_message(\"Hi!\")\n",
156 |     "chat_history.add_ai_message(\"How can I help you?\")"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "code",
161 |    "execution_count": null,
162 |    "metadata": {},
163 |    "outputs": [],
164 |    "source": [
165 |     "chat_history.messages"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "markdown",
170 |    "metadata": {},
171 |    "source": [
172 |     "#### Cleaning up\n",
173 |     "When the history of a specific session is obsolete and can be deleted from the database and memory, it can be done the following way.\n",
174 |     "\n",
175 |     "**Note:** Once deleted, the data is no longer stored in Firestore and is gone forever."
176 |    ]
177 |   },
178 |   {
179 |    "cell_type": "code",
180 |    "execution_count": null,
181 |    "metadata": {},
182 |    "outputs": [],
183 |    "source": [
184 |     "chat_history.clear()"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "markdown",
189 |    "metadata": {},
190 |    "source": [
191 |     "### Custom Client\n",
192 |     "\n",
193 |     "The client is created by default using the available environment variables. A [custom client](https://cloud.google.com/python/docs/reference/firestore/latest/client) can be passed to the constructor."
194 |    ]
195 |   },
196 |   {
197 |    "cell_type": "code",
198 |    "execution_count": null,
199 |    "metadata": {},
200 |    "outputs": [],
201 |    "source": [
202 |     "from google.auth import compute_engine\n",
203 |     "from google.cloud import firestore\n",
204 |     "\n",
205 |     "client = firestore.Client(\n",
206 |     "    project=\"project-custom\",\n",
207 |     "    database=\"non-default-database\",\n",
208 |     "    credentials=compute_engine.Credentials(),\n",
209 |     ")\n",
210 |     "\n",
211 |     "history = FirestoreChatMessageHistory(\n",
212 |     "    session_id=\"session-id\", collection=\"History\", client=client\n",
213 |     ")\n",
214 |     "\n",
215 |     "history.add_user_message(\"New message\")\n",
216 |     "\n",
217 |     "history.messages\n",
218 |     "\n",
219 |     "history.clear()"
220 |    ]
221 |   }
222 |  ],
223 |  "metadata": {
224 |   "kernelspec": {
225 |    "display_name": "Python 3 (ipykernel)",
226 |    "language": "python",
227 |    "name": "python3"
228 |   },
229 |   "language_info": {
230 |    "codemirror_mode": {
231 |     "name": "ipython",
232 |     "version": 3
233 |    },
234 |    "file_extension": ".py",
235 |    "mimetype": "text/x-python",
236 |    "name": "python",
237 |    "nbconvert_exporter": "python",
238 |    "pygments_lexer": "ipython3",
239 |    "version": "3.10.6"
240 |   }
241 |  },
242 |  "nbformat": 4,
243 |  "nbformat_minor": 4
244 | }
245 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # Copyright 2024 Google LLC
  3 | #
  4 | # Licensed under the Apache License, Version 2.0 (the "License");
  5 | # you may not use this file except in compliance with the License.
  6 | # You may obtain a copy of the License at
  7 | #
  8 | # http://www.apache.org/licenses/LICENSE-2.0
  9 | #
 10 | # Unless required by applicable law or agreed to in writing, software
 11 | # distributed under the License is distributed on an "AS IS" BASIS,
 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | # See the License for the specific language governing permissions and
 14 | # limitations under the License.
 15 | #
 16 | # langchain-google-firestore documentation build configuration file
 17 | #
 18 | # This file is execfile()d with the current directory set to its
 19 | # containing dir.
 20 | #
 21 | # Note that not all possible configuration values are present in this
 22 | # autogenerated file.
 23 | #
 24 | # All configuration values have a default; values that are commented out
 25 | # serve to show the default.
 26 | 
 27 | import os
 28 | import shlex
 29 | import sys
 30 | 
 31 | # If extensions (or modules to document with autodoc) are in another directory,
 32 | # add these directories to sys.path here. If the directory is relative to the
 33 | # documentation root, use os.path.abspath to make it absolute, like shown here.
 34 | sys.path.insert(0, os.path.abspath(".."))
 35 | 
 36 | # For plugins that can not read conf.py.
 37 | # See also: https://github.com/docascode/sphinx-docfx-yaml/issues/85
 38 | sys.path.insert(0, os.path.abspath("."))
 39 | 
 40 | __version__ = ""
 41 | 
 42 | # -- General configuration ------------------------------------------------
 43 | 
 44 | # If your documentation needs a minimal Sphinx version, state it here.
 45 | needs_sphinx = "1.5.5"
 46 | 
 47 | # Add any Sphinx extension module names here, as strings. They can be
 48 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 49 | # ones.
 50 | extensions = [
 51 |     "sphinx.ext.autodoc",
 52 |     "sphinx.ext.autosummary",
 53 |     "sphinx.ext.intersphinx",
 54 |     "sphinx.ext.coverage",
 55 |     "sphinx.ext.doctest",
 56 |     "sphinx.ext.napoleon",
 57 |     "sphinx.ext.todo",
 58 |     "sphinx.ext.viewcode",
 59 |     "recommonmark",
 60 | ]
 61 | 
 62 | # autodoc/autosummary flags
 63 | autoclass_content = "both"
 64 | autodoc_default_options = {"members": True}
 65 | autosummary_generate = True
 66 | 
 67 | 
 68 | # Add any paths that contain templates here, relative to this directory.
 69 | templates_path = ["_templates"]
 70 | 
 71 | # The suffix(es) of source filenames.
 72 | # You can specify multiple suffix as a list of string:
 73 | # source_suffix = ['.rst', '.md']
 74 | source_suffix = [".rst", ".md"]
 75 | 
 76 | # The encoding of source files.
 77 | # source_encoding = 'utf-8-sig'
 78 | 
 79 | # The root toctree document.
 80 | root_doc = "index"
 81 | 
 82 | # General information about the project.
 83 | project = "langchain-google-firestore"
 84 | copyright = "2024, Google"
 85 | author = "Google APIs"
 86 | 
 87 | # The version info for the project you're documenting, acts as replacement for
 88 | # |version| and |release|, also used in various other places throughout the
 89 | # built documents.
 90 | #
 91 | # The full version, including alpha/beta/rc tags.
 92 | release = __version__
 93 | # The short X.Y version.
 94 | version = ".".join(release.split(".")[0:2])
 95 | 
 96 | # The language for content autogenerated by Sphinx. Refer to documentation
 97 | # for a list of supported languages.
 98 | #
 99 | # This is also used if you do content translation via gettext catalogs.
100 | # Usually you set "language" from the command line for these cases.
101 | language = None
102 | 
103 | # There are two options for replacing |today|: either, you set today to some
104 | # non-false value, then it is used:
105 | # today = ''
106 | # Else, today_fmt is used as the format for a strftime call.
107 | # today_fmt = '%B %d, %Y'
108 | 
109 | # List of patterns, relative to source directory, that match files and
110 | # directories to ignore when looking for source files.
111 | exclude_patterns = [
112 |     "_build",
113 |     "**/.nox/**/*",
114 |     "samples/AUTHORING_GUIDE.md",
115 |     "samples/CONTRIBUTING.md",
116 |     "samples/snippets/README.rst",
117 | ]
118 | 
119 | # The reST default role (used for this markup: `text`) to use for all
120 | # documents.
121 | # default_role = None
122 | 
123 | # If true, '()' will be appended to :func: etc. cross-reference text.
124 | # add_function_parentheses = True
125 | 
126 | # If true, the current module name will be prepended to all description
127 | # unit titles (such as .. function::).
128 | # add_module_names = True
129 | 
130 | # If true, sectionauthor and moduleauthor directives will be shown in the
131 | # output. They are ignored by default.
132 | # show_authors = False
133 | 
134 | # The name of the Pygments (syntax highlighting) style to use.
135 | pygments_style = "sphinx"
136 | 
137 | # A list of ignored prefixes for module index sorting.
138 | # modindex_common_prefix = []
139 | 
140 | # If true, keep warnings as "system message" paragraphs in the built documents.
141 | # keep_warnings = False
142 | 
143 | # If true, `todo` and `todoList` produce output, else they produce nothing.
144 | todo_include_todos = True
145 | 
146 | 
147 | # -- Options for HTML output ----------------------------------------------
148 | 
149 | # The theme to use for HTML and HTML Help pages.  See the documentation for
150 | # a list of builtin themes.
151 | html_theme = "alabaster"
152 | 
153 | # Theme options are theme-specific and customize the look and feel of a theme
154 | # further.  For a list of options available for each theme, see the
155 | # documentation.
156 | html_theme_options = {
157 |     "description": "Google Cloud Client Libraries for langchain-google-firestore",
158 |     "github_user": "googleapis",
159 |     "github_repo": "langchain-google-firestore-python",
160 |     "github_banner": True,
161 |     "font_family": "'Roboto', Georgia, sans",
162 |     "head_font_family": "'Roboto', Georgia, serif",
163 |     "code_font_family": "'Roboto Mono', 'Consolas', monospace",
164 | }
165 | 
166 | # Add any paths that contain custom themes here, relative to this directory.
167 | # html_theme_path = []
168 | 
169 | # The name for this set of Sphinx documents.  If None, it defaults to
170 | # "<project> v<release> documentation".
171 | # html_title = None
172 | 
173 | # A shorter title for the navigation bar.  Default is the same as html_title.
174 | # html_short_title = None
175 | 
176 | # The name of an image file (relative to this directory) to place at the top
177 | # of the sidebar.
178 | # html_logo = None
179 | 
180 | # The name of an image file (within the static path) to use as favicon of the
181 | # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
182 | # pixels large.
183 | # html_favicon = None
184 | 
185 | # Add any paths that contain custom static files (such as style sheets) here,
186 | # relative to this directory. They are copied after the builtin static files,
187 | # so a file named "default.css" will overwrite the builtin "default.css".
188 | html_static_path = ["_static"]
189 | 
190 | # Add any extra paths that contain custom files (such as robots.txt or
191 | # .htaccess) here, relative to this directory. These files are copied
192 | # directly to the root of the documentation.
193 | # html_extra_path = []
194 | 
195 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
196 | # using the given strftime format.
197 | # html_last_updated_fmt = '%b %d, %Y'
198 | 
199 | # If true, SmartyPants will be used to convert quotes and dashes to
200 | # typographically correct entities.
201 | # html_use_smartypants = True
202 | 
203 | # Custom sidebar templates, maps document names to template names.
204 | # html_sidebars = {}
205 | 
206 | # Additional templates that should be rendered to pages, maps page names to
207 | # template names.
208 | # html_additional_pages = {}
209 | 
210 | # If false, no module index is generated.
211 | # html_domain_indices = True
212 | 
213 | # If false, no index is generated.
214 | # html_use_index = True
215 | 
216 | # If true, the index is split into individual pages for each letter.
217 | # html_split_index = False
218 | 
219 | # If true, links to the reST sources are added to the pages.
220 | # html_show_sourcelink = True
221 | 
222 | # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
223 | # html_show_sphinx = True
224 | 
225 | # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
226 | # html_show_copyright = True
227 | 
228 | # If true, an OpenSearch description file will be output, and all pages will
229 | # contain a <link> tag referring to it.  The value of this option must be the
230 | # base URL from which the finished HTML is served.
231 | # html_use_opensearch = ''
232 | 
233 | # This is the file name suffix for HTML files (e.g. ".xhtml").
234 | # html_file_suffix = None
235 | 
236 | # Language to be used for generating the HTML full-text search index.
237 | # Sphinx supports the following languages:
238 | #   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
239 | #   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
240 | # html_search_language = 'en'
241 | 
242 | # A dictionary with options for the search language support, empty by default.
243 | # Now only 'ja' uses this config value
244 | # html_search_options = {'type': 'default'}
245 | 
246 | # The name of a javascript file (relative to the configuration directory) that
247 | # implements a search results scorer. If empty, the default will be used.
248 | # html_search_scorer = 'scorer.js'
249 | 
250 | # Output file base name for HTML help builder.
251 | htmlhelp_basename = "langchain-google-firestore-doc"
252 | 
253 | # -- Options for warnings ------------------------------------------------------
254 | 
255 | 
256 | suppress_warnings = [
257 |     # Temporarily suppress this to avoid "more than one target found for
258 |     # cross-reference" warning, which are intractable for us to avoid while in
259 |     # a mono-repo.
260 |     # See https://github.com/sphinx-doc/sphinx/blob
261 |     # /2a65ffeef5c107c19084fabdd706cdff3f52d93c/sphinx/domains/python.py#L843
262 |     "ref.python"
263 | ]
264 | 
265 | # -- Options for LaTeX output ---------------------------------------------
266 | 
267 | latex_elements = {
268 |     # The paper size ('letterpaper' or 'a4paper').
269 |     #'papersize': 'letterpaper',
270 |     # The font size ('10pt', '11pt' or '12pt').
271 |     #'pointsize': '10pt',
272 |     # Additional stuff for the LaTeX preamble.
273 |     #'preamble': '',
274 |     # Latex figure (float) alignment
275 |     #'figure_align': 'htbp',
276 | }
277 | 
278 | # Grouping the document tree into LaTeX files. List of tuples
279 | # (source start file, target name, title,
280 | #  author, documentclass [howto, manual, or own class]).
281 | latex_documents = [
282 |     (
283 |         root_doc,
284 |         "langchain-google-firestore.tex",
285 |         "langchain-google-firestore Documentation",
286 |         author,
287 |         "manual",
288 |     )
289 | ]
290 | 
291 | # The name of an image file (relative to this directory) to place at the top of
292 | # the title page.
293 | # latex_logo = None
294 | 
295 | # For "manual" documents, if this is true, then toplevel headings are parts,
296 | # not chapters.
297 | # latex_use_parts = False
298 | 
299 | # If true, show page references after internal links.
300 | # latex_show_pagerefs = False
301 | 
302 | # If true, show URL addresses after external links.
303 | # latex_show_urls = False
304 | 
305 | # Documents to append as an appendix to all manuals.
306 | # latex_appendices = []
307 | 
308 | # If false, no module index is generated.
309 | # latex_domain_indices = True
310 | 
311 | 
312 | # -- Options for manual page output ---------------------------------------
313 | 
314 | # One entry per manual page. List of tuples
315 | # (source start file, name, description, authors, manual section).
316 | man_pages = [
317 |     (
318 |         root_doc,
319 |         "langchain-google-firestore",
320 |         "langchain-google-firestore Documentation",
321 |         [author],
322 |         1,
323 |     )
324 | ]
325 | 
326 | # If true, show URL addresses after external links.
327 | # man_show_urls = False
328 | 
329 | 
330 | # -- Options for Texinfo output -------------------------------------------
331 | 
332 | # Grouping the document tree into Texinfo files. List of tuples
333 | # (source start file, target name, title, author,
334 | #  dir menu entry, description, category)
335 | texinfo_documents = [
336 |     (
337 |         root_doc,
338 |         "langchain-google-firestore",
339 |         "langchain-google-firestore Documentation",
340 |         author,
341 |         "langchain-google-firestore",
342 |         "langchain-google-firestore Library",
343 |         "APIs",
344 |     )
345 | ]
346 | 
347 | # Documents to append as an appendix to all manuals.
348 | # texinfo_appendices = []
349 | 
350 | # If false, no module index is generated.
351 | # texinfo_domain_indices = True
352 | 
353 | # How to display URL addresses: 'footnote', 'no', or 'inline'.
354 | # texinfo_show_urls = 'footnote'
355 | 
356 | # If true, do not generate a @detailmenu in the "Top" node's menu.
357 | # texinfo_no_detailmenu = False
358 | 
359 | 
360 | # Example configuration for intersphinx: refer to the Python standard library.
361 | intersphinx_mapping = {
362 |     "python": ("https://python.readthedocs.org/en/latest/", None),
363 |     "google-auth": ("https://googleapis.dev/python/google-auth/latest/", None),
364 |     "google.api_core": (
365 |         "https://googleapis.dev/python/google-api-core/latest/",
366 |         None,
367 |     ),
368 |     "grpc": ("https://grpc.github.io/grpc/python/", None),
369 |     "proto-plus": ("https://proto-plus-python.readthedocs.io/en/latest/", None),
370 |     "protobuf": ("https://googleapis.dev/python/protobuf/latest/", None),
371 | }
372 | 
373 | 
374 | # Napoleon settings
375 | napoleon_google_docstring = True
376 | napoleon_numpy_docstring = True
377 | napoleon_include_private_with_doc = False
378 | napoleon_include_special_with_doc = True
379 | napoleon_use_admonition_for_examples = False
380 | napoleon_use_admonition_for_notes = False
381 | napoleon_use_admonition_for_references = False
382 | napoleon_use_ivar = False
383 | napoleon_use_param = True
384 | napoleon_use_rtype = True
385 | 


--------------------------------------------------------------------------------
/docs/document_loader.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Google Firestore (Native Mode)\n",
  8 |     "\n",
  9 |     "> [Firestore](https://cloud.google.com/firestore) is a serverless document-oriented database that scales to meet any demand. Extend your database application to build AI-powered experiences leveraging Firestore's Langchain integrations.\n",
 10 |     "\n",
 11 |     "This notebook goes over how to use [Firestore](https://cloud.google.com/firestore) to [save, load and delete langchain documents](https://python.langchain.com/docs/modules/data_connection/document_loaders/) with `FirestoreLoader` and `FirestoreSaver`.\n",
 12 |     "\n",
 13 |     "Learn more about the package on [GitHub](https://github.com/googleapis/langchain-google-firestore-python/).\n",
 14 |     "\n",
 15 |     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googleapis/langchain-google-firestore-python/blob/main/docs/document_loader.ipynb)"
 16 |    ]
 17 |   },
 18 |   {
 19 |    "cell_type": "markdown",
 20 |    "metadata": {},
 21 |    "source": [
 22 |     "## Before You Begin\n",
 23 |     "\n",
 24 |     "To run this notebook, you will need to do the following:\n",
 25 |     "\n",
 26 |     "* [Create a Google Cloud Project](https://developers.google.com/workspace/guides/create-project)\n",
 27 |     "* [Enable the Firestore API](https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com)\n",
 28 |     "* [Create a Firestore database](https://cloud.google.com/firestore/docs/manage-databases)\n",
 29 |     "\n",
 30 |     "After confirmed access to database in the runtime environment of this notebook, filling the following values and run the cell before running example scripts."
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": null,
 36 |    "metadata": {},
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "# @markdown Please specify a source for demo purpose.\n",
 40 |     "SOURCE = \"test\"  # @param {type:\"Query\"|\"CollectionGroup\"|\"DocumentReference\"|\"string\"}"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "markdown",
 45 |    "metadata": {},
 46 |    "source": [
 47 |     "### 🦜🔗 Library Installation\n",
 48 |     "\n",
 49 |     "The integration lives in its own `langchain-google-firestore` package, so we need to install it."
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": null,
 55 |    "metadata": {
 56 |     "tags": []
 57 |    },
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "%pip install -upgrade --quiet langchain-google-firestore"
 61 |    ]
 62 |   },
 63 |   {
 64 |    "cell_type": "markdown",
 65 |    "metadata": {},
 66 |    "source": [
 67 |     "**Colab only**: Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "code",
 72 |    "execution_count": null,
 73 |    "metadata": {},
 74 |    "outputs": [],
 75 |    "source": [
 76 |     "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
 77 |     "# import IPython\n",
 78 |     "\n",
 79 |     "# app = IPython.Application.instance()\n",
 80 |     "# app.kernel.do_shutdown(True)"
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "markdown",
 85 |    "metadata": {},
 86 |    "source": [
 87 |     "### ☁ Set Your Google Cloud Project\n",
 88 |     "Set your Google Cloud project so that you can leverage Google Cloud resources within this notebook.\n",
 89 |     "\n",
 90 |     "If you don't know your project ID, try the following:\n",
 91 |     "\n",
 92 |     "* Run `gcloud config list`.\n",
 93 |     "* Run `gcloud projects list`.\n",
 94 |     "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)."
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": null,
100 |    "metadata": {},
101 |    "outputs": [],
102 |    "source": [
103 |     "# @markdown Please fill in the value below with your Google Cloud project ID and then run the cell.\n",
104 |     "\n",
105 |     "PROJECT_ID = \"my-project-id\"  # @param {type:\"string\"}\n",
106 |     "\n",
107 |     "# Set the project id\n",
108 |     "!gcloud config set project {PROJECT_ID}"
109 |    ]
110 |   },
111 |   {
112 |    "cell_type": "markdown",
113 |    "metadata": {},
114 |    "source": [
115 |     "### 🔐 Authentication\n",
116 |     "\n",
117 |     "Authenticate to Google Cloud as the IAM user logged into this notebook in order to access your Google Cloud Project.\n",
118 |     "\n",
119 |     "- If you are using Colab to run this notebook, use the cell below and continue.\n",
120 |     "- If you are using Vertex AI Workbench, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "code",
125 |    "execution_count": null,
126 |    "metadata": {},
127 |    "outputs": [],
128 |    "source": [
129 |     "from google.colab import auth\n",
130 |     "\n",
131 |     "auth.authenticate_user()"
132 |    ]
133 |   },
134 |   {
135 |    "cell_type": "markdown",
136 |    "metadata": {},
137 |    "source": [
138 |     "## Basic Usage"
139 |    ]
140 |   },
141 |   {
142 |    "cell_type": "markdown",
143 |    "metadata": {},
144 |    "source": [
145 |     "### Save documents\n",
146 |     "\n",
147 |     "`FirestoreSaver` can store Documents into Firestore. By default it will try to extract the Document reference from the metadata\n",
148 |     "\n",
149 |     "Save langchain documents with `FirestoreSaver.upsert_documents(<documents>)`."
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": null,
155 |    "metadata": {},
156 |    "outputs": [],
157 |    "source": [
158 |     "from langchain_core.documents import Document\n",
159 |     "from langchain_google_firestore import FirestoreSaver\n",
160 |     "\n",
161 |     "saver = FirestoreSaver()\n",
162 |     "\n",
163 |     "data = [Document(page_content=\"Hello, World!\")]\n",
164 |     "\n",
165 |     "saver.upsert_documents(data)"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "markdown",
170 |    "metadata": {},
171 |    "source": [
172 |     "#### Save documents without reference\n",
173 |     "\n",
174 |     "If a collection is specified the documents will be stored with an auto generated id."
175 |    ]
176 |   },
177 |   {
178 |    "cell_type": "code",
179 |    "execution_count": null,
180 |    "metadata": {},
181 |    "outputs": [],
182 |    "source": [
183 |     "saver = FirestoreSaver(\"Collection\")\n",
184 |     "\n",
185 |     "saver.upsert_documents(data)"
186 |    ]
187 |   },
188 |   {
189 |    "cell_type": "markdown",
190 |    "metadata": {},
191 |    "source": [
192 |     "#### Save documents with other references"
193 |    ]
194 |   },
195 |   {
196 |    "cell_type": "code",
197 |    "execution_count": null,
198 |    "metadata": {},
199 |    "outputs": [],
200 |    "source": [
201 |     "doc_ids = [\"AnotherCollection/doc_id\", \"foo/bar\"]\n",
202 |     "saver = FirestoreSaver()\n",
203 |     "\n",
204 |     "saver.upsert_documents(documents=data, document_ids=doc_ids)"
205 |    ]
206 |   },
207 |   {
208 |    "cell_type": "markdown",
209 |    "metadata": {},
210 |    "source": [
211 |     "### Load from Collection or SubCollection"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "markdown",
216 |    "metadata": {},
217 |    "source": [
218 |     "Load langchain documents with `FirestoreLoader.load()` or `Firestore.lazy_load()`. `lazy_load` returns a generator that only queries database during the iteration. To initialize `FirestoreLoader` class you need to provide:\n",
219 |     "\n",
220 |     "1. `source` - An instance of a Query, CollectionGroup, DocumentReference or the single `\\`-delimited path to a Firestore collection."
221 |    ]
222 |   },
223 |   {
224 |    "cell_type": "code",
225 |    "execution_count": null,
226 |    "metadata": {},
227 |    "outputs": [],
228 |    "source": [
229 |     "from langchain_google_firestore import FirestoreLoader\n",
230 |     "\n",
231 |     "loader_collection = FirestoreLoader(\"Collection\")\n",
232 |     "loader_subcollection = FirestoreLoader(\"Collection/doc/SubCollection\")\n",
233 |     "\n",
234 |     "\n",
235 |     "data_collection = loader_collection.load()\n",
236 |     "data_subcollection = loader_subcollection.load()"
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "markdown",
241 |    "metadata": {},
242 |    "source": [
243 |     "### Load a single Document"
244 |    ]
245 |   },
246 |   {
247 |    "cell_type": "code",
248 |    "execution_count": null,
249 |    "metadata": {},
250 |    "outputs": [],
251 |    "source": [
252 |     "from google.cloud import firestore\n",
253 |     "\n",
254 |     "client = firestore.Client()\n",
255 |     "doc_ref = client.collection(\"foo\").document(\"bar\")\n",
256 |     "\n",
257 |     "loader_document = FirestoreLoader(doc_ref)\n",
258 |     "\n",
259 |     "data = loader_document.load()"
260 |    ]
261 |   },
262 |   {
263 |    "cell_type": "markdown",
264 |    "metadata": {},
265 |    "source": [
266 |     "### Load from CollectionGroup or Query"
267 |    ]
268 |   },
269 |   {
270 |    "cell_type": "code",
271 |    "execution_count": null,
272 |    "metadata": {},
273 |    "outputs": [],
274 |    "source": [
275 |     "from google.cloud.firestore import CollectionGroup, FieldFilter, Query\n",
276 |     "\n",
277 |     "col_ref = client.collection(\"col_group\")\n",
278 |     "collection_group = CollectionGroup(col_ref)\n",
279 |     "\n",
280 |     "loader_group = FirestoreLoader(collection_group)\n",
281 |     "\n",
282 |     "col_ref = client.collection(\"collection\")\n",
283 |     "query = col_ref.where(filter=FieldFilter(\"region\", \"==\", \"west_coast\"))\n",
284 |     "\n",
285 |     "loader_query = FirestoreLoader(query)"
286 |    ]
287 |   },
288 |   {
289 |    "cell_type": "markdown",
290 |    "metadata": {},
291 |    "source": [
292 |     "### Delete documents\n",
293 |     "\n",
294 |     "Delete a list of langchain documents from Firestore collection with `FirestoreSaver.delete_documents(<documents>)`.\n",
295 |     "\n",
296 |     "If document ids is provided, the Documents will be ignored."
297 |    ]
298 |   },
299 |   {
300 |    "cell_type": "code",
301 |    "execution_count": null,
302 |    "metadata": {},
303 |    "outputs": [],
304 |    "source": [
305 |     "saver = FirestoreSaver()\n",
306 |     "\n",
307 |     "saver.delete_documents(data)\n",
308 |     "\n",
309 |     "# The Documents will be ignored and only the document ids will be used.\n",
310 |     "saver.delete_documents(data, doc_ids)"
311 |    ]
312 |   },
313 |   {
314 |    "cell_type": "markdown",
315 |    "metadata": {},
316 |    "source": [
317 |     "## Advanced Usage"
318 |    ]
319 |   },
320 |   {
321 |    "cell_type": "markdown",
322 |    "metadata": {},
323 |    "source": [
324 |     "### Load documents with customize document page content & metadata\n",
325 |     "\n",
326 |     "The arguments of `page_content_fields` and `metadata_fields` will specify the Firestore Document fields to be written into LangChain Document `page_content` and `metadata`."
327 |    ]
328 |   },
329 |   {
330 |    "cell_type": "code",
331 |    "execution_count": null,
332 |    "metadata": {},
333 |    "outputs": [],
334 |    "source": [
335 |     "loader = FirestoreLoader(\n",
336 |     "    source=\"foo/bar/subcol\",\n",
337 |     "    page_content_fields=[\"data_field\"],\n",
338 |     "    metadata_fields=[\"metadata_field\"],\n",
339 |     ")\n",
340 |     "\n",
341 |     "data = loader.load()"
342 |    ]
343 |   },
344 |   {
345 |    "cell_type": "markdown",
346 |    "metadata": {},
347 |    "source": [
348 |     "#### Customize Page Content Format\n",
349 |     "\n",
350 |     "When the `page_content` contains only one field the information will be the field value only. Otherwise the `page_content` will be in JSON format."
351 |    ]
352 |   },
353 |   {
354 |    "cell_type": "markdown",
355 |    "metadata": {},
356 |    "source": [
357 |     "### Customize Connection & Authentication"
358 |    ]
359 |   },
360 |   {
361 |    "cell_type": "code",
362 |    "execution_count": null,
363 |    "metadata": {},
364 |    "outputs": [],
365 |    "source": [
366 |     "from google.auth import compute_engine\n",
367 |     "from google.cloud.firestore import Client\n",
368 |     "\n",
369 |     "client = Client(database=\"non-default-db\", creds=compute_engine.Credentials())\n",
370 |     "loader = FirestoreLoader(\n",
371 |     "    source=\"foo\",\n",
372 |     "    client=client,\n",
373 |     ")"
374 |    ]
375 |   }
376 |  ],
377 |  "metadata": {
378 |   "kernelspec": {
379 |    "display_name": "Python 3 (ipykernel)",
380 |    "language": "python",
381 |    "name": "python3"
382 |   },
383 |   "language_info": {
384 |    "codemirror_mode": {
385 |     "name": "ipython",
386 |     "version": 3
387 |    },
388 |    "file_extension": ".py",
389 |    "mimetype": "text/x-python",
390 |    "name": "python",
391 |    "nbconvert_exporter": "python",
392 |    "pygments_lexer": "ipython3",
393 |    "version": "3.10.6"
394 |   }
395 |  },
396 |  "nbformat": 4,
397 |  "nbformat_minor": 4
398 | }
399 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | 
 2 | .. include:: README.rst
 3 | 
 4 | API Reference
 5 | -------------
 6 | .. toctree::
 7 |   :maxdepth: 2
 8 | 
 9 |   langchain_google_firestore/vectorstore
10 |   langchain_google_firestore/loader
11 |   langchain_google_firestore/history
12 | 
13 | Changelog
14 | ---------
15 | .. toctree::
16 |   :maxdepth: 2
17 | 
18 |   changelog
19 | 


--------------------------------------------------------------------------------
/docs/langchain_google_firestore/history.rst:
--------------------------------------------------------------------------------
1 | 
2 | Chat Message History
3 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4 | 
5 | .. automodule:: langchain_google_firestore.chat_message_history
6 |   :members:
7 |   :private-members:
8 |   :noindex:
9 | 


--------------------------------------------------------------------------------
/docs/langchain_google_firestore/loader.rst:
--------------------------------------------------------------------------------
1 | 
2 | Document Loader
3 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4 | 
5 | .. automodule:: langchain_google_firestore.document_loader
6 |   :private-members:
7 |   :noindex:
8 | 


--------------------------------------------------------------------------------
/docs/langchain_google_firestore/vectorstore.rst:
--------------------------------------------------------------------------------
1 | 
2 | Vector Store
3 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4 | 
5 | .. automodule:: langchain_google_firestore.vectorstores
6 |   :members:
7 |   :private-members:
8 |   :noindex:
9 | 


--------------------------------------------------------------------------------
/docs/templates/layout.html:
--------------------------------------------------------------------------------
 1 | {% extends "!layout.html" %}
 2 | {%- block content %}
 3 | {%- if theme_fixed_sidebar|lower == 'true' %}
 4 |   <div class="document">
 5 |     {{ sidebar() }}
 6 |     {%- block document %}
 7 |       <div class="documentwrapper">
 8 |       {%- if render_sidebar %}
 9 |         <div class="bodywrapper">
10 |       {%- endif %}
11 | 
12 |           {%- block relbar_top %}
13 |             {%- if theme_show_relbar_top|tobool %}
14 |               <div class="related top">
15 |                 &nbsp;
16 |                 {{- rellink_markup () }}
17 |               </div>
18 |             {%- endif %}
19 |           {% endblock %}
20 | 
21 |           <div class="body" role="main">
22 |           	<div class="admonition" id="python2-eol"> 
23 |           	 As of January 1, 2020 this library no longer supports Python 2 on the latest released version. 
24 |           	 Library versions released prior to that date will continue to be available. For more information please
25 |           	 visit <a href="https://cloud.google.com/python/docs/python2-sunset/">Python 2 support on Google Cloud</a>.
26 |           	</div>
27 |             {% block body %} {% endblock %}
28 |           </div>
29 | 
30 |           {%- block relbar_bottom %}
31 |             {%- if theme_show_relbar_bottom|tobool %}
32 |               <div class="related bottom">
33 |                 &nbsp;
34 |                 {{- rellink_markup () }}
35 |               </div>
36 |             {%- endif %}
37 |           {% endblock %}
38 | 
39 |       {%- if render_sidebar %}
40 |         </div>
41 |       {%- endif %}
42 |       </div>
43 |     {%- endblock %}
44 |     <div class="clearer"></div>
45 |   </div>
46 | {%- else %}
47 | {{ super() }}
48 | {%- endif %}
49 | {%- endblock %}


--------------------------------------------------------------------------------
/docs/vectorstores.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "raw",
  5 |    "id": "1957f5cb",
  6 |    "metadata": {},
  7 |    "source": [
  8 |     "---\n",
  9 |     "sidebar_label: Firestore\n",
 10 |     "---"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "markdown",
 15 |    "id": "ef1f0986",
 16 |    "metadata": {},
 17 |    "source": [
 18 |     "# Google Firestore (Native Mode)\n",
 19 |     "\n",
 20 |     "> [Firestore](https://cloud.google.com/firestore) is a serverless document-oriented database that scales to meet any demand. Extend your database application to build AI-powered experiences leveraging Firestore's LangChain integrations.\n",
 21 |     "\n",
 22 |     "This notebook goes over how to use [Firestore](https://cloud.google.com/firestore) to to store vectors and query them using the `FirestoreVectorStore` class.\n",
 23 |     "\n",
 24 |     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googleapis/langchain-google-firestore-python/blob/main/docs/vectorstores.ipynb)"
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "markdown",
 29 |    "id": "36fdc060",
 30 |    "metadata": {},
 31 |    "source": [
 32 |     "## Before You Begin\n",
 33 |     "\n",
 34 |     "To run this notebook, you will need to do the following:\n",
 35 |     "\n",
 36 |     "* [Create a Google Cloud Project](https://developers.google.com/workspace/guides/create-project)\n",
 37 |     "* [Enable the Firestore API](https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com)\n",
 38 |     "* [Create a Firestore database](https://cloud.google.com/firestore/docs/manage-databases)\n",
 39 |     "\n",
 40 |     "After confirmed access to database in the runtime environment of this notebook, filling the following values and run the cell before running example scripts."
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": null,
 46 |    "id": "22e53b34",
 47 |    "metadata": {},
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "# @markdown Please specify a source for demo purpose.\n",
 51 |     "COLLECTION_NAME = \"test\"  # @param {type:\"CollectionReference\"|\"string\"}"
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "markdown",
 56 |    "id": "e5d3d8e4",
 57 |    "metadata": {},
 58 |    "source": [
 59 |     "### 🦜🔗 Library Installation\n",
 60 |     "\n",
 61 |     "The integration lives in its own `langchain-google-firestore` package, so we need to install it. For this notebook, we will also install `langchain-google-genai` to use Google Generative AI embeddings."
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": null,
 67 |    "id": "75510ef7",
 68 |    "metadata": {},
 69 |    "outputs": [],
 70 |    "source": [
 71 |     "%pip install --upgrade --quiet langchain-google-firestore langchain-google-vertexai"
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "markdown",
 76 |    "id": "2664ca45",
 77 |    "metadata": {},
 78 |    "source": [
 79 |     "**Colab only**: Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
 80 |    ]
 81 |   },
 82 |   {
 83 |    "cell_type": "code",
 84 |    "execution_count": null,
 85 |    "id": "ddfcd6b7",
 86 |    "metadata": {},
 87 |    "outputs": [],
 88 |    "source": [
 89 |     "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
 90 |     "# import IPython\n",
 91 |     "\n",
 92 |     "# app = IPython.Application.instance()\n",
 93 |     "# app.kernel.do_shutdown(True)"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "markdown",
 98 |    "id": "4ab63daa",
 99 |    "metadata": {},
100 |    "source": [
101 |     "### ☁ Set Your Google Cloud Project\n",
102 |     "Set your Google Cloud project so that you can leverage Google Cloud resources within this notebook.\n",
103 |     "\n",
104 |     "If you don't know your project ID, try the following:\n",
105 |     "\n",
106 |     "* Run `gcloud config list`.\n",
107 |     "* Run `gcloud projects list`.\n",
108 |     "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)."
109 |    ]
110 |   },
111 |   {
112 |    "cell_type": "code",
113 |    "execution_count": null,
114 |    "id": "129f1f8d",
115 |    "metadata": {},
116 |    "outputs": [],
117 |    "source": [
118 |     "# @markdown Please fill in the value below with your Google Cloud project ID and then run the cell.\n",
119 |     "\n",
120 |     "PROJECT_ID = \"extensions-testing\"  # @param {type:\"string\"}\n",
121 |     "\n",
122 |     "# Set the project id\n",
123 |     "!gcloud config set project {PROJECT_ID}"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "markdown",
128 |    "id": "ccd32ce5",
129 |    "metadata": {},
130 |    "source": [
131 |     "### 🔐 Authentication\n",
132 |     "\n",
133 |     "Authenticate to Google Cloud as the IAM user logged into this notebook in order to access your Google Cloud Project.\n",
134 |     "\n",
135 |     "- If you are using Colab to run this notebook, use the cell below and continue.\n",
136 |     "- If you are using Vertex AI Workbench, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": null,
142 |    "id": "4b5793e7",
143 |    "metadata": {},
144 |    "outputs": [],
145 |    "source": [
146 |     "from google.colab import auth\n",
147 |     "\n",
148 |     "auth.authenticate_user()"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "markdown",
153 |    "id": "2cade39f",
154 |    "metadata": {},
155 |    "source": [
156 |     "# Basic Usage"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "markdown",
161 |    "id": "580e6f96",
162 |    "metadata": {},
163 |    "source": [
164 |     "### Initialize FirestoreVectorStore\n",
165 |     "\n",
166 |     "`FirestoreVectorStore` allows you to store new vectors in a Firestore database. You can use it to store embeddings from any model, including those from Google Generative AI."
167 |    ]
168 |   },
169 |   {
170 |    "cell_type": "code",
171 |    "execution_count": null,
172 |    "id": "dc37144c-208d-4ab3-9f3a-0407a69fe052",
173 |    "metadata": {
174 |     "tags": []
175 |    },
176 |    "outputs": [],
177 |    "source": [
178 |     "from langchain_google_firestore import FirestoreVectorStore\n",
179 |     "from langchain_google_vertexai import VertexAIEmbeddings\n",
180 |     "\n",
181 |     "embedding = VertexAIEmbeddings(\n",
182 |     "    model_name=\"textembedding-gecko@latest\",\n",
183 |     "    project=PROJECT_ID,\n",
184 |     ")\n",
185 |     "\n",
186 |     "# Sample data\n",
187 |     "ids = [\"apple\", \"banana\", \"orange\"]\n",
188 |     "fruits_texts = ['{\"name\": \"apple\"}', '{\"name\": \"banana\"}', '{\"name\": \"orange\"}']\n",
189 |     "\n",
190 |     "# Create a vector store\n",
191 |     "vector_store = FirestoreVectorStore(\n",
192 |     "    collection=COLLECTION_NAME,\n",
193 |     "    embedding_service=embedding,\n",
194 |     ")\n",
195 |     "\n",
196 |     "# Add the fruits to the vector store\n",
197 |     "vector_store.add_texts(fruits_texts, ids=ids)"
198 |    ]
199 |   },
200 |   {
201 |    "cell_type": "markdown",
202 |    "id": "f8a4d7f7",
203 |    "metadata": {},
204 |    "source": [
205 |     "As a shorthand, you can initilize and add vectors in a single step using the `from_texts` and `from_documents` method."
206 |    ]
207 |   },
208 |   {
209 |    "cell_type": "code",
210 |    "execution_count": null,
211 |    "id": "0bb6745e",
212 |    "metadata": {},
213 |    "outputs": [],
214 |    "source": [
215 |     "vector_store = FirestoreVectorStore.from_texts(\n",
216 |     "    collection=COLLECTION_NAME,\n",
217 |     "    texts=fruits_texts,\n",
218 |     "    embedding=embedding,\n",
219 |     ")"
220 |    ]
221 |   },
222 |   {
223 |    "cell_type": "code",
224 |    "execution_count": null,
225 |    "id": "f86024b9",
226 |    "metadata": {},
227 |    "outputs": [],
228 |    "source": [
229 |     "from langchain_core.documents import Document\n",
230 |     "\n",
231 |     "fruits_docs = [Document(page_content=fruit) for fruit in fruits_texts]\n",
232 |     "\n",
233 |     "vector_store = FirestoreVectorStore.from_documents(\n",
234 |     "    collection=COLLECTION_NAME,\n",
235 |     "    documents=fruits_docs,\n",
236 |     "    embedding=embedding,\n",
237 |     ")"
238 |    ]
239 |   },
240 |   {
241 |    "cell_type": "markdown",
242 |    "id": "10018daa",
243 |    "metadata": {},
244 |    "source": [
245 |     "You can also add local, Google Cloud Storage, or web images using the `add_images` method."
246 |    ]
247 |   },
248 |   {
249 |    "cell_type": "code",
250 |    "execution_count": null,
251 |    "id": "89f26aab",
252 |    "metadata": {},
253 |    "outputs": [],
254 |    "source": [
255 |     "ids = [\"landmark1.png\", \"landmark2.png\", \"landmark3.png\"]\n",
256 |     "image_paths = [\n",
257 |     "    \"gs://your-storage-bucket/landmark1.png\",\n",
258 |     "    \"./images/landmark2.png\",\n",
259 |     "    \"https://your-website/images/landmark3.png\",\n",
260 |     "]\n",
261 |     "\n",
262 |     "vector_store.add_images(image_paths, ids=ids)"
263 |    ]
264 |   },
265 |   {
266 |    "cell_type": "markdown",
267 |    "id": "942911a8",
268 |    "metadata": {},
269 |    "source": [
270 |     "### Delete Vectors"
271 |    ]
272 |   },
273 |   {
274 |    "cell_type": "markdown",
275 |    "id": "ee1d8090",
276 |    "metadata": {},
277 |    "source": [
278 |     "You can delete documents with vectors from the database using the `delete` method. You'll need to provide the document ID of the vector you want to delete. This will remove the whole document from the database, including any other fields it may have."
279 |    ]
280 |   },
281 |   {
282 |    "cell_type": "code",
283 |    "execution_count": null,
284 |    "id": "901f2ae7",
285 |    "metadata": {},
286 |    "outputs": [],
287 |    "source": [
288 |     "vector_store.delete(ids)"
289 |    ]
290 |   },
291 |   {
292 |    "cell_type": "markdown",
293 |    "id": "bc8e555f",
294 |    "metadata": {},
295 |    "source": [
296 |     "### Update Vectors"
297 |    ]
298 |   },
299 |   {
300 |    "cell_type": "markdown",
301 |    "id": "af734e8f",
302 |    "metadata": {},
303 |    "source": [
304 |     "Updating vectors is similar to adding them. You can use the `add` method to update the vector of a document by providing the document ID and the new vector."
305 |    ]
306 |   },
307 |   {
308 |    "cell_type": "code",
309 |    "execution_count": null,
310 |    "id": "cb2aadb7",
311 |    "metadata": {},
312 |    "outputs": [],
313 |    "source": [
314 |     "fruit_to_update = ['{\"name\": \"apple\",\"price\": 12}']\n",
315 |     "apple_id = \"apple\"\n",
316 |     "\n",
317 |     "vector_store.add_texts(fruit_to_update, ids=[apple_id])"
318 |    ]
319 |   },
320 |   {
321 |    "cell_type": "markdown",
322 |    "id": "16342b7a",
323 |    "metadata": {},
324 |    "source": [
325 |     "## Similarity Search\n",
326 |     "\n",
327 |     "You can use the `FirestoreVectorStore` to perform similarity searches on the vectors you have stored. This is useful for finding similar documents, text, or images.\n",
328 |     "\n",
329 |     "**Note:** Similarity search requires a [composite vector index](https://cloud.google.com/firestore/docs/vector-search#create_and_manage_vector_indexes). Use the error message from the below commands to identify which indexes should be created using `gcloud` ."
330 |    ]
331 |   },
332 |   {
333 |    "cell_type": "code",
334 |    "execution_count": null,
335 |    "id": "44d1b94e",
336 |    "metadata": {},
337 |    "outputs": [],
338 |    "source": [
339 |     "vector_store.similarity_search(\"I like fuji apples\", k=3)"
340 |    ]
341 |   },
342 |   {
343 |    "cell_type": "code",
344 |    "execution_count": null,
345 |    "id": "acb2f640",
346 |    "metadata": {},
347 |    "outputs": [],
348 |    "source": [
349 |     "vector_store.max_marginal_relevance_search(\"fuji\", 5)"
350 |    ]
351 |   },
352 |   {
353 |    "cell_type": "code",
354 |    "execution_count": null,
355 |    "id": "373f3625",
356 |    "metadata": {},
357 |    "outputs": [],
358 |    "source": [
359 |     "vector_store.similarity_search_image(\"./images/landmark4.png\", k=1)"
360 |    ]
361 |   },
362 |   {
363 |    "cell_type": "markdown",
364 |    "id": "4ac1d391",
365 |    "metadata": {},
366 |    "source": [
367 |     "You can add a pre-filter to the search by using the `filters` parameter. This is useful for filtering by a specific field or value."
368 |    ]
369 |   },
370 |   {
371 |    "cell_type": "code",
372 |    "execution_count": null,
373 |    "id": "cd864d4f",
374 |    "metadata": {},
375 |    "outputs": [],
376 |    "source": [
377 |     "from google.cloud.firestore_v1.base_query import FieldFilter\n",
378 |     "\n",
379 |     "vector_store.max_marginal_relevance_search(\n",
380 |     "    \"fuji\", 5, filters=FieldFilter(\"content\", \"==\", \"apple\")\n",
381 |     ")"
382 |    ]
383 |   },
384 |   {
385 |    "cell_type": "markdown",
386 |    "id": "9988c71d",
387 |    "metadata": {},
388 |    "source": [
389 |     "### Customize Connection & Authentication"
390 |    ]
391 |   },
392 |   {
393 |    "cell_type": "code",
394 |    "execution_count": null,
395 |    "id": "6b9dfc65",
396 |    "metadata": {},
397 |    "outputs": [],
398 |    "source": [
399 |     "from google.api_core.client_options import ClientOptions\n",
400 |     "from google.cloud import firestore\n",
401 |     "from langchain_google_firestore import FirestoreVectorStore\n",
402 |     "\n",
403 |     "client_options = ClientOptions()\n",
404 |     "client = firestore.Client(client_options=client_options)\n",
405 |     "\n",
406 |     "# Create a vector store\n",
407 |     "vector_store = FirestoreVectorStore(\n",
408 |     "    collection=COLLECTION_NAME,\n",
409 |     "    embedding_service=embedding,\n",
410 |     "    client=client,\n",
411 |     ")"
412 |    ]
413 |   }
414 |  ],
415 |  "metadata": {
416 |   "kernelspec": {
417 |    "display_name": "Python 3 (ipykernel)",
418 |    "language": "python",
419 |    "name": "python3"
420 |   },
421 |   "language_info": {
422 |    "codemirror_mode": {
423 |     "name": "ipython",
424 |     "version": 3
425 |    },
426 |    "file_extension": ".py",
427 |    "mimetype": "text/x-python",
428 |    "name": "python",
429 |    "nbconvert_exporter": "python",
430 |    "pygments_lexer": "ipython3",
431 |    "version": "3.11.7"
432 |   }
433 |  },
434 |  "nbformat": 4,
435 |  "nbformat_minor": 5
436 | }
437 | 


--------------------------------------------------------------------------------
/integration.cloudbuild.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | steps:
16 |   - id: Install dependencies
17 |     name: python:${_VERSION}
18 |     entrypoint: pip
19 |     args: ["install", "--user", "-r", "requirements.txt"]
20 | 
21 |   - id: Install module (and test requirements)
22 |     name: python:${_VERSION}
23 |     entrypoint: pip
24 |     args: ["install", ".[test]", "--user"]
25 | 
26 |   - id: Run integration tests
27 |     name: python:${_VERSION}
28 |     entrypoint: python
29 |     args: ["-m", "pytest", "--cov=langchain_google_firestore", "--cov-config=.coveragerc", "tests/"]
30 | 
31 | substitutions:
32 |   _VERSION: "3.9"
33 | 
34 | options:
35 |   dynamicSubstitutions: true
36 | 


--------------------------------------------------------------------------------
/noxfile.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | #
  3 | # Copyright 2024 Google LLC
  4 | #
  5 | # Licensed under the Apache License, Version 2.0 (the "License");
  6 | # you may not use this file except in compliance with the License.
  7 | # You may obtain a copy of the License at
  8 | #
  9 | #     https://www.apache.org/licenses/LICENSE-2.0
 10 | #
 11 | # Unless required by applicable law or agreed to in writing, software
 12 | # distributed under the License is distributed on an "AS IS" BASIS,
 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14 | # See the License for the specific language governing permissions and
 15 | # limitations under the License.
 16 | 
 17 | from __future__ import absolute_import
 18 | 
 19 | import os
 20 | import pathlib
 21 | import shutil
 22 | from pathlib import Path
 23 | from typing import Optional
 24 | 
 25 | import nox
 26 | 
 27 | DEFAULT_PYTHON_VERSION = "3.10"
 28 | CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute()
 29 | 
 30 | nox.options.sessions = [
 31 |     "docs",
 32 |     "docfx",
 33 | ]
 34 | 
 35 | # Error if a python version is missing
 36 | nox.options.error_on_missing_interpreters = True
 37 | 
 38 | 
 39 | @nox.session(python="3.10")
 40 | def docs(session):
 41 |     """Build the docs for this library."""
 42 | 
 43 |     session.install("-e", ".")
 44 |     session.install(
 45 |         # We need to pin to specific versions of the `sphinxcontrib-*` packages
 46 |         # which still support sphinx 4.x.
 47 |         # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
 48 |         # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
 49 |         "sphinxcontrib-applehelp==1.0.4",
 50 |         "sphinxcontrib-devhelp==1.0.2",
 51 |         "sphinxcontrib-htmlhelp==2.0.1",
 52 |         "sphinxcontrib-qthelp==1.0.3",
 53 |         "sphinxcontrib-serializinghtml==1.1.5",
 54 |         "sphinx==4.5.0",
 55 |         "alabaster",
 56 |         "recommonmark",
 57 |     )
 58 | 
 59 |     shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
 60 |     session.run(
 61 |         "sphinx-build",
 62 |         "-W",  # warnings as errors
 63 |         "-T",  # show full traceback on exception
 64 |         "-N",  # no colors
 65 |         "-b",
 66 |         "html",
 67 |         "-d",
 68 |         os.path.join("docs", "_build", "doctrees", ""),
 69 |         os.path.join("docs", ""),
 70 |         os.path.join("docs", "_build", "html", ""),
 71 |     )
 72 | 
 73 | 
 74 | @nox.session(python="3.10")
 75 | def docfx(session):
 76 |     """Build the docfx yaml files for this library."""
 77 | 
 78 |     session.install("-e", ".")
 79 |     session.install(
 80 |         # We need to pin to specific versions of the `sphinxcontrib-*` packages
 81 |         # which still support sphinx 4.x.
 82 |         # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
 83 |         # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
 84 |         "sphinxcontrib-applehelp==1.0.4",
 85 |         "sphinxcontrib-devhelp==1.0.2",
 86 |         "sphinxcontrib-htmlhelp==2.0.1",
 87 |         "sphinxcontrib-qthelp==1.0.3",
 88 |         "sphinxcontrib-serializinghtml==1.1.5",
 89 |         "gcp-sphinx-docfx-yaml",
 90 |         "alabaster",
 91 |         "recommonmark",
 92 |     )
 93 | 
 94 |     shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
 95 |     session.run(
 96 |         "sphinx-build",
 97 |         "-T",  # show full traceback on exception
 98 |         "-N",  # no colors
 99 |         "-D",
100 |         (
101 |             "extensions=sphinx.ext.autodoc,"
102 |             "sphinx.ext.autosummary,"
103 |             "docfx_yaml.extension,"
104 |             "sphinx.ext.intersphinx,"
105 |             "sphinx.ext.coverage,"
106 |             "sphinx.ext.napoleon,"
107 |             "sphinx.ext.todo,"
108 |             "sphinx.ext.viewcode,"
109 |             "recommonmark"
110 |         ),
111 |         "-b",
112 |         "html",
113 |         "-d",
114 |         os.path.join("docs", "_build", "doctrees", ""),
115 |         os.path.join("docs", ""),
116 |         os.path.join("docs", "_build", "html", ""),
117 |     )
118 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [project]
 2 | name = "langchain-google-firestore"
 3 | dynamic = ["version"]
 4 | description = "LangChain integrations for Google Cloud Firestore"
 5 | readme = "README.rst"
 6 | license = {file = "LICENSE"}
 7 | requires-python = ">=3.9"
 8 | authors = [
 9 |     {name = "Google LLC", email = "googleapis-packages@google.com"}
10 | ]
11 | dependencies = [
12 |     "langchain-core>=0.1.1, <1.0.0",
13 |     "langchain-community>=0.0.18, <1.0.0",
14 |     "google-cloud-firestore>=2.16.0, <3.0.0",
15 |     "google-cloud-storage>=2.18.2, <3.0.0",
16 |     "more_itertools>=10.2.0, <11.0.0",
17 |     "requests>=2.32.3, <2.33.0"
18 | ]
19 | classifiers = [
20 |     "Intended Audience :: Developers",
21 |     "License :: OSI Approved :: Apache Software License",
22 |     "Programming Language :: Python",
23 |     "Programming Language :: Python :: 3",
24 |     "Programming Language :: Python :: 3.9",
25 |     "Programming Language :: Python :: 3.10",
26 |     "Programming Language :: Python :: 3.11",
27 |     "Programming Language :: Python :: 3.12",
28 | ]
29 | 
30 | [tool.setuptools.dynamic]
31 | version = {attr = "langchain_google_firestore.version.__version__"}
32 | 
33 | [project.urls]
34 | Homepage = "https://github.com/googleapis/langchain-google-firestore-python"
35 | Repository = "https://github.com/googleapis/langchain-google-firestore-python.git"
36 | "Bug Tracker" = "https://github.com/googleapis/langchain-google-firestore-python/issues"
37 | Changelog = "https://github.com/googleapis/langchain-google-firestore-python/blob/main/CHANGELOG.md"
38 | 
39 | [project.optional-dependencies]
40 | test = [
41 |     "black[jupyter]==24.10.0",
42 |     "isort==5.13.2",
43 |     "mypy==1.13.0",
44 |     "pytest-asyncio==0.24.0",
45 |     "pytest==8.3.3",
46 |     "pytest-cov==5.0.0"
47 | ]
48 | 
49 | [build-system]
50 | requires = ["setuptools"]
51 | build-backend = "setuptools.build_meta"
52 | 
53 | [tool.black]
54 | target-version = ['py39']
55 | 
56 | [tool.isort]
57 | profile = "black"
58 | 
59 | [tool.mypy]
60 | python_version = "3.11"
61 | warn_unused_configs = true
62 | 
63 | exclude = [
64 |     'docs/*',
65 |     'noxfile.py'
66 | ]
67 | 
68 | [[tool.mypy.overrides]]
69 | module = "google.cloud.*"
70 | ignore_missing_imports = true
71 | 
72 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | langchain-core==0.3.13
2 | langchain-community==0.3.3
3 | google-cloud-firestore==2.19.0
4 | google-cloud-storage==2.18.2
5 | more-itertools==10.5.0
6 | requests==2.32.3
7 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/__init__.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | from .chat_message_history import FirestoreChatMessageHistory
16 | from .document_loader import FirestoreLoader, FirestoreSaver
17 | from .vectorstores import FirestoreVectorStore
18 | from .version import __version__
19 | 
20 | __all__ = [
21 |     "FirestoreChatMessageHistory",
22 |     "FirestoreLoader",
23 |     "FirestoreSaver",
24 |     "FirestoreVectorStore",
25 |     "__version__",
26 | ]
27 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/chat_message_history.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | from __future__ import annotations
16 | 
17 | import json
18 | from typing import TYPE_CHECKING, List, Optional
19 | 
20 | from google.cloud import firestore  # type: ignore
21 | from langchain_core.chat_history import BaseChatMessageHistory
22 | from langchain_core.messages import BaseMessage, messages_from_dict
23 | 
24 | from .common import client_with_user_agent  # type: ignore
25 | from .version import __version__
26 | 
27 | USER_AGENT = "langchain-google-firestore-python:chat_history/" + __version__
28 | DEFAULT_COLLECTION = "ChatHistory"
29 | 
30 | if TYPE_CHECKING:
31 |     from google.cloud.firestore import Client  # type: ignore
32 | 
33 | 
34 | class FirestoreChatMessageHistory(BaseChatMessageHistory):
35 |     def __init__(
36 |         self,
37 |         session_id: str,
38 |         collection: str = DEFAULT_COLLECTION,
39 |         client: Optional[Client] = None,
40 |         encode_message: bool = True,
41 |     ) -> None:
42 |         """Chat Message History for Google Cloud Firestore.
43 | 
44 |         Args:
45 |             session_id: Arbitrary key that is used to store the messages of a single
46 |                 chat session. This is the document_path of a document.
47 |             collection: The single `/`-delimited path to a Firestore collection.
48 |             client: Client for interacting with the Google Cloud Firestore API.
49 |             encode_message: Encode the message when storing into Firestore.
50 |         """
51 |         self.encode_message = encode_message
52 |         self.client = client_with_user_agent(USER_AGENT, client)
53 |         self.session_id = session_id
54 |         self.doc_ref = self.client.collection(collection).document(session_id)
55 |         self.messages: List[BaseMessage] = []
56 |         self._load_messages()
57 | 
58 |     def _load_messages(self) -> None:
59 |         doc = self.doc_ref.get()
60 |         if doc.exists:
61 |             data_messages = doc.to_dict()
62 |             if "messages" in data_messages:
63 |                 self.messages = convert_messages_to_langchain(
64 |                     self.encode_message, data_messages["messages"]
65 |                 )
66 | 
67 |     def add_message(self, message: BaseMessage) -> None:
68 |         self.messages.append(message)
69 |         self._upsert_messages()
70 | 
71 |     def _upsert_messages(self) -> None:
72 |         if self.encode_message:
73 |             self.doc_ref.set({"messages": encode_messages(self.messages)})
74 |         else:
75 |             self.doc_ref.set({"messages": [m.json() for m in self.messages]})
76 | 
77 |     def clear(self) -> None:
78 |         self.messages = []
79 |         self.doc_ref.delete()
80 | 
81 | 
82 | def encode_messages(messages: List[BaseMessage]) -> List[bytes]:
83 |     return [str.encode(m.json()) for m in messages]
84 | 
85 | 
86 | def convert_messages_to_langchain(
87 |     is_encoded: bool, messages: List[bytes]
88 | ) -> List[BaseMessage]:
89 |     if is_encoded:
90 |         dict_messages = [json.loads(m.decode()) for m in messages]
91 |     else:
92 |         dict_messages = [json.loads(m) for m in messages]
93 |     return messages_from_dict([{"type": m["type"], "data": m} for m in dict_messages])
94 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/common.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | from typing import Optional
16 | 
17 | from google.cloud import firestore  # type: ignore
18 | from google.cloud.firestore_v1.services.firestore.transports.base import (  # type: ignore
19 |     DEFAULT_CLIENT_INFO,
20 | )
21 | 
22 | 
23 | def client_with_user_agent(
24 |     user_agent: str, client: Optional[firestore.Client] = None
25 | ) -> firestore.Client:
26 |     client_info = DEFAULT_CLIENT_INFO
27 |     client_info.user_agent = user_agent
28 |     if not client:
29 |         client = firestore.Client(client_info=client_info)
30 |     client_agent = client._client_info.user_agent
31 |     if not client_agent:
32 |         client._client_info.user_agent = user_agent
33 |     elif user_agent not in client_agent:
34 |         client._client_info.user_agent = " ".join([user_agent, client_agent])
35 |     return client
36 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/document_converter.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2024 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | from __future__ import annotations
 16 | 
 17 | import json
 18 | from typing import TYPE_CHECKING, Any, List, Optional
 19 | 
 20 | from google.cloud.firestore import DocumentReference, GeoPoint  # type: ignore
 21 | from google.cloud.firestore_v1.vector import Vector  # type: ignore
 22 | from langchain_core.documents import Document
 23 | 
 24 | if TYPE_CHECKING:
 25 |     from google.cloud.firestore import Client, DocumentSnapshot
 26 | 
 27 | 
 28 | FIRESTORE_TYPE = "firestore_type"
 29 | DOC_REF = "document_reference"
 30 | GEOPOINT = "geopoint"
 31 | VECTOR = "vector"
 32 | 
 33 | 
 34 | def convert_firestore_document(
 35 |     document: DocumentSnapshot,
 36 |     page_content_fields: Optional[List[str]] = None,
 37 |     metadata_fields: Optional[List[str]] = None,
 38 | ) -> Document:
 39 |     data_doc = document.to_dict()
 40 |     metadata = {
 41 |         "reference": {
 42 |             "path": document.reference.path,
 43 |             FIRESTORE_TYPE: DOC_REF,
 44 |         }
 45 |     }
 46 | 
 47 |     # Check for vector fields and move them from the data_doc to the metadata
 48 |     vector_keys = [k for k in data_doc if isinstance(data_doc[k], Vector)]
 49 |     for k in vector_keys:
 50 |         metadata[k] = _convert_from_firestore(data_doc.pop(k))
 51 | 
 52 |     set_page_fields = set(
 53 |         page_content_fields or (data_doc.keys() - set(metadata_fields or []))
 54 |     )
 55 |     set_metadata_fields = set(metadata_fields or (data_doc.keys() - set_page_fields))
 56 | 
 57 |     page_content = {}
 58 | 
 59 |     for k in sorted(set_metadata_fields):
 60 |         if k in data_doc:
 61 |             metadata[k] = _convert_from_firestore(data_doc[k])
 62 |     for k in sorted(set_page_fields):
 63 |         if k in data_doc:
 64 |             page_content[k] = _convert_from_firestore(data_doc[k])
 65 | 
 66 |     if len(page_content) == 1:
 67 |         page_content = str(page_content.popitem()[1])  # type: ignore
 68 |     else:
 69 |         page_content = json.dumps(page_content)  # type: ignore
 70 | 
 71 |     return Document(page_content=page_content, metadata=metadata)  # type: ignore
 72 | 
 73 | 
 74 | def convert_langchain_document(document: Document, client: Client) -> dict:
 75 |     metadata = document.metadata
 76 |     path = None
 77 |     data = {}
 78 | 
 79 |     if metadata:
 80 |         data.update(_convert_from_langchain(metadata, client))
 81 | 
 82 |     if metadata.get("reference", {}).get(FIRESTORE_TYPE) == DOC_REF:
 83 |         path = metadata["reference"]
 84 |         data.pop("reference")
 85 | 
 86 |     if document.page_content:
 87 |         try:
 88 |             content_dict = json.loads(document.page_content)
 89 |         except (ValueError, SyntaxError):
 90 |             content_dict = {"page_content": document.page_content}
 91 |         converted_page = _convert_from_langchain(content_dict, client)
 92 |         data.update(converted_page)
 93 | 
 94 |     return {"reference": path, "data": data}
 95 | 
 96 | 
 97 | def _convert_from_firestore(val: Any) -> Any:
 98 |     val_converted = val
 99 |     if isinstance(val, dict):
100 |         val_converted = {k: _convert_from_firestore(v) for k, v in val.items()}
101 |     elif isinstance(val, list):
102 |         val_converted = [_convert_from_firestore(v) for v in val]
103 |     elif isinstance(val, DocumentReference):
104 |         val_converted = {
105 |             "path": val.path,
106 |             FIRESTORE_TYPE: DOC_REF,
107 |         }
108 |     elif isinstance(val, GeoPoint):
109 |         val_converted = {
110 |             "latitude": val.latitude,
111 |             "longitude": val.longitude,
112 |             FIRESTORE_TYPE: GEOPOINT,
113 |         }
114 |     elif isinstance(val, Vector):
115 |         vector_map = val.to_map_value()
116 |         val_converted = {
117 |             "values": list(vector_map["value"]),
118 |             FIRESTORE_TYPE: VECTOR,
119 |         }
120 | 
121 |     return val_converted
122 | 
123 | 
124 | def _convert_from_langchain(val: Any, client: Client) -> Any:
125 |     val_converted = val
126 |     if isinstance(val, list):
127 |         val_converted = [_convert_from_langchain(v, client) for v in val]
128 |     elif isinstance(val, dict):
129 |         if val.get(FIRESTORE_TYPE) == DOC_REF:
130 |             val_converted = DocumentReference(*val["path"].split("/"), client=client)
131 |         elif val.get(FIRESTORE_TYPE) == GEOPOINT:
132 |             val_converted = GeoPoint(val["latitude"], val["longitude"])
133 |         elif val.get(FIRESTORE_TYPE) == VECTOR:
134 |             val_converted = Vector(val["values"])
135 |         else:
136 |             val_converted = {
137 |                 k: _convert_from_langchain(v, client) for k, v in val.items()
138 |             }
139 |     return val_converted
140 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/document_loader.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2024 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | from __future__ import annotations
 16 | 
 17 | import itertools
 18 | from typing import TYPE_CHECKING, Iterator, List, Optional
 19 | 
 20 | from google.cloud import firestore  # type: ignore
 21 | from google.cloud.firestore import DocumentReference  # type: ignore
 22 | from langchain_community.document_loaders.base import BaseLoader
 23 | from langchain_core.documents import Document
 24 | from more_itertools import chunked
 25 | 
 26 | from .common import client_with_user_agent
 27 | from .document_converter import (
 28 |     DOC_REF,
 29 |     FIRESTORE_TYPE,
 30 |     convert_firestore_document,
 31 |     convert_langchain_document,
 32 | )
 33 | from .version import __version__
 34 | 
 35 | USER_AGENT_LOADER = "langchain-google-firestore-python:document_loader/" + __version__
 36 | USER_AGENT_SAVER = "langchain-google-firestore-python:document_saver/" + __version__
 37 | WRITE_BATCH_SIZE = 500
 38 | 
 39 | 
 40 | if TYPE_CHECKING:
 41 |     from google.cloud.firestore import Client, CollectionGroup, Query
 42 | 
 43 | 
 44 | class FirestoreLoader(BaseLoader):
 45 |     def __init__(
 46 |         self,
 47 |         source: Query | CollectionGroup | DocumentReference | str,
 48 |         page_content_fields: List[str] = [],
 49 |         metadata_fields: List[str] = [],
 50 |         client: Client = None,
 51 |     ) -> None:
 52 |         """Document Loader for Google Cloud Firestore.
 53 | 
 54 |         Args:
 55 |             source: The source to load the documents. It can be an instance of Query,
 56 |                 CollectionGroup, DocumentReference or the single `/`-delimited path to
 57 |                 a Firestore collection.
 58 |             page_content_fields: The document field names to write into the `page_content`.
 59 |                 If an empty or None list is provided all fields will be written into
 60 |                 `page_content`. When only one field is provided only the value is written.
 61 |             metadata_fields: The document field names to write into the `metadata`. By default
 62 |                 it will write all fields that are not in `page_content`into `metadata`.
 63 |             client: Client for interacting with the Google Cloud Firestore API.
 64 |         """
 65 |         self.client = client_with_user_agent(USER_AGENT_LOADER, client)
 66 |         self.source = source
 67 |         self.page_content_fields = page_content_fields
 68 |         self.metadata_fields = metadata_fields
 69 | 
 70 |     def load(self) -> List[Document]:
 71 |         """Load Documents."""
 72 |         return list(self.lazy_load())
 73 | 
 74 |     def lazy_load(self) -> Iterator[Document]:
 75 |         """A lazy loader for Documents."""
 76 |         query = None
 77 |         if isinstance(self.source, DocumentReference):
 78 |             self.source._client = client_with_user_agent(
 79 |                 USER_AGENT_LOADER, self.source._client
 80 |             )
 81 |             yield convert_firestore_document(self.source.get())
 82 |         else:
 83 |             if isinstance(self.source, str):
 84 |                 query = self.client.collection(self.source)
 85 |             else:
 86 |                 query = self.source
 87 |                 client_with_user_agent(USER_AGENT_LOADER, query._client)
 88 | 
 89 |             for document_snapshot in query.stream():
 90 |                 yield convert_firestore_document(
 91 |                     document_snapshot,
 92 |                     self.page_content_fields,
 93 |                     self.metadata_fields,
 94 |                 )
 95 | 
 96 | 
 97 | class FirestoreSaver:
 98 |     """Write into Google Cloud Platform `Firestore`."""
 99 | 
100 |     def __init__(
101 |         self,
102 |         collection: Optional[str] = None,
103 |         client: Optional[Client] = None,
104 |     ) -> None:
105 |         """Document Saver for Google Cloud Firestore.
106 | 
107 |         Args:
108 |             collection: The single `/`-delimited path to a Firestore collection. If
109 |                 this value is present it will write documents with an auto generated id.
110 |             client: Client for interacting with the Google Cloud Firestore API.
111 |         """
112 |         self.collection = collection
113 |         self.client = client_with_user_agent(USER_AGENT_SAVER, client)
114 | 
115 |     def upsert_documents(
116 |         self,
117 |         documents: List[Document],
118 |         merge: Optional[bool] = False,
119 |         document_ids: Optional[List[str]] = None,
120 |     ) -> None:
121 |         """Create / merge documents into the Firestore database.
122 | 
123 |         Args:
124 |             documents: List of documents to be written into Firestore.
125 |             merge: To merge data with an existing document (creating if
126 |                 the document does not exist).
127 |             document_ids: List of document ids to be used. By default it
128 |                 will try to construct the document paths using the `reference`
129 |                 from the Document.
130 |         """
131 |         db_batch = self.client.batch()
132 | 
133 |         if document_ids and len(document_ids) != len(documents):
134 |             raise ValueError(
135 |                 "`documents` and `document_ids` parameters must be the same length"
136 |             )
137 | 
138 |         docs_list = itertools.zip_longest(documents, document_ids or [])
139 | 
140 |         for batch in chunked(docs_list, WRITE_BATCH_SIZE):
141 |             for doc, doc_id in batch:
142 |                 document_dict = convert_langchain_document(doc, self.client)
143 |                 if self.collection:
144 |                     doc_ref = self.client.collection(self.collection).document()
145 |                 elif doc_id:
146 |                     doc_ref = DocumentReference(*doc_id.split("/"), client=self.client)
147 |                 elif document_dict.get("reference", {}).get(FIRESTORE_TYPE) == DOC_REF:
148 |                     doc_ref = DocumentReference(
149 |                         *document_dict["reference"]["path"].split("/"),
150 |                         client=self.client,
151 |                     )
152 |                 else:
153 |                     raise ValueError(
154 |                         "Unable to construct document_path for document: " + str(doc)
155 |                     )
156 | 
157 |                 db_batch.set(
158 |                     reference=doc_ref,
159 |                     document_data=document_dict["data"],
160 |                     merge=merge,
161 |                 )
162 |             db_batch.commit()
163 | 
164 |     def delete_documents(
165 |         self,
166 |         documents: List[Document],
167 |         document_ids: Optional[List[str]] = None,
168 |     ) -> None:
169 |         """Delete documents from the Firestore database.
170 | 
171 |         Args:
172 |             documents: List of documents to be deleted from Firestore.
173 |                 It will try to extract the {document_path} from the `reference`
174 |                 in the document metadata.
175 |             document_ids: List of documents ids to be deleted from Firestore.
176 |                 If provided the `documents` argument will be ignored.
177 | 
178 |         """
179 |         db_batch = self.client.batch()
180 | 
181 |         docs_list = itertools.zip_longest(documents, document_ids or [])
182 | 
183 |         for batch in chunked(docs_list, WRITE_BATCH_SIZE):
184 |             for doc, doc_id in batch:
185 |                 document_path = None
186 |                 if doc_id:
187 |                     document_path = doc_id
188 |                 elif doc:
189 |                     document_dict = convert_langchain_document(doc, self.client)
190 |                     if (
191 |                         document_dict.get("reference", {}).get(FIRESTORE_TYPE)
192 |                         == DOC_REF
193 |                     ):
194 |                         document_path = document_dict["reference"]["path"]
195 |                 if not document_path:
196 |                     raise ValueError(
197 |                         "Unable to construct document_path for document: "
198 |                         + str(doc)
199 |                         + "or doc_id: "
200 |                         + str(doc_id)
201 |                     )
202 |                 doc_ref = DocumentReference(
203 |                     *document_path.split("/"), client=self.client
204 |                 )
205 |                 db_batch.delete(doc_ref)
206 |             db_batch.commit()
207 | 


--------------------------------------------------------------------------------
/src/langchain_google_firestore/py.typed:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/langchain-google-firestore-python/691eafbed7328b2b1b52f4bf7d202fb6844160af/src/langchain_google_firestore/py.typed


--------------------------------------------------------------------------------
/src/langchain_google_firestore/version.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | __version__ = "0.5.0"
16 | 


--------------------------------------------------------------------------------
/tests/fake.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | from typing import List
16 | 
17 | from langchain_community.embeddings import FakeEmbeddings
18 | 
19 | 
20 | class FakeImageEmbeddings(FakeEmbeddings):
21 |     """Fake embedding model for images."""
22 | 
23 |     def embed_image(self, image_path: str) -> List[float]:
24 |         return self._get_embedding()
25 | 


--------------------------------------------------------------------------------
/tests/test_chat_message_history.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2024 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | import uuid
 16 | from multiprocessing import Pool
 17 | from typing import List
 18 | from unittest import TestCase
 19 | 
 20 | import pytest
 21 | from google.cloud.firestore import Client  # type: ignore
 22 | from langchain_core.messages import AIMessage, HumanMessage
 23 | 
 24 | from langchain_google_firestore import FirestoreChatMessageHistory
 25 | 
 26 | 
 27 | @pytest.fixture
 28 | def test_case() -> TestCase:
 29 |     return TestCase()
 30 | 
 31 | 
 32 | def test_firestore_history_workflow(test_case: TestCase) -> None:
 33 |     session_id = uuid.uuid4().hex
 34 |     chat_history = FirestoreChatMessageHistory(
 35 |         session_id=session_id, collection="HistoryWorkflow"
 36 |     )
 37 | 
 38 |     chat_history.add_ai_message("AI message")
 39 |     chat_history.add_user_message("User message")
 40 | 
 41 |     expected_messages = [
 42 |         AIMessage(content="AI message"),
 43 |         HumanMessage(content="User message"),
 44 |     ]
 45 | 
 46 |     test_case.assertCountEqual(expected_messages, chat_history.messages)
 47 | 
 48 |     chat_history.clear()
 49 |     chat_history._load_messages()
 50 | 
 51 |     assert len(chat_history.messages) == 0
 52 | 
 53 | 
 54 | def test_firestore_without_encoding_workflow(test_case: TestCase) -> None:
 55 |     session_id = uuid.uuid4().hex
 56 |     chat_history = FirestoreChatMessageHistory(
 57 |         session_id=session_id,
 58 |         collection="HistoryWorkflow",
 59 |         encode_message=False,
 60 |     )
 61 |     chat_history.add_user_message("User message")
 62 | 
 63 |     expected_messages = [
 64 |         HumanMessage(content="User message"),
 65 |     ]
 66 |     chat_history._load_messages()
 67 | 
 68 |     test_case.assertCountEqual(expected_messages, chat_history.messages)
 69 | 
 70 |     chat_history.clear()
 71 |     chat_history._load_messages()
 72 | 
 73 |     assert len(chat_history.messages) == 0
 74 | 
 75 | 
 76 | def test_firestore_load_messages(test_case: TestCase) -> None:
 77 |     NUM_MESSAGES = 25
 78 |     session_id = uuid.uuid4().hex
 79 |     chat_history = FirestoreChatMessageHistory(
 80 |         session_id=session_id, collection="HistoryLoad"
 81 |     )
 82 | 
 83 |     expected_messages: List[AIMessage | HumanMessage] = []
 84 | 
 85 |     for i in range(NUM_MESSAGES):
 86 |         ai_m = AIMessage(content=f"AI message: {i}")
 87 |         human_m = HumanMessage(content=f"Human message: {i}")
 88 | 
 89 |         expected_messages.append(ai_m)
 90 |         expected_messages.append(human_m)
 91 | 
 92 |         chat_history.add_ai_message(ai_m)
 93 |         chat_history.add_user_message(human_m)
 94 | 
 95 |     test_case.assertCountEqual(expected_messages, chat_history.messages)
 96 | 
 97 |     chat_history.clear()
 98 |     chat_history._load_messages()
 99 | 
100 |     assert len(chat_history.messages) == 0
101 | 
102 | 
103 | def test_firestore_multiple_sessions(test_case: TestCase) -> None:
104 |     collection = "MultipleSession"
105 |     session_1 = uuid.uuid4().hex
106 |     chat_history_1 = FirestoreChatMessageHistory(
107 |         session_id=session_1, collection=collection
108 |     )
109 |     session_2 = uuid.uuid4().hex
110 |     chat_history_2 = FirestoreChatMessageHistory(
111 |         session_id=session_2, collection=collection
112 |     )
113 | 
114 |     chat_history_1.add_ai_message("AI message session 1")
115 |     chat_history_1.add_user_message("Human message session 1")
116 |     chat_history_2.add_ai_message("AI message session 2")
117 |     chat_history_2.add_user_message("Human message session 2")
118 | 
119 |     expected_message_session_1 = [
120 |         AIMessage(content="AI message session 1"),
121 |         HumanMessage(content="Human message session 1"),
122 |     ]
123 |     expected_message_session_2 = [
124 |         AIMessage(content="AI message session 2"),
125 |         HumanMessage(content="Human message session 2"),
126 |     ]
127 | 
128 |     test_case.assertCountEqual(expected_message_session_1, chat_history_1.messages)
129 |     test_case.assertCountEqual(expected_message_session_2, chat_history_2.messages)
130 | 
131 |     chat_history_1.clear()
132 |     chat_history_2.clear()
133 | 
134 |     assert len(chat_history_1.messages) == 0
135 |     assert len(chat_history_2.messages) == 0
136 | 
137 | 
138 | def test_firestore_reopen_session(test_case: TestCase) -> None:
139 |     collection = "Session"
140 |     session = uuid.uuid4().hex
141 |     chat_history = FirestoreChatMessageHistory(
142 |         session_id=session, collection=collection
143 |     )
144 | 
145 |     chat_history.add_ai_message("AI message")
146 |     chat_history.add_user_message("Human message")
147 | 
148 |     chat_history_reopen = FirestoreChatMessageHistory(
149 |         session_id=session, collection=collection
150 |     )
151 | 
152 |     expected_messages = [
153 |         AIMessage(content="AI message"),
154 |         HumanMessage(content="Human message"),
155 |     ]
156 | 
157 |     test_case.assertCountEqual(expected_messages, chat_history_reopen.messages)
158 | 
159 |     chat_history.clear()
160 |     chat_history_reopen.clear()
161 | 
162 | 
163 | def test_firestore_custom_client(test_case: TestCase) -> None:
164 |     client = Client(database="(default)")
165 |     session_id = uuid.uuid4().hex
166 |     chat_history = FirestoreChatMessageHistory(
167 |         session_id=session_id, collection="HistoryWorkflow", client=client
168 |     )
169 | 
170 |     chat_history.add_ai_message("AI message")
171 |     chat_history.add_user_message("User message")
172 | 
173 |     expected_messages = [
174 |         AIMessage(content="AI message"),
175 |         HumanMessage(content="User message"),
176 |     ]
177 | 
178 |     test_case.assertCountEqual(expected_messages, chat_history.messages)
179 | 
180 |     chat_history.clear()
181 | 


--------------------------------------------------------------------------------
/tests/test_document_converter.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2024 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | from unittest.mock import patch
 16 | 
 17 | import pytest
 18 | from google.cloud.firestore import (  # type: ignore
 19 |     DocumentReference,
 20 |     DocumentSnapshot,
 21 |     GeoPoint,
 22 | )
 23 | from google.cloud.firestore_v1.vector import Vector  # type: ignore
 24 | from langchain_core.documents import Document
 25 | 
 26 | from langchain_google_firestore.document_converter import (
 27 |     DOC_REF,
 28 |     FIRESTORE_TYPE,
 29 |     GEOPOINT,
 30 |     VECTOR,
 31 |     convert_firestore_document,
 32 |     convert_langchain_document,
 33 | )
 34 | 
 35 | 
 36 | @pytest.fixture(scope="module", autouse=True)
 37 | def firestore_client():
 38 |     with patch("google.cloud.firestore.Client") as _fixture:
 39 |         yield _fixture
 40 | 
 41 | 
 42 | @pytest.mark.parametrize(
 43 |     "document_snapshot,langchain_doc",
 44 |     [
 45 |         (
 46 |             DocumentSnapshot(
 47 |                 reference=DocumentReference("foo", "bar"),
 48 |                 data={"field_1": "data_1", "field_2": 2},
 49 |                 exists=True,
 50 |                 read_time=None,
 51 |                 create_time=None,
 52 |                 update_time=None,
 53 |             ),
 54 |             Document(
 55 |                 page_content='{"field_1": "data_1", "field_2": 2}',
 56 |                 metadata={
 57 |                     "reference": {
 58 |                         "path": "foo/bar",
 59 |                         FIRESTORE_TYPE: DOC_REF,
 60 |                     }
 61 |                 },
 62 |             ),
 63 |         ),
 64 |         (
 65 |             DocumentSnapshot(
 66 |                 reference=DocumentReference("foo", "bar"),
 67 |                 data={
 68 |                     "field_1": GeoPoint(1, 2),
 69 |                     "field_2": [
 70 |                         "data",
 71 |                         2,
 72 |                         {"nested": DocumentReference("abc", "xyz")},
 73 |                     ],
 74 |                 },
 75 |                 exists=True,
 76 |                 read_time=None,
 77 |                 create_time=None,
 78 |                 update_time=None,
 79 |             ),
 80 |             Document(
 81 |                 page_content='{"field_1": {"latitude": 1, "longitude": 2, "firestore_type": "geopoint"}, '
 82 |                 + '"field_2": ["data", 2, {"nested": {"path": "abc/xyz", "firestore_type": "document_reference"}}]}',
 83 |                 metadata={
 84 |                     "reference": {
 85 |                         "path": "foo/bar",
 86 |                         FIRESTORE_TYPE: DOC_REF,
 87 |                     }
 88 |                 },
 89 |             ),
 90 |         ),
 91 |     ],
 92 | )
 93 | def test_convert_firestore_document_default_fields(
 94 |     document_snapshot, langchain_doc
 95 | ) -> None:
 96 |     return_doc = convert_firestore_document(document_snapshot)
 97 | 
 98 |     assert return_doc == langchain_doc
 99 | 
100 | 
101 | @pytest.mark.parametrize(
102 |     "document_snapshot,langchain_doc,page_content_fields,metadata_fields",
103 |     [
104 |         (
105 |             DocumentSnapshot(
106 |                 reference=DocumentReference("abc", "xyz"),
107 |                 data={"data_field": "data", "extra_field": 1},
108 |                 exists=True,
109 |                 read_time=None,
110 |                 create_time=None,
111 |                 update_time=None,
112 |             ),
113 |             Document(
114 |                 page_content="data",
115 |                 metadata={
116 |                     "reference": {
117 |                         "path": "abc/xyz",
118 |                         FIRESTORE_TYPE: DOC_REF,
119 |                     },
120 |                     "data_field": "data",
121 |                 },
122 |             ),
123 |             ["data_field"],
124 |             ["data_field"],
125 |         ),
126 |         (
127 |             DocumentSnapshot(
128 |                 reference=DocumentReference("abc", "xyz"),
129 |                 data={"field_1": 1, "field_2": "val"},
130 |                 exists=True,
131 |                 read_time=None,
132 |                 create_time=None,
133 |                 update_time=None,
134 |             ),
135 |             Document(
136 |                 page_content="val",
137 |                 metadata={
138 |                     "reference": {
139 |                         "path": "abc/xyz",
140 |                         FIRESTORE_TYPE: DOC_REF,
141 |                     },
142 |                     "field_1": 1,
143 |                 },
144 |             ),
145 |             ["field_2"],
146 |             ["field_1"],
147 |         ),
148 |         (
149 |             DocumentSnapshot(
150 |                 reference=DocumentReference("abc", "xyz"),
151 |                 data={
152 |                     "field_1": "val_1",
153 |                     "field_2": "val_2",
154 |                     "field_3": "val_3",
155 |                     "field_4": "val_4",
156 |                 },
157 |                 exists=True,
158 |                 read_time=None,
159 |                 create_time=None,
160 |                 update_time=None,
161 |             ),
162 |             Document(
163 |                 page_content='{"field_2": "val_2", "field_3": "val_3"}',
164 |                 metadata={
165 |                     "reference": {
166 |                         "path": "abc/xyz",
167 |                         FIRESTORE_TYPE: DOC_REF,
168 |                     },
169 |                     "field_1": "val_1",
170 |                 },
171 |             ),
172 |             ["field_2", "field_3"],
173 |             ["field_1"],
174 |         ),
175 |         (
176 |             DocumentSnapshot(
177 |                 reference=DocumentReference("abc", "xyz"),
178 |                 data={
179 |                     "field_1": "val_1",
180 |                     "field_2": "val_2",
181 |                     "field_3": "val_3",
182 |                     "field_4": "val_4",
183 |                 },
184 |                 exists=True,
185 |                 read_time=None,
186 |                 create_time=None,
187 |                 update_time=None,
188 |             ),
189 |             Document(
190 |                 page_content='{"field_2": "val_2", "field_3": "val_3"}',
191 |                 metadata={
192 |                     "reference": {
193 |                         "path": "abc/xyz",
194 |                         FIRESTORE_TYPE: DOC_REF,
195 |                     },
196 |                     "field_1": "val_1",
197 |                     "field_4": "val_4",
198 |                 },
199 |             ),
200 |             [],
201 |             ["field_1", "field_4"],
202 |         ),
203 |         (
204 |             DocumentSnapshot(
205 |                 reference=DocumentReference("abc", "xyz"),
206 |                 data={
207 |                     "field_1": "val_1",
208 |                     "field_2": "val_2",
209 |                     "field_3": "val_3",
210 |                     "field_4": "val_4",
211 |                 },
212 |                 exists=True,
213 |                 read_time=None,
214 |                 create_time=None,
215 |                 update_time=None,
216 |             ),
217 |             Document(
218 |                 page_content='{"field_2": "val_2", "field_4": "val_4"}',
219 |                 metadata={
220 |                     "reference": {
221 |                         "path": "abc/xyz",
222 |                         FIRESTORE_TYPE: DOC_REF,
223 |                     },
224 |                     "field_1": "val_1",
225 |                     "field_3": "val_3",
226 |                 },
227 |             ),
228 |             ["field_2", "field_4"],
229 |             [],
230 |         ),
231 |     ],
232 | )
233 | def test_convert_firestore_document_with_filters(
234 |     document_snapshot, langchain_doc, page_content_fields, metadata_fields
235 | ) -> None:
236 |     return_doc = convert_firestore_document(
237 |         document_snapshot, page_content_fields, metadata_fields
238 |     )
239 | 
240 |     assert return_doc == langchain_doc
241 | 
242 | 
243 | @pytest.mark.parametrize(
244 |     "langchain_doc,firestore_doc",
245 |     [
246 |         (
247 |             Document(
248 |                 page_content="value",
249 |                 metadata={
250 |                     "reference": {
251 |                         "path": "foo/bar",
252 |                         FIRESTORE_TYPE: DOC_REF,
253 |                     }
254 |                 },
255 |             ),
256 |             {
257 |                 "reference": {
258 |                     "path": "foo/bar",
259 |                     FIRESTORE_TYPE: DOC_REF,
260 |                 },
261 |                 "data": {"page_content": "value"},
262 |             },
263 |         ),
264 |         (
265 |             Document(page_content="value", metadata={"reference": {}}),
266 |             {
267 |                 "reference": None,
268 |                 "data": {"page_content": "value", "reference": {}},
269 |             },
270 |         ),
271 |         (
272 |             Document(
273 |                 page_content="value",
274 |                 metadata={"reference": {"path": "foo/bar", "unexpected_field": "data"}},
275 |             ),
276 |             {
277 |                 "reference": None,
278 |                 "data": {
279 |                     "page_content": "value",
280 |                     "reference": {
281 |                         "path": "foo/bar",
282 |                         "unexpected_field": "data",
283 |                     },
284 |                 },
285 |             },
286 |         ),
287 |         (
288 |             Document(
289 |                 page_content="value",
290 |                 metadata={
291 |                     "reference": {
292 |                         "path": "foo/bar",
293 |                         FIRESTORE_TYPE: DOC_REF,
294 |                     },
295 |                     "metadata_field": {
296 |                         "path": "abc/xyz",
297 |                         FIRESTORE_TYPE: DOC_REF,
298 |                     },
299 |                 },
300 |             ),
301 |             {
302 |                 "reference": {
303 |                     "path": "foo/bar",
304 |                     FIRESTORE_TYPE: DOC_REF,
305 |                 },
306 |                 "data": {
307 |                     "page_content": "value",
308 |                     "metadata_field": DocumentReference(
309 |                         *["abc", "xyz"], client=firestore_client
310 |                     ),
311 |                 },
312 |             },
313 |         ),
314 |         (
315 |             Document(
316 |                 page_content='{"field_1": "val_1", "field_2": "val_2"}',
317 |                 metadata={
318 |                     "reference": {
319 |                         "path": "foo/bar",
320 |                         FIRESTORE_TYPE: DOC_REF,
321 |                     },
322 |                     "field_3": "val_3",
323 |                 },
324 |             ),
325 |             {
326 |                 "reference": {
327 |                     "path": "foo/bar",
328 |                     FIRESTORE_TYPE: DOC_REF,
329 |                 },
330 |                 "data": {
331 |                     "field_1": "val_1",
332 |                     "field_2": "val_2",
333 |                     "field_3": "val_3",
334 |                 },
335 |             },
336 |         ),
337 |         (
338 |             Document(
339 |                 page_content="",
340 |                 metadata={
341 |                     "reference": {
342 |                         "path": "foo/bar",
343 |                         FIRESTORE_TYPE: DOC_REF,
344 |                     }
345 |                 },
346 |             ),
347 |             {
348 |                 "reference": {
349 |                     "path": "foo/bar",
350 |                     FIRESTORE_TYPE: DOC_REF,
351 |                 },
352 |                 "data": {},
353 |             },
354 |         ),
355 |         (
356 |             Document(
357 |                 page_content="",
358 |                 metadata={
359 |                     "reference": {
360 |                         "path": "foo/bar",
361 |                         FIRESTORE_TYPE: DOC_REF,
362 |                     },
363 |                     "point": {
364 |                         "latitude": 1,
365 |                         "longitude": 2,
366 |                         FIRESTORE_TYPE: GEOPOINT,
367 |                     },
368 |                     "field_2": "val_2",
369 |                 },
370 |             ),
371 |             {
372 |                 "reference": {
373 |                     "path": "foo/bar",
374 |                     FIRESTORE_TYPE: DOC_REF,
375 |                 },
376 |                 "data": {"point": GeoPoint(1, 2), "field_2": "val_2"},
377 |             },
378 |         ),
379 |         (
380 |             Document(page_content="", metadata={}),
381 |             {"reference": None, "data": {}},
382 |         ),
383 |         (
384 |             Document(
385 |                 page_content='{"array":[1, "data", {"k_1":"v_1", "k_point": {"latitude":1, "longitude":0, "firestore_type": "geopoint"}}], "f_2":2}',
386 |                 metadata={},
387 |             ),
388 |             {
389 |                 "reference": None,
390 |                 "data": {
391 |                     "array": [
392 |                         1,
393 |                         "data",
394 |                         {"k_1": "v_1", "k_point": GeoPoint(1, 0)},
395 |                     ],
396 |                     "f_2": 2,
397 |                 },
398 |             },
399 |         ),
400 |     ],
401 | )
402 | def test_convert_langchain_document(langchain_doc, firestore_doc):
403 |     return_doc = convert_langchain_document(langchain_doc, firestore_client)
404 |     assert return_doc == firestore_doc
405 | 
406 | 
407 | @pytest.mark.parametrize(
408 |     "firestore_doc",
409 |     [
410 |         (
411 |             DocumentSnapshot(
412 |                 reference=DocumentReference(*["foo", "bar"], client=firestore_client),
413 |                 data={
414 |                     "field_1": GeoPoint(1, 2),
415 |                     "field_2": [
416 |                         "data",
417 |                         2,
418 |                         {
419 |                             "nested": DocumentReference(
420 |                                 *["abc", "xyz"], client=firestore_client
421 |                             )
422 |                         },
423 |                     ],
424 |                 },
425 |                 exists=True,
426 |                 read_time=None,
427 |                 create_time=None,
428 |                 update_time=None,
429 |             )
430 |         ),
431 |     ],
432 | )
433 | def test_roundtrip_firestore(firestore_doc):
434 |     langchain_doc = convert_firestore_document(firestore_doc)
435 |     roundtrip_doc = convert_langchain_document(langchain_doc, firestore_client)
436 | 
437 |     assert roundtrip_doc["data"] == firestore_doc.to_dict()
438 |     assert roundtrip_doc["reference"]["path"] == firestore_doc.reference.path
439 | 
440 | 
441 | @pytest.mark.parametrize(
442 |     "firestore_doc, langchain_doc",
443 |     [
444 |         (
445 |             DocumentSnapshot(
446 |                 reference=DocumentReference(*["foo", "bar"], client=firestore_client),
447 |                 data={
448 |                     "embedding": Vector([1, 2, 3]),
449 |                     "content": "test_doc2",
450 |                 },
451 |                 exists=True,
452 |                 read_time=None,
453 |                 create_time=None,
454 |                 update_time=None,
455 |             ),
456 |             Document(
457 |                 page_content="test_doc2",
458 |                 metadata={
459 |                     "reference": {
460 |                         "path": "foo/bar",
461 |                         FIRESTORE_TYPE: DOC_REF,
462 |                     },
463 |                     "embedding": {
464 |                         "values": [1, 2, 3],
465 |                         FIRESTORE_TYPE: VECTOR,
466 |                     },
467 |                 },
468 |             ),
469 |         ),
470 |     ],
471 | )
472 | def test_vector_type_from_firestore(firestore_doc, langchain_doc):
473 |     """
474 |     Test vector type conversion from Firestore to LangChain.
475 |     """
476 | 
477 |     assert convert_firestore_document(firestore_doc) == langchain_doc
478 | 
479 | 
480 | @pytest.mark.parametrize(
481 |     "langchain_doc, firestore_doc",
482 |     [
483 |         (
484 |             Document(
485 |                 page_content="test_doc2",
486 |                 metadata={
487 |                     "reference": {
488 |                         "path": "foo/bar",
489 |                         FIRESTORE_TYPE: DOC_REF,
490 |                     },
491 |                     "embedding": {
492 |                         "values": [1, 2, 3],
493 |                         FIRESTORE_TYPE: VECTOR,
494 |                     },
495 |                 },
496 |             ),
497 |             {
498 |                 "reference": {
499 |                     "path": "foo/bar",
500 |                     FIRESTORE_TYPE: DOC_REF,
501 |                 },
502 |                 "data": {
503 |                     "page_content": "test_doc2",
504 |                     "embedding": Vector([1, 2, 3]),
505 |                 },
506 |             },
507 |         ),
508 |     ],
509 | )
510 | def test_vector_type_to_firestore(langchain_doc, firestore_doc):
511 |     """
512 |     Test vector type conversion from LangChain to Firestore.
513 |     """
514 | 
515 |     assert convert_langchain_document(langchain_doc, firestore_client) == firestore_doc
516 | 
517 | 
518 | @pytest.mark.parametrize(
519 |     "firestore_doc",
520 |     [
521 |         (
522 |             DocumentSnapshot(
523 |                 reference=DocumentReference(*["foo", "bar"], client=firestore_client),
524 |                 data={
525 |                     "field_1": GeoPoint(1, 2),
526 |                     "field_2": [
527 |                         "data",
528 |                         2,
529 |                         {
530 |                             "nested": DocumentReference(
531 |                                 *["abc", "xyz"], client=firestore_client
532 |                             )
533 |                         },
534 |                     ],
535 |                     "field_3": Vector([1, 2, 3]),
536 |                 },
537 |                 exists=True,
538 |                 read_time=None,
539 |                 create_time=None,
540 |                 update_time=None,
541 |             )
542 |         ),
543 |     ],
544 | )
545 | def test_vector_type_roundtrip(firestore_doc):
546 |     """
547 |     Test vector type roundtrip conversion between LangChain and Firestore.
548 |     """
549 | 
550 |     langchain_doc = convert_firestore_document(firestore_doc)
551 |     roundtrip_doc = convert_langchain_document(langchain_doc, firestore_client)
552 | 
553 |     assert roundtrip_doc["data"] == firestore_doc.to_dict()
554 |     assert roundtrip_doc["reference"]["path"] == firestore_doc.reference.path
555 | 


--------------------------------------------------------------------------------
/tests/test_document_loader.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2024 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | import time
 16 | import unittest.mock as mock
 17 | import uuid
 18 | from unittest import TestCase
 19 | 
 20 | import pytest
 21 | from google.cloud.firestore import Client, CollectionGroup, FieldFilter  # type: ignore
 22 | from langchain_core.documents import Document
 23 | 
 24 | from langchain_google_firestore import FirestoreLoader, FirestoreSaver
 25 | 
 26 | 
 27 | @pytest.fixture
 28 | def test_case() -> TestCase:
 29 |     return TestCase()
 30 | 
 31 | 
 32 | @pytest.fixture
 33 | def client() -> Client:
 34 |     return Client()
 35 | 
 36 | 
 37 | def test_firestore_write_roundtrip_and_load() -> None:
 38 |     source = "WriteRoundTrip" + str(uuid.uuid4())
 39 |     saver = FirestoreSaver(source)
 40 |     loader = FirestoreLoader(source)
 41 | 
 42 |     docs = [Document(page_content="data", metadata={})]
 43 | 
 44 |     saver.upsert_documents(docs)
 45 |     # wait 1s for consistency
 46 |     time.sleep(1)
 47 |     written_docs = loader.load()
 48 |     saver.delete_documents(written_docs)
 49 |     # wait 1s for consistency
 50 |     time.sleep(1)
 51 | 
 52 |     deleted_docs = loader.load()
 53 | 
 54 |     assert len(written_docs) == 1
 55 |     assert written_docs[0].page_content == "data"
 56 |     assert written_docs[0].metadata != {}
 57 |     assert "reference" in written_docs[0].metadata
 58 |     assert len(deleted_docs) == 0
 59 | 
 60 | 
 61 | def test_firestore_write_load_batch(test_case: TestCase) -> None:
 62 |     source = "WriteBatch" + str(uuid.uuid4())
 63 |     saver = FirestoreSaver(source)
 64 |     loader = FirestoreLoader(source)
 65 |     NUM_DOCS = 1000
 66 | 
 67 |     docs = []
 68 |     expected_docs = []
 69 |     for i in range(NUM_DOCS):
 70 |         docs.append(Document(page_content=f"content {i}"))
 71 |         expected_docs.append(
 72 |             Document(
 73 |                 page_content=f"content {i}",
 74 |                 metadata={
 75 |                     "reference": {
 76 |                         "path": mock.ANY,
 77 |                         "firestore_type": "document_reference",
 78 |                     }
 79 |                 },
 80 |             )
 81 |         )
 82 | 
 83 |     saver.upsert_documents(docs)
 84 |     # wait 5s for consistency
 85 |     time.sleep(5)
 86 |     docs_after_write = loader.load()
 87 |     saver.delete_documents(docs_after_write)
 88 |     # wait 5s for consistency
 89 |     time.sleep(5)
 90 |     docs_after_delete = loader.load()
 91 | 
 92 |     test_case.assertCountEqual(expected_docs, docs_after_write)
 93 |     assert len(docs_after_delete) == 0
 94 | 
 95 | 
 96 | def test_firestore_write_with_reference(test_case: TestCase) -> None:
 97 |     source = "WriteRef" + str(uuid.uuid4())
 98 |     saver = FirestoreSaver()
 99 |     loader = FirestoreLoader(source)
100 | 
101 |     expected_doc = [
102 |         Document(
103 |             page_content='{"f1": 1, "f2": 2}',
104 |             metadata={
105 |                 "reference": {
106 |                     "path": source + "/doc",
107 |                     "firestore_type": "document_reference",
108 |                 }
109 |             },
110 |         )
111 |     ]
112 |     saver.upsert_documents(expected_doc)
113 |     # wait 1s for consistency
114 |     time.sleep(1)
115 |     written_doc = loader.load()
116 |     saver.delete_documents(written_doc)
117 |     # wait 1s for consistency
118 |     time.sleep(1)
119 |     deleted_doc = loader.load()
120 | 
121 |     test_case.assertCountEqual(expected_doc, written_doc)
122 |     assert len(deleted_doc) == 0
123 | 
124 | 
125 | def test_firestore_write_doc_id_error(test_case: TestCase) -> None:
126 |     saver = FirestoreSaver()
127 |     doc_to_insert = [Document(page_content='{"f1": 1, "f2": 2}')]
128 |     doc_id = ["a/b", "c/d"]
129 | 
130 |     test_case.assertRaises(
131 |         ValueError, saver.upsert_documents, documents=doc_to_insert, document_ids=doc_id
132 |     )
133 | 
134 | 
135 | def test_firestore_write_with_doc_id(test_case: TestCase) -> None:
136 |     source = "WriteId" + str(uuid.uuid4())
137 |     saver = FirestoreSaver()
138 |     loader = FirestoreLoader(source)
139 | 
140 |     doc_to_insert = [
141 |         Document(
142 |             page_content='{"f1": 1, "f2": 2}',
143 |             metadata={
144 |                 "reference": {"path": "foo/bar", "firestore_type": "document_reference"}
145 |             },
146 |         )
147 |     ]
148 | 
149 |     expected_doc = [
150 |         Document(
151 |             page_content='{"f1": 1, "f2": 2}',
152 |             metadata={
153 |                 "reference": {
154 |                     "path": source + "/doc",
155 |                     "firestore_type": "document_reference",
156 |                 }
157 |             },
158 |         )
159 |     ]
160 |     doc_id = [source + "/doc"]
161 |     saver.upsert_documents(documents=doc_to_insert, document_ids=doc_id)
162 |     # wait 1s for consistency
163 |     time.sleep(1)
164 |     written_doc = loader.load()
165 |     saver.delete_documents(written_doc, doc_id)
166 |     # wait 1s for consistency
167 |     time.sleep(1)
168 |     deleted_doc = loader.load()
169 | 
170 |     test_case.assertCountEqual(expected_doc, written_doc)
171 |     assert len(deleted_doc) == 0
172 | 
173 | 
174 | @pytest.mark.parametrize(
175 |     "page_fields,metadata_fields,expected_page_content,expected_metadata",
176 |     [
177 |         ([], [], '{"f1": "v1", "f2": "v2", "f3": "v3"}', {"reference": mock.ANY}),
178 |         (["f1"], [], "v1", {"reference": mock.ANY, "f2": "v2", "f3": "v3"}),
179 |         ([], ["f2"], '{"f1": "v1", "f3": "v3"}', {"reference": mock.ANY, "f2": "v2"}),
180 |         (["f1"], ["f2"], "v1", {"reference": mock.ANY, "f2": "v2"}),
181 |         (["f2"], ["f2"], "v2", {"reference": mock.ANY, "f2": "v2"}),
182 |     ],
183 | )
184 | def test_firestore_load_with_fields(
185 |     page_fields,
186 |     metadata_fields,
187 |     expected_page_content,
188 |     expected_metadata,
189 |     test_case: TestCase,
190 | ):
191 |     source = "WritePageFields" + str(uuid.uuid4())
192 |     saver = FirestoreSaver(source)
193 |     loader = FirestoreLoader(
194 |         source=source,
195 |         page_content_fields=page_fields,
196 |         metadata_fields=metadata_fields,
197 |     )
198 | 
199 |     doc_to_insert = [
200 |         Document(page_content='{"f1": "v1", "f2": "v2", "f3": "v3"}', metadata={})
201 |     ]
202 |     expected_doc = [
203 |         Document(page_content=expected_page_content, metadata=expected_metadata)
204 |     ]
205 | 
206 |     saver.upsert_documents(doc_to_insert)
207 |     # wait 1s for consistency
208 |     time.sleep(1)
209 |     loaded_doc = loader.load()
210 |     saver.delete_documents(loaded_doc)
211 |     # wait 1s for consistency
212 |     time.sleep(1)
213 |     deleted_docs = loader.load()
214 | 
215 |     test_case.assertCountEqual(expected_doc, loaded_doc)
216 |     assert len(deleted_docs) == 0
217 | 
218 | 
219 | def test_firestore_load_from_subcollection(test_case: TestCase):
220 |     source = "collection/doc/subcol" + str(uuid.uuid4())
221 |     saver = FirestoreSaver()
222 |     loader = FirestoreLoader(source)
223 | 
224 |     doc_to_insert = [
225 |         Document(
226 |             page_content="data",
227 |             metadata={
228 |                 "reference": {
229 |                     "path": source + "/sdoc",
230 |                     "firestore_type": "document_reference",
231 |                 }
232 |             },
233 |         )
234 |     ]
235 | 
236 |     saver.upsert_documents(doc_to_insert)
237 |     # wait 1s for consistency
238 |     time.sleep(1)
239 |     loaded_doc = loader.load()
240 |     saver.delete_documents(loaded_doc)
241 |     # wait 1s for consistency
242 |     time.sleep(1)
243 |     deleted_docs = loader.load()
244 | 
245 |     test_case.assertCountEqual(doc_to_insert, loaded_doc)
246 |     assert len(deleted_docs) == 0
247 | 
248 | 
249 | def test_firestore_load_from_query(test_case: TestCase, client: Client):
250 |     source = "WriteQuery" + str(uuid.uuid4())
251 |     saver = FirestoreSaver(source)
252 |     loader_cleanup = FirestoreLoader(source)
253 | 
254 |     docs_to_insert = [
255 |         Document(page_content='{"num": 20, "region": "west_coast"}'),
256 |         Document(page_content='{"num": 20, "region": "south_coast"}'),
257 |         Document(page_content='{"num": 30, "region": "west_coast"}'),
258 |         Document(page_content='{"num": 0, "region": "east_coast"}'),
259 |     ]
260 |     expected_docs = [
261 |         Document(
262 |             page_content='{"num": 20, "region": "west_coast"}',
263 |             metadata={"reference": mock.ANY},
264 |         ),
265 |         Document(
266 |             page_content='{"num": 30, "region": "west_coast"}',
267 |             metadata={"reference": mock.ANY},
268 |         ),
269 |     ]
270 | 
271 |     col_ref = client.collection(source)
272 |     query = col_ref.where(filter=FieldFilter("region", "==", "west_coast"))
273 |     loader = FirestoreLoader(query)
274 | 
275 |     saver.upsert_documents(docs_to_insert)
276 |     # wait 1s for consistency
277 |     time.sleep(1)
278 |     loaded_docs = loader.load()
279 |     saver.delete_documents(loader_cleanup.load())
280 |     # wait 1s for consistency
281 |     time.sleep(1)
282 |     deleted_docs = loader.load()
283 | 
284 |     test_case.assertCountEqual(expected_docs, loaded_docs)
285 |     assert len(deleted_docs) == 0
286 | 
287 | 
288 | def test_firestore_load_from_col_group(test_case: TestCase, client: Client):
289 |     saver = FirestoreSaver()
290 |     source_1 = "ColGroup" + str(uuid.uuid4())
291 |     source_2 = "foo" + str(uuid.uuid4())
292 | 
293 |     docs_to_insert = [
294 |         Document(
295 |             page_content="data_A",
296 |             metadata={
297 |                 "reference": {
298 |                     "path": "ColA/doc/" + source_1 + "/doc1",
299 |                     "firestore_type": "document_reference",
300 |                 }
301 |             },
302 |         ),
303 |         Document(
304 |             page_content="data_B",
305 |             metadata={
306 |                 "reference": {
307 |                     "path": "ColA/doc/" + source_1 + "/doc2",
308 |                     "firestore_type": "document_reference",
309 |                 }
310 |             },
311 |         ),
312 |         Document(
313 |             page_content="data_C",
314 |             metadata={
315 |                 "reference": {
316 |                     "path": source_2 + "/bar",
317 |                     "firestore_type": "document_reference",
318 |                 }
319 |             },
320 |         ),
321 |     ]
322 |     expected_docs = [
323 |         Document(
324 |             page_content="data_A",
325 |             metadata={
326 |                 "reference": {
327 |                     "path": "ColA/doc/" + source_1 + "/doc1",
328 |                     "firestore_type": "document_reference",
329 |                 }
330 |             },
331 |         ),
332 |         Document(
333 |             page_content="data_B",
334 |             metadata={
335 |                 "reference": {
336 |                     "path": "ColA/doc/" + source_1 + "/doc2",
337 |                     "firestore_type": "document_reference",
338 |                 }
339 |             },
340 |         ),
341 |     ]
342 | 
343 |     saver.upsert_documents(docs_to_insert)
344 |     # wait 1s for consistency
345 |     time.sleep(1)
346 | 
347 |     col_ref = client.collection(source_1)
348 |     collection_group = CollectionGroup(col_ref)
349 |     loader = FirestoreLoader(collection_group)
350 |     loaded_docs = loader.load()
351 |     saver.delete_documents(docs_to_insert)
352 | 
353 |     test_case.assertCountEqual(expected_docs, loaded_docs)
354 | 
355 | 
356 | def test_firestore_load_from_doc_ref(test_case: TestCase, client: Client):
357 |     saver = FirestoreSaver()
358 | 
359 |     source = "foo" + str(uuid.uuid4())
360 | 
361 |     doc_to_insert = [
362 |         Document(
363 |             page_content="data",
364 |             metadata={
365 |                 "reference": {
366 |                     "path": source + "/bar",
367 |                     "firestore_type": "document_reference",
368 |                 }
369 |             },
370 |         )
371 |     ]
372 | 
373 |     doc_ref = client.collection(source).document("bar")
374 | 
375 |     saver.upsert_documents(doc_to_insert)
376 |     # wait 1s for consistency
377 |     time.sleep(1)
378 |     loader = FirestoreLoader(doc_ref)
379 |     loaded_doc = loader.load()
380 |     saver.delete_documents(doc_to_insert)
381 | 
382 |     test_case.assertCountEqual(doc_to_insert, loaded_doc)
383 | 
384 | 
385 | def test_firestore_empty_load():
386 |     loader = FirestoreLoader("Empty")
387 | 
388 |     loaded_docs = loader.load()
389 | 
390 |     assert len(loaded_docs) == 0
391 | 
392 | 
393 | def test_firestore_custom_client() -> None:
394 |     client = Client(database="(default)")
395 |     source = "Custom" + str(uuid.uuid4())
396 |     saver = FirestoreSaver(source, client=client)
397 |     loader = FirestoreLoader(source, client=client)
398 | 
399 |     docs = [Document(page_content="data", metadata={})]
400 | 
401 |     saver.upsert_documents(docs)
402 |     # wait 1s for consistency
403 |     time.sleep(1)
404 |     written_docs = loader.load()
405 |     saver.delete_documents(written_docs)
406 |     # wait 1s for consistency
407 |     time.sleep(1)
408 | 
409 |     deleted_docs = loader.load()
410 | 
411 |     assert len(written_docs) == 1
412 |     assert written_docs[0].page_content == "data"
413 |     assert written_docs[0].metadata != {}
414 |     assert "reference" in written_docs[0].metadata
415 |     assert len(deleted_docs) == 0
416 | 


--------------------------------------------------------------------------------