trinity-rft 0.1.0__py3-none-any.whl

trinity/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""Trinity-RFT (Reinforcement Fine-Tuning)"""
+
+__version__ = "0.1.0"

trinity/buffer/__init__.py

@@ -0,0 +1,7 @@
+from trinity.buffer.buffer import Buffer, get_buffer_reader, get_buffer_writer
+
+__all__ = [
+    "Buffer",
+    "get_buffer_reader",
+    "get_buffer_writer",
+]

trinity/buffer/buffer.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""The buffer module"""
+import ray
+
+from trinity.buffer.buffer_reader import BufferReader
+from trinity.buffer.buffer_writer import BufferWriter
+from trinity.common.config import BufferConfig, Config, StorageConfig
+from trinity.common.constants import StorageType
+
+
+@ray.remote(name="buffer")
+class Buffer:
+    """Responsible for storing experiences."""
+
+    def __init__(self, config: Config):
+        self.buffer_mapping: dict[str, StorageConfig] = {}
+        self._register_from_config(config)
+
+    def get_dataset_info(self, dataset_name: str) -> StorageConfig:
+        storage_config = self.buffer_mapping.get(dataset_name, None)
+        if storage_config is None:
+            raise ValueError(f"{dataset_name} not found.")
+        return storage_config
+
+    def register_dataset(self, storage_config: StorageConfig) -> None:
+        if storage_config.name in self.buffer_mapping:
+            raise ValueError(f"{storage_config.name} already exists.")
+        self.buffer_mapping[storage_config.name] = storage_config
+
+
+def get_buffer_reader(storage_config: StorageConfig, buffer_config: BufferConfig) -> BufferReader:
+    """Get a buffer reader for the given dataset name."""
+    if storage_config.storage_type == StorageType.SQL:
+        from trinity.buffer.reader.sql_reader import SQLReader
+
+        return SQLReader(storage_config, buffer_config)
+    elif storage_config.storage_type == StorageType.QUEUE:
+        from trinity.buffer.reader.queue_reader import QueueReader
+
+        return QueueReader(storage_config, buffer_config)
+    elif storage_config.storage_type == StorageType.FILE:
+        from trinity.buffer.reader.file_reader import FILE_READERS
+
+        file_read_type = storage_config.algorithm_type
+        if file_read_type is not None:
+            file_read_type = file_read_type.value
+        else:
+            file_read_type = "rollout"
+        return FILE_READERS.get(file_read_type)(storage_config, buffer_config)
+    else:
+        raise ValueError(f"{storage_config.storage_type} not supported.")
+
+
+def get_buffer_writer(storage_config: StorageConfig, buffer_config: BufferConfig) -> BufferWriter:
+    """Get a buffer writer for the given dataset name."""
+    if storage_config.storage_type == StorageType.SQL:
+        from trinity.buffer.writer.sql_writer import SQLWriter
+
+        return SQLWriter(storage_config, buffer_config)
+    elif storage_config.storage_type == StorageType.QUEUE:
+        from trinity.buffer.writer.queue_writer import QueueWriter
+
+        return QueueWriter(storage_config, buffer_config)
+    else:
+        raise ValueError(f"{storage_config.storage_type} not supported.")

trinity/buffer/buffer_reader.py

@@ -0,0 +1,13 @@
+"""Reader of the buffer."""
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from trinity.common.constants import ReadStrategy
+
+
+class BufferReader(ABC):
+    """Interface of the buffer reader."""
+
+    @abstractmethod
+    def read(self, strategy: Optional[ReadStrategy] = None) -> List:
+        """Read from buffer."""

trinity/buffer/buffer_writer.py

@@ -0,0 +1,15 @@
+"""Writer of the buffer."""
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class BufferWriter(ABC):
+    """Interface of the buffer writer."""
+
+    @abstractmethod
+    def write(self, data: List) -> None:
+        """Write to buffer."""
+
+    @abstractmethod
+    def finish(self) -> None:
+        """Finish writing."""

trinity/buffer/queue.py

