rdflib-ocdm 0.1.0__tar.gz

rdflib_ocdm-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: rdflib-ocdm
+Version: 0.1.0
+Summary: 
+License: ISC
+Author: arcangelo7
+Author-email: arcangelomas@gmail.com
+Requires-Python: >=3.7.4,<4.0.0
+Classifier: License :: OSI Approved
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: oc-ocdm (>=7.1.7,<8.0.0)
+Requires-Dist: rdflib (>=6.2.0,<7.0.0)
+Requires-Dist: sparqlwrapper (>=2.0.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+[<img src="https://img.shields.io/badge/powered%20by-OpenCitations-%239931FC?labelColor=2D22DE" />](http://opencitations.net)
+[![Run tests](https://github.com/opencitations/rdflib-ocdm/actions/workflows/run_tests.yml/badge.svg)](https://github.com/opencitations/rdflib-ocdm/actions/workflows/run_tests.yml)
+![Coverage](https://raw.githubusercontent.com/opencitations/rdflib-ocdm/main/test/coverage/coverage.svg)
+![PyPI](https://img.shields.io/pypi/pyversions/rdflib-ocdm)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/opencitations/rdflib-ocdm)
+
+# rdflib-ocdm
+

rdflib_ocdm-0.1.0/README.md

@@ -0,0 +1,7 @@
+[<img src="https://img.shields.io/badge/powered%20by-OpenCitations-%239931FC?labelColor=2D22DE" />](http://opencitations.net)
+[![Run tests](https://github.com/opencitations/rdflib-ocdm/actions/workflows/run_tests.yml/badge.svg)](https://github.com/opencitations/rdflib-ocdm/actions/workflows/run_tests.yml)
+![Coverage](https://raw.githubusercontent.com/opencitations/rdflib-ocdm/main/test/coverage/coverage.svg)
+![PyPI](https://img.shields.io/pypi/pyversions/rdflib-ocdm)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/opencitations/rdflib-ocdm)
+
+# rdflib-ocdm

rdflib_ocdm-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "rdflib-ocdm"
+version = "0.1.0"
+description = ""
+authors = ["arcangelo7 <arcangelomas@gmail.com>"]
+license = "ISC"
+readme = "README.md"
+packages = [{include = "rdflib_ocdm"}]
+
+[tool.poetry.dependencies]
+python = "^3.7.4"
+rdflib = "^6.2.0"
+oc-ocdm = "^7.1.7"
+sparqlwrapper = "^2.0.0"
+
+
+[tool.poetry.group.dev.dependencies]
+coverage = "^7.2.3"
+coverage-badge = "^1.1.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

rdflib_ocdm-0.1.0/rdflib_ocdm/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright 2023 Arcangelo Massari <arcangelo.massari@unibo.it> 
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS' AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.

rdflib_ocdm-0.1.0/rdflib_ocdm/abstract_entity.py

@@ -0,0 +1,174 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016, Silvio Peroni <essepuntato@gmail.com>
+# Copyright (c) 2023, Arcangelo Massari <arcangelo.massari@unibo.it>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+
+
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING
+
+from rdflib import RDF, RDFS, Graph, Literal, URIRef
+
+from rdflib_ocdm.support import create_literal, create_type
+
+if TYPE_CHECKING:
+    from typing import ClassVar, Dict, Iterable, List, Optional
+
+class AbstractEntity(ABC):
+    """
+    Abstract class which represents a generic entity. 
+    It sits at the top of the entity class hierarchy.
+    """
+
+    short_name_to_type_iri: ClassVar[Dict[str, URIRef]] = {}
+
+    def __init__(self) -> None:
+        """
+        Constructor of the ``AbstractEntity`` class.
+        """
+        self.g: Graph = Graph()
+        self.res: URIRef = URIRef("")
+
+    def remove_every_triple(self) -> None:
+        """
+        Remover method that removes every triple from the current entity.
+
+        :return: None
+        """
+        self.g.remove((None, None, None))
+
+    # LABEL
+    def get_label(self) -> Optional[str]:
+        """
+        Getter method corresponding to the ``rdfs:label`` RDF predicate.
+
+        :return: The requested value if found, None otherwise
+        """
+        return self._get_literal(RDFS.label)
+
+    def create_label(self, string: str) -> None:
+        """
+        Setter method corresponding to the ``rdfs:label`` RDF predicate.
+
+        **WARNING: this is a functional property, hence any existing value will be overwritten!**
+
+        :param string: The value that will be set as the object of the property related to this method
+        :type string: str
+        :return: None
+        """
+        self.remove_label()
+        self._create_literal(RDFS.label, string)
+
+    def remove_label(self) -> None:
+        """
+        Remover method corresponding to the ``rdfs:label`` RDF predicate.
+
+        :return: None
+        """
+        self.g.remove((self.res, RDFS.label, None))
+
+    def _create_literal(self, p: URIRef, s: str, dt: URIRef = None, nor: bool = True) -> None:
+        """
+        Adds an RDF triple with a literal object inside the graph of the entity
+
+        :param p: The predicate
+        :type p: URIRef
+        :param s: The string to add as a literal value
+        :type s: str
+        :param dt: The object's datatype, if present
+        :type dt: URIRef, optional
+        :param nor: Whether to normalize the graph or not
+        :type nor: bool, optional
+        :return: None
+        """
+        create_literal(self.g, self.res, p, s, dt, nor)
+
+    # TYPE
+    def get_types(self) -> List[URIRef]:
+        """
+        Getter method corresponding to the ``rdf:type`` RDF predicate.
+
+        :return: A list containing the requested values if found, None otherwise
+        """
+        uri_list: List[URIRef] = self._get_multiple_uri_references(RDF.type)
+        return uri_list
+
+    def _create_type(self, res_type: URIRef, identifier: str = None) -> None:
+        """
+        Setter method corresponding to the ``rdf:type`` RDF predicate.
+
+        :param res_type: The value that will be set as the object of the property related to this method
+        :type res_type: URIRef
+        :return: None
+        """
+        create_type(self.g, self.res, res_type, identifier)
+
+    def remove_type(self) -> None:
+        """
+        Remover method corresponding to the ``rdf:type`` RDF predicate.
+
+        :return: None
+        """
+        self.g.remove((self.res, RDF.type, None))
+
+    # Overrides __str__ method
+    def __str__(self) -> str:
+        return str(self.res)
+
+    def add_triples(self, iterable_of_triples: Iterable) -> None:
+        """
+        A utility method that allows to add a batch of triples into the graph of the entity.
+
+        **WARNING: Only triples that have this entity as their subject will be imported!**
+
+        :param iterable_of_triples: A collection of triples to be added to the entity
+        :type iterable_of_triples: Iterable
+        :return: None
+        """
+        for s, p, o in iterable_of_triples:
+            if s == self.res:  # This guarantees that only triples belonging to the resource will be added
+                self.g.add((s, p, o))
+
+    def _get_literal(self, predicate: URIRef) -> Optional[str]:
+        result: Optional[str] = None
+        for o in self.g.objects(self.res, predicate):
+            if type(o) == Literal:
+                result = str(o)
+                break
+        return result
+
+    def _get_multiple_literals(self, predicate: URIRef) -> List[str]:
+        result: List[str] = []
+        for o in self.g.objects(self.res, predicate):
+            if type(o) == Literal:
+                result.append(str(o))
+        return result
+
+    def _get_uri_reference(self, predicate: URIRef) -> Optional[URIRef]:
+        result: Optional[URIRef] = None
+        for o in self.g.objects(self.res, predicate):
+            if type(o) == URIRef:
+                result = o
+                break
+        return result
+
+    def _get_multiple_uri_references(self, predicate: URIRef) -> List[URIRef]:
+        result: List[URIRef] = []
+        for o in self.g.objects(self.res, predicate):
+            if type(o) == URIRef:
+                result.append(o)
+        return result

rdflib_ocdm-0.1.0/rdflib_ocdm/counter_handler/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright 2023 Arcangelo Massari <arcangelo.massari@unibo.it>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS' AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.

rdflib_ocdm-0.1.0/rdflib_ocdm/counter_handler/counter_handler.py

@@ -0,0 +1,61 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016, Silvio Peroni <essepuntato@gmail.com>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+from abc import ABC, abstractmethod
+
+
+class CounterHandler(ABC):
+    """Abstract class representing the interface for every concrete counter handler."""
+
+    @abstractmethod
+    def set_counter(self, new_value: int, entity_name: str) -> None:
+        """
+        Method signature for concrete implementations that allow setting the counter value
+        of provenance entities.
+
+        :param new_value: The new counter value to be set
+        :type new_value: int
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises NotImplementedError: always
+        :return: None
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def read_counter(self, entity_name: str) -> int:
+        """
+        Method signature for concrete implementations that allow reading the counter value
+        of graph and provenance entities.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises NotImplementedError: always
+        :return: The requested counter value.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def increment_counter(self, entity_name: str) -> int:
+        """
+        Method signature for concrete implementations that allow incrementing by one unit
+        the counter value of graph and provenance entities.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises NotImplementedError: always
+        :return: The newly-updated (already incremented) counter value.
+        """
+        raise NotImplementedError

rdflib_ocdm-0.1.0/rdflib_ocdm/counter_handler/filesystem_counter_handler.py

@@ -0,0 +1,125 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016, Silvio Peroni <essepuntato@gmail.com>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+from __future__ import annotations
+
+import json
+import os
+
+from rdflib_ocdm.counter_handler.counter_handler import CounterHandler
+from rdflib_ocdm.support import is_string_empty
+
+
+class FilesystemCounterHandler(CounterHandler):
+    """A concrete implementation of the ``CounterHandler`` interface that persistently stores
+    the counter values within the filesystem."""
+
+    def __init__(self, info_dir: str) -> None:
+        """
+        Constructor of the ``FilesystemCounterHandler`` class.
+
+        :param info_dir: The path to the folder that does/will contain the counter values.
+        :type info_dir: str
+        :raises ValueError: if ``info_dir`` is None or an empty string.
+        """
+        if info_dir is None or is_string_empty(info_dir):
+            raise ValueError("info_dir parameter is required!")
+
+        if info_dir[-1] != os.sep:
+            info_dir += os.sep
+
+        self.info_dir: str = info_dir
+        self.prov_files = dict()
+        self.provenance_index_filename = 'provenance_index.json'
+
+    def set_counter(self, new_value: int, entity_name: str) -> None:
+        """
+        It allows to set the counter value of provenance entities.
+
+        :param new_value: The new counter value to be set
+        :type new_value: int
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises ValueError: if ``new_value`` is a negative integer.
+        :return: None
+        """
+        entity_name = str(entity_name)
+        if new_value < 0:
+            raise ValueError("new_value must be a non negative integer!")
+        file_path: str = self._get_prov_path()
+        self.__initialize_file_if_not_existing(file_path, entity_name)
+        with open(file_path, 'r', encoding='utf8') as file:
+            data = json.load(file)
+        with open(file_path, 'w', encoding='utf8') as outfile:
+            data[entity_name] = new_value
+            outfile.write(data)
+
+    def read_counter(self, entity_name: str) -> int:
+        """
+        It allows to read the counter value of provenance entities.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The requested counter value.
+        """
+        entity_name = str(entity_name)
+        file_path: str = self._get_prov_path()
+        return self._read_number(file_path, entity_name)
+
+    def increment_counter(self, entity_name: str) -> int:
+        """
+        It allows to increment the counter value of provenance entities by one unit.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The newly-updated (already incremented) counter value.
+        """
+        entity_name = str(entity_name)
+        file_path: str = self._get_prov_path()
+        return self._add_number(file_path, entity_name)
+
+    def _get_prov_path(self) -> str:
+        return os.path.join(self.info_dir, self.provenance_index_filename)
+
+    def __initialize_file_if_not_existing(self, file_path: str, entity_name: str):
+        entity_name = str(entity_name)
+        if not os.path.exists(os.path.dirname(file_path)):
+            os.makedirs(os.path.dirname(file_path))
+        if not os.path.isfile(file_path):
+            with open(file_path, 'w', encoding='utf8') as outfile:
+                json_object = json.dumps({entity_name: 0}, ensure_ascii=False, indent=None)
+                outfile.write(json_object)
+
+    def _read_number(self, file_path: str, entity_name: str) -> int:
+        self.__initialize_file_if_not_existing(file_path, entity_name)
+        with open(file_path, 'r', encoding='utf8') as file:
+            data = json.load(file)
+            if entity_name in data:
+                self.prov_files[entity_name] = data[entity_name]
+            else:
+                self.prov_files[entity_name] = 0
+        return self.prov_files[entity_name]
+
+    def _add_number(self, file_path: str, entity_name: str) -> int:
+        self.__initialize_file_if_not_existing(file_path, entity_name)
+        cur_number = self._read_number(file_path, entity_name)
+        cur_number += 1
+        with open(file_path, 'r', encoding='utf8') as file:
+            data = json.load(file)
+        with open(file_path, 'w', encoding='utf8') as outfile:
+            data[entity_name] = cur_number
+            json_object = json.dumps(data, ensure_ascii=False, indent=None)
+            outfile.write(json_object)
+        return cur_number

rdflib_ocdm-0.1.0/rdflib_ocdm/counter_handler/in_memory_counter_handler.py

@@ -0,0 +1,81 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016, Silvio Peroni <essepuntato@gmail.com>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import List, Dict
+
+from rdflib_ocdm.counter_handler.counter_handler import CounterHandler
+
+
+class InMemoryCounterHandler(CounterHandler):
+    """A concrete implementation of the ``CounterHandler`` interface that temporarily stores
+    the counter values in the volatile system memory."""
+
+    def __init__(self) -> None:
+        """
+        Constructor of the ``InMemoryCounterHandler`` class.
+        """
+        self.prov_counters = dict()
+
+    def set_counter(self, new_value: int, entity_name: str) -> None:
+        """
+        It allows to set the counter value of graph and provenance entities.
+
+        :param new_value: The new counter value to be set
+        :type new_value: int
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises ValueError: if ``new_value`` is a negative integer.
+        :return: None
+        """
+        entity_name = str(entity_name)
+        if new_value < 0:
+            raise ValueError("new_value must be a non negative integer!")
+        self.prov_counters[entity_name] = new_value
+
+    def read_counter(self, entity_name: str) -> int:
+        """
+        It allows to read the counter value of provenance entities.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The requested counter value.
+        """
+        entity_name = str(entity_name)
+        if entity_name in self.prov_counters:
+            return self.prov_counters[entity_name]
+        else:
+            self.prov_counters[entity_name] = 0
+            return 0
+
+    def increment_counter(self, entity_name: str) -> int:
+        """
+        It allows to increment the counter value of graph and provenance entities by one unit.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The newly-updated (already incremented) counter value.
+        """
+        entity_name = str(entity_name)
+        if entity_name in self.prov_counters:
+            self.prov_counters[entity_name] += 1
+        else:
+            self.prov_counters[entity_name] = 1
+        return self.prov_counters[entity_name]

rdflib_ocdm-0.1.0/rdflib_ocdm/counter_handler/sqlite_counter_handler.py

@@ -0,0 +1,87 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2023, Arcangelo Massari <arcangelo.massari@unibo.it>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+
+import sqlite3
+
+from rdflib_ocdm.counter_handler.counter_handler import CounterHandler
+
+
+class SqliteCounterHandler(CounterHandler):
+    """A concrete implementation of the ``CounterHandler`` interface that persistently stores
+    the counter values within a SQLite database."""
+
+    def __init__(self, database: str) -> None:
+        """
+        Constructor of the ``SqliteCounterHandler`` class.
+
+        :param database: The name of the database
+        :type info_dir: str
+        """
+        sqlite3.threadsafety = 3
+        self.con = sqlite3.connect(database)
+        self.cur = self.con.cursor()
+        self.cur.execute("""CREATE TABLE IF NOT EXISTS info(
+            entity TEXT PRIMARY KEY, 
+            count INTEGER)""")
+
+    def set_counter(self, new_value: int, entity_name: str) -> None:
+        """
+        It allows to set the counter value of provenance entities.
+
+        :param new_value: The new counter value to be set
+        :type new_value: int
+        :param entity_name: The entity name
+        :type entity_name: str
+        :raises ValueError: if ``new_value`` is a negative integer.
+        :return: None
+        """
+        entity_name = str(entity_name)
+        if new_value < 0:
+            raise ValueError("new_value must be a non negative integer!")
+        self.cur.execute(f"INSERT OR REPLACE INTO info (entity, count) VALUES ('{entity_name}', {new_value})")
+        self.con.commit()
+
+    def read_counter(self, entity_name: str) -> int:
+        """
+        It allows to read the counter value of provenance entities.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The requested counter value.
+        """
+        entity_name = str(entity_name)
+        result = self.cur.execute(f"SELECT count FROM info WHERE entity='{entity_name}'")
+        rows = result.fetchall()
+        if len(rows) == 1:
+            return rows[0][0]
+        elif len(rows) == 0:
+            return 0
+        else:
+            raise(Exception("There is more than one counter for this entity. The databse id broken"))
+
+    def increment_counter(self, entity_name: str) -> int:
+        """
+        It allows to increment the counter value of graph and provenance entities by one unit.
+
+        :param entity_name: The entity name
+        :type entity_name: str
+        :return: The newly-updated (already incremented) counter value.
+        """
+        entity_name = str(entity_name)
+        cur_count = self.read_counter(entity_name)
+        count = cur_count + 1
+        self.set_counter(count, entity_name)
+        return count