hspylib-clitt 0.9.41__py3-none-any.whl → 0.9.51__py3-none-any.whl

clitt/addons/setman/setman_enums.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.setman
-      @file: setman_enums.py
-   @created: Fri, 29 May 2023
-    @author: "<B>H</B>ugo <B>S</B>aporetti <B>J</B>unior")"
-      @site: "https://github.com/yorevs/hspylib")
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-from hspylib.core.enums.enumeration import Enumeration
-from typing import List
-
-
-class SetmanOps(Enumeration):
-    """Setman operations."""
-
-    # fmt: off
-    GET         = 'get'
-    SET         = 'set'
-    DEL         = 'del'
-    LIST        = 'list'
-    SEARCH      = 'search'
-    TRUNCATE    = 'truncate'
-    # fmt: on
-
-    @staticmethod
-    def choices() -> List[str]:
-        return SetmanOps.values()
-
-
-class SettingsType(Enumeration):
-    """Settings types."""
-
-    # fmt: off
-    ENVIRONMENT = 'environment'
-    PROPERTY    = 'property'
-    # fmt: on
-
-    @staticmethod
-    def choices() -> List[str]:
-        return SettingsType.values()
-
-    @staticmethod
-    def selectables(selected: str = None) -> str:
-        return "|".join([s if not s or s != selected else f"<{s}>" for s in SettingsType.values()])
-
-    @property
-    def val(self) -> str:
-        return str(self.value)

clitt/core/settings/__init__.py

@@ -1,15 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.41
-#
-# Package: main.clitt.core.settings
-"""Package initialization."""
-
-__all__ = [
-  'settings', 
-  'settings_config', 
-  'settings_entry', 
-  'settings_repository', 
-  'settings_service'
-]
-__version__ = '0.9.41'

