langchain 0.1.34 → 0.1.36

package/dist/retrievers/self_query/base.d.ts

@@ -1,69 +1 @@
-import { VectorStore } from "@langchain/core/vectorstores";
-import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "../../chains/query_constructor/ir.js";
-/**
- * Options object for the BasicTranslator class. Specifies the allowed
- * operators and comparators.
- */
-export type TranslatorOpts = {
-    allowedOperators: Operator[];
-    allowedComparators: Comparator[];
-};
-/**
- * Abstract class that provides a blueprint for creating specific
- * translator classes. Defines two abstract methods: formatFunction and
- * mergeFilters.
- */
-export declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {
-    /**
-     * Formats a given function (either an operator or a comparator) into a
-     * string.
-     * @param func The function to format.
-     * @returns Formatted string representation of the function.
-     */
-    abstract formatFunction(func: Operator | Comparator): string;
-    /**
-     * Merges two filters into one, using a specified merge type.
-     * @param defaultFilter The default filter.
-     * @param generatedFilter The generated filter.
-     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.
-     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.
-     * @returns The merged filter, or undefined if both filters are empty.
-     */
-    abstract mergeFilters(defaultFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, generatedFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, mergeType?: "and" | "or" | "replace", forceDefaultFilter?: boolean): this["VisitStructuredQueryOutput"]["filter"] | undefined;
-}
-/**
- * Class that extends the BaseTranslator class and provides concrete
- * implementations for the abstract methods. Also declares three types:
- * VisitOperationOutput, VisitComparisonOutput, and
- * VisitStructuredQueryOutput, which are used as the return types for the
- * visitOperation, visitComparison, and visitStructuredQuery methods
- * respectively.
- */
-export declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {
-    VisitOperationOutput: VisitorOperationResult;
-    VisitComparisonOutput: VisitorComparisonResult;
-    VisitStructuredQueryOutput: VisitorStructuredQueryResult;
-    allowedOperators: Operator[];
-    allowedComparators: Comparator[];
-    constructor(opts?: TranslatorOpts);
-    formatFunction(func: Operator | Comparator): string;
-    /**
-     * Visits an operation and returns a result.
-     * @param operation The operation to visit.
-     * @returns The result of visiting the operation.
-     */
-    visitOperation(operation: Operation): this["VisitOperationOutput"];
-    /**
-     * Visits a comparison and returns a result.
-     * @param comparison The comparison to visit.
-     * @returns The result of visiting the comparison.
-     */
-    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
-    /**
-     * Visits a structured query and returns a result.
-     * @param query The structured query to visit.
-     * @returns The result of visiting the structured query.
-     */
-    visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
-    mergeFilters(defaultFilter: VisitorStructuredQueryResult["filter"] | undefined, generatedFilter: VisitorStructuredQueryResult["filter"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult["filter"] | undefined;
-}
+export { type TranslatorOpts, BaseTranslator, BasicTranslator, } from "@langchain/core/structured_query";

package/dist/retrievers/self_query/base.js

@@ -1,134 +1 @@
-import { Comparators, Operators, Visitor, } from "../../chains/query_constructor/ir.js";
-import { isFilterEmpty, castValue } from "./utils.js";
-/**
- * Abstract class that provides a blueprint for creating specific
- * translator classes. Defines two abstract methods: formatFunction and
- * mergeFilters.
- */
-export class BaseTranslator extends Visitor {
-}
-/**
- * Class that extends the BaseTranslator class and provides concrete
- * implementations for the abstract methods. Also declares three types:
- * VisitOperationOutput, VisitComparisonOutput, and
- * VisitStructuredQueryOutput, which are used as the return types for the
- * visitOperation, visitComparison, and visitStructuredQuery methods
- * respectively.
- */
-export class BasicTranslator extends BaseTranslator {
-    constructor(opts) {
-        super();
-        Object.defineProperty(this, "allowedOperators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "allowedComparators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.allowedOperators = opts?.allowedOperators ?? [
-            Operators.and,
-            Operators.or,
-        ];
-        this.allowedComparators = opts?.allowedComparators ?? [
-            Comparators.eq,
-            Comparators.ne,
-            Comparators.gt,
-            Comparators.gte,
-            Comparators.lt,
-            Comparators.lte,
-        ];
-    }
-    formatFunction(func) {
-        if (func in Comparators) {
-            if (this.allowedComparators.length > 0 &&
-                this.allowedComparators.indexOf(func) === -1) {
-                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
-            }
-        }
-        else if (func in Operators) {
-            if (this.allowedOperators.length > 0 &&
-                this.allowedOperators.indexOf(func) === -1) {
-                throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
-            }
-        }
-        else {
-            throw new Error("Unknown comparator or operator");
-        }
-        return `$${func}`;
-    }
-    /**
-     * Visits an operation and returns a result.
-     * @param operation The operation to visit.
-     * @returns The result of visiting the operation.
-     */
-    visitOperation(operation) {
-        const args = operation.args?.map((arg) => arg.accept(this));
-        return {
-            [this.formatFunction(operation.operator)]: args,
-        };
-    }
-    /**
-     * Visits a comparison and returns a result.
-     * @param comparison The comparison to visit.
-     * @returns The result of visiting the comparison.
-     */
-    visitComparison(comparison) {
-        return {
-            [comparison.attribute]: {
-                [this.formatFunction(comparison.comparator)]: castValue(comparison.value),
-            },
-        };
-    }
-    /**
-     * Visits a structured query and returns a result.
-     * @param query The structured query to visit.
-     * @returns The result of visiting the structured query.
-     */
-    visitStructuredQuery(query) {
-        let nextArg = {};
-        if (query.filter) {
-            nextArg = {
-                filter: query.filter.accept(this),
-            };
-        }
-        return nextArg;
-    }
-    mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
-        if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {
-            return undefined;
-        }
-        if (isFilterEmpty(defaultFilter) || mergeType === "replace") {
-            if (isFilterEmpty(generatedFilter)) {
-                return undefined;
-            }
-            return generatedFilter;
-        }
-        if (isFilterEmpty(generatedFilter)) {
-            if (forceDefaultFilter) {
-                return defaultFilter;
-            }
-            if (mergeType === "and") {
-                return undefined;
-            }
-            return defaultFilter;
-        }
-        if (mergeType === "and") {
-            return {
-                $and: [defaultFilter, generatedFilter],
-            };
-        }
-        else if (mergeType === "or") {
-            return {
-                $or: [defaultFilter, generatedFilter],
-            };
-        }
-        else {
-            throw new Error("Unknown merge type");
-        }
-    }
-}
+export { BaseTranslator, BasicTranslator, } from "@langchain/core/structured_query";

package/dist/retrievers/self_query/chroma.cjs

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChromaTranslator = void 0;
-const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
-const base_js_1 = require("./base.cjs");
+const structured_query_1 = require("@langchain/core/structured_query");
 /**
  * Specialized translator for the Chroma vector database. It extends the
  * BasicTranslator class and translates internal query language elements
@@ -24,17 +23,17 @@ const base_js_1 = require("./base.cjs");
  * );
  * ```
  */
-class ChromaTranslator extends base_js_1.BasicTranslator {
+class ChromaTranslator extends structured_query_1.BasicTranslator {
     constructor() {
         super({
-            allowedOperators: [ir_js_1.Operators.and, ir_js_1.Operators.or],
+            allowedOperators: [structured_query_1.Operators.and, structured_query_1.Operators.or],
             allowedComparators: [
-                ir_js_1.Comparators.eq,
-                ir_js_1.Comparators.ne,
-                ir_js_1.Comparators.gt,
-                ir_js_1.Comparators.gte,
-                ir_js_1.Comparators.lt,
-                ir_js_1.Comparators.lte,
+                structured_query_1.Comparators.eq,
+                structured_query_1.Comparators.ne,
+                structured_query_1.Comparators.gt,
+                structured_query_1.Comparators.gte,
+                structured_query_1.Comparators.lt,
+                structured_query_1.Comparators.lte,
             ],
         });
     }

package/dist/retrievers/self_query/chroma.d.ts

@@ -1,5 +1,5 @@
 import { Chroma } from "@langchain/community/vectorstores/chroma";
-import { BasicTranslator } from "./base.js";
+import { BasicTranslator } from "@langchain/core/structured_query";
 /**
  * Specialized translator for the Chroma vector database. It extends the
  * BasicTranslator class and translates internal query language elements

package/dist/retrievers/self_query/chroma.js

@@ -1,5 +1,4 @@
-import { Comparators, Operators } from "../../chains/query_constructor/ir.js";
-import { BasicTranslator } from "./base.js";
+import { BasicTranslator, Comparators, Operators, } from "@langchain/core/structured_query";
 /**
  * Specialized translator for the Chroma vector database. It extends the
  * BasicTranslator class and translates internal query language elements

package/dist/retrievers/self_query/functional.cjs

@@ -1,198 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionalTranslator = void 0;
-const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
-const base_js_1 = require("./base.cjs");
-const utils_js_1 = require("./utils.cjs");
-/**
- * A class that extends `BaseTranslator` to translate structured queries
- * into functional filters.
- * @example
- * ```typescript
- * const functionalTranslator = new FunctionalTranslator();
- * const relevantDocuments = await functionalTranslator.getRelevantDocuments(
- *   "Which movies are rated higher than 8.5?",
- * );
- * ```
- */
-class FunctionalTranslator extends base_js_1.BaseTranslator {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "allowedOperators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: [ir_js_1.Operators.and, ir_js_1.Operators.or]
-        });
-        Object.defineProperty(this, "allowedComparators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: [
-                ir_js_1.Comparators.eq,
-                ir_js_1.Comparators.ne,
-                ir_js_1.Comparators.gt,
-                ir_js_1.Comparators.gte,
-                ir_js_1.Comparators.lt,
-                ir_js_1.Comparators.lte,
-            ]
-        });
-    }
-    formatFunction() {
-        throw new Error("Not implemented");
-    }
-    /**
-     * Returns a function that performs a comparison based on the provided
-     * comparator.
-     * @param comparator The comparator to base the comparison function on.
-     * @returns A function that takes two arguments and returns a boolean based on the comparison.
-     */
-    getComparatorFunction(comparator) {
-        switch (comparator) {
-            case ir_js_1.Comparators.eq: {
-                return (a, b) => a === b;
-            }
-            case ir_js_1.Comparators.ne: {
-                return (a, b) => a !== b;
-            }
-            case ir_js_1.Comparators.gt: {
-                return (a, b) => a > b;
-            }
-            case ir_js_1.Comparators.gte: {
-                return (a, b) => a >= b;
-            }
-            case ir_js_1.Comparators.lt: {
-                return (a, b) => a < b;
-            }
-            case ir_js_1.Comparators.lte: {
-                return (a, b) => a <= b;
-            }
-            default: {
-                throw new Error("Unknown comparator");
-            }
-        }
-    }
-    /**
-     * Returns a function that performs an operation based on the provided
-     * operator.
-     * @param operator The operator to base the operation function on.
-     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.
-     */
-    getOperatorFunction(operator) {
-        switch (operator) {
-            case ir_js_1.Operators.and: {
-                return (a, b) => a && b;
-            }
-            case ir_js_1.Operators.or: {
-                return (a, b) => a || b;
-            }
-            default: {
-                throw new Error("Unknown operator");
-            }
-        }
-    }
-    /**
-     * Visits the operation part of a structured query and translates it into
-     * a functional filter.
-     * @param operation The operation part of a structured query.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.
-     */
-    visitOperation(operation) {
-        const { operator, args } = operation;
-        if (this.allowedOperators.includes(operator)) {
-            const operatorFunction = this.getOperatorFunction(operator);
-            return (document) => {
-                if (!args) {
-                    return true;
-                }
-                return args.reduce((acc, arg) => {
-                    const result = arg.accept(this);
-                    if (typeof result === "function") {
-                        return operatorFunction(acc, result(document));
-                    }
-                    else {
-                        throw new Error("Filter is not a function");
-                    }
-                }, true);
-            };
-        }
-        else {
-            throw new Error("Operator not allowed");
-        }
-    }
-    /**
-     * Visits the comparison part of a structured query and translates it into
-     * a functional filter.
-     * @param comparison The comparison part of a structured query.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.
-     */
-    visitComparison(comparison) {
-        const { comparator, attribute, value } = comparison;
-        const undefinedTrue = [ir_js_1.Comparators.ne];
-        if (this.allowedComparators.includes(comparator)) {
-            const comparatorFunction = this.getComparatorFunction(comparator);
-            return (document) => {
-                const documentValue = document.metadata[attribute];
-                if (documentValue === undefined) {
-                    if (undefinedTrue.includes(comparator)) {
-                        return true;
-                    }
-                    return false;
-                }
-                return comparatorFunction(documentValue, (0, utils_js_1.castValue)(value));
-            };
-        }
-        else {
-            throw new Error("Comparator not allowed");
-        }
-    }
-    /**
-     * Visits a structured query and translates it into a functional filter.
-     * @param query The structured query to translate.
-     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.
-     */
-    visitStructuredQuery(query) {
-        if (!query.filter) {
-            return {};
-        }
-        const filterFunction = query.filter?.accept(this);
-        if (typeof filterFunction !== "function") {
-            throw new Error("Structured query filter is not a function");
-        }
-        return { filter: filterFunction };
-    }
-    /**
-     * Merges two filters into one, based on the specified merge type.
-     * @param defaultFilter The default filter function.
-     * @param generatedFilter The generated filter function.
-     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.
-     */
-    mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-            return undefined;
-        }
-        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) || mergeType === "replace") {
-            if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-                return undefined;
-            }
-            return generatedFilter;
-        }
-        if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-            if (mergeType === "and") {
-                return undefined;
-            }
-            return defaultFilter;
-        }
-        if (mergeType === "and") {
-            return (document) => defaultFilter(document) && generatedFilter(document);
-        }
-        else if (mergeType === "or") {
-            return (document) => defaultFilter(document) || generatedFilter(document);
-        }
-        else {
-            throw new Error("Unknown merge type");
-        }
-    }
-}
-exports.FunctionalTranslator = FunctionalTranslator;
+var structured_query_1 = require("@langchain/core/structured_query");
+Object.defineProperty(exports, "FunctionalTranslator", { enumerable: true, get: function () { return structured_query_1.FunctionalTranslator; } });

