langfun 0.1.2.dev202501080804__py3-none-any.whl → 0.1.2.dev202501240804__py3-none-any.whl

langfun/core/coding/python/errors.py

@@ -1,108 +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 errors."""
-
-import io
-import sys
-import textwrap
-import traceback
-import langfun.core as lf
-
-
-class CodeError(RuntimeError):
-  """Python code error."""
-
-  def __init__(
-      self,
-      code: str,
-      cause: Exception,
-      ):
-    self.code = code
-    self.cause = cause
-
-    # Figure out the starting and ending line numbers of the erratic code.
-    lineno = None
-    end_lineno = None
-    if isinstance(cause, SyntaxError):
-      lineno = cause.lineno
-      end_lineno = cause.end_lineno
-    elif not isinstance(cause, TimeoutError):
-      tb = sys.exc_info()[2]
-      frames = traceback.extract_tb(tb, limit=5)
-      for f in frames:
-        if not f.filename or f.filename == '<string>':
-          lineno = f.lineno
-          end_lineno = lineno
-          break
-    self.lineno = lineno
-    self.end_lineno = end_lineno
-
-  def __str__(self):
-    return self.format(include_complete_code=True)
-
-  def code_lines(self, start_line: int, end_line: int):
-    """Returns code lines ."""
-    return '\n'.join(self.code.split('\n')[start_line:end_line])
-
-  def format(self, include_complete_code: bool = True):
-    """Formats the code error."""
-    r = io.StringIO()
-    error_message = str(self.cause).rstrip()
-    if 'line' not in error_message and self.lineno is not None:
-      error_message += f' (<unknown>, line {self.lineno})'
-    r.write(
-        lf.colored(
-            f'{self.cause.__class__.__name__}: {error_message}', 'magenta'))
-
-    if self.lineno is not None:
-      r.write('\n\n')
-      r.write(textwrap.indent(
-          lf.colored(
-              self.code_lines(self.lineno - 1, self.end_lineno), 'magenta'),
-          ' ' * 2
-      ))
-      r.write('\n')
-
-    if include_complete_code:
-      r.write('\n')
-      r.write(lf.colored('[Generated Code]', 'green', styles=['bold']))
-      r.write('\n\n')
-      r.write(lf.colored('  ```python\n', 'green'))
-      r.write(textwrap.indent(
-          lf.colored(self.code, 'green'),
-          ' ' * 2
-      ))
-      r.write(lf.colored('\n  ```\n', 'green'))
-    return r.getvalue()
-
-
-class SerializationError(RuntimeError):
-  """Object serialization error."""
-
-  def __init__(self, message: str | None, cause: Exception):
-    self.message = message
-    self.cause = cause
-
-  def __str__(self):
-    r = io.StringIO()
-    cause_message = str(self.cause).rstrip()
-    if self.message:
-      r.write(lf.colored(self.message, 'magenta'))
-      r.write('\n\n')
-    r.write(
-        lf.colored(
-            f'{self.cause.__class__.__name__}: {cause_message}', 'magenta'
-        )
-    )
-    return r.getvalue()

langfun/core/coding/python/errors_test.py

@@ -1,99 +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 code errors."""
-
-import unittest
-
-from langfun.core.coding.python import errors
-from langfun.core.coding.python import execution
-
-
-def code_error(code: str) -> errors.CodeError | None:
-  try:
-    execution.run(code, timeout=2)
-    return None
-  except errors.CodeError as e:
-    return e
-
-
-class CodeErrorsTest(unittest.TestCase):
-
-  def test_format(self):
-    e = code_error(
-        """
-        x = y + 1
-        """
-    )
-    self.assertIn('[Generated Code]', str(e))
-    self.assertNotIn(
-        '[Generated Code]', e.format(include_complete_code=False))
-
-  def test_lineno(self):
-    self.assertEqual(
-        code_error(
-            """
-            x = y + 1
-            """
-        ).lineno, 1)
-    self.assertEqual(
-        code_error(
-            """
-            x = 1
-            for i of x:
-              y = i
-            """
-        ).lineno, 2)
-    self.assertEqual(
-        code_error(
-            """
-            x = 1
-            y = 2
-            raise ValueError
-            """
-        ).lineno, 3)
-
-  def test_lineno_in_error_message(self):
-    def assert_lineno(code):
-      e = code_error(code)
-      self.assertIn('line', e.format(include_complete_code=False))
-
-    assert_lineno(
-        """
-        x = y + 1
-        """
-    )
-    assert_lineno(
-        """
-        x = 1
-          y = 2
-        """
-    )
-    assert_lineno(
-        """
-        raise ValueError()
-        """
-    )
-
-
-class SerializationErrorTest(unittest.TestCase):
-
-  def test_str(self):
-    e = errors.SerializationError(
-        'Output cannot be serialized.', ValueError('abc'))
-    self.assertIn('Output cannot be serialized', str(e))
-    self.assertIn('ValueError: abc', str(e))
-
-
-if __name__ == '__main__':
-  unittest.main()

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/text_formatting.py

@@ -1,168 +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
-
-try:
-  import termcolor      # pylint: disable=g-import-not-at-top
-except ImportError:
-  termcolor = None
-
-
-# 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.
-  """
-  if not termcolor:
-    return 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,65 +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)
-
-  def test_colored_without_termcolor(self):
-    termcolor = text_formatting.termcolor
-    text_formatting.termcolor = None
-    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, original_text)
-    self.assertEqual(text_formatting.decolored(colored_text), original_text)
-    text_formatting.termcolor = termcolor
-
-
-if __name__ == '__main__':
-  unittest.main()