langfun 0.0.2.dev20240330__py3-none-any.whl → 0.1.2.dev202501140804__py3-none-any.whl

langfun/core/coding/python/permissions.py

@@ -1,90 +0,0 @@
-# Copyright 2023 The Langfun Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Python code permissions."""
-
-import contextlib
-import enum
-import pyglove as pg
-
-
-class CodePermission(enum.Flag):
-  """Permissions for code execution."""
-
-  # Allows basic Python code: Creating objects, assignment, operations.
-  BASIC = enum.auto()
-
-  # Allows conditions.
-  CONDITION = enum.auto()
-
-  # Allows loops.
-  LOOP = enum.auto()
-
-  # Allows exception.
-  EXCEPTION = enum.auto()
-
-  # Allows class definitions.
-  CLASS_DEFINITION = enum.auto()
-
-  # Allows function definitions.
-  FUNCTION_DEFINITION = enum.auto()
-
-  # Allows import.
-  IMPORT = enum.auto()
-
-  @classmethod
-  @property
-  def ALL(cls) -> 'CodePermission':    # pylint: disable=invalid-name
-    """Returns all permissions."""
-    return (
-        CodePermission.BASIC | CodePermission.CONDITION | CodePermission.LOOP |
-        CodePermission.EXCEPTION | CodePermission.CLASS_DEFINITION |
-        CodePermission.FUNCTION_DEFINITION | CodePermission.IMPORT)
-
-
-_TLS_CODE_RUN_PERMISSION = '__code_run_permission__'
-
-
-@contextlib.contextmanager
-def permission(perm: CodePermission):
-  """Context manager for controling the permission for code execution.
-
-  When the `permission` context manager is nested, the outtermost permission
-  will be used. This design allows users to control permission at the top level.
-
-  Args:
-    perm: Code execution permission.
-
-  Yields:
-    Actual permission applied.
-  """
-
-  outter_perm = pg.object_utils.thread_local_get(_TLS_CODE_RUN_PERMISSION, None)
-
-  # Use the top-level permission as the actual permission
-  if outter_perm is not None:
-    perm = outter_perm
-
-  pg.object_utils.thread_local_set(_TLS_CODE_RUN_PERMISSION, perm)
-
-  try:
-    yield perm
-  finally:
-    if outter_perm is None:
-      pg.object_utils.thread_local_del(_TLS_CODE_RUN_PERMISSION)
-
-
-def get_permission() -> CodePermission:
-  """Gets the current permission for code execution."""
-  return pg.object_utils.thread_local_get(
-      _TLS_CODE_RUN_PERMISSION, CodePermission.ALL)

langfun/core/coding/python/permissions_test.py

@@ -1,86 +0,0 @@
-# Copyright 2023 The Langfun Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tests for Python code permissions."""
-
-import unittest
-from langfun.core.coding.python import permissions
-
-
-class CodePermissionTest(unittest.TestCase):
-
-  def assert_set(
-      self,
-      permission: permissions.CodePermission,
-      flag: permissions.CodePermission,
-  ):
-    self.assertEqual(permission & flag, flag)
-
-  def assert_not_set(
-      self,
-      permission: permissions.CodePermission,
-      flag: permissions.CodePermission,
-  ):
-    self.assertFalse(permission & flag)
-
-  def test_all(self):
-    self.assert_set(
-        permissions.CodePermission.ALL, permissions.CodePermission.BASIC
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL, permissions.CodePermission.CONDITION
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL, permissions.CodePermission.LOOP
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL, permissions.CodePermission.EXCEPTION
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL,
-        permissions.CodePermission.CLASS_DEFINITION,
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL,
-        permissions.CodePermission.FUNCTION_DEFINITION,
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL, permissions.CodePermission.IMPORT
-    )
-
-  def test_xor(self):
-    self.assert_not_set(
-        permissions.CodePermission.ALL ^ permissions.CodePermission.BASIC,
-        permissions.CodePermission.BASIC,
-    )
-    self.assert_set(
-        permissions.CodePermission.ALL ^ permissions.CodePermission.BASIC,
-        permissions.CodePermission.CONDITION,
-    )
-
-  def test_permission_control(self):
-    self.assertEqual(
-        permissions.get_permission(), permissions.CodePermission.ALL
-    )
-    with permissions.permission(permissions.CodePermission.BASIC):
-      self.assertEqual(
-          permissions.get_permission(), permissions.CodePermission.BASIC
-      )
-      with permissions.permission(permissions.CodePermission.ALL):
-        self.assertEqual(
-            permissions.get_permission(), permissions.CodePermission.BASIC
-        )
-
-
-if __name__ == '__main__':
-  unittest.main()

