cmem-plugin-pgvector 0.5.0__tar.gz → 0.6.0__tar.gz

{cmem_plugin_pgvector-0.5.0 → cmem_plugin_pgvector-0.6.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: cmem-plugin-pgvector
-Version: 0.5.0
-Summary: Store embedding vectors into a Postgres vector store.
+Version: 0.6.0
+Summary: Store and search for embedding vectors in a Postgres vector store.
 License: Apache-2.0
 Keywords: eccenca Corporate Memory,plugin
 Author: eccenca GmbH
@@ -24,43 +24,20 @@ Description-Content-Type: text/markdown
 
 # cmem-plugin-pgvector
 
-[![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier] 
-
-Store embedding vectors into a Postgres vector store.
-
-This plugin consumes the costumable entity's paths ```embedding```, ```text``` and ```metadata``` as following:
-
-  - The text path contain the text used to generate the embeddings, default ```text```.
-  - The embedding path contain the embedding representation of the text, default ```embedding```.
-  - The metadata path contain the information that will be associated with the embedding, default all paths.
+Store and search for embedding vectors in a Postgres vector store.
 
 [![eccenca Corporate Memory][cmem-shield]][cmem-link]
 
-## Use
-
-Interact with Large Language Models.
-
 This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com).
 
-You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line
-clients like this:
+You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line client like this:
 
-```
+``` bash
 cmemc admin workspace python install cmem-plugin-llm
 ```
 
-### Parameters
-
-- ```collection_name```: The name of the collection where the embeddings are going to be stored, default ```my_collection```
-- ```user```:the database user
-- ```password```: the database password
-- ```host```: the databse host, i.e. locahost
-- ```port```: the database port, default ```5432```
-- ```database```: the name of the database
-- ```pre_delete_collection```: boolean parameter indicating if the collection should be cleanse before insertion, default ```false```
-- ```embedding_path```: output path that will contain the generated embedding, default ```embedding```
-- ```text_path```: path containing the text used for genereting the embedding, default ```text```
-- ```metadata_paths```: paths from the entity that will be stored along with the embedding, default all paths
+[![pypi version](https://img.shields.io/pypi/v/cmem-plugin-pgvector)](https://pypi.org/project/cmem-plugin-pgvector) [![license](https://img.shields.io/pypi/l/cmem-plugin-pgvector)](https://pypi.org/project/cmem-plugin-pgvector)
+[![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier] 
 
 [cmem-link]: https://documentation.eccenca.com
 [cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json

cmem_plugin_pgvector-0.6.0/README-public.md

@@ -0,0 +1,28 @@
+# cmem-plugin-pgvector
+
+Store and search for embedding vectors in a Postgres vector store.
+
+[![eccenca Corporate Memory][cmem-shield]][cmem-link]
+
+This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com).
+
+You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line client like this:
+
+``` bash
+cmemc admin workspace python install cmem-plugin-llm
+```
+
+[![pypi version](https://img.shields.io/pypi/v/cmem-plugin-pgvector)](https://pypi.org/project/cmem-plugin-pgvector) [![license](https://img.shields.io/pypi/l/cmem-plugin-pgvector)](https://pypi.org/project/cmem-plugin-pgvector)
+[![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier] 
+
+[cmem-link]: https://documentation.eccenca.com
+[cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
+[poetry-link]: https://python-poetry.org/
+[poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
+[ruff-link]: https://docs.astral.sh/ruff/
+[ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
+[mypy-link]: https://mypy-lang.org/
+[mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
+[copier]: https://copier.readthedocs.io/
+[copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json
+

cmem_plugin_pgvector-0.6.0/cmem_plugin_pgvector/commons.py

@@ -0,0 +1,131 @@
+"""PGVector commons"""
+
+from typing import Any, ClassVar
+
+import psycopg
+from cmem_plugin_base.dataintegration.context import (
+    PluginContext,
+)
+from cmem_plugin_base.dataintegration.description import PluginParameter
+from cmem_plugin_base.dataintegration.parameter.password import PasswordParameterType
+from cmem_plugin_base.dataintegration.types import (
+    Autocompletion,
+    IntParameterType,
+    StringParameterType,
+)
+
+
+def get_collection_names(
+    dbname: str, user: str, password: str, host: str = "localhost", port: int = 5432
+) -> list[str]:
+    """Return list of collection names"""
+    # Create a connection to the database
+    with (
+        psycopg.connect(dbname=dbname, user=user, password=password, host=host, port=port) as conn,
+        conn.cursor() as cursor,
+    ):
+        # Execute query
+        cursor.execute("SELECT name FROM public.langchain_pg_collection;")
+        return [row[0] for row in cursor.fetchall()]  # Fetch all names
+
+
+class PGVectorCollection(StringParameterType):
+    """PGVector Collection Type"""
+
+    autocompletion_depends_on_parameters: ClassVar[list[str]] = [
+        "host",
+        "port",
+        "database",
+        "user",
+        "password",
+    ]
+
+    # auto complete for values
+    allow_only_autocompleted_values: bool = True
+    # auto complete for labels
+    autocomplete_value_with_labels: bool = True
+
+    def autocomplete(
+        self,
+        query_terms: list[str],
+        depend_on_parameter_values: list[Any],
+        context: PluginContext,
+    ) -> list[Autocompletion]:
+        """Return all results that match ALL provided query terms."""
+        _ = context
+        host = depend_on_parameter_values[0]
+        port = depend_on_parameter_values[1]
+        dbname = depend_on_parameter_values[2]
+        user = depend_on_parameter_values[3]
+        password = depend_on_parameter_values[4]
+        password = password if isinstance(password, str) else password.decrypt()
+        result = []
+        try:
+            collections = get_collection_names(
+                host=host, port=port, dbname=dbname, user=user, password=password
+            )
+            filtered_models = set()
+            if query_terms:
+                for term in query_terms:
+                    for collection in collections:
+                        if term in collection:
+                            filtered_models.add(collection)
+            else:
+                filtered_models = set(collections)
+            result = [Autocompletion(value=f"{_}", label=f"{_}") for _ in filtered_models]
+        except Exception as error:
+            raise ValueError(
+                "Failed to authenticate with OpenAI API, Please check URL and API key."
+            ) from error
+        result.sort(key=lambda x: x.label)
+        return result
+
+
+class DatabaseParams:
+    """Common Plugin parameters"""
+
+    host = PluginParameter(
+        name="host",
+        label="Database Host",
+        description="The hostname of the postgres database service.",
+        default_value="pgvector",
+    )
+    port = PluginParameter(
+        name="port",
+        label="Database Port",
+        param_type=IntParameterType(),
+        description="The port number of the postgres database service.",
+        default_value=5432,
+    )
+    user = PluginParameter(
+        name="user",
+        label="Database User",
+        description="The account name used to login to the postgres database service.",
+        default_value="pgvector",
+    )
+    password = PluginParameter(
+        name="password",
+        label="Database Password",
+        param_type=PasswordParameterType(),
+        description="The password of the database account.",
+    )
+    database = PluginParameter(
+        name="database",
+        label="Database Name",
+        description="The database name.",
+        default_value="pgvector",
+    )
+    collection_name = PluginParameter(
+        name="collection_name",
+        label="Collection Name",
+        description="The name of the collection that will be used for search.",
+        param_type=PGVectorCollection(),
+    )
+
+    def as_list(self) -> list[PluginParameter]:
+        """Provide all parameters as list"""
+        return [
+            getattr(self, attr)
+            for attr in dir(self)
+            if not callable(getattr(self, attr)) and not attr.startswith("__")
+        ]

cmem_plugin_pgvector-0.6.0/cmem_plugin_pgvector/search_task.py

@@ -0,0 +1,221 @@
+"""Search Task"""
+
+import json
+from ast import literal_eval
+from collections.abc import Generator, Sequence
+
+from cmem_plugin_base.dataintegration.context import ExecutionContext, ExecutionReport
+from cmem_plugin_base.dataintegration.description import Icon, Plugin, PluginParameter
+from cmem_plugin_base.dataintegration.entity import Entities, Entity, EntityPath, EntitySchema
+from cmem_plugin_base.dataintegration.parameter.password import Password
+from cmem_plugin_base.dataintegration.plugins import WorkflowPlugin
+from cmem_plugin_base.dataintegration.ports import (
+    FixedNumberOfInputs,
+    FixedSchemaPort,
+)
+from cmem_plugin_base.dataintegration.types import IntParameterType
+from langchain_core.documents import Document
+from langchain_postgres import PGVector
+
+from cmem_plugin_pgvector.commons import DatabaseParams
+
+
+@Plugin(
+    label="Search Vector Embeddings",
+    description="Search for top-k metadata stored in Postgres Vector Store (PGVector).",
+    documentation="""
+This workflow task search for the top-k metadata stored into Postgres Vector Store.
+
+The incoming embedding entities are used to retrieve the nearest top-k
+vectors in the collection stored in the Postgres Vector Store.
+It is possible to specify which paths are going to be used for searching as well as which Postgres
+Vector Store and collection name.
+
+The task uses the embeddings from the path configured with the Embedding Query Path
+parameter (`embedding_query_path`, default value: `_embedding`) to search over the collection.
+The results are provided in the output path configured with the Search Result Path parameter
+(`search_result_path`, default value: `_search_result`).
+
+The results in this output are structured like this:
+
+``` json
+[
+  {
+    "id": "..."
+     "metadata": "..."
+     "content": "..."
+     "score": "..."
+  },
+...
+]
+```
+""",
+    icon=Icon(package=__package__, file_name="postgresql.svg"),
+    plugin_id="cmem_plugin_pgvector-Search",
+    parameters=[
+        *DatabaseParams().as_list(),
+        PluginParameter(
+            name="embedding_query_path",
+            label="Embedding Query Path",
+            description="""The path containing the embedding to be used for searching.""",
+            default_value="_embedding",
+        ),
+        PluginParameter(
+            name="search_result_path",
+            label="Search Result Path",
+            description="""The path containing the search result in the output entities.""",
+            default_value="_search_result",
+        ),
+        PluginParameter(
+            name="top_k",
+            label="Top-k",
+            description="The number of entries to be returned in the search result.",
+            default_value=10,
+            param_type=IntParameterType(),
+        ),
+    ],
+)
+class PGVectorSearchPlugin(WorkflowPlugin):
+    """PGVectorSearchPlugin: Enable the search of vectors in a Postgres Vector Store."""
+
+    connection_string: str
+    user: str
+    password: str
+    host: str
+    port: int
+    database: str
+    collection_name: str
+    embedding_query_path: str
+    inputs: Sequence[Entities]
+    db: PGVector
+    execution_context: ExecutionContext
+    report: ExecutionReport
+    search_result_path: str
+    top_k: int
+
+    def __init__(  # noqa: PLR0913
+        self,
+        host: str = DatabaseParams.host.default_value,
+        port: int = DatabaseParams.port.default_value,
+        user: str = DatabaseParams.user.default_value,
+        password: Password | str = "",
+        database: str = DatabaseParams.database.default_value,
+        collection_name: str = DatabaseParams.collection_name.default_value,
+        search_result_path: str = "_search_result",
+        embedding_query_path: str = "_embedding",
+        top_k: int = 10,
+    ) -> None:
+        self.collection_name = collection_name
+        self.user = user
+        self.host = host
+        self.port = port
+        self.database = database
+        self.embedding_query_path = embedding_query_path
+        self.search_result_path = search_result_path
+        self.top_k = top_k
+
+        str_password = self.password = password if isinstance(password, str) else password.decrypt()
+        self.connection_string = (
+            f"postgresql+psycopg://{user}:{str_password}@{host}:{port}/{database}"
+        )
+
+        self.report = ExecutionReport()
+        self.report.operation = "search"
+        self.report.operation_desc = "searches"
+
+        self.db = PGVector(
+            collection_name=self.collection_name,
+            connection=self.connection_string,
+            embeddings=None,  # type: ignore  # noqa: PGH003
+            use_jsonb=True,
+            pre_delete_collection=False,
+        )
+        self._setup_ports()
+
+    def _setup_ports(self) -> None:
+        """Configure input and output ports depending on the configuration"""
+        input_paths = [EntityPath(path=self.embedding_query_path)]
+        input_schema = EntitySchema(type_uri="entity", paths=input_paths)
+        self.input_ports = FixedNumberOfInputs(ports=[FixedSchemaPort(schema=input_schema)])
+
+        output_schema = self._generate_output_schema(input_schema=input_schema)
+        self.output_port = FixedSchemaPort(schema=output_schema)
+
+    def _generate_output_schema(self, input_schema: EntitySchema) -> EntitySchema:
+        """Get output schema"""
+        paths = list(input_schema.paths).copy()
+        paths.append(EntityPath(self.search_result_path))
+        return EntitySchema(type_uri=input_schema.type_uri, paths=paths)
+
+    @staticmethod
+    def _entity_to_dict(paths: Sequence[EntityPath], entity: Entity) -> dict[str, list[str]]:
+        """Create a dict representation of an entity"""
+        entity_dic = {}
+        for key, value in zip(paths, entity.values, strict=False):
+            entity_dic[key.path] = list(value)
+        return entity_dic
+
+    def _update_report(self, count: int) -> None:
+        """Update the report"""
+        self.report.entity_count = count
+        self.execution_context.report.update(self.report)
+
+    def _cancel_workflow(self) -> bool:
+        """Cancel workflow"""
+        try:
+            if self.execution_context.workflow.status() == "Canceling":
+                self.log.info("End task (Cancelled Workflow).")
+                return True
+        except AttributeError:
+            pass
+        return False
+
+    def _docs_to_json(self, docs: list[tuple[Document, float]]) -> list:
+        """Convert a list of Documents to a list of metadata"""
+        doc_list: list = []
+        for doc_tuple in docs:
+            json_entity = {}
+            json_entity["id"] = doc_tuple[0].id
+            json_entity["metadata"] = str(doc_tuple[0].metadata)
+            json_entity["content"] = doc_tuple[0].page_content
+            json_entity["score"] = str(doc_tuple[1])
+            doc_list.append(json_entity)
+        return doc_list
+
+    def _process_entities(self, entities: Entities) -> Generator[Entity]:
+        """Process incoming entities' embeddings in vector search"""
+        schema_paths: list[EntityPath] = list(entities.schema.paths)
+        n_processed_entries: int = 0
+        self._update_report(n_processed_entries)
+        for entity in entities.entities:
+            if self._cancel_workflow():
+                return
+            entity_dict = self._entity_to_dict(schema_paths, entity)
+            embedding: list[float] = literal_eval(entity_dict[self.embedding_query_path][0])
+            result: list[tuple[Document, float]] = self.db.similarity_search_with_score_by_vector(
+                embedding=embedding, k=self.top_k
+            )
+            json_result = self._docs_to_json(result)
+            entity_dict[self.search_result_path] = [json.dumps(json_result)]
+            values = list(entity_dict.values())
+            n_processed_entries += 1
+            self._update_report(n_processed_entries)
+            yield Entity(uri=entity.uri, values=values)
+
+    def execute(
+        self,
+        inputs: Sequence[Entities],
+        context: ExecutionContext,
+    ) -> Entities:
+        """Run the workflow operator."""
+        self.log.info("Start searching collection.")
+        self.inputs = inputs
+        self.execution_context = context
+        try:
+            first_input: Entities = self.inputs[0]
+        except IndexError as error:
+            raise ValueError("Input port not connected.") from error
+        entities = self._process_entities(first_input)
+        schema = self._generate_output_schema(first_input.schema)
+        self.log.info("End")
+        return Entities(entities=entities, schema=schema)

cmem_plugin_pgvector-0.5.0/cmem_plugin_pgvector/cmem_plugin_pgvector.py → cmem_plugin_pgvector-0.6.0/cmem_plugin_pgvector/store_task.py

@@ -1,7 +1,4 @@
-"""Random values workflow plugin module
-
-Remove this and other example files after bootstrapping your project.
-"""
+"""Store Task"""
 
 from ast import literal_eval
 from collections.abc import Sequence
@@ -10,15 +7,16 @@ from typing import Any
 from cmem_plugin_base.dataintegration.context import ExecutionContext, ExecutionReport
 from cmem_plugin_base.dataintegration.description import Icon, Plugin, PluginParameter
 from cmem_plugin_base.dataintegration.entity import Entities, Entity, EntityPath
-from cmem_plugin_base.dataintegration.parameter.password import Password, PasswordParameterType
+from cmem_plugin_base.dataintegration.parameter.password import Password
 from cmem_plugin_base.dataintegration.plugins import WorkflowPlugin
 from cmem_plugin_base.dataintegration.ports import (
     FixedNumberOfInputs,
     UnknownSchemaPort,
 )
-from cmem_plugin_base.dataintegration.types import IntParameterType
 from langchain_postgres import PGVector
 
+from cmem_plugin_pgvector.commons import DatabaseParams
+
 
 class DataContainer:
     """Encapsulate the data to be added to the database."""
@@ -26,19 +24,19 @@ class DataContainer:
     def __init__(self):
         self.texts = []
         self.embeddings = []
-        self.metadatas = []
+        self.metadata = []
 
     def add(self, text: str, embedding: list[float], metadata: dict) -> None:
         """Add objects to the respective lists."""
         self.texts.append(text)
         self.embeddings.append(embedding)
-        self.metadatas.append(metadata)
+        self.metadata.append(metadata)
 
     def clear(self) -> None:
         """Clear all three lists."""
         self.texts.clear()
         self.embeddings.clear()
-        self.metadatas.clear()
+        self.metadata.clear()
 
     def size(self) -> int:
         """Return the size of the lists (assuming all lists have the same length)."""
@@ -46,8 +44,8 @@ class DataContainer:
 
 
 @Plugin(
-    label="Postgres Vector Store",
-    description="Store embeddings into Postgres Vector Store.",
+    label="Store Vector Embeddings",
+    description="Store embeddings into Postgres Vector Store (PGVector).",
     documentation="""
 This plugin workflow store embeddings into Postgres Vector Store.
 
@@ -57,44 +55,9 @@ It is possible to specify either the name of the attributes containing the vecto
 metadata.
 """,
     icon=Icon(package=__package__, file_name="postgresql.svg"),
+    plugin_id="cmem_plugin_pgvector-Store",
     parameters=[
-        PluginParameter(
-            name="host",
-            label="Database Host",
-            description="The hostname of the postgres database service.",
-            default_value="pgvector",
-        ),
-        PluginParameter(
-            name="port",
-            label="Database Port",
-            param_type=IntParameterType(),
-            description="The port number of the postgres database service.",
-            default_value=5432,
-        ),
-        PluginParameter(
-            name="user",
-            label="Database User",
-            description="The account name used to login to the postgres database service.",
-            default_value="pgvector",
-        ),
-        PluginParameter(
-            name="password",
-            label="Database Password",
-            param_type=PasswordParameterType(),
-            description="The password of the database account.",
-        ),
-        PluginParameter(
-            name="database",
-            label="Database Name",
-            description="The database name.",
-            default_value="pgvector",
-        ),
-        PluginParameter(
-            name="collection_name",
-            label="Collection Name",
-            description="The name of the collection, where the embeddings are going to be stored.",
-            default_value="my_collection",
-        ),
+        *DatabaseParams().as_list(),
         PluginParameter(
             name="pre_delete_collection",
             label="Pre Delete Collection",
@@ -153,12 +116,12 @@ class PGVectorStorePlugin(WorkflowPlugin):
 
     def __init__(  # noqa: PLR0913
         self,
-        host: str = "pgvector",
-        port: int = 5432,
-        user: str = "pgvector",
+        host: str = DatabaseParams.host.default_value,
+        port: int = DatabaseParams.port.default_value,
+        user: str = DatabaseParams.user.default_value,
         password: Password | str = "",
-        database: str = "pgvector",
-        collection_name: str = "my_collection",
+        database: str = DatabaseParams.database.default_value,
+        collection_name: str = DatabaseParams.collection_name.default_value,
         pre_delete_collection: bool = True,
         source_path: str = "_embedding_source",
         embedding_path: str = "_embedding",
@@ -247,14 +210,14 @@ class PGVectorStorePlugin(WorkflowPlugin):
                 else self._metadata(entity, schema_paths),
             )
             if container.size() == self.batch_processing_size:
-                self.db.add_embeddings(container.texts, container.embeddings, container.metadatas)
+                self.db.add_embeddings(container.texts, container.embeddings, container.metadata)
                 n_processed_entries += container.size()
                 self._update_report(n_processed_entries)
                 container.clear()
             if self._cancel_workflow():
                 return
         if container.size() > 0:
-            self.db.add_embeddings(container.texts, container.embeddings, container.metadatas)
+            self.db.add_embeddings(container.texts, container.embeddings, container.metadata)
             n_processed_entries += container.size()
             self._update_report(n_processed_entries)
 

{cmem_plugin_pgvector-0.5.0 → cmem_plugin_pgvector-0.6.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "cmem-plugin-pgvector"
-version = "0.5.0"
+version = "0.6.0"
 license = "Apache-2.0"
-description = "Store embedding vectors into a Postgres vector store."
+description = "Store and search for embedding vectors in a Postgres vector store."
 authors = ["eccenca GmbH <cmempy-developer@eccenca.com>"]
 maintainers = ["Edgard Marx <edgard.marx@eccenca.com>"]
 classifiers = [

cmem_plugin_pgvector-0.5.0/README-public.md

@@ -1,51 +0,0 @@
-# cmem-plugin-pgvector
-
-[![poetry][poetry-shield]][poetry-link] [![ruff][ruff-shield]][ruff-link] [![mypy][mypy-shield]][mypy-link] [![copier][copier-shield]][copier] 
-
-Store embedding vectors into a Postgres vector store.
-
-This plugin consumes the costumable entity's paths ```embedding```, ```text``` and ```metadata``` as following:
-
-  - The text path contain the text used to generate the embeddings, default ```text```.
-  - The embedding path contain the embedding representation of the text, default ```embedding```.
-  - The metadata path contain the information that will be associated with the embedding, default all paths.
-
-[![eccenca Corporate Memory][cmem-shield]][cmem-link]
-
-## Use
-
-Interact with Large Language Models.
-
-This is a plugin for [eccenca](https://eccenca.com) [Corporate Memory](https://documentation.eccenca.com).
-
-You can install it with the [cmemc](https://eccenca.com/go/cmemc) command line
-clients like this:
-
-```
-cmemc admin workspace python install cmem-plugin-llm
-```
-
-### Parameters
-
-- ```collection_name```: The name of the collection where the embeddings are going to be stored, default ```my_collection```
-- ```user```:the database user
-- ```password```: the database password
-- ```host```: the databse host, i.e. locahost
-- ```port```: the database port, default ```5432```
-- ```database```: the name of the database
-- ```pre_delete_collection```: boolean parameter indicating if the collection should be cleanse before insertion, default ```false```
-- ```embedding_path```: output path that will contain the generated embedding, default ```embedding```
-- ```text_path```: path containing the text used for genereting the embedding, default ```text```
-- ```metadata_paths```: paths from the entity that will be stored along with the embedding, default all paths
-
-[cmem-link]: https://documentation.eccenca.com
-[cmem-shield]: https://img.shields.io/endpoint?url=https://dev.documentation.eccenca.com/badge.json
-[poetry-link]: https://python-poetry.org/
-[poetry-shield]: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
-[ruff-link]: https://docs.astral.sh/ruff/
-[ruff-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&label=Code%20Style
-[mypy-link]: https://mypy-lang.org/
-[mypy-shield]: https://www.mypy-lang.org/static/mypy_badge.svg
-[copier]: https://copier.readthedocs.io/
-[copier-shield]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json
-