@@ -0,0 +1,54 @@
+"""A queue implemented by Ray Actor."""
+import asyncio
+from copy import deepcopy
+from typing import List
+
+import ray
+
+from trinity.buffer.writer.sql_writer import SQLWriter
+from trinity.common.config import BufferConfig, StorageConfig
+from trinity.common.constants import StorageType
+
+
+@ray.remote
+class QueueActor:
+    """An asyncio.Queue based queue actor."""
+
+    FINISH_MESSAGE = "$FINISH$"
+
+    def __init__(self, storage_config: StorageConfig, config: BufferConfig) -> None:
+        self.config = config
+        self.capacity = getattr(config, "capacity", 10000)
+        self.queue = asyncio.Queue(self.capacity)
+        if storage_config.path is not None and len(storage_config.path) > 0:
+            sql_config = deepcopy(storage_config)
+            sql_config.storage_type = StorageType.SQL
+            self.sql_writer = SQLWriter(sql_config, self.config)
+        else:
+            self.sql_writer = None
+
+    def length(self) -> int:
+        """The length of the queue."""
+        return self.queue.qsize()
+
+    async def put_batch(self, exp_list: List) -> None:
+        """Put batch of experience."""
+        await self.queue.put(exp_list)
+        if self.sql_writer is not None:
+            self.sql_writer.write(exp_list)
+
+    async def finish(self) -> None:
+        """Stop the queue."""
+        await self.queue.put(self.FINISH_MESSAGE)
+
+    async def get_batch(self, batch_size: int) -> List:
+        """Get batch of experience."""
+        batch = []
+        while True:
+            exp_list = await self.queue.get()
+            if exp_list == self.FINISH_MESSAGE:
+                raise StopAsyncIteration()
+            batch.extend(exp_list)
+            if len(batch) >= batch_size:
+                break
+        return batch

trinity/buffer/reader/file_reader.py