package/dist/retrievers/self_query/functional.d.ts

@@ -1,87 +1 @@
-import { Document } from "@langchain/core/documents";
-import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "../../chains/query_constructor/ir.js";
-import { BaseTranslator } from "./base.js";
-/**
- * A type alias for an object that maps comparison operators to string or
- * number values. This is used in the comparison functions to determine
- * the result of a comparison operation.
- */
-type ValueType = {
-    eq: string | number;
-    ne: string | number;
-    lt: string | number;
-    lte: string | number;
-    gt: string | number;
-    gte: string | number;
-};
-/**
- * A type alias for a function that takes a `Document` as an argument and
- * returns a boolean. This function is used as a filter for documents.
- */
-export type FunctionFilter = (document: Document) => boolean;
-/**
- * A class that extends `BaseTranslator` to translate structured queries
- * into functional filters.
- * @example
- * ```typescript
- * const functionalTranslator = new FunctionalTranslator();
- * const relevantDocuments = await functionalTranslator.getRelevantDocuments(
- *   "Which movies are rated higher than 8.5?",
- * );
- * ```
- */
-export declare class FunctionalTranslator extends BaseTranslator {
-    VisitOperationOutput: FunctionFilter;
-    VisitComparisonOutput: FunctionFilter;
-    VisitStructuredQueryOutput: {
-        filter: FunctionFilter;
-    } | {
-        [k: string]: never;
-    };
-    allowedOperators: Operator[];
-    allowedComparators: Comparator[];
-    formatFunction(): string;
-    /**
-     * Returns a function that performs a comparison based on the provided
-     * comparator.
-     * @param comparator The comparator to base the comparison function on.
-     * @returns A function that takes two arguments and returns a boolean based on the comparison.
-     */
-    getComparatorFunction<C extends Comparator>(comparator: Comparator): (a: string | number, b: ValueType[C]) => boolean;
-    /**
-     * Returns a function that performs an operation based on the provided
-     * operator.
-     * @param operator The operator to base the operation function on.
-     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.
-     */
-    getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean;
-    /**
-     * Visits the operation part of a structured query and translates it into
-     * a functional filter.
-     * @param operation The operation part of a structured query.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.
-     */
-    visitOperation(operation: Operation): this["VisitOperationOutput"];
-    /**
-     * Visits the comparison part of a structured query and translates it into
-     * a functional filter.
-     * @param comparison The comparison part of a structured query.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.
-     */
-    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
-    /**
-     * Visits a structured query and translates it into a functional filter.
-     * @param query The structured query to translate.
-     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.
-     */
-    visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
-    /**
-     * Merges two filters into one, based on the specified merge type.
-     * @param defaultFilter The default filter function.
-     * @param generatedFilter The generated filter function.
-     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.
-     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.
-     */
-    mergeFilters(defaultFilter: FunctionFilter, generatedFilter: FunctionFilter, mergeType?: string): FunctionFilter | undefined;
-}
-export {};
+export { FunctionFilter, FunctionalTranslator, } from "@langchain/core/structured_query";