ctbl 0.1.11__tar.gz

ctbl-0.1.11/.gitignore

@@ -0,0 +1,11 @@
+**/.vscode
+dist/
+build.txt
+.git
+**/__pycache__
+src/ctbl_tools/prob.py
+bin/
+lib/
+lib64
+pyvenv.cfg
+*.code-workspace

ctbl-0.1.11/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Cristian A. Bravo Lillo, cristian.bravo@gmail.com
+
+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.

ctbl-0.1.11/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: ctbl
+Version: 0.1.11
+Summary: A set of helpers classes for daily tasks.
+Author-email: Cristian Bravo Lillo <cristian.bravo@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# ctbl_tools: miscelaneous daily tasks helpers
+
+A package with miscelaneous classes meant to help at coding console helpers. Currently there are three classes:
+
+1. **config**: it implements a config file that saves itself. It is a specialization of [configparser](https://docs.python.org/3/library/configparser.html).
+2. **process**: it runs external processes, it saves the return code, and it helps (a little bit) to parse the standard output (or the standard error).
+3. **git**: a simple interface for git commands.
+
+## config: a self-preserving config file
+
+It implements a config file that saves itself.
+
+The idea is: we want to use a config file for an application, which is a simple text file that contains pairs of values, in a similar fashion to an INI file. If the file exists, it is used; if it doesn't, it is created. We use [configparser](https://docs.python.org/3/library/configparser.html) for this.
+
+An example:
+
+```python
+from ctbl_tools.config import config
+
+cfg = config(initpath = '~/somewhere/blabla.ini')
+cfg.create_section('my_configuration')
+cfg.set('my_configuration', 'x', 1)
+cfg.set('my_configuration', 'y', '2')
+```
+
+When the program above ends, it will save all created configuration to the file ~/somewhere/blabla.ini.
+
+## process: a helper to run external programs
+
+It runs an external program, and it stores the return code and both the standard output and standard error.
+
+You first create an object of this type:
+```python
+p = process()
+```
+
+Then run a command:
+```python
+p.run("whoami")
+```
+
+Immediately after you gain access to the return code, stdout and stderr:
+```python
+print(p.returncode)
+for line in p.stdout:
+  print(line)
+```
+
+You may check if return code was 0 (i.e., all good) by checking `p.is_ok()` to be true. You may also check whether there is any stdout or any stderr with `p.is_there_stdout()` and with `p.is_there_stderr()`, respectively.
+
+Finally you may extract information out of stdout by using `extract()`. This method receives a regular expression and a boolean that is true by default (meaning that you want to inspect stdout; if false it will inspect stderr instead). The method will look for all matches in each line of stdout and store them in a list. The list stores as many elements as lines stdout has, and each element is a list of all matches within the corresponding line.
+
+## git: a simple git interface
+
+It provides a simple programmatical interface to git.
+
+First, you create a git object by providing a local path to a repo:
+
+```python
+from ctbl_tools.git import git
+
+x = git("~/Dev/my_repo")
+```
+The previous will fail if provided path is not a git repo.
+
+Then you may either get the remote urls with `x.get_remote()`, or a get the status of the working tree by invoking `x.get_status()`.
+
+You may also do a commit with a list of files with `x.commit(list-of-files)`, or do a push (`x.git_push('my-commit-message')`) or a pull (`x.git_pull()`).
+
+This package also includes two auxiliary functions:
+
+* `git_clone(url:str, path:str)`: It clones `url` into `path`.
+* `is_git_url(url:str)`: It checks whether `url` is a valid git url.

ctbl-0.1.11/README.md

@@ -0,0 +1,73 @@
+# ctbl_tools: miscelaneous daily tasks helpers
+
+A package with miscelaneous classes meant to help at coding console helpers. Currently there are three classes:
+
+1. **config**: it implements a config file that saves itself. It is a specialization of [configparser](https://docs.python.org/3/library/configparser.html).
+2. **process**: it runs external processes, it saves the return code, and it helps (a little bit) to parse the standard output (or the standard error).
+3. **git**: a simple interface for git commands.
+
+## config: a self-preserving config file
+
+It implements a config file that saves itself.
+
+The idea is: we want to use a config file for an application, which is a simple text file that contains pairs of values, in a similar fashion to an INI file. If the file exists, it is used; if it doesn't, it is created. We use [configparser](https://docs.python.org/3/library/configparser.html) for this.
+
+An example:
+
+```python
+from ctbl_tools.config import config
+
+cfg = config(initpath = '~/somewhere/blabla.ini')
+cfg.create_section('my_configuration')
+cfg.set('my_configuration', 'x', 1)
+cfg.set('my_configuration', 'y', '2')
+```
+
+When the program above ends, it will save all created configuration to the file ~/somewhere/blabla.ini.
+
+## process: a helper to run external programs
+
+It runs an external program, and it stores the return code and both the standard output and standard error.
+
+You first create an object of this type:
+```python
+p = process()
+```
+
+Then run a command:
+```python
+p.run("whoami")
+```
+
+Immediately after you gain access to the return code, stdout and stderr:
+```python
+print(p.returncode)
+for line in p.stdout:
+  print(line)
+```
+
+You may check if return code was 0 (i.e., all good) by checking `p.is_ok()` to be true. You may also check whether there is any stdout or any stderr with `p.is_there_stdout()` and with `p.is_there_stderr()`, respectively.
+
+Finally you may extract information out of stdout by using `extract()`. This method receives a regular expression and a boolean that is true by default (meaning that you want to inspect stdout; if false it will inspect stderr instead). The method will look for all matches in each line of stdout and store them in a list. The list stores as many elements as lines stdout has, and each element is a list of all matches within the corresponding line.
+
+## git: a simple git interface
+
+It provides a simple programmatical interface to git.
+
+First, you create a git object by providing a local path to a repo:
+
+```python
+from ctbl_tools.git import git
+
+x = git("~/Dev/my_repo")
+```
+The previous will fail if provided path is not a git repo.
+
+Then you may either get the remote urls with `x.get_remote()`, or a get the status of the working tree by invoking `x.get_status()`.
+
+You may also do a commit with a list of files with `x.commit(list-of-files)`, or do a push (`x.git_push('my-commit-message')`) or a pull (`x.git_pull()`).
+
+This package also includes two auxiliary functions:
+
+* `git_clone(url:str, path:str)`: It clones `url` into `path`.
+* `is_git_url(url:str)`: It checks whether `url` is a valid git url.

ctbl-0.1.11/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tools", "src/cylon"]
+
+[project]
+name = "ctbl"
+version = "0.1.11"
+license = "MIT"
+authors = [
+	{ name = "Cristian Bravo Lillo", email = "cristian.bravo@gmail.com" },
+]
+description = "A set of helpers classes for daily tasks."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+	"Programming Language :: Python :: 3.8",
+	"License :: OSI Approved :: MIT License",
+	"Development Status :: 3 - Alpha",
+	"Environment :: Console",
+	"Operating System :: POSIX :: Linux",
+	"Topic :: Utilities",
+]

ctbl-0.1.11/src/cylon/__init__.py

@@ -0,0 +1,52 @@
+__all__ = ["cprint", "get_remote_folders"]
+
+import re
+import json
+from colorama import Fore, Style
+from tools.process import process
+
+#> -----------------------------------------------------------------------------------
+def cprint(arg:str, return_it:bool = False, end:str = "\n"):
+    """Prints colored output.
+    
+    This method prints colored output. The argument has to specify which substrings
+    should be colored through the following format:
+    
+    "... bla bla bla [r|this text will be in red] and [b|this one will go in blue]..."
+
+    Allowed colors are r (red), g (green), b (blue) and y (yellow)."""
+
+    arg = re.sub(r"\[R\|([^]]+?)\]", Fore.RED + Style.BRIGHT + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[G\|([^]]+?)\]", Fore.GREEN + Style.BRIGHT + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[B\|([^]]+?)\]", Fore.BLUE + Style.BRIGHT + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[Y\|([^]]+?)\]", Fore.YELLOW + Style.BRIGHT + r"\1" + Style.RESET_ALL, arg)
+
+    arg = re.sub(r"\[r\|([^]]+?)\]", Fore.RED + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[g\|([^]]+?)\]", Fore.GREEN + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[b\|([^]]+?)\]", Fore.BLUE + r"\1" + Style.RESET_ALL, arg)
+    arg = re.sub(r"\[y\|([^]]+?)\]", Fore.YELLOW + r"\1" + Style.RESET_ALL, arg)
+
+    if return_it:
+        return arg
+    else:
+        print(arg, end=end)
+        return None
+
+#> -----------------------------------------------------------------------------------
+def get_remote_folders(rmt_server:str, rmt_path:str, rmt_file:str = 'cylon.json') -> dict:
+    """
+    It gets all remote folders as a list, using the cylon convention.
+    
+    If rmt_server or rmt_path are empty, it returns an empty list.
+    """
+
+    if not rmt_server or not rmt_path:
+        raise ValueError("rmt_server and rmt_path must be non-empty strings")
+
+    tst = process()
+    tst.run(f"ssh {rmt_server} cat '{rmt_path}/{rmt_file}'")
+    if not tst.is_ok():
+        raise OSError(f"Cannot run ssh {rmt_server} cat '{rmt_path}/{rmt_file}'")
+
+    content = "\n".join(tst.stdout)
+    return json.loads(content)