langfun/core/structured/prompting.py

@@ -1,217 +0,0 @@
-# Copyright 2023 The Langfun Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Symbolic query."""
-
-from typing import Any, Type, Union
-
-import langfun.core as lf
-from langfun.core.structured import mapping
-from langfun.core.structured import schema as schema_lib
-import pyglove as pg
-
-
-@lf.use_init_args(['schema', 'default', 'examples'])
-class QueryStructure(mapping.Mapping):
-  """Query an object out from a natural language text."""
-
-  context_title = 'CONTEXT'
-  input_title = 'INPUT_OBJECT'
-
-  # Mark schema as required.
-  schema: pg.typing.Annotated[
-      schema_lib.schema_spec(), 'Required schema for parsing.'
-  ]
-
-
-class QueryStructureJson(QueryStructure):
-  """Query a structured value using JSON as the protocol."""
-
-  preamble = """
-      Please respond to the last {{ input_title }} with {{ output_title}} according to {{ schema_title }}:
-
-      INSTRUCTIONS:
-        1. If the schema has `_type`, carry it over to the JSON output.
-        2. If a field from the schema cannot be extracted from the response, use null as the JSON value.
-
-      {{ input_title }}:
-        1 + 1 =
-
-      {{ schema_title }}:
-        {"result": {"_type": "langfun.core.structured.prompting.Answer", "final_answer": int}}
-
-      {{ output_title}}:
-        {"result": {"_type": "langfun.core.structured.prompting.Answer", "final_answer": 2}}
-      """
-
-  protocol = 'json'
-  schema_title = 'SCHEMA'
-  output_title = 'JSON'
-
-
-class QueryStructurePython(QueryStructure):
-  """Query a structured value using Python as the protocol."""
-
-  preamble = """
-      Please respond to the last {{ input_title }} with {{ output_title }} according to {{ schema_title }}.
-
-      {{ input_title }}:
-        1 + 1 =
-
-      {{ schema_title }}:
-        Answer
-
-        ```python
-        class Answer:
-          final_answer: int
-        ```
-
-      {{ output_title }}:
-        ```python
-        Answer(final_answer=2)
-        ```
-      """
-  protocol = 'python'
-  schema_title = 'OUTPUT_TYPE'
-  output_title = 'OUTPUT_OBJECT'
-
-
-def _query_structure_cls(
-    protocol: schema_lib.SchemaProtocol,
-) -> Type[QueryStructure]:
-  if protocol == 'json':
-    return QueryStructureJson
-  elif protocol == 'python':
-    return QueryStructurePython
-  else:
-    raise ValueError(f'Unknown protocol: {protocol!r}.')
-
-
-def query(
-    prompt: Union[str, pg.Symbolic],
-    schema: Union[
-        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
-    ] = None,
-    default: Any = lf.RAISE_IF_HAS_ERROR,
-    *,
-    lm: lf.LanguageModel | None = None,
-    examples: list[mapping.MappingExample] | None = None,
-    cache_seed: int | None = 0,
-    autofix: int = 0,
-    autofix_lm: lf.LanguageModel | None = None,
-    protocol: schema_lib.SchemaProtocol = 'python',
-    returns_message: bool = False,
-    skip_lm: bool = False,
-    **kwargs,
-) -> Any:
-  """Parse a natural langugage message based on schema.
-
-  Examples:
-
-    ```
-    class FlightDuration:
-      hours: int
-      minutes: int
-
-    class Flight(pg.Object):
-      airline: str
-      flight_number: str
-      departure_airport_code: str
-      arrival_airport_code: str
-      departure_time: str
-      arrival_time: str
-      duration: FlightDuration
-      stops: int
-      price: float
-
-    prompt = '''
-      Information about flight UA2631.
-      '''
-
-    r = lf.query(prompt, Flight)
-    assert isinstance(r, Flight)
-    assert r.airline == 'United Airlines'
-    assert r.departure_airport_code == 'SFO'
-    assert r.duration.hour = 7
-    ```
-
-  Args:
-    prompt: A str (may contain {{}} as template) as natural language input, or a
-      `pg.Symbolic` object as structured input as prompt to LLM.
-    schema: A type annotation as the schema for output object. If str (default),
-      the response will be a str in natural language.
-    default: The default value if parsing failed. If not specified, error will
-      be raised.
-    lm: The language model to use. If not specified, the language model from
-      `lf.context` context manager will be used.
-    examples: An optional list of fewshot examples for helping parsing. If None,
-      the default one-shot example will be added.
-    cache_seed: Seed for computing cache key. The cache key is determined by a
-      tuple of (lm, prompt, cache seed). If None, cache will be disabled for
-      the query even cache is configured by the LM.
-    autofix: Number of attempts to auto fix the generated code. If 0, autofix is
-      disabled. Auto-fix is not supported for 'json' protocol.
-    autofix_lm: The language model to use for autofix. If not specified, the
-      `autofix_lm` from `lf.context` context manager will be used. Otherwise it
-      will use `lm`.
-    protocol: The protocol for schema/value representation. Applicable values
-      are 'json' and 'python'. By default `python` will be used.
-    returns_message: If True, returns `lf.Message` as the output, instead of
-      returning the structured `message.result`.
-    skip_lm: If True, returns the rendered prompt as a UserMessage object.
-      otherwise return the LLM response based on the rendered prompt.
-    **kwargs: Keyword arguments passed to the
-      `lf.structured.NaturalLanguageToStructureed` transform.
-
-  Returns:
-    The result based on the schema.
-  """
-    # Internal usage logging.
-
-  # When `lf.query` is used for symbolic completion, schema is automatically
-  # inferred when it is None.
-  if isinstance(prompt, pg.Symbolic) and prompt.sym_partial and schema is None:
-    schema = prompt.__class__
-
-  if schema in (None, str):
-    # Query with natural language output.
-    output = lf.LangFunc.from_value(prompt, **kwargs)(
-        lm=lm, cache_seed=cache_seed, skip_lm=skip_lm
-    )
-    return output if returns_message else output.text
-
-  # Query with structured output.
-  if isinstance(prompt, str):
-    prompt = lf.Template(prompt, **kwargs)
-  elif isinstance(prompt, lf.Template):
-    prompt = prompt.rebind(**kwargs)
-
-  if isinstance(prompt, lf.Template):
-    prompt = prompt.render(lm=lm)
-  else:
-    prompt = schema_lib.mark_missing(prompt)
-
-  output = _query_structure_cls(protocol)(
-      input=prompt,
-      schema=schema,
-      default=default,
-      examples=examples,
-      autofix=autofix if protocol == 'python' else 0,
-      **kwargs,
-  )(
-      lm=lm,
-      autofix_lm=autofix_lm or lm,
-      cache_seed=cache_seed,
-      skip_lm=skip_lm,
-  )
-  return output if returns_message else output.result