@@ -0,0 +1,231 @@
+"""Filed based buffer reader."""
+
+from typing import List, Optional
+
+import datasets
+import transformers
+from datasets import load_dataset
+
+from trinity.buffer.buffer_reader import BufferReader
+from trinity.common.config import BufferConfig, StorageConfig
+from trinity.common.constants import AlgorithmType, PromptType, ReadStrategy, TaskType
+from trinity.common.experience import Experience
+from trinity.common.rewards import REWARD_FUNCTIONS
+from trinity.common.workflows import WORKFLOWS, Task
+from trinity.utils.registry import Registry
+
+FILE_READERS = Registry("file_readers")
+
+
+@FILE_READERS.register_module(AlgorithmType.SFT.value)
+class SFTDataReader(BufferReader):
+    """Reader for SFT file data."""
+
+    def __init__(self, meta: StorageConfig, config: BufferConfig):
+        self.split = meta.split
+        subset_name = meta.subset_name
+        self.prompt_type = meta.format.prompt_type
+        self.messages_key = meta.format.messages_key
+        self.prompt_key = meta.format.prompt_key
+        self.response_key = meta.format.response_key
+        self.read_batch_size = config.read_batch_size
+        self.dataset = load_dataset(
+            meta.path, name=subset_name, split=self.split
+        )  # TODO: support resume
+        self.data_iter = self.dataset.iter(self.read_batch_size, drop_last_batch=True)
+        self.tokenizer = transformers.AutoTokenizer.from_pretrained(config.tokenizer_path)
+
+    def read(self, strategy: Optional[ReadStrategy] = None) -> List:
+        try:
+            batch_data = next(self.data_iter)
+        except StopIteration:
+            self.dataset = self.dataset.shuffle()
+            self.data_iter = self.dataset.iter(self.read_batch_size, drop_last_batch=True)
+            batch_data = next(self.data_iter)
+        exp_list = []
+        if self.prompt_type == PromptType.MESSAGES:
+            for messages in batch_data[self.messages_key]:
+                tokens = self.tokenizer.apply_chat_template(
+                    messages, add_generation_prompt=False, return_tensors="pt"
+                )[0]
+                prompt_tokens = self.tokenizer.apply_chat_template(
+                    messages[:-1], add_generation_prompt=True, return_tensors="pt"
+                )[0]
+                experience = Experience(
+                    tokens=tokens,
+                    prompt_length=len(prompt_tokens),
+                )
+                exp_list.append(experience)
+
+        elif self.prompt_type == PromptType.CHATPAIR:
+            for prompt_messages, response_messages in zip(
+                batch_data[self.prompt_key], batch_data[self.response_key]
+            ):
+                if not isinstance(prompt_messages, list):
+                    prompt_messages = [prompt_messages]
+                if not isinstance(response_messages, list):
+                    response_messages = [response_messages]
+                full_messages = prompt_messages + response_messages
+
+                tokens = self.tokenizer.apply_chat_template(
+                    full_messages, add_generation_prompt=False, return_tensors="pt"
+                )[0]
+
+                prompt_tokens = self.tokenizer.apply_chat_template(
+                    prompt_messages, add_generation_prompt=True, return_tensors="pt"
+                )[0]
+
+                experience = Experience(
+                    tokens=tokens,
+                    prompt_length=len(prompt_tokens),
+                )
+                exp_list.append(experience)
+
+        elif self.prompt_type == PromptType.PLAINTEXT:
+            # TODO: support HF format without chat template
+            for prompt, response in zip(batch_data[self.prompt_key], batch_data[self.response_key]):
+                tokens = self.tokenizer(prompt + response, return_tensors="pt")["input_ids"][0]
+                prompt_tokens = self.tokenizer(prompt, return_tensors="pt")["input_ids"][0]
+                experience = Experience(
+                    tokens=tokens,
+                    prompt_length=len(prompt_tokens),
+                )
+                exp_list.append(experience)
+        else:
+            raise ValueError(f"Unknown data format: {self.prompt_type}")
+        return exp_list
+
+
+@FILE_READERS.register_module(AlgorithmType.DPO.value)
+class DPODataReader(BufferReader):
+    def __init__(self, meta: StorageConfig, config: BufferConfig):
+        self.split = meta.split
+        subset_name = meta.subset_name
+        self.prompt_type = meta.format.prompt_type
+        self.prompt_key = meta.format.prompt_key
+        self.chosen_key = meta.format.chosen_key
+        self.rejected_key = meta.format.rejected_key
+        self.read_batch_size = config.read_batch_size
+        self.dataset = load_dataset(
+            meta.path, name=subset_name, split=self.split
+        )  # TODO: support resume
+        self.data_iter = self.dataset.iter(self.read_batch_size, drop_last_batch=True)
+        self.tokenizer = transformers.AutoTokenizer.from_pretrained(config.tokenizer_path)
+
+    def _get_assistant_message(self, item) -> dict:
+        if isinstance(item, List):
+            item = item[0]
+        if isinstance(item, str):
+            return {"role": "assistant", "content": item}
+        else:
+            return item
+
+    def read(self, strategy: Optional[ReadStrategy] = None) -> List:
+        try:
+            batch_data = next(self.data_iter)
+        except StopIteration:
+            self.dataset = self.dataset.shuffle()
+            self.data_iter = self.dataset.iter(self.read_batch_size, drop_last_batch=True)
+            batch_data = next(self.data_iter)
+        exp_list = []
+        for prompt, chosen, rejected in zip(
+            batch_data[self.prompt_key], batch_data[self.chosen_key], batch_data[self.rejected_key]
+        ):
+            if self.prompt_type == PromptType.MESSAGES:
+                prompt_messages = prompt
+
+            elif self.prompt_type == PromptType.PLAINTEXT:
+                prompt_messages = [
+                    {
+                        "role": "user",
+                        "content": prompt,
+                    }
+                ]
+            else:
+                raise ValueError(f"Unknown prompt type: {self.prompt_type}")
+            prompt_tokens = self.tokenizer.apply_chat_template(
+                prompt_messages, add_generation_prompt=True, return_tensors="pt"
+            )[0]
+            prompt_length = len(prompt_tokens)
+            messages_with_chosen = prompt_messages + [self._get_assistant_message(chosen)]
+            chosen_tokens = self.tokenizer.apply_chat_template(
+                messages_with_chosen,
+                add_generation_prompt=False,
+                return_tensors="pt",
+            )[0][prompt_length:]
+            messages_with_rejected = prompt_messages + [self._get_assistant_message(rejected)]
+            rejected_tokens = self.tokenizer.apply_chat_template(
+                messages_with_rejected,
+                add_generation_prompt=False,
+                return_tensors="pt",
+            )[0][prompt_length:]
+            experience = Experience(
+                tokens=prompt_tokens,
+                prompt_length=len(prompt_tokens),
+                chosen=chosen_tokens,
+                rejected=rejected_tokens,
+            )
+            exp_list.append(experience)
+        return exp_list
+
+
+@FILE_READERS.register_module("rollout")
+class RolloutDataReader(BufferReader):
+    def __init__(self, meta: StorageConfig, config: BufferConfig):
+        self.meta = meta
+        self.name = meta.name
+        self.split = meta.split
+        subset_name = meta.subset_name
+        # disable datasets caching to avoid reuse old-version dataset
+        datasets.disable_caching()
+        self.dataset = load_dataset(
+            meta.path, name=subset_name, split=self.split
+        )  # TODO: may from db_url
+        # if task_type != TaskType.EVAL and config.db_url != "":
+        #     logger.info(f"Loading dataset from database with url: {config.db_url}")
+        #     db_type = config.db_url.split(":")[0]
+        #     db_name = config.db_url.split("/")[-1]
+        #     dataset = Dataset.from_sql(RftDatasetModel.__tablename__, f"{db_type}:///{db_name}")
+        datasets.enable_caching()
+        self.index = meta.index  # TODO: apply shuffle
+
+        self.prompt_key = meta.format.prompt_key
+        self.response_key = meta.format.response_key
+        self.workflow_key = meta.format.workflow_key
+        self.reward_fn_key = meta.format.reward_fn_key
+
+        self.task_type = meta.task_type
+        self.default_workflow_cls = WORKFLOWS.get(meta.default_workflow_type)
+        self.default_reward_fn_cls = REWARD_FUNCTIONS.get(meta.default_reward_fn_type)
+        self.total_epochs = meta.total_epochs if self.task_type == TaskType.EXPLORE else 1
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def read(self, strategy: Optional[ReadStrategy] = None):
+        if self.index >= len(self.dataset) * self.total_epochs:
+            raise StopIteration
+        sample = self.dataset[self.index % len(self.dataset)]
+        workflow_class = (
+            WORKFLOWS.get(sample[self.workflow_key])
+            if self.workflow_key in sample
+            else self.default_workflow_cls
+        )
+        reward_fn = (
+            REWARD_FUNCTIONS.get(sample[self.reward_fn_key])
+            if self.reward_fn_key in sample
+            else self.default_reward_fn_cls
+        )
+        assert workflow_class is not None, "`default_reward_fn_type` or `workflow_key` is required"
+        task = Task(
+            workflow=workflow_class,
+            format_args=self.meta.format,
+            rollout_args=self.meta.rollout_args,
+            is_eval=self.meta.task_type == TaskType.EVAL,
+            reward_fn=reward_fn,
+            raw_task=sample,
+        )
+        self.index += 1
+        if self.task_type == TaskType.EVAL and self.index == len(self.dataset):
+            self.index = 0
+        return task