ctbl-0.1.11/src/cylon/interface.py

@@ -0,0 +1,171 @@
+import sys, getopt
+import os.path
+import cylon
+
+class interface:
+    """Parsea la línea de comando, recupera los argumentos y opciones, y los guarda para consulta posterior en el diccionario 'model'.
+    'model' tiene dos elementos: 'opts', que es a su vez un diccionario con todas las opciones especificadas por CLI, y 'args', que guarda
+    los argumentos especificados. De momento estamos usando solo un argumento.
+    """
+    model = {}
+    verbose = False
+
+    def __init__(self, options:str = '') -> None:
+        """Toma cada uno de los caracteres en 'options' y revisa si recibió alguno como opción en la CLI. Si detecta una opción en la CLI
+        que no fue especificada en 'options', termina con un error."""
+
+        try:
+            opts,args = getopt.getopt(sys.argv[1:], options)
+
+        except getopt.GetoptError as err:
+            cylon.cprint(f"[r|{err}]. Giving up.\n")
+            exit(1)
+
+        self.model = {
+            'opts': {},
+            'args': args
+        }
+
+        for i in options:
+            self.model['opts'][i] = False
+
+        for opt,_ in opts:
+            opt = opt[1:]
+            self.model['opts'][opt] = True
+
+        if self.is_opt('v'):
+            self.verbose = True
+
+    def assert_command(self, comm:str) -> bool:
+        """Chequea si el comando en línea de comando es 'comm'."""
+        if self.model['args'] and len(self.model['args'])>0 and self.model['args'][0] == comm:
+            if self.verbose:
+                cylon.cprint(f"\b\b> {comm}")
+            return True
+        else:
+            return False
+
+    def is_opt(self, opt:str) -> bool:
+        """Chequea si la opción 'opt' fue indicada por CLI."""
+        return opt != "" and opt in self.model['opts'] and self.model['opts'][opt]
+
+    def output(self, msg:str, msg_v:str = ''):
+        """Si estamos en modo "simple", imprime 'msg'; si estamos en modo verboso, imprime 'msg_v'."""
+        cylon.cprint(msg) if not self.verbose else cylon.cprint(msg_v)
+
+    def ask_yes_no(self, txt:str, default:str = 'y', quit_if_yes:bool = False, quit_if_no:bool = False) -> str:
+        """Presenta el texto 'txt', y pregunta 'sí' (y) o 'no' (n). Usa 'default' para decidir cuál de las dos opciones es la
+        default; si el usuario no ingresa nada, se entiende que escoge la opción default."""
+        print(txt + " ", end='')
+
+        match default:
+            case 'y':
+                qst = "Y/n"
+            case 'n':
+                qst = "y/N"
+            case _:
+                qst = "y/n"
+
+        res = input(f"({qst}): ")
+
+        if res == '' and default in ['y','n']:
+            res = default
+
+        if (quit_if_yes and res=='y') or (quit_if_no and res=='n'):
+            print("OK, no problem")
+            exit(0)
+
+        return res
+
+    def ask_for_options(self, options:dict[str,str], question:str) -> str:
+        """Presenta la lista 'options' de forma numerada, luego presenta el texto 'question', y pide ingresar un número para las opciones.
+        El número 0 se usa para salir del menú."""
+        i=0
+
+        cylon.cprint("\t[b|quit> Quit!]\n")
+        for tmp in options:
+            cylon.cprint(f"\t[b|{tmp}> {options[tmp]}]\n")
+
+        key = ''
+        while key == '' or key not in options:
+            key = input(question + ' ')
+
+        if key == 'quit':
+            exit(0)
+
+        return key
+
+    def pick_remote(self, lcng):
+        if self.verbose:
+            self.ask_yes_no(f"Do I get options from {lcng.get_remote_url()}?", quit_if_no=True)
+        else:
+            self.ask_yes_no(f"Check {lcng.get_remote_url()}?", quit_if_no=True)
+
+        rmt = self.get_remote_folders(lcng)
+
+        # Cuantos remote folders tenemos?
+        match len(rmt):
+            # Si no hay ninguno, estamos jodidos
+            case 0:
+                cylon.cprint("[r|No cylons available]. Giving up.\n")
+                exit(0)
+
+            # Si hay un solo folder remoto, lo guardamos para preguntar si lo bajamos o no.
+            case 1:
+                self.ask_yes_no(f"Do I download {rmt[0]}?", quit_if_no=True)
+                whichone = rmt[0]
+
+            # Si hay más de uno, mostramos los que hay y preguntamos cuál se quiere bajar.
+            case _:
+                opt = self.ask_for_options(rmt, "Which one do I download?")
+                whichone = rmt[opt]
+        return whichone
+
+    def get_remote_folders(self, lcng):
+        out = False
+        rmt = {}
+
+        while not out:
+            rmt = cylon.get_remote_folders(lcng.get('remote_server'), lcng.get('remote_path'))
+            if not rmt:
+                self.ask_yes_no("No answer. Should I try again?", quit_if_no=True)
+            else:
+                out = True
+
+        return rmt
+
+    def pick_target(self, lcng, whichone):
+        # Preguntamos dónde tenemos que bajar el folder remoto
+        ok = False
+        target = ''
+
+        while not ok:
+            if self.verbose:
+                target = input(f"Where should I download {whichone} to? (~/lib by default): ")
+            else:
+                target = input("Where to? (~/lib by default): ")
+
+            if target == '':
+                target = '~/lib'
+
+            if os.path.exists(target):
+                self.output(
+                    f"{target} exists. Pick another.\n",
+                    f"[r|{target} already exists]. I refuse to overwrite it. Pick another folder.\n"
+                )
+            else:
+                ok = True
+        return target
+
+    def confirm_download(self, whichone, target):
+        self.output(
+            f"[y|{whichone}] -> [y|{target}]. ",
+            f"I'll download [b|{whichone}] to [b|{target}]. "
+        )
+        self.ask_yes_no("Is that OK?", quit_if_no=True)
+
+    def confirm_patching(self, folder):
+        if self.verbose:
+            self.ask_yes_no(f"Do I point the env var to {folder}?", default='y', quit_if_no=True)
+        else:
+            self.ask_yes_no(f"env var -> {folder}?", default='y', quit_if_no=True)