langfun/core/text_formatting.py

@@ -1,162 +0,0 @@
-# Copyright 2023 The Langfun Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Utility library for LM input/output formatting."""
-
-import io
-import re
-from typing import Any
-import termcolor
-
-
-# Regular expression for ANSI color characters.
-_ANSI_COLOR_REGEX = re.compile(r'\x1b\[[0-9;]*m')
-
-
-def decolored(text: str) -> str:
-  """Return the de-colored string that may contains ANSI color characters."""
-  return re.sub(_ANSI_COLOR_REGEX, '', text)
-
-
-def colored(
-    text: str,
-    color: str | None = None,
-    background: str | None = None,
-    styles: list[str] | None = None
-) -> str:
-  """Returns the colored text with ANSI color characters.
-
-  Args:
-    text: A string that may or may not already has ANSI color characters.
-    color: A string for text colors. Applicable values are:
-      'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'.
-    background: A string for background colors. Applicable values are:
-      'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'.
-    styles: A list of strings for applying styles on the text.
-      Applicable values are: 
-      'bold', 'dark', 'underline', 'blink', 'reverse', 'concealed'.
-
-  Returns:
-    A string with ANSI color characters embracing the entire text.
-  """
-  return termcolor.colored(
-      text,
-      color=color,
-      on_color=('on_' + background) if background else None,
-      attrs=styles)
-
-
-def colored_template(
-    text: str,
-    expression_color: str | None = 'white',
-    expression_background: str | None = 'blue',
-    expression_styles: list[str] | None = None,
-    statement_color: str | None = 'red',
-    statement_background: str | None = None,
-    statement_styles: list[str] | None = None,
-    comment_color: str | None = 'green',
-    comment_background: str | None = None,
-    comment_styles: list[str] | None = None,
-    ) -> str:
-  """Returns colored (maybe) Jinja2 template string."""
-  text = color_text_blocks(
-      text, '{{', '}}',
-      color=expression_color,
-      background=expression_background,
-      styles=expression_styles)
-
-  text = color_text_blocks(
-      text, '{%', '%}',
-      color=statement_color,
-      background=statement_background,
-      styles=statement_styles)
-
-  text = color_text_blocks(
-      text, '{#', '#}',
-      color=comment_color,
-      background=comment_background,
-      styles=comment_styles)
-
-  return text
-
-
-def color_text_blocks(
-    text: str,
-    block_start: str,
-    block_end: str,
-    color: str | None = None,
-    background: str | None = None,
-    styles: list[str] | None = None
-) -> str:
-  """Apply colors to text blocks.
-
-  Args:
-    text: A string that may or may not already has ANSI color characters.
-    block_start: A string that signals the start of a block. E.g. '{{'
-    block_end: A string that signals the end of a block. E.g. '}}'.
-    color: A string for text colors. Applicable values are:
-      'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'.
-    background: A string for background colors. Applicable values are:
-      'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'.
-    styles: A list of strings for applying styles on the text.
-      Applicable values are: 
-      'bold', 'dark', 'underline', 'blink', 'reverse', 'concealed'.
-
-  Returns:
-    A string with ANSI color characters embracing the matched text blocks.
-  """
-  if not color and not background and not styles:
-    return text
-
-  string_buffer = io.StringIO()
-  start_index = 0
-  end_index = 0
-  previous_color = None
-
-  def write_nonblock_text(text: str, previous_color: str | None):
-    if previous_color:
-      string_buffer.write(previous_color)
-    string_buffer.write(text)
-
-  while start_index < len(text):
-    start_index = text.find(block_start, end_index)
-    if start_index == -1:
-      write_nonblock_text(text[end_index:], previous_color)
-      break
-
-    # Deal with text since last block.
-    since_last_block = text[end_index:start_index]
-    write_nonblock_text(since_last_block, previous_color)
-    colors = re.findall(_ANSI_COLOR_REGEX, since_last_block)
-    if colors:
-      previous_color = colors[-1]
-
-    # Match block.
-    end_index = text.find(block_end, start_index + len(block_start))
-    if end_index == -1:
-      write_nonblock_text(text[start_index:], previous_color)
-      break
-    end_index += len(block_end)
-
-    # Write block text.
-    block = text[start_index:end_index]
-    colored_block = colored(
-        block, color=color, background=background, styles=styles)
-    string_buffer.write(colored_block)
-  return string_buffer.getvalue()
-
-
-def colored_print(value: Any):
-  """Prints text with color."""
-  print(colored_template(str(value)))
-