clitt/core/settings/settings.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.addons.setman
-      @file: settings.py
-   @created: Thu, 04 Jul 2023
-    @author: "<B>H</B>ugo <B>S</B>aporetti <B>J</B>unior")"
-      @site: "https://github.com/yorevs/hspylib")
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-import binascii
-import contextlib
-import logging as log
-import os
-import uuid
-from typing import Any, List, Optional, Tuple
-
-from datasource.identity import Identity
-from hspylib.core.exception.exceptions import ApplicationError
-from hspylib.core.preconditions import check_state
-from hspylib.core.tools.commons import file_is_not_empty, safe_delete_file, touch_file
-from hspylib.core.zoned_datetime import now
-from hspylib.modules.security.security import decode_file, encode_file
-
-from clitt.addons.setman.setman_enums import SettingsType
-from clitt.core.settings.settings_config import SettingsConfig
-from clitt.core.settings.settings_entry import SettingsEntry
-from clitt.core.settings.settings_service import SettingsService
-
-
-class Settings:
-    """Class to provide settings interactions."""
-
-    def __init__(self, configs: SettingsConfig) -> None:
-        self._is_open = False
-        self._configs = configs
-        self._service = SettingsService(self.configs)
-        if not file_is_not_empty(self.configs.database):
-            self._create_db()
-
-    def __str__(self):
-        entries = f",{os.linesep}  ".join(list(map(lambda s: str(s), self.list())))
-        return (
-            f"Settings: [{os.linesep + '  ' if entries else ''}"
-            f"{entries}"
-            f"{os.linesep if entries else ''}]"
-        )
-
-    def __repr__(self):
-        return str(self)
-
-    def __getitem__(self, name: str) -> SettingsEntry:
-        return self.get(name)
-
-    def __setitem__(self, name: str, item: Tuple[Any, SettingsType]) -> None:
-        self.upsert(name, item[0], item[1])
-
-    @property
-    def configs(self) -> SettingsConfig:
-        return self._configs
-
-    @property
-    def is_open(self) -> bool:
-        return self._is_open
-
-    @is_open.setter
-    def is_open(self, new_is_open: bool) -> None:
-        self._is_open = new_is_open
-        log.debug(f"Settings database open: {self.configs.database}")
-
-    @contextlib.contextmanager
-    def open(self) -> None:
-        """Decode and open the SQL lite database file. Return the context to manipulate it."""
-        try:
-            if not self.is_open:
-                self.is_open = True
-                if self.configs.is_db_encoded:
-                    self._decode_db_file()
-            yield self
-        except (UnicodeDecodeError, binascii.Error) as err:
-            err_msg = f"Failed to open settings file => {self.configs.database}"
-            log.error(ApplicationError(err_msg, err))
-        except Exception as err:
-            err_msg = f"Unable to close settings file => {self.configs.database}"
-            raise ApplicationError(err_msg, err) from err
-        finally:
-            self.close()
-
-    def close(self) -> None:
-        """Encode and open the SQL lite database file. Return the context to manipulate it."""
-        try:
-            if self._is_open:
-                if self.configs.is_db_encoded:
-                    self._encode_db_file()
-                self._is_open = False
-                log.debug(f"Settings database closed: {self.configs.database}")
-        except (UnicodeDecodeError, binascii.Error) as err:
-            err_msg = f"Failed to close settings file => {self.configs.database}"
-            raise ApplicationError(err_msg, err) from err
-        except Exception as err:
-            err_msg = f"Unable to close settings file => {self.configs.database}"
-            raise ApplicationError(err_msg, err) from err
-        finally:
-            safe_delete_file(self.configs.encoded_db)
-            safe_delete_file(self.configs.decoded_db)
-
-    def list(self) -> List[SettingsEntry]:
-        """List all database settings using as a formatted table."""
-        check_state(self.is_open, "Settings database is not open")
-        return self._service.list()
-
-    def search(self, name: str, stype: SettingsType, simple_fmt: bool) -> List[str]:
-        """Display all settings matching the name and settings type."""
-        check_state(self.is_open, "Settings database is not open")
-        return list(map(lambda e: e.to_string(simple_fmt), self._service.search(name, stype)))
-
-    def remove(self, name: str) -> Optional[SettingsEntry]:
-        """Delete the specified setting."""
-        check_state(self.is_open, "Settings database is not open")
-        if name:
-            found = self._service.get(name)
-            if found:
-                self._service.remove(found)
-                return found
-        return None
-
-    def get(self, name: str) -> Optional[SettingsEntry]:
-        """Get the specified setting."""
-        check_state(self.is_open, "Settings database is not open")
-        if name:
-            return self._service.get(name)
-        return None
-
-    def upsert(
-        self,
-        name: str,
-        value: Any,
-        stype: SettingsType) -> Tuple[Optional[SettingsEntry], Optional[SettingsEntry]]:
-        """Upsert the specified setting."""
-
-        check_state(self.is_open, "Settings database is not open")
-        found = self._service.get(name)
-        entry = found or SettingsEntry(Identity(SettingsEntry.SetmanId(uuid.uuid4().hex)), name, value, stype)
-        if not name or value is None or not stype:
-            entry = SettingsEntry.prompt(entry)
-        if entry:
-            entry.modified = now()
-            self._service.save(entry)
-        return found, entry
-
-    def clear(self) -> None:
-        """Clear all settings from the settings table."""
-        check_state(self.is_open, "Settings database is not open")
-        self._service.clear()
-
-    def _create_db(self) -> bool:
-        """Create the settings SQLite DB file."""
-        touch_file(self.configs.database)
-        self._service.create_db()
-        log.info("Settings file has been created")
-        self._is_open = True
-        return os.path.exists(self.configs.database)
-
-    def _encode_db_file(self) -> None:
-        """Decode the Base64 encoded database file."""
-        if file_is_not_empty(self.configs.database):
-            encoded = f"{self.configs.database}-encoded"
-            encode_file(self.configs.database, encoded, binary=True)
-            os.rename(encoded, self.configs.database)
-            log.debug("Settings file is encoded")
-
-    def _decode_db_file(self) -> None:
-        """Base64 encode the database file."""
-        if file_is_not_empty(self.configs.database):
-            decoded = f"{self.configs.database}-decoded"
-            decode_file(self.configs.database, decoded, binary=True)
-            os.rename(decoded, self.configs.database)
-            log.debug("Settings file is decoded")

