langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/chains/query_constructor/parser.py

@@ -1,272 +0,0 @@
-import datetime
-import warnings
-from collections.abc import Sequence
-from typing import Any, Literal, Optional, Union
-
-from langchain_core.utils import check_package_version
-from typing_extensions import TypedDict
-
-try:
-    check_package_version("lark", gte_version="1.1.5")
-    from lark import Lark, Transformer, v_args
-except ImportError:
-
-    def v_args(*_: Any, **__: Any) -> Any:  # type: ignore[misc]
-        """Dummy decorator for when lark is not installed."""
-        return lambda _: None
-
-    Transformer = object  # type: ignore[assignment,misc]
-    Lark = object  # type: ignore[assignment,misc]
-
-from langchain_core.structured_query import (
-    Comparator,
-    Comparison,
-    FilterDirective,
-    Operation,
-    Operator,
-)
-
-GRAMMAR = r"""
-    ?program: func_call
-    ?expr: func_call
-        | value
-
-    func_call: CNAME "(" [args] ")"
-
-    ?value: SIGNED_INT -> int
-        | SIGNED_FLOAT -> float
-        | DATE -> date
-        | DATETIME -> datetime
-        | list
-        | string
-        | ("false" | "False" | "FALSE") -> false
-        | ("true" | "True" | "TRUE") -> true
-
-    args: expr ("," expr)*
-    DATE.2: /["']?(\d{4}-[01]\d-[0-3]\d)["']?/
-    DATETIME.2: /["']?\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d[Zz]?["']?/
-    string: /'[^']*'/ | ESCAPED_STRING
-    list: "[" [args] "]"
-
-    %import common.CNAME
-    %import common.ESCAPED_STRING
-    %import common.SIGNED_FLOAT
-    %import common.SIGNED_INT
-    %import common.WS
-    %ignore WS
-"""
-
-
-class ISO8601Date(TypedDict):
-    """A date in ISO 8601 format (YYYY-MM-DD)."""
-
-    date: str
-    type: Literal["date"]
-
-
-class ISO8601DateTime(TypedDict):
-    """A datetime in ISO 8601 format (YYYY-MM-DDTHH:MM:SS)."""
-
-    datetime: str
-    type: Literal["datetime"]
-
-
-@v_args(inline=True)
-class QueryTransformer(Transformer):
-    """Transform a query string into an intermediate representation."""
-
-    def __init__(
-        self,
-        *args: Any,
-        allowed_comparators: Optional[Sequence[Comparator]] = None,
-        allowed_operators: Optional[Sequence[Operator]] = None,
-        allowed_attributes: Optional[Sequence[str]] = None,
-        **kwargs: Any,
-    ):
-        """Initialize the QueryTransformer.
-
-        Args:
-            allowed_comparators: Optional sequence of allowed comparators.
-            allowed_operators: Optional sequence of allowed operators.
-            allowed_attributes: Optional sequence of allowed attributes for comparators.
-            **kwargs: Additional keyword arguments.
-        """
-        super().__init__(*args, **kwargs)
-        self.allowed_comparators = allowed_comparators
-        self.allowed_operators = allowed_operators
-        self.allowed_attributes = allowed_attributes
-
-    def program(self, *items: Any) -> tuple:
-        """Transform the items into a tuple."""
-        return items
-
-    def func_call(self, func_name: Any, args: list) -> FilterDirective:
-        """Transform a function name and args into a FilterDirective.
-
-        Args:
-            func_name: The name of the function.
-            args: The arguments passed to the function.
-        Returns:
-            FilterDirective: The filter directive.
-        Raises:
-            ValueError: If the function is a comparator and the first arg is not in the
-            allowed attributes.
-        """
-        func = self._match_func_name(str(func_name))
-        if isinstance(func, Comparator):
-            if self.allowed_attributes and args[0] not in self.allowed_attributes:
-                msg = (
-                    f"Received invalid attributes {args[0]}. Allowed attributes are "
-                    f"{self.allowed_attributes}"
-                )
-                raise ValueError(msg)
-            return Comparison(comparator=func, attribute=args[0], value=args[1])
-        if len(args) == 1 and func in (Operator.AND, Operator.OR):
-            return args[0]
-        return Operation(operator=func, arguments=args)
-
-    def _match_func_name(self, func_name: str) -> Union[Operator, Comparator]:
-        if func_name in set(Comparator):
-            if (
-                self.allowed_comparators is not None
-                and func_name not in self.allowed_comparators
-            ):
-                msg = (
-                    f"Received disallowed comparator {func_name}. Allowed "
-                    f"comparators are {self.allowed_comparators}"
-                )
-                raise ValueError(msg)
-            return Comparator(func_name)
-        if func_name in set(Operator):
-            if (
-                self.allowed_operators is not None
-                and func_name not in self.allowed_operators
-            ):
-                msg = (
-                    f"Received disallowed operator {func_name}. Allowed operators"
-                    f" are {self.allowed_operators}"
-                )
-                raise ValueError(msg)
-            return Operator(func_name)
-        msg = (
-            f"Received unrecognized function {func_name}. Valid functions are "
-            f"{list(Operator) + list(Comparator)}"
-        )
-        raise ValueError(msg)
-
-    def args(self, *items: Any) -> tuple:
-        """Transforms items into a tuple.
-
-        Args:
-            items: The items to transform.
-        """
-        return items
-
-    def false(self) -> bool:
-        """Returns false."""
-        return False
-
-    def true(self) -> bool:
-        """Returns true."""
-        return True
-
-    def list(self, item: Any) -> list:
-        """Transforms an item into a list.
-
-        Args:
-            item: The item to transform.
-        """
-        if item is None:
-            return []
-        return list(item)
-
-    def int(self, item: Any) -> int:
-        """Transforms an item into an int.
-
-        Args:
-            item: The item to transform.
-        """
-        return int(item)
-
-    def float(self, item: Any) -> float:
-        """Transforms an item into a float.
-
-        Args:
-            item: The item to transform.
-        """
-        return float(item)
-
-    def date(self, item: Any) -> ISO8601Date:
-        """Transforms an item into a ISO8601Date object.
-
-        Args:
-            item: The item to transform.
-        Raises:
-            ValueError: If the item is not in ISO 8601 date format.
-        """
-        item = str(item).strip("\"'")
-        try:
-            datetime.datetime.strptime(item, "%Y-%m-%d")  # noqa: DTZ007
-        except ValueError:
-            warnings.warn(
-                "Dates are expected to be provided in ISO 8601 date format "
-                "(YYYY-MM-DD).",
-                stacklevel=3,
-            )
-        return {"date": item, "type": "date"}
-
-    def datetime(self, item: Any) -> ISO8601DateTime:
-        """Transforms an item into a ISO8601DateTime object.
-
-        Args:
-            item: The item to transform.
-        Raises:
-            ValueError: If the item is not in ISO 8601 datetime format.
-        """
-        item = str(item).strip("\"'")
-        try:
-            # Parse full ISO 8601 datetime format
-            datetime.datetime.strptime(item, "%Y-%m-%dT%H:%M:%S%z")
-        except ValueError:
-            try:
-                datetime.datetime.strptime(item, "%Y-%m-%dT%H:%M:%S")  # noqa: DTZ007
-            except ValueError as e:
-                msg = "Datetime values are expected to be in ISO 8601 format."
-                raise ValueError(msg) from e
-        return {"datetime": item, "type": "datetime"}
-
-    def string(self, item: Any) -> str:
-        """Transforms an item into a string.
-
-        Removes escaped quotes.
-
-        Args:
-            item: The item to transform.
-        """
-        return str(item).strip("\"'")
-
-
-def get_parser(
-    allowed_comparators: Optional[Sequence[Comparator]] = None,
-    allowed_operators: Optional[Sequence[Operator]] = None,
-    allowed_attributes: Optional[Sequence[str]] = None,
-) -> Lark:
-    """Return a parser for the query language.
-
-    Args:
-        allowed_comparators: Optional[Sequence[Comparator]]
-        allowed_operators: Optional[Sequence[Operator]]
-
-    Returns:
-        Lark parser for the query language.
-    """
-    # QueryTransformer is None when Lark cannot be imported.
-    if QueryTransformer is None:
-        msg = "Cannot import lark, please install it with 'pip install lark'."
-        raise ImportError(msg)
-    transformer = QueryTransformer(
-        allowed_comparators=allowed_comparators,
-        allowed_operators=allowed_operators,
-        allowed_attributes=allowed_attributes,
-    )
-    return Lark(GRAMMAR, parser="lalr", transformer=transformer, start="program")