langfun/core/text_formatting_test.py

@@ -1,47 +0,0 @@
-# Copyright 2023 The Langfun Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tests for text formatting."""
-
-import inspect
-import unittest
-from langfun.core import text_formatting
-
-
-class TextFormattingTest(unittest.TestCase):
-
-  def test_colored_template(self):
-    original_text = inspect.cleandoc("""
-        Hi {{ foo }}
-        {# print x if x is present #}
-        {% if x %}
-        {{ x }}
-        {% endif %}
-        """)
-
-    colored_text = text_formatting.colored_template(
-        text_formatting.colored(original_text, color='blue')
-    )
-    self.assertEqual(
-        colored_text,
-        '\x1b[34mHi \x1b[44m\x1b[37m{{ foo }}\x1b[0m\x1b[34m\n'
-        '\x1b[32m{# print x if x is present #}\x1b[0m\x1b[34m\n'
-        '\x1b[31m{% if x %}\x1b[0m\x1b[34m\n'
-        '\x1b[44m\x1b[37m{{ x }}\x1b[0m\x1b[34m\n'
-        '\x1b[31m{% endif %}\x1b[0m\x1b[34m\x1b[0m'
-    )
-    self.assertEqual(text_formatting.decolored(colored_text), original_text)
-
-
-if __name__ == '__main__':
-  unittest.main()

