pypomes-sob 0.0.1__tar.gz

pypomes_sob-0.0.1/.gitignore

@@ -0,0 +1,16 @@
+.cache
+.env
+.venv
+.idea
+.vscode
+env
+venv
+temp
+tmp
+**/__pycache__
+*.py[cod]
+*.sh
+*.ps1
+/dist
+/env
+deploy.txt

pypomes_sob-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 GT Nunes
+
+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.

pypomes_sob-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: pypomes_sob
+Version: 0.0.1
+Summary: A collection of Python pomes, penyeach (simple object  module)
+Project-URL: Homepage, https://github.com/TheWiseCoder/PyPomes-SOB
+Project-URL: Bug Tracker, https://github.com/TheWiseCoder/PyPomes-SOB/issues
+Author-email: GT Nunes <wisecoder01@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Requires-Dist: pypomes-core>=2.5.1
+Requires-Dist: pypomes-db>=2.3.5
+Description-Content-Type: text/markdown
+
+# PyPomes-SOB
+Pomes penyeach (Simple Object module)

pypomes_sob-0.0.1/README.md

@@ -0,0 +1,2 @@
+# PyPomes-SOB
+Pomes penyeach (Simple Object module)

pypomes_sob-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = [
+    "hatchling>=1.27.0"
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "pypomes_sob"
+version = "0.0.1"
+authors = [
+  { name="GT Nunes", email="wisecoder01@gmail.com" }
+]
+description = "A collection of Python pomes, penyeach (simple object  module)"
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "pypomes_core>=2.5.1",
+    "pypomes_db>=2.3.5"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/TheWiseCoder/PyPomes-SOB"
+"Bug Tracker" = "https://github.com/TheWiseCoder/PyPomes-SOB/issues"

pypomes_sob-0.0.1/src/pypomes_sob/.ruff.toml

@@ -0,0 +1,136 @@
+# environment
+cache-dir = "~/.cache/ruff"
+force-exclude = true
+required-version = ">=0.12"
+target-version = "py312"
+respect-gitignore = true
+lint.task-tags = ["TODO", "FIXME", "HACK", "HAZARD"]
+lint.select = [
+    # flake8 group
+    "A",     # flake8-builtins - prevent shadowing of python builtins
+    "ANN",   # flake8-annotations - enforce PEP 3107-style function
+    "ARG",   # flake8-unused-arguments - check for unused function arguments
+    "ASYNC", # flake8-async - check for bad async / asyncio practices
+    "B",     # flake8-bugbear - warnings for likely bugs / antipatterns
+    "C4",    # flake8-comprehensions - check for bad use of list/set/dict comprehensions
+    "COM",   # flake8-commas - rules for trailing commas
+    "DTZ",   # flake8-datetimez - check for usage of unsafe naive datetime class
+    "EM",    # flake8-errmsg - enforce good formatting of error messages
+    "FA",    # flake8-future-annotations - verify use of 'from __future__ import annotations'
+    "FIX",   # flake8-fix_me - check for FIXMEs, TODOs and other temporary developer notes
+    "G",     # flake8-logging-format - validate logging format strings
+    "ICN",   # flake8-import-conventions - check for proper importing and aliasing of packages
+    "INP",   # flake8-no-pep420 - prevent PEP-420 implicit namespace packages
+    "INT",   # flake8-gettext - check formats resolved before function call
+    "ISC",   # flake8-implicit-str-concat - enforce correct string literal concatenation
+    "PIE",   # flake8-pie - miscellaneous lints
+    "PT",    # flake8-pytest-style - check common style issues or inconsistencies with pytest-based tests
+    "PTH",   # flake8-use-pathlib - check use of functions that can be replaced by pathlib module
+    "PYI",   # flake8-pyi - provide specializations for type hinting stub files
+    "Q",     # flake8-quotes - linter for quotes
+    "RET",   # flake8-return - check return values
+    "RSE",   # flake8-raise - enforce proper coding of 'raise' statements
+    "S",     # flake8-bandit - security testing
+    "SIM",   # flake8-simplify - help simplify Python code
+    "SLF",   # flake8-self - private member access linting
+    "SLOT",  # flake8-slots -  require '__slots__' to be defined for subclasses of immutable types
+    "TD",    # flake8-todos - check TODOs in the project
+    "TCH",   # flake8-type-checking - move imports in or out of type-checking blocks
+    "TID",   # flake8-tidy-imports - help writing tidier imports
+    "YTT",   # flake8-2020 - check for misuse of sys.version / sys.version_info
+    # pycodestyle group
+    "E",     # pycodestyle (Errors) - enforce style conventions in PEP 8
+    "W",     # pycodestyle (Warnings) - enforce style conventions in PEP 8
+    # Ruff-specific group
+    "RUF",   # the Ruff developer's own rules
+    # others
+    "C90",   # mccabe - check for excessive McCabe complexity
+    "D",     # pydocstyle - enforce docstring conventions
+    "F",     # Pyflakes - Python classic checker
+    "FLY",   # flynt - enforce use of 'f-strings' for formatting
+    "N",     # pep8-naming - enforce naming conventions in PEP 8
+    "NPY",   # NumPy-specific rules
+    "PERF",  # Perflint - linter for performance anti-patterns
+    "PGH",   # pygrep-hooks - check pre-commit hooks
+    "PD",    # pandas-vet - provide opinionated linting for pandas code
+    "PL",    # Pylint - Python classic static code analyser
+    "TRY",   # tryceratops - prevent exception handling antipatterns
+    "UP",    # pyupgrade - upgrade syntax for newer versions of the language
+#   unused
+#   "AIR",   # Airflow - check workflows
+#   "BLE",   # flake8-blind-except - check for except clauses that catch all exceptions
+#   "CPY",   # flake8-copyright - check for copyright notices in all python files
+#   "DJ",    # flake8-django - detect bad practices on Django projects
+#   "ERA",   # eradicate - check for commented-out code
+#   "EXE",   # flake8-executable - ensure the executable permissions and shebangs of Python files are correctly set
+#   "FBT",   # flake8-boolean-trap - check for boolean traps
+#   "I",     # isort - organize imports
+#   "T10",   # flake8-debugger - check for 'pdb;idbp' imports and set traces
+#   "T20",   # flake8-print - check for 'print' and 'pprint' statements in python files
+]
+lint.ignore = [
+    "ANN002",   # missing type annotation for *kargs
+    "ANN101",   # missing type annotation for 'self' in method
+    "ANN401",   # dynamically typed expressions (typing.Any) are disallowed
+    "COM812",   # checks for the absence of trailing commas
+    "COM819",   # prohibited trailing commas
+    "D100",     # missing docstring in public module
+    "D104",     # missing docstring in public package
+    "D200",     # one-line docstring should fit on one line
+    "D203",     # 1 blank line required before class docstring
+    "D204",     # 1 blank line required after class docstring
+    "D210",     # whitespaces surrounding docstring text
+    "D212",     # multi-line docstring summary to start at the second line
+    "DTZ005",   # the use of datetime.datetime.now() without tz argument is not allowed
+    "DTZ006",   # usage of 'datetime.datetime.fromtimestamp()' that do not specify a timezone
+    "FA102",    # use PEP 585- and PEP 604-style type annotations (not applicable for Python versions >= 3.10)
+    "G004",     # logging statement uses 'f-string'
+    "N815",     # variable in class scope should not be mixedCase
+    "PERF203",  # try-except within a loop incurs performance overhead (not applicable for Python >= 3.11)
+    "PGH004",   # use specific rule codes when using 'noqa'
+    "PLC0415",  # 'import' should be at the top level of a file
+    "PLR2004",  # magic value used in comparison, consider replacing it with a constant variable
+    "PLW0603",  # using the global statement to update a variable is discouraged
+    "PTH118",   # os.{module}.join() should be replaced by Path with / operator
+    "RUF013",   # implicit Optional in type annotations when the default parameter value is None
+    "RUF022",   # __all__ is not sorted
+    "S104",     # possible binding to all interfaces
+    "S105",     # hardcoded-password-string
+    "S108",     # probable insecure usage of temporary file or directory
+    "S113",     # probable use of requests call without timeout
+    "S301",     # 'pickle' and modules that wrap it can be unsafe when used to deserialize untrusted data
+    "S608",     # possible SQL injection vector through string-based query construction
+    "SIM108",   # use ternary operator instead of if-else-block
+    "TC001",    # move application import into a type-checking block
+    "TC002",    # move third-party import into a type-checking block
+    "TC003",    # move standard library import into a type-checking block
+    "TRY003",   # avoid specifying long messages outside the exception class
+    "TRY400",   # use 'logging.exception' instead of 'logging.error'
+]
+
+# rules
+line-length = 120
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[lint.flake8-bandit]
+hardcoded-tmp-directory = ["/tmp"]
+
+[lint.flake8-errmsg]
+max-string-length = 60      # maximum string length for string literals in exception messages
+
+[lint.flake8-quotes]
+docstring-quotes = "double"
+inline-quotes = "double"
+multiline-quotes = "double"
+
+[lint.mccabe]
+max-complexity = 50         # upper limit for McCabe code complexity
+
+[lint.pycodestyle]
+max-doc-length = 120
+
+[lint.pylint]
+max-args = 30
+max-branches = 40
+max-returns = 1
+max-statements = 150

pypomes_sob-0.0.1/src/pypomes_sob/__init__.py

@@ -0,0 +1,9 @@
+from .sob_pomes import DB_ID, DB_TABLE, PySob
+
+__all__ = [
+    "DB_ID", "DB_TABLE", "PySob"
+]
+
+from importlib.metadata import version
+__version__: str = version("pypomes_core")
+__version_info__: tuple = tuple(int(i) for i in __version__.split(".") if i.isdigit())

pypomes_sob-0.0.1/src/pypomes_sob/sob_pomes.py

@@ -0,0 +1,418 @@
+from __future__ import annotations  # allow forward references
+from inspect import FrameInfo, stack
+from enum import Enum, StrEnum, auto
+from logging import Logger
+from pypomes_core import dict_get_key, dict_stringify, validate_format_error
+from pypomes_db import (
+    db_exists, db_count, db_select,
+    db_insert, db_update, db_delete
+)
+# 'type' is not a viable replacement for 'typing.Type', because it does not accept subclasses
+from typing import Any, ClassVar, Final, Type  # noqa
+
+DB_ID: Final[str] = "id"
+DB_TABLE: Final[str] = "table"
+
+
+# noinspection Annotator
+# ruff: noqa: UP006
+class PySob:
+    """
+    Root entity.
+    """
+    class _Db(StrEnum):
+        TABLE = auto()
+        ID = auto()
+
+    db_specs: ClassVar[dict[Type[PySob], list[StrEnum]]] = {}
+
+    attrs_map: ClassVar[dict[Type[PySob], dict[StrEnum, StrEnum]]] = []
+
+    def __init__(self,
+                 __references: list[Type[PySob]],
+                 /,
+                 errors: list[str] = None,
+                 load_references: bool = False,
+                 where_data: dict[str, Any] = None,
+                 db_conn: Any = None,
+                 logger: Logger = None) -> None:
+
+        self._references: list[Type[PySob]] = __references
+        self._logger: Logger = logger
+        self.id: int = 0
+
+        if where_data:
+            attrs: list[str] = self.get_columns()
+            recs: list[tuple] = db_select(errors=errors,
+                                          sel_stmt=f"SELECT {', '.join(attrs)} "
+                                                   f"FROM {PySob.db_specs[self.__class__][DB_TABLE]}",
+                                          where_data=where_data,
+                                          limit_count=2,
+                                          connection=db_conn,
+                                          logger=self._logger)
+            msg: str | None = None
+            if errors:
+                # 201: Erro na interação com o BD em {}: {}
+                msg = validate_format_error(201,
+                                            f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                            f"{'; '.join(errors)}")
+            elif not recs:
+                # 202: Nenhum registro encontrado no BD, em {} para {}
+                msg = validate_format_error(202,
+                                            f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                            f"{dict_stringify(where_data)}")
+            elif len(recs) > 1:
+                # 207 Mais de um registro existente no BD, em {} para {}
+                msg = validate_format_error(207,
+                                            f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                            f"{dict_stringify(where_data)}")
+            if msg:
+                errors.append(msg)
+                if self._logger:
+                    self._logger.error(msg=msg)
+            else:
+                rec: tuple = recs[0]
+                for inx, attr in enumerate(attrs):
+                    self.__dict__[attr] = rec[inx]
+                if load_references:
+                    self.__load_references(errors=errors,
+                                           db_conn=db_conn)
+
+    def insert(self,
+               errors: list[str] | None,
+               db_conn: Any = None) -> bool:
+
+        # prepara os dados para INSERT
+        insert_data: dict[str, Any] = self.to_columns(omit_nulls=False)
+        insert_data.pop(PySob.db_specs[self.__class__][DB_ID])
+
+        # executa o INSERT
+        errors = errors if isinstance(errors, list) else []
+        rec: tuple[int] = db_insert(errors=errors,
+                                    insert_stmt=f"INSERT INTO {PySob.db_specs[self.__class__][DB_TABLE]}",
+                                    insert_data=insert_data,
+                                    return_cols={PySob.db_specs[self.__class__][DB_ID]: int},
+                                    connection=db_conn,
+                                    logger=self._logger)
+        if errors:
+            # 201: Erro na interação com o BD em {}: {}
+            msg = validate_format_error(201,
+                                        f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                        f"{'; '.join(errors)}")
+            errors.append(msg)
+            if self._logger:
+                self._logger.error(msg=msg)
+        else:
+            self.id = rec[0]
+
+        return not errors
+
+    def update(self,
+               errors: list[str] | None,
+               load_references: bool = False,
+               db_conn: Any = None) -> bool | None:
+
+        # inicializa a variável de retorno
+        result: bool | None = None
+
+        # prepara os dados para UPDATE
+        update_data: dict[str, Any] = self.to_columns(omit_nulls=False)
+        key: int = update_data.pop(PySob.db_specs[self.__class__][DB_ID])
+
+        # execute the UPDATE operation
+        errors = errors if isinstance(errors, list) else []
+        db_update(errors=errors,
+                  update_stmt=f"UPDATE {PySob.db_specs[self.__class__][DB_TABLE]}",
+                  update_data=update_data,
+                  where_data={PySob.db_specs[self.__class__][DB_ID]: key},
+                  min_count=1,
+                  max_count=1,
+                  connection=db_conn,
+                  logger=self._logger)
+
+        if not errors and load_references:
+            self.__load_references(errors=errors,
+                                   db_conn=db_conn)
+        if errors:
+            # 201: Erro na interação com o BD em {}: {}
+            msg = validate_format_error(201,
+                                        f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                        f"{'; '.join(errors)}")
+            errors.append(msg)
+            if self._logger:
+                self._logger.error(msg=msg)
+        else:
+            result = True
+
+        return result
+
+    def delete(self,
+               errors: list[str] | None,
+               db_conn: Any = None) -> int | None:
+
+        where_data: dict[str, Any]
+        if self.id:
+            where_data = {PySob.db_specs[self.__class__][DB_ID]: self.id}
+        else:
+            where_data = self.to_columns(omit_nulls=True)
+            where_data.pop(PySob.db_specs[self.__class__][DB_ID])
+
+        # execute the DELETE operation
+        result: int = db_delete(errors=errors,
+                                delete_stmt=f"DELETE FROM {PySob.db_specs[self.__class__][DB_TABLE]}",
+                                where_data=where_data,
+                                max_count=1,
+                                connection=db_conn,
+                                logger=self._logger)
+        if errors:
+            # 201: Erro na interação com o BD em {}: {}
+            msg = validate_format_error(201,
+                                        f"{PySob.db_specs[self.__class__][DB_TABLE]}",
+                                        f"{'; '.join(errors)}")
+            errors.append(msg)
+            if self._logger:
+                self._logger.error(msg=msg)
+        else:
+            self.clear()
+
+        return result
+
+    def clear(self) -> None:
+
+        for key in self.__dict__.keys():
+            self.__dict__[key] = None
+
+    def set(self,
+            data: dict[str, Any]) -> None:
+
+        for key, value in data.items():
+            attr: str = PySob.attrs_map[self.__class__].get(key) or key
+
+            # usa nomes de enums atribuídos como valores em 'data'
+            if isinstance(value, Enum) and "use_names" in value.__class__:
+                value = value.name
+
+            if attr in self.__dict__:
+                self.__dict__[attr] = value
+            elif self._logger:
+                self._logger.warning(msg=f"'{attr}' não é atributo de "
+                                         f"'{PySob.db_specs[self.__class__][DB_TABLE]}'")
+
+    def exists(self,
+               errors: list[str] | None,
+               where_data: dict[str, Any] = None,
+               db_conn: Any = None) -> bool | None:
+
+        if not where_data:
+            if self.id:
+                # use object's ID
+                where_data = {PySob.db_specs[self.__class__][DB_ID]: self.id}
+            else:
+                # use object's available data
+                where_data = self.to_columns(omit_nulls=True)
+                where_data.pop(PySob.db_specs[self.__class__][DB_ID])
+
+        return db_exists(errors=errors,
+                         table=PySob.db_specs[self.__class__][DB_TABLE],
+                         where_data=where_data,
+                         connection=db_conn,
+                         logger=self._logger)
+
+    def load(self,
+             errors: list[str] | None,
+             omit_nulls: bool,
+             where_data: dict[str, Any] = None,
+             db_conn: Any = None) -> bool:
+
+        if not where_data:
+            if self.id:
+                where_data = {PySob.db_specs[self.__class__][DB_ID]: self.id}
+            else:
+                where_data = self.to_columns(omit_nulls=omit_nulls)
+                where_data.pop(PySob.db_specs[self.__class__][DB_ID])
+
+        # it is acceptable that loading the object from the database might fail
+        attrs: list[str] = self.get_columns()
+        errors = errors if isinstance(errors, list) else []
+        recs: list[tuple] = db_select(errors=errors,
+                                      sel_stmt=f"SELECT {', '.join(attrs)} "
+                                               f"FROM {PySob.db_specs[self.__class__][DB_TABLE]}",
+                                      where_data=where_data,
+                                      limit_count=2,
+                                      connection=db_conn,
+                                      logger=self._logger)
+        if recs and len(recs) == 1:
+            rec: tuple = recs[0]
+            for inx, attr in enumerate(attrs):
+                self.__dict__[attr] = rec[inx]
+        elif self._logger:
+            self._logger.warning(msg=f"Unable to load from "
+                                     f"'{PySob.db_specs[self.__class__][DB_TABLE]}' "
+                                     f"with data {where_data}")
+
+        return recs and len(recs) == 1
+
+    def get_columns(self) -> list[str]:
+
+        return [k for k in self.__dict__
+                if k.islower() and not k.startswith("_")]
+
+    def to_columns(self,
+                   omit_nulls: bool) -> dict[str, Any]:
+
+        result: dict[str, Any] = {}
+        for key, value in self.__dict__.items():
+            if key.islower() and not key.startswith("_") and \
+                    (not omit_nulls or value is not None):
+                result[key] = value
+
+        return result
+
+    def to_params(self,
+                  omit_nulls: bool) -> dict[str, Any]:
+
+        result: dict[str, Any] = {}
+        for key, value in self.__dict__.items():
+            if key.islower() and not key.startswith("_") and \
+                    (not omit_nulls or value is not None):
+                attr: str = dict_get_key(source=PySob.attrs_map[self.__class__],
+                                         value=key) or key
+                result[attr] = value
+
+        return result
+
+    def data_to_params(self,
+                       data: dict[str, Any],
+                       omit_nulls: bool) -> dict[str, Any]:
+
+        result: dict[str, Any] = {}
+        for key, value in data.items():
+            if not omit_nulls or value is not None:
+                attr: str = dict_get_key(source=PySob.attrs_map[self.__class__],
+                                         value=key) or key
+                result[attr] = value
+
+        return result
+
+    # noinspection PyMethodMayBeStatic, PyUnusedLocal
+    def load_reference(self,
+                       errors: list[str] | None,  # noqa: ARG002
+                       db_conn: Any | None) -> PySob | list[PySob] | None:  # noqa: ARG002
+
+        # to be implemented by subclasses containing references
+        return None
+
+    def __load_references(self,
+                          errors: list[str],
+                          db_conn: Any) -> None:
+
+        for cls in self._references or []:
+            self.load_reference(errors=errors,
+                                db_conn=db_conn)
+            if errors:
+                # 201: Erro na interação com o BD em {}: {}
+                msg = validate_format_error(201,
+                                            f"{cls._Db.TABLE}",
+                                            f"{'; '.join(errors)}")
+                errors.append(msg)
+                if self._logger:
+                    self._logger.error(msg=msg)
+                break
+
+    @staticmethod
+    def count(errors: list[str] | None,
+              where_data: dict[str, Any],
+              db_conn: Any = None,
+              logger: Logger = None) -> int | None:
+
+        # obtem a classe invocante
+        # noinspection PyTypeChecker
+        cls: Type[PySob] = PySob.__get_invoking_class()
+
+        return db_count(errors=errors,
+                        table=cls._Db.TABLE,
+                        where_data=where_data,
+                        connection=db_conn,
+                        logger=logger)
+
+    @staticmethod
+    def retrieve(errors: list[str] | None,
+                 where_data: dict[str, Any] = None,
+                 references: list[Type[PySob]] = None,
+                 required: bool = False,
+                 db_conn: Any = None,
+                 logger: Logger = None) -> list[Type[PySob]] | None:
+
+        # inicializa a variável de retorno
+        result: list[PySob] | None = None
+
+        # obtem a classe invocante
+        # noinspection PyTypeChecker
+        cls: Type[PySob] = PySob.__get_invoking_class()
+
+        errors = errors if isinstance(errors, list) else []
+        recs: list[tuple[int]] = db_select(errors=errors,
+                                           sel_stmt=f"SELECT {cls._Db.ID} FROM {cls._Db.TABLE}",
+                                           where_data=where_data,
+                                           min_count=1 if required else None,
+                                           connection=db_conn,
+                                           logger=logger)
+        if not errors:
+            # constrói a lista de objetos
+            # noinspection PyTypeChecker
+            objs: list[PySob] = []
+            for rec in recs:
+                # noinspection PyTypeChecker
+                objs.append(cls(references,
+                                errors=errors,
+                                load_references=isinstance(references, list) and len(references) > 0,
+                                db_conn=db_conn,
+                                where_data={cls._Db.ID: rec[0]},
+                                logger=logger))
+                if errors:
+                    break
+
+            if not errors:
+                result = objs
+
+        return result
+
+    @staticmethod
+    def erase(errors: list[str] | None,
+              where_data: dict[str, Any],
+              db_conn: Any = None,
+              logger: Logger = None) -> int | None:
+
+        # obtem a classe invocante
+        # noinspection PyTypeChecker
+        cls: Type[PySob] = PySob.__get_invoking_class()
+
+        # delete specified tuples
+        return db_delete(errors=errors,
+                         delete_stmt=f"DELETE FROM {cls._Db.TABLE}",
+                         where_data=where_data,
+                         connection=db_conn,
+                         logger=logger)
+
+    @staticmethod
+    def __get_invoking_class() -> Type[PySob]:
+
+        # obtem a função invocante
+        caller_frame: FrameInfo = stack()[1]
+        mark: str = f".{caller_frame.function}("
+
+        # obtem a classe invocante
+        caller_frame = stack()[2]
+        context: str = caller_frame.code_context[0]
+        pos_to: int = context.find(mark)
+        pos_from: int = context.rfind(" ", 0, pos_to)
+        mark = "." + context[pos_from+1:pos_to]
+
+        result: Type[PySob] | None = None
+        for typ in PySob.db_specs:
+            name = f"{typ.__module__}.{typ.__qualname__}"
+            if name.endswith(mark):
+                result = typ
+                break
+
+        return result