ctbl-0.1.11/src/cylon/skin.py

@@ -0,0 +1,141 @@
+"""It implements a copy of a cylon: a git package, retrieved from a source.
+
+A skin is a simply a set of folders and files to be put at the root of a user account in a server, with a set
+of instructions about what to do to deploy. For example, I would like to copy most files, and then create symbolic
+links to these files. Sometimes I would like to create certain files out of some content. All of these instructions
+are contained within a config file, that is implemented through cbl_tools/config.
+
+This class has no CLI interaction with the user.
+"""
+
+import os.path
+from datetime import datetime
+from tools import norm_path
+from tools.config import config
+from tools.process import process
+from tools.git import git
+
+class skin(config):
+
+    def __init__(self, path:str, touch_inifile:bool = False) -> None:
+        """It loads a skin located in path. Path should be the root of the cylon folder,
+        not the files/ folder which contains the ini file.
+
+        Loading a skin means to load a local folder, already downloaded from a source, and
+        reading the config file in order to check whether this copy is in good condition.
+        """
+        super().__init__(initpath=os.path.join(path, 'files/cylon.ini'), create_folder=False)
+
+        # Seteamos valores importantes en cylon.ini
+        self.set('local', 'home', os.getenv('HOME'))
+        self.set('local', 'sh', os.getenv('SHELL'))
+        self._set_value('uname -o', 'os')
+        self._set_value('uname -n', 'node')
+        self._set_value('uname -p', 'arch')
+
+        # Crea un objeto git y lo asocia a una variable interna
+        self.gitobj = git(self.get_dirname())
+        self.set('local', 'path', self.gitobj.local_path)
+
+        # Finalmente, registra un método que actualiza el valor de "last_modified"
+        if touch_inifile:
+            self.register(self._set_postvalue)
+
+    def _set_value(self, com:str, label:str) -> None:
+        p = process()
+        p.run(com)
+        if not p.is_ok() or not p.is_there_stdout():
+            raise OSError(f"Cannot run {com}")
+        self.set('local', label, p.stdout[0])
+
+    def _set_postvalue(self) -> None:
+        self.set('local', 'last_modified', datetime.now().strftime('%Y%m%d%H%M%S'))
+
+    def fix_links(self, color:bool = True) -> list:
+        """Checks all links in section "symlinks", and fixes them if they are not currently set.
+
+        The idea is: the section "symlinks" contains a set of pairs. The key is a symlink in the root of the user ("a link"),
+        and the value is a file within the "path" of the cylon folder ("the target"). This method checks whether the target
+        exists (if not, it complains), whether the link exists and is not a link (if not, it complains), and whether the link
+        indeed points to the target (if not, it corrects the link so it points to the target).
+        """
+
+        results = []
+        for key in self.options("symlinks"):
+            link = os.path.join(self.get("local", "home"), key)
+            target = norm_path(self.get('local', 'path'), self.get("symlinks", key))
+            result = {'link': link, 'target': target, 'OK':False}
+
+            if not os.path.exists(target):
+                result['OK'] = False
+                if color:
+                    result['msg'] = f"[r|Target {target} in config file does not exist]. Please check."
+                else:
+                    result['msg'] = f"Target {target} in config file does not exist. Please check."
+
+            elif os.path.exists(link) and not os.path.islink(link):
+                result['OK'] = False
+                if color:
+                    result['msg'] = f"[r|Link {link} mentioned in config file exists, and is not a link]. Please check."
+                else:
+                    result['msg'] = f"Link {link} mentioned in config file exists, and is not a link. Please check."
+
+            elif os.path.lexists(link) and os.path.realpath(link) != target:
+                os.remove(link)
+                result['OK'] = True
+                if color:
+                    result['msg'] = f"[r|{link} points to {os.path.realpath(link)} instead of {target}], so fixing it..."
+                else:
+                    result['msg'] = f"{link} points to {os.path.realpath(link)} instead of {target}, so fixing it..."
+
+            elif not os.path.exists(link):
+                os.symlink(target, link)
+                result['OK'] = True
+                if color:
+                    result['msg'] = f"[y|Creating {link} -> {target}]"
+                else:
+                    result['msg'] = f"Creating {link} -> {target}"
+            else:
+                result['OK'] = None
+                result['msg'] = "No change"
+
+            results.append(result)
+        return results
+
+    def fix_xdg_dirs(self) -> dict[str, list[str]]:
+        """Checks all user dirs, based on the xdg group. Returns a dict with two arrays: one for all stuff that went
+        well, and another for all that didn't.
+        
+        The idea is: the group "xdg" contains the user dirs, as defined by the unix manual "man xdg-user-dirs-update".
+        This method cycles through all keys in that section, and points them to the correct user dir. If the special
+        keyword "None" is used, that means that we don't want to have a dir for that, so that key is set to /dev/null.
+        """
+
+        p = process()
+        results = {
+            "Yes": [],
+            "No": []
+        }
+
+        for key in self.options("xdg"):
+
+            if self.get("xdg", key) == "None":
+                p.run(f"xdg-user-dirs-update --set {key} /dev/null")
+                if p.is_ok():
+                    results['Yes'].append(f"xdg:{key} set to None")
+                else:
+                    results['No'].append(f"xdg:{key} does not exist!")
+                continue
+
+            val = os.path.join(self.get("local", "path"), self.get("xdg", key))
+
+            if not os.path.exists(val):
+                results['No'].append(f"xdg:{key} points to non-existent file/folder!")
+            else:
+                p.run(f"xdg-user-dirs-update --set {key} {val}")
+                if p.is_ok():
+                    results['Yes'].append(f"xdg:{key} set to {val}")
+                else:
+                    results['No'].append(f"xdg:{key} does not exist!")
+
+        return results

ctbl-0.1.11/src/tools/__init__.py

@@ -0,0 +1,32 @@
+__all__ = ["create_tempdir", "norm_path", "is_file_readable"]
+
+import os.path
+import random
+import tempfile
+
+#> -----------------------------------------------------------------------------------
+def create_tempdir(mkdir:bool = False) -> str:
+    random.seed()
+ 
+    p = tempfile.gettempdir()
+    while True:
+        fld = "cbl-config-" + str(random.randint(100000, 999999))
+        thispath = os.path.join(p, fld)
+        if not os.path.exists(thispath):
+            break
+
+    if mkdir:
+        os.mkdir(thispath)
+
+    return thispath
+
+#> -----------------------------------------------------------------------------------
+def norm_path(*args) -> str:
+    if len(args) == 0 or not args[0]:
+        return ""
+    else:
+        return os.path.normpath(os.path.expanduser(os.path.join(*args)))
+
+#> -----------------------------------------------------------------------------------
+def is_file_readable(file:str) -> bool:
+    return file != "" and os.path.exists(file) and os.path.isfile(file) and os.access(file, os.R_OK)