langfun-0.0.2.dev20240330.dist-info/METADATA

@@ -1,99 +0,0 @@
-Metadata-Version: 2.1
-Name: langfun
-Version: 0.0.2.dev20240330
-Summary: Langfun: Language as Functions.
-Home-page: https://github.com/google/langfun
-Author: Langfun Authors
-Author-email: langfun-authors@google.com
-License: Apache License 2.0
-Keywords: llm generative-ai machine-learning
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Libraries
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: google-generativeai >=0.3.2
-Requires-Dist: jinja2 >=3.1.2
-Requires-Dist: openai ==0.27.2
-Requires-Dist: pyglove >=0.4.5.dev20240323
-Requires-Dist: python-magic >=0.4.27
-Requires-Dist: requests >=2.31.0
-Requires-Dist: termcolor ==1.1.0
-Requires-Dist: tqdm >=4.64.1
-
-<div align="center">
-<img src="https://raw.githubusercontent.com/google/langfun/main/docs/_static/logo.svg" width="520px" alt="logo"></img>
-</div>
-
-# Langfun
-
-[![PyPI version](https://badge.fury.io/py/langfun.svg)](https://badge.fury.io/py/langfun)
-[![codecov](https://codecov.io/gh/google/langfun/branch/main/graph/badge.svg)](https://codecov.io/gh/google/langfun)
-![pytest](https://github.com/google/langfun/actions/workflows/ci.yaml/badge.svg)
-
-[**Installation**](#install) | [**Getting started**](#hello-world)
-
-## What is Langfun
-
-Langfun is a Python library that aims to make language models (LM) fun
-to work with. Its design enables a programming model that flows naturally,
-resembling the human thought process. It emphasizes the reuse and combination of
-language pieces to form prompts, thereby accelerating innovation. In contrast to
-other LM frameworks, which feed program-generated data into the LM, langfun
-takes a distinct approach: It starts with natural language, allowing for
-seamless interactions between language and program logic, and concludes with
-natural language and optional structured output. Consequently, langfun can
-aptly be described as Language as functions, capturing the core of its
-methodology.
-
-## Install
-
-```
-pip install langfun
-```
-
-Or install nightly build with:
-
-```
-pip install langfun --pre
-```
-
-## Hello World
-
-```python
-import langfun as lf
-
-class NumericAnswerExtractor(lf.LangFunc):
-  """Numeric answer extractor.
-
-  Here is my question:
-  {{question}}
-
-  Here is the response:
-  {{question()}}
-
-  Can you help me extract a number from the response as the answer to my
-  question? Your response should only contain a number in numeric form.
-  If the answer is not a number or you cannot extract it, respond with UNKNOWN.
-  """
-  output_transform = lf.transforms.Match('\d+').to_int()
-
-l = NumericAnswerExtractor()
-
-with lf.context(lm=lf.llms.Gpt35(debug=True)):
-  r = l(question=lf.LangFunc('What is result of {{x}} plus {{y}}?'),
-        x='one',
-        y='two')
-  print('Result:', r.result)
-```
-
-*Disclaimer: this is not an officially supported Google product.*