soup-files 1.2__tar.gz → 1.2.1__tar.gz

{soup_files-1.2 → soup_files-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soup_files
-Version: 1.2
+Version: 1.2.1
 Summary: soup_files
 Author: Bruno Chaves
 Requires-Python: >=3.11

{soup_files-1.2 → soup_files-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soup_files"
-version = "1.2"
+version = "1.2.1"
 authors = [
   { name="Bruno Chaves"},
 ]
@@ -18,5 +18,5 @@ dependencies = [
 
 [tool.setuptools]
 packages = [
-
+  "soup_files"
 ]

soup_files-1.2.1/soup_files/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+from .version import __version__
+from .progress import ProgressBarAdapter, ProgressBarSimple, ABCProgressBar
+from .files import (
+    File,
+    Directory,
+    JsonData,
+    JsonConvert,
+    InputFiles,
+    LibraryDocs,
+    UserFileSystem,
+    UserAppDir,
+    KERNEL_TYPE,
+)
+

soup_files-1.2.1/soup_files/files.py

@@ -0,0 +1,486 @@
+#!/usr/bin/env python3
+#
+"""
+    Esté módulo serve para manipulação de arquivos, diretórios e documentos
+entre outros. Não depende de módulos externos apenas de builtins e stdlib.
+"""
+from __future__ import annotations
+from typing import List, Dict
+from enum import Enum
+import os
+import json
+import platform
+from pathlib import Path
+from hashlib import md5
+
+
+# Windows / Linux / ...
+KERNEL_TYPE = platform.system()
+
+
+class LibraryDocs(Enum):
+
+    IMAGE = ['.png', '.jpg', '.jpeg', '.svg']
+    PDF = ['.pdf']
+    DOCUMENTS = ['.png', '.jpg', '.jpeg', '.svg', '.pdf']
+    #
+    EXCEL = ['.xlsx']
+    CSV = ['.csv', '.txt']
+    #
+    SHEET = ['.csv', '.txt', '.xlsx', '.xls']
+    JSON = ['.json']
+    #
+    ALL_DOCUMENTS = [
+        '.png', '.jpg', '.jpeg', '.svg',
+        '.csv', '.txt', '.xlsx', 
+        '.pdf',
+        '.json',
+    ]
+    #
+    ALL = None
+
+
+class File(object):
+    def __init__(self, filename: str):
+        if os.path.isdir(filename):
+            raise ValueError(f'{__class__.__name__} File() não pode ser um diretório.')
+        self.filename: str = os.path.abspath(filename)
+        self.__path: Path = Path(self.filename)
+
+    @property
+    def path(self) -> Path:
+        return self.__path
+    
+    @path.setter
+    def path(self, new:Path):
+        if not isinstance(new, Path):
+            return
+        self.__path = new
+        
+    def __eq__(self, value):
+        if not isinstance(value, File):
+            return NotImplemented
+        return self.absolute() == value.absolute()
+    
+    def __hash__(self):
+        return self.absolute().__hash__()
+
+    def is_image(self) -> bool:
+        try:
+            return True if self.extension() in LibraryDocs.IMAGE.value else False
+        except:
+            return False
+
+    def is_pdf(self) -> bool:
+        try:
+            return True if self.extension() in LibraryDocs.PDF.value else False
+        except:
+            return False
+        
+    def is_excel(self) -> bool:
+        try:
+            return True if self.extension() in LibraryDocs.EXCEL.value else False
+        except:
+            return False
+        
+    def is_csv(self) -> bool:
+        try:
+            return True if self.extension() in LibraryDocs.CSV.value else False
+        except:
+            return False
+
+    def is_sheet(self) -> bool:
+        try:
+            return True if self.extension() in LibraryDocs.SHEET.value else False
+        except:
+            return False
+
+    def update_extension(self, e: str) -> File:
+        """
+            Retorna uma instância de File() no mesmo diretório com a nova
+        extensão informada.
+        """
+        current = self.extension()
+        full_path = self.absolute().replace(current, '')
+        return File(os.path.join(f'{full_path}{e}'))
+
+    def get_text(self) -> str | None:
+        try:
+            return self.__path.read_text()
+        except Exception as e:
+            print(e)
+            return None
+
+    def write_string(self, s:str):
+        self.__path.write_text(s)
+
+    def write_list(self, items: List[str]):
+        # Abrindo o arquivo em modo de escrita
+        with open(self.filename, "w", encoding="utf-8") as file:
+            for string in items:
+                file.write(string + "\n")  # Adiciona uma quebra de linha após cada string
+
+    def name(self):
+        e = self.extension()
+        if (e is None) or (e == ''):
+            return os.path.basename(self.filename)
+        return os.path.basename(self.filename).replace(e, '')
+    
+    def name_absolute(self) -> str:
+        e = self.extension()
+        if (e is None) or (e == ''):
+            return self.filename
+        return self.filename.replace(e, '')
+
+    def extension(self) -> str:
+        return self.__path.suffix
+
+    def dirname(self) -> str:
+        return os.path.dirname(self.filename)
+
+    def basename(self) -> str:
+        return os.path.basename(self.filename)
+
+    def exists(self) -> bool:
+        return self.__path.exists()
+
+    def absolute(self) -> str:
+        return self.filename
+    
+    def size(self):
+        return os.path.getsize(self.filename)
+    
+    def md5(self) -> str | None:
+        """Retorna a hash md5 de um arquivo se ele existir no disco."""
+        if not self.path.exists():
+            return None
+        _hash_md5 = md5()
+        with open(self.absolute(), "rb") as f:
+            for _block in iter(lambda: f.read(4096), b""):
+                _hash_md5.update(_block)
+        return _hash_md5.hexdigest()
+
+
+class Directory(object):
+    def __init__(self, dirpath:str):
+        self.dirpath: str = os.path.abspath(dirpath)
+        self.path: Path = Path(self.dirpath)
+        
+    def __eq__(self, value):
+        if not isinstance(value, Directory):
+            return NotImplemented
+        return self.absolute() == value.absolute()
+    
+    def __hash__(self):
+        return self.absolute().__hash__()
+        
+    def iterpaths(self) -> List[Path]:
+        return self.path.rglob('*')
+
+    def __content_recursive(self) -> List[File]:
+        _paths = self.iterpaths()
+        values = []
+        for p in _paths:
+            if p.is_file():
+                values.append(
+                    File(
+                        os.path.abspath(p.absolute())
+                    )
+                )
+        return values
+
+    def __content_no_recursive(self) -> List[File]:
+        files = os.listdir(self.absolute())
+        values: List[File] = []
+        for f in files:
+            if os.path.isfile(f):
+                values.append(
+                    File(os.path.abspath(f))
+                )
+        return values
+
+    def content_files(self, *, recursive: bool = True) -> List[File]:
+        if recursive:
+            return self.__content_recursive()
+        return self.__content_no_recursive()
+
+    def content_dirs(self, recursive: bool = True) -> List[Directory]:
+        values: List[Directory] = []
+        if recursive:
+            _paths = self.iterpaths()
+            for p in _paths:
+                if p.is_dir():
+                    values.append(
+                        Directory(os.path.abspath(p.absolute()))
+                    )
+        else:
+            _paths = os.listdir(self.absolute())
+            for d in _paths:
+                if os.path.isdir(d):
+                    values.append(
+                        Directory(os.path.abspath(d))
+                    )
+        return values
+    
+    def basename(self) -> str:
+        return os.path.basename(self.absolute())
+
+    def mkdir(self):
+        try:
+            os.makedirs(self.absolute())
+        except:
+            pass
+
+    def absolute(self) -> str:
+        return self.dirpath
+
+    def concat(self, d:str, create:bool=False) -> Directory:
+        if create == True:
+            try:
+                os.makedirs(os.path.join(self.absolute(), d))
+            except:
+                pass
+        return Directory(
+                os.path.join(self.absolute(), d)
+            )
+
+    def parent(self) -> Directory:
+        return Directory(
+            os.path.abspath(self.path.parent)
+        )
+
+    def join_file(self, name:str) -> File:
+        return File(
+            os.path.join(self.absolute(), name)
+        )
+   
+   
+class InputFiles(object):
+    """
+        Obeter uma lista de arquivos/documentos do diretório informado.
+    """
+    def __init__(self, d: Directory, *, maxFiles: int = 5000):
+        if not isinstance(d, Directory):
+            raise ValueError(f'{__class__.__name__}\nUse: Directory(), não {type(d)}')
+        self.input_dir: Directory = d
+        self.maxFiles: int = maxFiles
+        
+    def get_files_with(self, *, infile: str, sort: bool = True) -> List[File]:
+        """
+            Retorna arquivos que contém a ocorrência (infile) no nome absoluto.
+        """
+        content_files: List[File] = []
+        count: int = 0
+        paths = self.input_dir.iterpaths()
+        for file in paths:
+            if not file.is_file():
+                continue
+            if infile in os.path.abspath(file.absolute()):
+                content_files.append(
+                        File(os.path.abspath(file.absolute()))
+                    )
+                count += 1
+            if count >= self.maxFiles:
+                break
+        return content_files
+
+    def __get_files_recursive(self, *, file_type: LibraryDocs, sort: bool) -> List[File]:
+        #
+        #
+        _paths: List[Path] = self.input_dir.iterpaths()
+        _all_files = []
+        count: int = 0
+        if file_type == LibraryDocs.ALL:
+            # Todos os tipos de arquivos
+            for p in _paths:
+                if not p.is_file():
+                    continue
+                _all_files.append(
+                    File(os.path.abspath(p.absolute()))
+                )
+                count += 1
+                if count >= self.maxFiles:
+                    break
+        else:
+            # Arquivos especificados em LibraryDocs
+            for p in _paths:
+                if not p.is_file():
+                    continue
+                if (p.suffix is None) or (p.suffix == ''):
+                    continue
+                if p.suffix in file_type.value:
+                    _all_files.append(
+                        File(os.path.abspath(p.absolute()))
+                    )
+                    count += 1
+                if count >= self.maxFiles:
+                    break
+        if sort:
+            _all_files.sort(key=File.absolute)
+        return _all_files
+
+    def __get_files_no_recursive(self, *, file_type: LibraryDocs, sort: bool):
+        _paths: List[str] = os.listdir(self.input_dir.absolute())
+        _all_files = []
+        count: int = 0
+        if file_type == LibraryDocs.ALL:
+            # Todos os tipos de arquivos
+            for p in _paths:
+                if os.path.isfile(p):
+                    _all_files.append(
+                        File(os.path.abspath(p))
+                    )
+                    count += 1
+                    if count >= self.maxFiles:
+                        break
+        else:
+            # Arquivos especificados em LibraryDocs
+            for p in _paths:
+                if os.path.isfile(p):
+                    _path_file = Path(p)
+                    if (_path_file.suffix is None) or (_path_file.suffix == ''):
+                        continue
+                    if _path_file.suffix in file_type.value:
+                        _all_files.append(
+                            File(os.path.abspath(_path_file.absolute()))
+                        )
+                        count += 1
+                    if count >= self.maxFiles:
+                        break
+        if sort:
+            _all_files.sort(key=File.absolute)
+        return _all_files
+
+    def get_files(
+                self, *,
+                file_type: LibraryDocs = LibraryDocs.ALL_DOCUMENTS,
+                sort: bool = True,
+                recursive: bool = True
+            ) -> List[File]:
+        """
+            Retorna uma lista de File() de acordo com o tipo de arquivo
+        especificado.
+        - LibraryDocs.ALL_DOCUMENTS => Retorna todos os documentos do diretório.
+        - LibraryDocs.EXCEL         => Retorna arquivos que são planilhas excel.
+        - ...
+        
+        """
+        if recursive:
+            return self.__get_files_recursive(file_type=file_type, sort=sort)
+        else:
+            return self.__get_files_no_recursive(file_type=file_type, sort=sort)
+
+
+class JsonData(object):
+    """
+        Representação de um dado JSON apartir de uma string python.
+    """
+    def __init__(self, string:str):
+        if not isinstance(string, str):
+            raise ValueError(f'{__class__.__name__} o JSON informado precisa ser do tipo string, não {type(string)}')
+        self.jsonString:str = string
+        
+    def is_null(self) -> bool:
+        if (self.jsonString is None) or (self.jsonString == ''):
+            return True
+        return False
+       
+    def to_string(self) -> str:
+        return self.jsonString
+        
+    def to_dict(self) -> Dict[str, object]:
+        """
+            Exportar/Converter o dado atual em um dicionário python.
+        """
+        return json.loads(self.jsonString)
+
+    def to_file(self, f:File):
+        """Exportar o dado atual para um arquivo .json"""
+        _data:str = json.loads(self.jsonString)
+        with open(f.absolute(), "w", encoding="utf-8") as file:
+            json.dump(_data, file, indent=4, ensure_ascii=False)
+
+
+class JsonConvert(object):
+    """
+        Conversão de um dado JSON em dados python
+    """
+    def __init__(self, jsonData: JsonData):
+        self.jsonData: JsonData = jsonData
+        
+    def to_json_data(self) -> JsonData:
+        return self.jsonData
+    
+    @classmethod
+    def from_file(cls, file:File) -> JsonConvert:
+        """
+            Gerar um dado JsonData apartir de um arquivo .json
+        """
+        # Ler o arquivo e carregar o JSON em um dicionário Python
+        data = None
+        try:
+            with open(file.absolute(), "r", encoding="utf-8") as fp:
+                data:str = json.load(fp)
+        except Exception as e:
+            print(f'{__class__.__name__}\n{e}')
+            return cls(JsonData(''))
+        else:
+            #return JsonData(json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True))
+            return cls(JsonData(json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True)))
+    
+    @classmethod
+    def from_string_json(cls, data:str) -> JsonConvert:
+        """
+            Gerar um dado JsonData apartir de uma string.
+        """
+        json_string = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True)
+        return cls(JsonData(json_string))
+
+    @classmethod
+    def from_dict(cls, data:Dict[str, object]) -> JsonConvert:
+        """
+            Converte um dicionário em objeto JSON/JsonData.
+        """
+        if not isinstance(data, dict):
+            raise ValueError(f'{__class__.__name__} Informe um JSON em formato dict, não {type(data)}')
+        json_string = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True)
+        return cls(JsonData(json_string))
+    
+
+class UserFileSystem(object):
+    """
+        Diretórios comuns para cache e configurações de usuário.
+    """
+    def __init__(self, base_home:Directory=None):
+        if base_home is None:
+            self.baseHome:Directory = Directory(os.path.abspath(Path().home()))
+        elif isinstance(base_home, Directory):
+            self.baseHome:Directory = base_home
+        else:
+            raise ValueError(f'{__class__.__name__}\nUse:Directory(), não {type(base_home)}')
+        self.userDownloads:Directory = self.baseHome.concat('Downloads', create=True)
+        self.userVarDir:Directory = self.baseHome.concat('var', create=True)
+        
+    def config_dir(self) -> Directory:
+        return self.userVarDir.concat('config', create=True)
+    
+    def cache_dir(self) -> Directory:
+        return self.userVarDir.concat('cache', create=True)
+    
+    
+class UserAppDir(object):
+    """
+        Diretório comun para cache e configurações do aplicativo.
+    """
+    def __init__(self, appname:str, *, user_file_system:UserFileSystem=UserFileSystem()):
+        self.appname = appname
+        self.userFileSystem:UserFileSystem = user_file_system
+        self.workspaceDirApp:Directory = self.userFileSystem.userDownloads.concat(self.appname, create=True)
+        self.installDir:Directory = self.userFileSystem.userVarDir.concat('opt').concat(self.appname, create=True)
+        
+    def cache_dir_app(self) -> Directory:
+        return self.userFileSystem.cache_dir().concat(self.appname, create=True)
+    
+    def config_dir_app(self) -> Directory:
+        return self.userFileSystem.config_dir().concat(self.appname, create=True)
+    