clitt/core/settings/settings_config.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.setman
-      @file: settings_config.py
-   @created: Mon, 5 Jun 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-from datasource.db_configuration import DBConfiguration
-from hspylib.core.tools.commons import str_to_bool
-
-
-class SettingsConfig(DBConfiguration):
-    """Holds the settings configurations."""
-
-    INSTANCE = None
-
-    def __init__(self, resource_dir: str, filename: str):
-        super().__init__(resource_dir, filename)
-        self._database: str = self["hhs.settings.database"]
-        self._encode_db: bool = str_to_bool(self["hhs.settings.encode.database"])
-
-    @property
-    def database(self) -> str:
-        """Return the settings database name."""
-        return self._database
-
-    @property
-    def is_db_encoded(self) -> bool:
-        """Return the settings encode database."""
-        return self._encode_db
-
-    @property
-    def encoded_db(self) -> str:
-        """Return the settings encoded-database name."""
-        return f"{self.database}-encoded"
-
-    @property
-    def decoded_db(self) -> str:
-        """Return the settings decoded-database name."""
-        return f"{self.database}-decoded"

clitt/core/settings/settings_entry.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.setman
-      @file: settings_entry.py
-   @created: Mon, 5 Jun 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-from clitt.addons.setman.setman_enums import SettingsType
-from clitt.core.tui.minput.menu_input import MenuInput
-from clitt.core.tui.minput.minput import minput
-from collections import namedtuple
-from datasource.crud_entity import CrudEntity
-from datasource.identity import Identity
-from hspylib.core.tools.text_tools import environ_name
-from hspylib.core.zoned_datetime import now
-from textwrap import dedent
-from typing import Any, Optional, Union
-
-
-class SettingsEntry(CrudEntity):
-    """Represents the Settings domain object."""
-
-    SetmanId = namedtuple("SetmanId", ["uuid"])
-
-    # Setman entry display format.
-    _DISPLAY_FORMAT = dedent(
-        """
-    [%BLUE%{}%NC%]:
-            Type: %GREEN%{}%NC%
-           Value: %GREEN%{}%NC%
-        Modified: %GREEN%{}%NC%
-    """
-    )
-
-    # Setman entry simple format.
-    _SIMPLE_FORMAT = "{}={}"
-
-    @staticmethod
-    def prompt(entry: Union["SettingsEntry", None] = None) -> Optional["SettingsEntry"]:
-        """Create a settings entry from a form input."""
-
-        entry = entry or SettingsEntry()
-        # fmt: off
-        form_fields = MenuInput.builder() \
-            .field() \
-                .label('Name') \
-                .min_max_length(1, 60) \
-                .value(entry.name) \
-                .build() \
-            .field() \
-                .label('Value') \
-                .min_max_length(1, 60) \
-                .value(entry.value) \
-                .build() \
-            .field() \
-                .label('Type') \
-                .itype('select') \
-                .dest('stype') \
-                .value(SettingsType.selectables(entry.stype) if entry.stype else None) \
-                .build() \
-            .build()
-        # fmt: on
-
-        if result := minput(form_fields, "Please fill the settings details"):
-            entry.name = result.name
-            entry.value = result.value
-            entry.stype = result.stype
-            entry.modified = now()
-
-        return entry if result else None
-
-    def __init__(
-        self,
-        entity_id: Identity = SetmanId(Identity.auto().values),
-        name: str = None,
-        value: Any | None = None,
-        stype: SettingsType = None,
-        modified: str = now(),
-    ):
-        super().__init__(entity_id)
-        self.name: str = name
-        self.value: Any = value
-        self.stype: str = stype.val if stype else SettingsType.PROPERTY.val
-        self.modified: str = modified
-
-    def __str__(self) -> str:
-        return str(self.as_dict())
-
-    def __repr__(self) -> str:
-        return self.to_string()
-
-    def to_string(self, simple: bool = False) -> str:
-        """Return the string representation of this entry."""
-        if simple:
-            return (
-                self._SIMPLE_FORMAT.format(environ_name(self.name), self.value)
-                if self.stype == SettingsType.ENVIRONMENT.val
-                else self._SIMPLE_FORMAT.format(self.name, self.value)
-            )
-        else:
-            return self._DISPLAY_FORMAT.format(self.name, self.stype, self.value, self.modified)