trinity/buffer/reader/queue_reader.py

@@ -0,0 +1,34 @@
+"""Reader of the Queue buffer."""
+
+from typing import List, Optional
+
+import ray
+
+from trinity.buffer.buffer_reader import BufferReader
+from trinity.buffer.queue import QueueActor
+from trinity.common.config import BufferConfig, StorageConfig
+from trinity.common.constants import ReadStrategy, StorageType
+from trinity.utils.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class QueueReader(BufferReader):
+    """Reader of the Queue buffer."""
+
+    def __init__(self, meta: StorageConfig, config: BufferConfig):
+        assert meta.storage_type == StorageType.QUEUE
+        self.config = config
+        self.queue = QueueActor.options(
+            name=f"queue-{meta.name}",
+            get_if_exists=True,
+        ).remote(meta, config)
+
+    def read(self, strategy: Optional[ReadStrategy] = None) -> List:
+        if strategy is not None and strategy != ReadStrategy.FIFO:
+            raise NotImplementedError(f"Read strategy {strategy} not supported for Queue Reader.")
+        try:
+            exps = ray.get(self.queue.get_batch.remote(self.config.read_batch_size))
+        except StopAsyncIteration:
+            raise StopIteration()
+        return exps

trinity/buffer/reader/sql_reader.py

