soup-files 1.0.1__py3-none-any.whl → 1.2__py3-none-any.whl

soup_files-1.2.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: soup_files
+Version: 1.2
+Summary: soup_files
+Author: Bruno Chaves
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# soup_files
+

soup_files-1.2.dist-info/RECORD

@@ -0,0 +1,4 @@
+soup_files-1.2.dist-info/METADATA,sha256=MLZFMkC5m0e76krmmDZkyRCF2S3hsrHbRLFiTlWUpyg,172
+soup_files-1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+soup_files-1.2.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+soup_files-1.2.dist-info/RECORD,,

{soup_files-1.0.1.dist-info → soup_files-1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

soup_files-1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+

soup_files/__init__.py

@@ -1,3 +0,0 @@
-#!/usr/bin/env python3
-
-from .soup_files import *

soup_files/soup_files.py

@@ -1,403 +0,0 @@
-#!/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
-
-__version__ = '1.0'
-
-# 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_files(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 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(self, *, file_type:LibraryDocs = LibraryDocs.ALL_DOCUMENTS, sort: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.
-        - ...
-        
-        """
-        _paths = 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(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(p.absolute()))
-                    count += 1
-                if count >= self.maxFiles:
-                    break
-        if sort == True:
-            _all_files.sort(key=File.absolute)
-        return _all_files
-
-
-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.0.1.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: soup-files
-Version: 1.0.1
-Summary: Leitura e manipulação de arquivos
-Author: Bruno
-License: MIT
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
-# file-utils
-
-# Uso
-from soup_files import File, Directory
-
-filename:str = 'path/to/file'
-dirpath:str = 'path/to/dir'
-
-f = File(filename)
-d = Directory(dirpath)

soup_files-1.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-soup_files/__init__.py,sha256=O9oM7fGDdnzHAhpsxXSqO_SH2yMn2O_6t0n2EyyzOFY,49
-soup_files/soup_files.py,sha256=JhigMvXDorHa_2io-kJSTmX8Z2U7B8MoGV5NOj9mXds,12891
-soup_files-1.0.1.dist-info/METADATA,sha256=ixYhA3xag-tz-mIwO2cegFzOHaFZ08fKR2DN9EoSG-4,352
-soup_files-1.0.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-soup_files-1.0.1.dist-info/top_level.txt,sha256=CBSaCdIqL_Rlkr74APmmI0kXkPK9pVf6HTlOPZ-Kk4E,11
-soup_files-1.0.1.dist-info/RECORD,,

soup_files-1.0.1.dist-info/top_level.txt

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