clickhouserag 0.1.0__tar.gz

clickhouserag-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Leonid Chesnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clickhouserag-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: clickhouserag
+Version: 0.1.0
+Summary: A Python library for creating RAG with Clickhouse.
+License: MIT
+Author: Леонид Чесников
+Author-email: leonid.chesnikov@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: clickhouse-connect (>=0.7.16,<0.8.0)
+Requires-Dist: clickhouse-driver (>=0.2.8,<0.3.0)
+Requires-Dist: numpy (<2.0.0)
+Description-Content-Type: text/markdown
+
+# RAG-clickhouse-template

clickhouserag-0.1.0/README.md

@@ -0,0 +1 @@
+# RAG-clickhouse-template

clickhouserag-0.1.0/clickhouserag/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/config/base_config.py

@@ -0,0 +1 @@
+"""Base configuration module for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/config/clickhouse_config.py

@@ -0,0 +1 @@
+"""Clickhouse configuration module for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/core/__init__.py

@@ -0,0 +1 @@
+"""Core package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/data_access/__init__.py

@@ -0,0 +1 @@
+"""Data access package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/data_access/abstract_client.py

@@ -0,0 +1,38 @@
+"""Abstract client module for Clickhouse data access."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class ClickhouseClient(ABC):
+    """Abstract class for Clickhouse client."""
+
+    @abstractmethod
+    def connect(self) -> None:
+        """Connect to the Clickhouse database."""
+        pass
+
+    @abstractmethod
+    def execute_query(self, query: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Execute a query in the Clickhouse database."""
+        pass
+
+    @abstractmethod
+    def fetch_one(self, query: str, params: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+        """Fetch one result from the Clickhouse database."""
+        pass
+
+    @abstractmethod
+    def fetch_all(self, query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Fetch all results from the Clickhouse database."""
+        pass
+
+    @abstractmethod
+    def fetch_column(self, query: str, column: int = 0, params: Optional[Dict[str, Any]] = None) -> List[Any]:
+        """Fetch a specific column from the Clickhouse database."""
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the connection to the Clickhouse database."""
+        pass

clickhouserag-0.1.0/clickhouserag/data_access/abstract_table.py

@@ -0,0 +1,56 @@
+"""Abstract table module for Clickhouse data access."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from clickhouserag.data_access.abstract_client import ClickhouseClient
+
+
+class ClickhouseTable(ABC):
+    """Abstract class for Clickhouse table management."""
+
+    def __init__(self, client: ClickhouseClient, table_name: str) -> None:
+        """Initialize ClickhouseTable.
+
+        Args:
+        ----
+            client (ClickhouseClient): The Clickhouse client.
+            table_name (str): The name of the table.
+
+        """
+        self.client = client
+        self.table_name = table_name
+
+    @abstractmethod
+    def insert(self, values: List[Dict[str, Any]]) -> None:
+        """Insert values into the table."""
+        pass
+
+    @abstractmethod
+    def update(self, values: Dict[str, Any], conditions: Dict[str, Any]) -> None:
+        """Update values in the table based on conditions."""
+        pass
+
+    @abstractmethod
+    def delete(self, conditions: Dict[str, Any]) -> None:
+        """Delete values from the table based on conditions."""
+        pass
+
+    @abstractmethod
+    def search(
+        self, query: str, params: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """Search the table based on a query."""
+        pass
+
+    @abstractmethod
+    def fetch_all(
+        self, params: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """Fetch all values from the table."""
+        pass
+
+    @abstractmethod
+    def reset_table(self) -> None:
+        """Reset the table."""
+        pass

clickhouserag-0.1.0/clickhouserag/data_access/clickhouse_client.py

@@ -0,0 +1,85 @@
+"""Clickhouse client module for Clickhouse data access."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from clickhouse_driver import Client
+
+from clickhouserag.data_access.abstract_client import ClickhouseClient
+
+
+class ClickhouseConnectClient(ClickhouseClient):
+    """Clickhouse client implementation using clickhouse-driver."""
+
+    def __init__(self, host: str, port: int, username: str, password: str, database: str):
+        """Initialize ClickhouseConnectClient.
+
+        Args:
+        ----
+            host (str): The host of the Clickhouse server.
+            port (int): The port of the Clickhouse server.
+            username (str): The username for Clickhouse authentication.
+            password (str): The password for Clickhouse authentication.
+            database (str): The database to connect to.
+
+        """
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.database = database
+        self.client = None
+        self.logger = logging.getLogger(__name__)
+
+    def connect(self) -> None:
+        """Connect to the Clickhouse database."""
+        try:
+            self.client = Client(host=self.host, port=self.port, user=self.username, password=self.password, database=self.database)
+        except Exception as e:
+            self.logger.error(f"Failed to connect to Clickhouse: {e}")
+            raise
+
+    def execute_query(self, query: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Execute a query in the Clickhouse database."""
+        try:
+            if params:
+                return self.client.execute(query, params)
+            return self.client.execute(query)
+        except Exception as e:
+            self.logger.error(f"Failed to execute query: {e}")
+            raise
+
+    def fetch_one(self, query: str, params: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+        """Fetch one result from the Clickhouse database."""
+        try:
+            result = self.execute_query(query, params)
+            return result[0] if result else None
+        except Exception as e:
+            self.logger.error(f"Failed to fetch one: {e}")
+            raise
+
+    def fetch_all(self, query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Fetch all results from the Clickhouse database."""
+        try:
+            return self.execute_query(query, params)
+        except Exception as e:
+            self.logger.error(f"Failed to fetch all: {e}")
+            raise
+
+    def fetch_column(self, query: str, column: int = 0, params: Optional[Dict[str, Any]] = None) -> List[Any]:
+        """Fetch a specific column from the Clickhouse database."""
+        try:
+            result = self.execute_query(query, params)
+            return [row[column] for row in result]
+        except Exception as e:
+            self.logger.error(f"Failed to fetch column: {e}")
+            raise
+
+    def close(self) -> None:
+        """Close the connection to the Clickhouse database."""
+        try:
+            if self.client:
+                self.client.disconnect()
+        except Exception as e:
+            self.logger.error(f"Failed to close connection: {e}")
+            raise

clickhouserag-0.1.0/clickhouserag/data_access/clickhouse_table.py

@@ -0,0 +1,54 @@
+"""Clickhouse table management module."""
+
+from typing import Any, Dict, List, Optional
+
+from clickhouserag.data_access.abstract_table import ClickhouseTable
+from clickhouserag.data_access.clickhouse_client import ClickhouseConnectClient
+
+
+class ClickhouseTableManager(ClickhouseTable):
+    """Clickhouse table manager implementation."""
+
+    def __init__(self, client: ClickhouseConnectClient, table_name: str) -> None:
+        """Initialize ClickhouseTableManager.
+
+        Args:
+        ----
+            client (ClickhouseConnectClient): The Clickhouse client.
+            table_name (str): The name of the table.
+
+        """
+        super().__init__(client, table_name)
+
+    def insert(self, values: List[Dict[str, Any]]) -> None:
+        """Insert values into the table."""
+        query = f"INSERT INTO {self.table_name} VALUES"
+        self.client.execute_query(query, values)
+
+    def update(self, values: Dict[str, Any], conditions: Dict[str, Any]) -> None:
+        """Update values in the table based on conditions."""
+        set_clause = ", ".join([f"{key} = %({key})s" for key in values.keys()])
+        condition_clause = " AND ".join([f"{key} = %({key})s" for key in conditions.keys()])
+        query = f"ALTER TABLE {self.table_name} UPDATE {set_clause} WHERE {condition_clause}"
+        self.client.execute_query(query, {**values, **conditions})
+
+    def delete(self, conditions: Dict[str, Any]) -> None:
+        """Delete values from the table based on conditions."""
+        condition_clause = " AND ".join([f"{key} = %(cond_{key})s" for key in conditions.keys()])
+        query = f"DELETE FROM {self.table_name} WHERE {condition_clause}"
+        params = {f"cond_{key}": value for key, value in conditions.items()}
+        self.client.execute_query(query, params)
+
+    def search(self, query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Search the table based on a query."""
+        return self.client.fetch_all(query, params)
+
+    def fetch_all(self, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Fetch all values from the table."""
+        query = f"SELECT * FROM {self.table_name}"
+        return self.client.fetch_all(query, params)
+
+    def reset_table(self) -> None:
+        """Reset the table."""
+        query = f"TRUNCATE TABLE {self.table_name}"
+        self.client.execute_query(query)

clickhouserag-0.1.0/clickhouserag/rag/__init__.py

@@ -0,0 +1 @@
+"""RAG package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/rag/base.py

@@ -0,0 +1,33 @@
+"""Base module for RAG management."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+class RAGBase(ABC):
+    """Abstract base class for RAG management."""
+
+    @abstractmethod
+    def add_data(self, data: Dict[str, Any]) -> None:
+        """Add data to the RAG."""
+        pass
+
+    @abstractmethod
+    def delete_data(self, data_id: str) -> None:
+        """Delete data from the RAG."""
+        pass
+
+    @abstractmethod
+    def update_data(self, data_id: str, new_data: Dict[str, Any]) -> None:
+        """Update data in the RAG."""
+        pass
+
+    @abstractmethod
+    def search(self, query: str) -> List[Dict[str, Any]]:
+        """Search the RAG."""
+        pass
+
+    @abstractmethod
+    def reset_database(self) -> None:
+        """Reset the RAG database."""
+        pass

clickhouserag-0.1.0/clickhouserag/rag/manager.py

@@ -0,0 +1,202 @@
+"""RAG manager module for managing data in Clickhouse."""
+
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from clickhouserag.data_access.clickhouse_client import ClickhouseClient
+from clickhouserag.data_access.clickhouse_table import ClickhouseTableManager
+from clickhouserag.rag.base import RAGBase
+from clickhouserag.vectorizers.base import VectorizerBase
+from clickhouserag.vectorizers.manager import VectorizerManager
+
+
+class RAGManager(RAGBase):
+    """Manager class for RAG operations in Clickhouse."""
+
+    def __init__(self, client: ClickhouseClient, table_name: str, table_schema: Optional[Dict[str, str]] = None, engine: str = "MergeTree", order_by: str = "id") -> None:
+        """Initialize RAGManager.
+
+        Args:
+        ----
+            client (ClickhouseClient): The Clickhouse client.
+            table_name (str): The name of the table.
+            table_schema (Optional[Dict[str, str]]): The schema of the table.
+            engine (str): The engine to use for the table.
+            order_by (str): The column to order the table by.
+
+        """
+        self.client = client
+        self.table_manager = ClickhouseTableManager(client, table_name)
+        self.table_name = table_name
+        self.table_schema = table_schema
+        self.engine = engine
+        self.order_by = order_by
+        self.vectorizer_manager = VectorizerManager()
+        self.logger = logging.getLogger(__name__)
+
+        if table_schema:
+            self._initialize_table(table_schema, engine, order_by)
+
+    def _initialize_table(self, table_schema: Dict[str, str], engine: str, order_by: str) -> None:
+        """Initialize the table in Clickhouse based on the provided schema if it does not exist."""
+        if not self._check_table_exists():
+            self._create_table(table_schema, engine, order_by)
+        else:
+            self.logger.info(f"Table '{self.table_name}' already exists.")
+
+    def _create_table(self, table_schema: Dict[str, str], engine: str, order_by: str) -> None:
+        """Create a table in Clickhouse based on the provided schema."""
+        try:
+            fields = ", ".join([f"{name} {dtype}" for name, dtype in table_schema.items()])
+            query = f"CREATE TABLE {self.table_name} ({fields}) ENGINE = {engine} ORDER BY {order_by}"
+            self.client.execute_query(query)
+            self.logger.info(f"Table '{self.table_name}' created with schema: {table_schema}, engine: {engine}, order by: {order_by}")
+        except Exception as e:
+            self.logger.error(f"Failed to create table '{self.table_name}': {e}")
+            raise
+
+    def _check_table_exists(self) -> bool:
+        """Check if the table exists in the database."""
+        query = f"EXISTS TABLE {self.table_name}"
+        result = self.client.execute_query(query)
+        return result[0][0] == 1
+
+    def add_data(self, data: Dict[str, Any], vectorizer_name: Optional[str] = None) -> None:
+        """Add data to the RAG."""
+        if vectorizer_name:
+            data["vector"] = self.vectorize(data, vectorizer_name)
+        self.validate_data(data)
+        self.table_manager.insert([data])
+        self.logger.info(f"Data added with id {data.get('id')}")
+
+    def add_bulk_data(self, data_list: List[Dict[str, Any]], vectorizer_name: Optional[str] = None) -> None:
+        """Add multiple data records to the RAG."""
+        if vectorizer_name:
+            for data in data_list:
+                data["vector"] = self.vectorize(data, vectorizer_name)
+        for data in data_list:
+            self.validate_data(data)
+        self.table_manager.insert(data_list)
+        self.logger.info(f"Bulk data added with {len(data_list)} records")
+
+    def delete_data(self, data_id: str) -> None:
+        """Delete data from the RAG."""
+        self.table_manager.delete({"id": data_id})
+        self.logger.info(f"Data deleted with id {data_id}")
+
+    def update_data(self, data_id: str, new_data: Dict[str, Any], vectorizer_name: Optional[str] = None) -> None:
+        """Update data in the RAG."""
+        if vectorizer_name:
+            new_data["vector"] = self.vectorize(new_data, vectorizer_name)
+        self.validate_data(new_data)
+        self.table_manager.update(new_data, {"id": data_id})
+        self.logger.info(f"Data updated with id {data_id}")
+
+    def search(self, query: str, similarity: bool = False, top_k: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Search the RAG."""
+        if similarity:
+            return self.similarity_search(query, top_k)
+        else:
+            results = self.table_manager.search(query)
+            self.logger.info(f"Search executed with query '{query}', found {len(results)} results")
+            return results
+
+    def similarity_search(self, embedding: np.array, top_k: Optional[int]) -> List[Dict[str, Any]]:
+        """Search the RAG based on cosine similarity."""
+        query = f"""
+        WITH %(embedding)s as query_vector
+        SELECT id, title,
+        arraySum(x -> x * x, vector) * arraySum(x -> x * x, query_vector) != 0
+        ? arraySum((x, y) -> x * y, vector, query_vector) / sqrt(arraySum(x -> x * x, vector) * arraySum(x -> x * x, query_vector))
+        : 0 AS cosine_distance
+        FROM {self.table_name}
+        WHERE length(query_vector) == length(vector)
+        ORDER BY cosine_distance DESC
+        LIMIT %(top_k)s
+        """
+
+        params = {"embedding": embedding.tolist(), "top_k": top_k}
+        result = self.client.execute_query(query, params=params, settings={"max_query_size": "10000000000000"})
+        self.logger.info(f"Similarity search executed with embedding, top {top_k} results found")
+        return [{"id": row[0], "title": row[1], "cosine_distance": row[2]} for row in result]
+
+    def compute_cosine_similarity(self, vector1: List[float], vector2: List[float]) -> float:
+        """Compute the cosine similarity between two vectors."""
+        dot_product = sum(p * q for p, q in zip(vector1, vector2))
+        magnitude1 = sum(p ** 2 for p in vector1) ** 0.5
+        magnitude2 = sum(q ** 2 for q in vector2) ** 0.5
+        if magnitude1 * magnitude2 == 0:
+            return 0.0
+        return dot_product / (magnitude1 * magnitude2)
+
+    def reset_database(self) -> None:
+        """Reset the RAG database."""
+        self.table_manager.reset_table()
+        self.logger.info("RAG table reset")
+
+    def backup_database(self, path: str) -> None:
+        """Backup the RAG database to a file."""
+        data = self.table_manager.fetch_all()
+        with open(path, "w") as file:
+            json.dump(data, file)
+        self.logger.info(f"Database backup created at {path}")
+
+    def restore_database(self, path: str, table_schema: Optional[Dict[str, str]] = None, engine: str = "MergeTree", order_by: str = "id") -> None:
+        """Restore the RAG database from a file."""
+        if table_schema:
+            self._create_table(table_schema, engine, order_by)
+        with open(path, "r") as file:
+            data = json.load(file)
+        self.table_manager.reset_table()
+        self.table_manager.insert(data)
+        self.logger.info(f"Database restored from {path}")
+
+    def save_to_file(self, path: str) -> None:
+        """Save the RAG database to a file."""
+        self.backup_database(path)
+
+    def load_from_file(self, path: str, table_schema: Optional[Dict[str, str]] = None, engine: str = "MergeTree", order_by: str = "id") -> None:
+        """Load the RAG database from a file."""
+        self.restore_database(path, table_schema, engine, order_by)
+
+    def validate_data(self, data: Dict[str, Any]) -> None:
+        """Validate the data to be inserted into the RAG."""
+        if "id" not in data:
+            raise ValueError("Data must contain an 'id' field")
+        # Additional data validation can be added here
+
+    def get_data(self, data_id: str) -> Optional[Dict[str, Any]]:
+        """Get data from the RAG by ID."""
+        query = f"SELECT * FROM {self.table_name} WHERE id = %(data_id)s"
+        result = self.client.fetch_one(query, params={"data_id": data_id})
+        if result:
+            return dict(zip(self.table_manager.columns, result))
+        return None
+
+    def set_data(self, data: Dict[str, Any], vectorizer_name: Optional[str] = None) -> None:
+        """Set data in the RAG."""
+        if "id" in data:
+            if self.get_data(data["id"]):
+                self.update_data(data["id"], data, vectorizer_name)
+            else:
+                self.add_data(data, vectorizer_name)
+        else:
+            raise ValueError("Data must contain an 'id' field")
+
+    def get_vectorizer(self, name: str) -> Optional[VectorizerBase]:
+        """Get a vectorizer by name."""
+        return self.vectorizer_manager.get_vectorizer(name)
+
+    def add_vectorizer(self, name: str, vectorizer: VectorizerBase) -> None:
+        """Add a vectorizer to the manager."""
+        self.vectorizer_manager.add_vectorizer(name, vectorizer)
+
+    def vectorize(self, data: Dict[str, Any], vectorizer_name: str) -> List[float]:
+        """Vectorize data using the specified vectorizer."""
+        vectorizer = self.get_vectorizer(vectorizer_name)
+        if not vectorizer:
+            raise ValueError(f"Vectorizer '{vectorizer_name}' not found")
+        return vectorizer.vectorize(data["title"])

clickhouserag-0.1.0/clickhouserag/utils/__init__.py

@@ -0,0 +1 @@
+"""Utilities package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/vectorizers/__init__.py

@@ -0,0 +1 @@
+"""Vectorizers package for ClickhouseRAG."""

clickhouserag-0.1.0/clickhouserag/vectorizers/base.py

@@ -0,0 +1,13 @@
+"""Base module for vectorizers in ClickhouseRAG."""
+
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+
+class VectorizerBase(ABC):
+    """Abstract base class for vectorizers."""
+
+    @abstractmethod
+    def vectorize(self, data: Any) -> List[float]:
+        """Convert data into a vector representation."""
+        pass

clickhouserag-0.1.0/clickhouserag/vectorizers/manager.py

@@ -0,0 +1,34 @@
+"""Manager module for vectorizers in ClickhouseRAG."""
+
+from typing import Any, Dict, List, Optional
+
+from clickhouserag.vectorizers.base import VectorizerBase
+
+
+class VectorizerManager:
+    """Manager class for handling multiple vectorizers."""
+
+    def __init__(self):
+        """Initialize VectorizerManager."""
+        self.vectorizers: Dict[str, VectorizerBase] = {}
+
+    def add_vectorizer(self, name: str, vectorizer: VectorizerBase) -> None:
+        """Add a vectorizer to the manager."""
+        self.vectorizers[name] = vectorizer
+
+    def remove_vectorizer(self, name: str) -> None:
+        """Remove a vectorizer from the manager."""
+        if name in self.vectorizers:
+            del self.vectorizers[name]
+
+    def get_vectorizer(self, name: str) -> Optional[VectorizerBase]:
+        """Get a vectorizer by name."""
+        return self.vectorizers.get(name)
+
+    def vectorize(self, name: str, data: Any) -> List[float]:
+        """Vectorize data using the specified vectorizer."""
+        vectorizer = self.get_vectorizer(name)
+        if vectorizer:
+            return vectorizer.vectorize(data)
+        else:
+            raise ValueError(f"Vectorizer '{name}' not found.")

clickhouserag-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[tool.poetry]
+name = "clickhouserag"
+version = "0.1.0"
+description = "A Python library for creating RAG with Clickhouse."
+authors = ["Леонид Чесников <leonid.chesnikov@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+clickhouse-connect = "^0.7.16"
+numpy = "<2.0.0"
+clickhouse-driver = "^0.2.8"
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.5.4"
+pytest = "^8.3.1"
+transformers = "^4.42.4"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+lint.select = [
+    "A",  # Pyflakes (checks for various errors)
+    "B",  # pycodestyle (PEP 8)
+    "E",  # pycodestyle (PEP 8)
+    "F",  # Pyflakes (checks for various errors)
+    "W",  # pycodestyle (PEP 8)
+    "I",  # isort (import sorting)
+    "C",  # McCabe (complexity)
+    "D",  # pydocstyle (docstring style)
+    "N",  # pep8-naming (naming conventions)
+    "PT", # flake8-pytest-style (pytest style)
+    "Q",  # flake8-quotes (quote consistency)
+    "S",  # flake8-bandit (security issues)
+    "T",  # flake8-debugger (debug statements)
+]
+lint.ignore = ["E501"]
+fix = true
+
+[tool.pylint.messages_control]
+disable = ["one-blank-line-before-class", "multi-line-summary-first-line"]
+enable = ["multi-line-summary-second-line"]