langchain/chains/query_constructor/prompt.py

@@ -1,226 +0,0 @@
-from langchain_core.prompts import PromptTemplate
-
-SONG_DATA_SOURCE = """\
-```json
-{{
-    "content": "Lyrics of a song",
-    "attributes": {{
-        "artist": {{
-            "type": "string",
-            "description": "Name of the song artist"
-        }},
-        "length": {{
-            "type": "integer",
-            "description": "Length of the song in seconds"
-        }},
-        "genre": {{
-            "type": "string",
-            "description": "The song genre, one of \"pop\", \"rock\" or \"rap\""
-        }}
-    }}
-}}
-```\
-"""
-
-FULL_ANSWER = """\
-```json
-{{
-    "query": "teenager love",
-    "filter": "and(or(eq(\\"artist\\", \\"Taylor Swift\\"), eq(\\"artist\\", \\"Katy Perry\\")), lt(\\"length\\", 180), eq(\\"genre\\", \\"pop\\"))"
-}}
-```\
-"""  # noqa: E501
-
-NO_FILTER_ANSWER = """\
-```json
-{{
-    "query": "",
-    "filter": "NO_FILTER"
-}}
-```\
-"""
-
-WITH_LIMIT_ANSWER = """\
-```json
-{{
-    "query": "love",
-    "filter": "NO_FILTER",
-    "limit": 2
-}}
-```\
-"""
-
-DEFAULT_EXAMPLES = [
-    {
-        "i": 1,
-        "data_source": SONG_DATA_SOURCE,
-        "user_query": "What are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genre",  # noqa: E501
-        "structured_request": FULL_ANSWER,
-    },
-    {
-        "i": 2,
-        "data_source": SONG_DATA_SOURCE,
-        "user_query": "What are songs that were not published on Spotify",
-        "structured_request": NO_FILTER_ANSWER,
-    },
-]
-
-EXAMPLES_WITH_LIMIT = [
-    {
-        "i": 1,
-        "data_source": SONG_DATA_SOURCE,
-        "user_query": "What are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genre",  # noqa: E501
-        "structured_request": FULL_ANSWER,
-    },
-    {
-        "i": 2,
-        "data_source": SONG_DATA_SOURCE,
-        "user_query": "What are songs that were not published on Spotify",
-        "structured_request": NO_FILTER_ANSWER,
-    },
-    {
-        "i": 3,
-        "data_source": SONG_DATA_SOURCE,
-        "user_query": "What are three songs about love",
-        "structured_request": WITH_LIMIT_ANSWER,
-    },
-]
-
-EXAMPLE_PROMPT_TEMPLATE = """\
-<< Example {i}. >>
-Data Source:
-{data_source}
-
-User Query:
-{user_query}
-
-Structured Request:
-{structured_request}
-"""
-
-EXAMPLE_PROMPT = PromptTemplate.from_template(EXAMPLE_PROMPT_TEMPLATE)
-
-USER_SPECIFIED_EXAMPLE_PROMPT = PromptTemplate.from_template(
-    """\
-<< Example {i}. >>
-User Query:
-{user_query}
-
-Structured Request:
-```json
-{structured_request}
-```
-"""
-)
-
-DEFAULT_SCHEMA = """\
-<< Structured Request Schema >>
-When responding use a markdown code snippet with a JSON object formatted in the following schema:
-
-```json
-{{{{
-    "query": string \\ text string to compare to document contents
-    "filter": string \\ logical condition statement for filtering documents
-}}}}
-```
-
-The query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.
-
-A logical condition statement is composed of one or more comparison and logical operation statements.
-
-A comparison statement takes the form: `comp(attr, val)`:
-- `comp` ({allowed_comparators}): comparator
-- `attr` (string):  name of attribute to apply the comparison to
-- `val` (string): is the comparison value
-
-A logical operation statement takes the form `op(statement1, statement2, ...)`:
-- `op` ({allowed_operators}): logical operator
-- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to
-
-Make sure that you only use the comparators and logical operators listed above and no others.
-Make sure that filters only refer to attributes that exist in the data source.
-Make sure that filters only use the attributed names with its function names if there are functions applied on them.
-Make sure that filters only use format `YYYY-MM-DD` when handling date data typed values.
-Make sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.
-Make sure that filters are only used as needed. If there are no filters that should be applied return "NO_FILTER" for the filter value.\
-"""  # noqa: E501
-DEFAULT_SCHEMA_PROMPT = PromptTemplate.from_template(DEFAULT_SCHEMA)
-
-SCHEMA_WITH_LIMIT = """\
-<< Structured Request Schema >>
-When responding use a markdown code snippet with a JSON object formatted in the following schema:
-
-```json
-{{{{
-    "query": string \\ text string to compare to document contents
-    "filter": string \\ logical condition statement for filtering documents
-    "limit": int \\ the number of documents to retrieve
-}}}}
-```
-
-The query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.
-
-A logical condition statement is composed of one or more comparison and logical operation statements.
-
-A comparison statement takes the form: `comp(attr, val)`:
-- `comp` ({allowed_comparators}): comparator
-- `attr` (string):  name of attribute to apply the comparison to
-- `val` (string): is the comparison value
-
-A logical operation statement takes the form `op(statement1, statement2, ...)`:
-- `op` ({allowed_operators}): logical operator
-- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to
-
-Make sure that you only use the comparators and logical operators listed above and no others.
-Make sure that filters only refer to attributes that exist in the data source.
-Make sure that filters only use the attributed names with its function names if there are functions applied on them.
-Make sure that filters only use format `YYYY-MM-DD` when handling date data typed values.
-Make sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.
-Make sure that filters are only used as needed. If there are no filters that should be applied return "NO_FILTER" for the filter value.
-Make sure the `limit` is always an int value. It is an optional parameter so leave it blank if it does not make sense.
-"""  # noqa: E501
-SCHEMA_WITH_LIMIT_PROMPT = PromptTemplate.from_template(SCHEMA_WITH_LIMIT)
-
-DEFAULT_PREFIX = """\
-Your goal is to structure the user's query to match the request schema provided below.
-
-{schema}\
-"""
-
-PREFIX_WITH_DATA_SOURCE = (
-    DEFAULT_PREFIX
-    + """
-
-<< Data Source >>
-```json
-{{{{
-    "content": "{content}",
-    "attributes": {attributes}
-}}}}
-```
-"""
-)
-
-DEFAULT_SUFFIX = """\
-<< Example {i}. >>
-Data Source:
-```json
-{{{{
-    "content": "{content}",
-    "attributes": {attributes}
-}}}}
-```
-
-User Query:
-{{query}}
-
-Structured Request:
-"""
-
-SUFFIX_WITHOUT_DATA_SOURCE = """\
-<< Example {i}. >>
-User Query:
-{{query}}
-
-Structured Request:
-"""

langchain/chains/query_constructor/schema.py

@@ -1,14 +0,0 @@
-from pydantic import BaseModel, ConfigDict
-
-
-class AttributeInfo(BaseModel):
-    """Information about a data source attribute."""
-
-    name: str
-    description: str
-    type: str
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        frozen=True,
-    )

langchain/chains/question_answering/__init__.py

@@ -1,6 +0,0 @@
-from langchain.chains.question_answering.chain import LoadingCallable, load_qa_chain
-
-__all__ = [
-    "LoadingCallable",
-    "load_qa_chain",
-]