@@ -0,0 +1,79 @@
+"""Reader of the SQL buffer."""
+
+import time
+from typing import List, Optional
+
+from sqlalchemy import asc, create_engine, desc
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import NullPool
+
+from trinity.buffer.buffer_reader import BufferReader
+from trinity.buffer.schema import Base, create_dynamic_table
+from trinity.buffer.utils import retry_session
+from trinity.common.config import BufferConfig, StorageConfig
+from trinity.common.constants import ReadStrategy, StorageType
+from trinity.utils.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class SQLReader(BufferReader):
+    """Reader of the SQL buffer."""
+
+    def __init__(self, meta: StorageConfig, config: BufferConfig) -> None:
+        assert meta.storage_type == StorageType.SQL
+        self.engine = create_engine(meta.path, poolclass=NullPool)
+
+        self.table_model_cls = create_dynamic_table(meta.algorithm_type, meta.name)
+        try:
+            Base.metadata.create_all(self.engine, checkfirst=True)
+        except OperationalError:
+            logger.warning("Failed to create database, assuming it already exists.")
+        self.session = sessionmaker(bind=self.engine)
+        self.batch_size = config.read_batch_size
+        self.max_retry_times = config.max_retry_times
+        self.max_retry_interval = config.max_retry_interval
+
+    def read(self, strategy: Optional[ReadStrategy] = None) -> List:
+        if strategy is None:
+            strategy = ReadStrategy.LFU
+
+        if strategy == ReadStrategy.LFU:
+            sortOrder = (asc(self.table_model_cls.consumed), desc(self.table_model_cls.id))
+
+        elif strategy == ReadStrategy.LRU:
+            sortOrder = (desc(self.table_model_cls.id),)
+
+        elif strategy == ReadStrategy.PRIORITY:
+            sortOrder = (desc(self.table_model_cls.priority), desc(self.table_model_cls.id))
+
+        else:
+            raise NotImplementedError(f"Unsupported strategy {strategy} by SQLStorage")
+
+        exp_list = []
+        while len(exp_list) < self.batch_size:
+            if len(exp_list):
+                logger.info("waiting for experiences...")
+                time.sleep(1)
+            with retry_session(
+                self.session, self.max_retry_times, self.max_retry_interval
+            ) as session:
+                # get a batch of experiences from the database
+                experiences = (
+                    session.query(self.table_model_cls)
+                    .filter(self.table_model_cls.reward.isnot(None))
+                    .order_by(*sortOrder)  # TODO: very slow
+                    .limit(self.batch_size - len(exp_list))
+                    .with_for_update()
+                    .all()
+                )
+                # update the consumed field
+                for exp in experiences:
+                    exp.consumed += 1
+                exp_list.extend([self.table_model_cls.to_experience(exp) for exp in experiences])
+        logger.info(f"get {len(exp_list)} experiences:")
+        logger.info(f"reward = {[exp.reward for exp in exp_list]}")
+        logger.info(f"first prompt_text = {exp_list[0].prompt_text}")
+        logger.info(f"first response_text = {exp_list[0].response_text}")
+        return exp_list

trinity/buffer/schema/__init__.py

@@ -0,0 +1,3 @@
+from .sql_schema import Base, create_dynamic_table
+
+__all__ = ["create_dynamic_table", "Base"]

trinity/buffer/schema/sql_schema.py