clitt/core/settings/settings_repository.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.setman
-      @file: settings_repository.py
-   @created: Mon, 5 Jun 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-from clitt.addons.setman.setman_enums import SettingsType
-from datasource.identity import Identity
-from datasource.sqlite.sqlite_repository import SQLiteRepository
-from textwrap import dedent
-from typing import List, Optional
-
-from clitt.core.settings.settings_entry import SettingsEntry
-
-
-class SettingsRepository(SQLiteRepository[SettingsEntry]):
-    """Provide CRUD operations for the Settings."""
-
-    @property
-    def database(self) -> str:
-        return self._config.database
-
-    def find_by_name(self, name: str) -> Optional[SettingsEntry]:
-        """Find settings by name."""
-        sql = f"SELECT * FROM SETTINGS WHERE name = ? ORDER BY name"
-        result = next((e for e in self.execute(sql, name=name)[1]), None)
-
-        return self.to_entity_type(result) if result else None
-
-    def search(self, name: str, stype: SettingsType) -> List[SettingsEntry]:
-        """Search settings by settings type."""
-        search_name = name.replace("*", "%") if name else "%"
-        if stype:
-            sql = "SELECT * FROM SETTINGS WHERE name LIKE ? AND stype = ? ORDER BY name"
-            result = self.execute(sql, name=search_name, stype=stype.val)[1] or []
-        else:
-            sql = "SELECT * FROM SETTINGS WHERE name LIKE ? ORDER BY name"
-            result = self.execute(sql, name=search_name)[1] or []
-
-        return list(map(self.to_entity_type, result))
-
-    def truncate(self) -> None:
-        """TODO"""
-        self.execute("DELETE FROM SETTINGS")
-
-    def create_db(self) -> None:
-        """TODO"""
-        self.execute(
-            dedent(
-                """
-                CREATE TABLE IF NOT EXISTS SETTINGS
-                (
-                    uuid         TEXT       not null,
-                    name         TEXT       not null,
-                    value        TEXT       not null,
-                    stype        TEXT       not null,
-                    modified     TEXT       not null,
-
-                    CONSTRAINT UUID_pk PRIMARY KEY (uuid),
-                    CONSTRAINT NAME_uk UNIQUE (name)
-                )
-                """
-            )
-        )
-        self.execute(
-            dedent(
-                """
-                CREATE TABLE IF NOT EXISTS SETTINGS_EVENTS
-                (
-                    uuid         TEXT       not null,
-                    event        TEXT       not null,
-                    name         TEXT       not null,
-                    old_value    TEXT       not null,
-                    new_value    TEXT       not null,
-                    created      TEXT       not null,
-
-                    CONSTRAINT UUID_pk PRIMARY KEY (uuid)
-                )
-            """
-            )
-        )
-
-    def table_name(self) -> str:
-        return "SETTINGS"
-
-    def to_entity_type(self, entity_dict: dict | tuple) -> SettingsEntry:
-        if isinstance(entity_dict, dict):
-            return SettingsEntry(Identity(SettingsEntry.SetmanId(entity_dict["uuid"])), **entity_dict)
-        return SettingsEntry(
-            Identity(SettingsEntry.SetmanId(entity_dict[0])),
-            entity_dict[1],
-            entity_dict[2],
-            SettingsType.of_value(entity_dict[3]),
-            entity_dict[4],
-        )

clitt/core/settings/settings_service.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.setman
-      @file: settings_service.py
-   @created: Mon, 5 Jun 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright 2023, HsPyLib team
-"""
-from typing import List, Optional
-
-from datasource.crud_service import CrudService
-
-from clitt.addons.setman.setman_enums import SettingsType
-from clitt.core.settings.settings_config import SettingsConfig
-from clitt.core.settings.settings_entry import SettingsEntry
-from clitt.core.settings.settings_repository import SettingsRepository
-
-
-class SettingsService(CrudService[SettingsRepository, SettingsEntry]):
-    """Provides a CRUD service for the Setman application."""
-
-    def __init__(self, setman_config: SettingsConfig):
-        super().__init__(SettingsRepository(setman_config))
-
-    def get(self, name: str) -> Optional[SettingsEntry]:
-        """Get a setman entry using the specified name.
-        :param name: the setman entry name to find.
-        """
-        return self.repository.find_by_name(name)
-
-    def search(self, name: str, stype: SettingsType = None) -> List[SettingsEntry]:
-        """Get a setman entry using the specified name.
-        :param name: the setman entry name to find.
-        :param stype: the settings type to filter.
-        """
-        return self.repository.search(name, stype)
-
-    def clear(self) -> None:
-        """Clear all settings from the settings table."""
-        self.repository.truncate()
-
-    def create_db(self) -> None:
-        """Create a brand new setman database file."""
-        self.repository.create_db()