soup_files-1.2.1/soup_files/progress.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+
+from abc import ABC, abstractmethod
+
+
+class ABCProgressBar(ABC):
+    """
+        Barra de progresso Abstrata
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._num_progress: float = 0
+        self.pbar_real: object = None
+
+    @property
+    def num_progress(self) -> float:
+        return self._num_progress
+
+    @num_progress.setter
+    def num_progress(self, new: float):
+        if isinstance(new, float):
+            self._num_progress = new
+            return
+        try:
+            _prog = float(new)
+        except Exception as e:
+            print(e)
+        else:
+            self._num_progress = _prog
+
+    @abstractmethod
+    def set_percent(self, percent: float):
+        """Seta o progresso com float de porcentagem, ex: '42.8'"""
+        pass
+
+    @abstractmethod
+    def set_text(self, text: str):
+        """Seta um texto indicando a situação atual"""
+        pass
+
+    def start(self):
+        """Inicia a barra de progresso (pode ser vazio dependendo da implementação)"""
+        pass
+
+    def stop(self):
+        """Para a barra de progresso (pode ser vazio dependendo da implementação)"""
+        pass
+
+
+class ProgressBarSimple(ABCProgressBar):
+    """Barra de progresso simples para mostrar no terminal."""
+
+    def __init__(self, simple_pbar=None):
+        super().__init__()
+        self.pbar_real = simple_pbar
+        self._text: str = 'Aguarde!'
+        self.num_progress: float = 0
+
+    def set_percent(self, percent: float):
+        if not isinstance(percent, float):
+            return
+        if len(f'{percent}') > 4:
+            percent = round(float(percent), 2)
+        self.num_progress = percent
+        #print(f'[{self.num_progress}%] {self._text}', end='\r')
+
+    def set_text(self, text: str):
+        self._text = text
+        print(f'[{self.num_progress}%] {self._text}', end='\r')
+
+    def start(self):
+        pass
+
+    def stop(self):
+        pass
+
+
+class ProgressBarAdapter(object):
+    def __init__(self, progress_bar: ABCProgressBar = ProgressBarSimple()):
+        self.pbar_implement: ABCProgressBar = progress_bar
+
+    def get_current_percent(self) -> float:
+        return self.pbar_implement.num_progress
+
+    def update_text(self, text: str = "-"):
+        self.pbar_implement.set_text(text)
+
+    def update_percent(self, percent: float = 0):
+        if not isinstance(percent, float):
+            try:
+                percent = float(percent)
+            except Exception as e:
+                print(f'{__class__.__name__} {e}')
+                percent = 0
+        self.pbar_implement.set_percent(percent)
+
+    def update(self, percent: float, status: str = "-"):
+        self.update_percent(percent)
+        self.update_text(status)
+        #self.pbar_implement.set_text(status)
+
+    def start(self):
+        self.pbar_implement.start()
+
+    def stop(self):
+        self.pbar_implement.stop()
+

soup_files-1.2.1/soup_files/version.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+
+__version__ = '1.2.1'

{soup_files-1.2 → soup_files-1.2.1}/soup_files.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soup_files
-Version: 1.2
+Version: 1.2.1
 Summary: soup_files
 Author: Bruno Chaves
 Requires-Python: >=3.11

{soup_files-1.2 → soup_files-1.2.1}/soup_files.egg-info/SOURCES.txt

@@ -1,5 +1,9 @@
 README.md
 pyproject.toml
+soup_files/__init__.py
+soup_files/files.py
+soup_files/progress.py
+soup_files/version.py
 soup_files.egg-info/PKG-INFO
 soup_files.egg-info/SOURCES.txt
 soup_files.egg-info/dependency_links.txt

soup_files-1.2.1/soup_files.egg-info/top_level.txt

@@ -0,0 +1 @@
+soup_files

soup_files-1.2/soup_files.egg-info/top_level.txt

@@ -1 +0,0 @@
-