@@ -0,0 +1,149 @@
+"""Schema for SQLAlchemy models."""
+
+from typing import Any, Optional, Union
+
+from sqlalchemy import Column, Float, Integer, LargeBinary, String
+from sqlalchemy.ext.declarative import declarative_base
+
+from trinity.common.constants import AlgorithmType
+from trinity.common.experience import Experience
+from trinity.common.models.utils import tokenize_and_mask_messages_hf
+
+Base = declarative_base()
+
+
+class TaskModel(Base):  # type: ignore
+    """Model for storing tasks in SQLAlchemy."""
+
+    __abstract__ = True
+
+    __table_args__ = {
+        "keep_existing": True,
+    }
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    task_desc = Column(String, nullable=True)
+    workflow_type = Column(String, nullable=True)
+    reward_type = Column(String, nullable=True)
+
+
+class ExperienceModel(Base):  # type: ignore
+    """SQLAlchemy model for Experience."""
+
+    __abstract__ = True
+
+    __table_args__ = {
+        "keep_existing": True,
+    }
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    serialized_exp = Column(LargeBinary, nullable=True)
+    prompt = Column(String, nullable=True)
+    response = Column(String, nullable=True)
+    reward = Column(Float, nullable=True)
+    consumed = Column(Integer, default=0)
+    priority = Column(Float, default=0.0)
+
+    def to_experience(self) -> Experience:
+        """Load the experience from the database."""
+        return Experience.deserialize(self.serialized_exp)
+
+    @classmethod
+    def from_experience(cls, experience: Experience):
+        """Save the experience to database."""
+        return cls(
+            serialized_exp=experience.serialize(),
+            reward=experience.reward,
+            prompt=experience.prompt_text,
+            response=experience.response_text,
+        )
+
+
+class SFTDataModel(Base):  # type: ignore
+    """SQLAlchemy model for SFT data."""
+
+    __abstract__ = True
+
+    __table_args__ = {
+        "keep_existing": True,
+    }
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    serialized_exp = Column(LargeBinary, nullable=True)
+    messages = Column(String, nullable=True)
+    consumed = Column(Integer, default=0)
+
+    def to_experience(self) -> Experience:
+        """Load the experience from the database."""
+        return Experience.deserialize(self.serialized_exp)
+
+    @classmethod
+    def from_messages(
+        cls,
+        messages: list[dict],
+        tokenizer: Any,
+        chat_template: Optional[str] = None,
+    ) -> "SFTDataModel":
+        """Convert a list of messages into a single instance of SFT data."""
+        token_ids, action_mask = tokenize_and_mask_messages_hf(
+            tokenizer=tokenizer,
+            messages=messages,
+            chat_template=chat_template,
+        )
+        exp = Experience(
+            tokens=token_ids,
+            prompt_length=0,
+            action_mask=action_mask,
+            info={"response_num": sum([1 if m["role"] == "assistant" else 0 for m in messages])},
+        )
+        return cls(
+            serialized_exp=exp.serialize(),
+            messages=messages,
+        )
+
+
+class DPODataModel(Base):  # type: ignore
+    """SQLAlchemy model for DPO data."""
+
+    __abstract__ = True
+
+    __table_args__ = {
+        "keep_existing": True,
+    }
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    serialized_exp = Column(LargeBinary, nullable=True)
+    chosen = Column(LargeBinary, nullable=True)
+    rejected = Column(LargeBinary, nullable=True)
+    consumed = Column(Integer, default=0)
+
+    def to_experience(self) -> Experience:
+        """Load the experience from the database."""
+        exp = Experience.deserialize(self.serialized_exp)
+        exp.chosen = Experience.deserialize(self.chosen)
+        exp.rejected = Experience.deserialize(self.rejected)
+        return exp
+
+
+SCHEMA_MAPPING = {
+    None: TaskModel,
+    AlgorithmType.SFT: SFTDataModel,
+    AlgorithmType.PPO: ExperienceModel,
+    AlgorithmType.GRPO: ExperienceModel,
+    AlgorithmType.OPMD: ExperienceModel,
+    AlgorithmType.DPO: DPODataModel,
+}
+
+
+def create_dynamic_table(algorithm_type: Union[AlgorithmType | None], table_name: str) -> Any:
+    """Create a dynamic table based on the provided algorithm type and table name."""
+    if algorithm_type not in SCHEMA_MAPPING:
+        raise ValueError(f"Unknown schema: {algorithm_type}")
+
+    base_class = SCHEMA_MAPPING[algorithm_type]
+
+    table_attrs = {
+        "__tablename__": table_name,
+    }
+
+    return type(table_name, (base_class,), table_attrs)