ctbl 0.1.11__py3-none-any.whl

ctbl-0.1.11.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+cylon/__init__.py,sha256=y53Q0TRluziSSKygMFzCCMsbOjlLsrQxiE-JM9j4kLg,2122
+cylon/interface.py,sha256=tRVOIEzOoDm_5d-lWd7V1dLip5kvJ3RatydRKTDBWVQ,5993
+cylon/skin.py,sha256=qRAp3Xa1W--RGFDlEoUvP7EOhH25saULqoW2R6qfbTc,6339
+tools/__init__.py,sha256=jk6C-Ht-VrJ8DU_9slDWEQSuDHsWhNG_W-HawB37r7A,1022
+tools/config.py,sha256=VnCGvIX8whWAv1Mybsh-0jcuNa0TS6VBo2y7XfSQFS4,4262
+tools/exceptions.py,sha256=aI0JXEHrPyScHD5d73XtXFK7QD4mp29QZhuY-Qe8SZI,178
+tools/git.py,sha256=Jz6mnWPbeDaWvtJ6RHlstIfAPwP1lSlT100nwP8n3hQ,7466
+tools/prob.py,sha256=VopW8sM5kthyhQ6s1V0U3B-BDBDFDhw4bQ3SZ1maFFU,991
+tools/process.py,sha256=xr2vYu3wGvZKWuHVQD4urTNNAhn7lAKt1RAKZIBD6lY,2797
+ctbl-0.1.11.dist-info/METADATA,sha256=sXb0QGqXYrhB3aMQdYq0qOfaWoGwnxkaEPj5fGZvLYY,3636
+ctbl-0.1.11.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ctbl-0.1.11.dist-info/licenses/LICENSE,sha256=v9QcLF_Lav1RCnJPMKZB_b7wQ6AGgiRwg5SdlvhfTMk,1106
+ctbl-0.1.11.dist-info/RECORD,,

ctbl-0.1.11.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ctbl-0.1.11.dist-info/licenses/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.

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)

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)

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

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)

tools/config.py

@@ -0,0 +1,101 @@
+"""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 for this.
+
+This class has just one public variable: path, which is the absolute path formed by initpath and filename, arguments to the constructor of the class.
+
+_values is the configparser where one will find all the values that were read, if present. I'm not sure if I should make it public though.
+"""
+
+import os
+import atexit
+import errno
+import configparser
+from typing import Callable, Optional
+from configparser import ExtendedInterpolation
+from tools.exceptions import *
+
+class config(configparser.ConfigParser):
+
+    path:str = ""
+
+    def __init__(self, initpath:str = '~/.config/config.ini', create_folder:bool = True, default_section:str = 'default') -> None:
+        """It creates a config file.
+
+        To create the file, we specify its path (by default, '~/.config/config.ini'). The last folder within the path may not exist,
+        in which case it will be created. Neither initpath nor filename could be empty (an OSError will be raised). We can also specify whether an inexistent folder
+        should be created with create_folder (by default, True).
+
+        If thispath is empty it raises an error. If the last portion of thispath doesn't exist and create_folder is False, it raises a FileNotFoundError
+        since we're being asked to use a folder that doesn't exist, and we're being told not to create it.
+
+        Finally, if a file exists in initpath, it's read and put into self.values. If it doesn't exist, it will be created when the
+        program is terminated, or when flush() is invoked.
+        """
+
+        if not initpath:
+            raise EmptyValueError("initpath must not be empty")
+
+        folder,filename = os.path.split(os.path.normpath(os.path.expanduser(initpath)))
+
+        if not os.path.exists(folder) and not create_folder:
+            raise FileNotFoundError(errno.ENOENT, "path does not exist and create_folder is False", folder)
+
+        try:
+            if not os.path.exists(folder) and create_folder:
+                os.mkdir(folder, 0o700)
+
+        except FileNotFoundError:
+            raise FileNotFoundError(errno.ENOENT, "one or more of the parent folders in thispath don't exist, and won't be created", folder)
+
+        except PermissionError:
+            raise PermissionError(errno.EACCES, "cannot create folder: permission denied", folder)
+
+        self.path = os.path.join(folder, filename)
+
+        if os.path.exists(self.path) and not os.path.isfile(self.path):
+            raise NotAFileError("last part of initpath already exists, and it's not a file")
+
+        # If path goes out of normalized init_path, the user may be abusing this class, so we ban it
+        if os.path.commonpath([self.path, initpath]) != initpath:
+            raise ValueError(f"filename ({filename}) is relative to initpath ({initpath}), and it should be within it, but it's not ({self.path})")
+
+        super().__init__(delimiters=('='), comment_prefixes=('#'), interpolation=ExtendedInterpolation(), default_section=default_section)
+        # self.optionxform = str
+
+        # Si el archivo existe, hay que leerlo
+        if os.path.exists(self.path):
+            super().read(self.path)
+
+        self.register(self._flush)
+
+    def __str__(self) -> str:
+        return f"<{__class__.__name__} object; path={self.path}>"
+
+    def _flush(self) -> None:
+        f = open(self.path, "w")
+        self.write(f)
+        f.close()
+
+    def get_dirname(self) -> str:
+        if self.path:
+            return os.path.dirname(self.path)
+        else:
+            return ""
+
+    def get_filename(self) -> str:
+        if self.path:
+            return os.path.basename(self.path)
+        else:
+            return ""
+
+    def register(self, func:Callable) -> None:
+        atexit.register(func)
+
+    def section(self, section:str) -> dict:
+        "It returns all the values in a section, but as a dict instead of a list of tuples."
+        sct = {}
+        for x,y in self.items(section):
+            sct[x] = y
+        return sct

tools/exceptions.py

@@ -0,0 +1,12 @@
+
+class ValueExistsError(ValueError):
+    pass
+
+class EmptyValueError(ValueError):
+    pass
+
+class MissingValueError(ValueError):
+    pass
+
+class NotAFileError(OSError):
+    pass

tools/git.py

@@ -0,0 +1,222 @@
+"""It provides a simple programmatical interface to git.
+
+First, you create a git object by providing a local path to a repo:
+
+```python
+from cbl_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.
+* `is_git_folder(path:str, return_folder:bool = False)`: It checks whether `path` is a cylon folder or one of its subfolders. If `return_folder` is False,
+  it returns a boolean with the result. Otherwise, it returns the path of the root of the cylon folder.
+"""
+import re
+import errno
+import os.path
+from tools import process
+from tools import norm_path
+from tools.exceptions import EmptyValueError
+
+
+def git_clone(url:str, path:str) -> bool:
+    """It clones url to the local path."""
+
+    path = norm_path(path)
+    if os.path.exists(path):
+        raise FileExistsError(f"{path} already exists")
+
+    if not is_git_url(url):
+        raise ValueError(f"{url} is not a valid git url")
+
+    p = process.process()
+    p.run(f"git clone {url} {path}")
+    return p.is_ok()
+
+def is_git_url(url:str)-> bool:
+    """It tests url to be one of the five valid url-like git strings."""
+    if not url:
+        raise EmptyValueError("empty url")
+
+    allw = r"[\w\-\d\.]"
+    user = fr"({allw}+@)"
+    host = fr"{allw}+(\.{allw}+)+"
+    port = r"(:\d+)"
+    path = fr"(/{allw}+)*"
+
+    # Type of URL #1: via SSH
+    if re.fullmatch(fr"ssh://{user}?{host}{port}?{path}", url):
+        return True
+
+    # Type of URL #2: via HTTP(S), FTP(S), or via a pseudo-url with GIT as protocol
+    if re.fullmatch(fr"((ht|f)tps?|git)://{user}?{host}{port}?{path}", url):
+        return True
+
+    # Type of URL #3: via user and host, which is for a private server
+    if re.fullmatch(fr"{user}?{host}:~?{allw}+{path}", url):
+        return True
+
+    return False
+
+def is_git_folder(path:str) -> bool:
+
+    # We run a rev-parse
+    path = norm_path(path)
+    p = process.process()
+    p.run(f"git -C {path} rev-parse --absolute-git-dir")
+
+    # If there was something wrong, it's not a git folder
+    if not p.is_ok() or p.is_there_stderr() or not p.is_there_stdout():
+        return False
+
+    # We split the returned line and check if there is a dir there
+    is_git = os.path.isdir(os.path.dirname(p.stdout[0])) and os.path.basename(p.stdout[0]) == '.git'
+
+    # if return_folder and is_git:
+    #     return os.path.dirname(p.stdout[0])
+
+    # if return_folder:
+    #     return None
+
+    return is_git
+
+
+class git:
+
+    local_path:str = ""
+    remote_path:dict = {}
+
+    def __init__(self, path:str) -> None:
+        """This method takes a local path and treats it as if it were a cylon repo;
+        that is, it expects to find a git repo, with a files/ folder and a cylon.
+        """
+        # If normed path is not a folder, we reject it
+        path = norm_path(path)
+        if not os.path.isdir(path):
+            raise NotADirectoryError(errno.ENOTDIR, f"{path} is not a folder", path)
+
+        # We ask if it's a git folder
+        if not is_git_folder(path):
+            raise ValueError("Argument is not a git folder")
+
+        p = process.process()
+        p.run(f"git -C {path} rev-parse --absolute-git-dir")
+
+        if not p.is_ok() or not p.is_there_stdout() or p.is_there_stderr():
+            raise ValueError("Internal inconsistency in the arguments")
+
+        self.local_path = os.path.dirname(p.stdout[0])
+
+    def get_remote(self) -> dict:
+        """It retrieves the list of remote repositories (usually just one), with their 'fetch' and 'push'
+        URLs (usually the same). It returns (and stores within self.remote_path) a dictionary with the
+        following structure:
+
+        name-of-repo -> {
+            'fetch' -> ['username', 'server', 'path'],
+            'push' -> ['username', 'server', 'path']
+        }
+        """
+
+        p = process.process()
+        p.run(f"git -C {self.local_path} remote -v")
+
+        if not p.is_ok() or p.is_there_stderr() or not p.is_there_stdout():
+            return {}
+
+        res = {}
+        for line in p.stdout:
+            x = re.fullmatch(r"(\w+)\t(\S+)\s\((fetch|push)\)", line)
+            if x:
+                if not x.group(1) in res:
+                    res[x.group(1)] = {}
+                res[x.group(1)][x.group(3)] = self._url_split(x.group(2))
+        self.remote_path = res
+        return res
+
+    def _url_split(self, arg:str) -> list:
+        tst = re.search(r"([^@]+?)@([^:]+?):(.+)", arg)
+
+        if tst:
+            url_user = tst.group(1)
+            url_domain = tst.group(2)
+            url_path = tst.group(3)
+
+            if url_path.startswith("~" + url_user):
+                url_path = '~' + url_path[len(url_user)+1:]
+            return [url_user, url_domain, url_path]
+        else:
+            return [None, None, arg]
+
+    def get_url(self, arg:str = "") -> str:
+        """If self.remote_path has been populated, it returns the remote url for the only repo;
+        otherwise, it returns an empty string. If there is more than one repo, you should provide its name
+        as argument; otherwise, it returns an empty string."""
+        if not self.remote_path:
+            return ""
+
+        if len(self.remote_path)>1:
+            if arg == '':
+                return ""
+            ln = self.remote_path[arg]
+        else:
+            ln = self.remote_path[list(self.remote_path.keys())[0]]
+
+        return ln[0] + '@' + ln[1] + ':' + ln[2]
+
+    def get_status(self) -> dict:
+        """It gets the status of the working tree in the porcelain v1 format (described
+        in the git manual for status). It returns a dictionary (possibly empty). The keys
+        of the dict are the XY codes described for the porcelain v1 format, while the
+        elements are simple lists with paths of the corresponding files."""
+        p = process.process()
+        p.run(f"git -C {self.local_path} status --porcelain")
+        if not p.is_ok() or not p.is_there_stdout():
+            return {}
+
+        res = {}
+        for line in p.stdout:
+            x = re.fullmatch(r"(.{2})\s(.+)", line)
+            if x:
+                if not x.group(1) in res:
+                    res[x.group(1)] = []
+                res[x.group(1)].append(x.group(2))
+
+        return res
+
+    def git_add(self, include_new:bool = False) -> bool:
+        if include_new:
+            opt = '-A'
+        else:
+            opt = '-u'
+
+        p = process.process()
+        p.run(f"git -C {self.local_path} add {opt}")
+        return p.is_ok()
+
+    def git_commit(self, msg:str = '') -> process.process:
+        if not msg:
+            msg = 'Automatic commit by cbl_tools.git.commit()'
+
+        p = process.process()
+        p.run(f"git -C {self.local_path} commit -m '{msg}'")
+        return p
+
+    def git_push(self) -> process.process:
+        p = process.process()
+        p.run(f"git -C {self.local_path} push --all")
+        return p
+
+    def git_pull(self) -> process.process:
+        p = process.process()
+        p.run(f"git -C {self.local_path} pull")
+        return p

tools/prob.py

@@ -0,0 +1,36 @@
+from itertools import combinations
+
+def p_any(lst, vrb = False):
+
+    if vrb:
+        print("Recibido:", lst)
+
+    sm = sum(lst)
+
+    if vrb:
+        for i in range(0, len(lst)):
+            print(lst[i], " + ", sep="", end="")
+        print("")
+
+    sk = 1
+    for x in range(len(lst), 1, -1):
+        tuplet = list(combinations(lst, x))
+        sk *= -1
+        for y in tuplet:
+            mlt = 1
+            if vrb:
+                print("\t+", sk, end="")
+            for z in range(0, len(y)):
+                mlt *= y[z]
+                if vrb:
+                    print(" * ", y[z], sep="", end="")
+            sm += sk * mlt
+            if vrb:
+                print("")
+
+    return sm
+
+drupal = [.9757, .9754, .9746, .9658, .9286, .9271, .9237, .6823, .4359, .1694, 0.0678, 0.0612, 0.0557, 0.0397, 0.0363, 0.0275, 0.019, 0.0142]
+wordpress = [.0033, .0025, .0016, .0016, .0016, .0014, .0012, .0009, .0008, .0005, .0004]
+wagtail = [.0011, .0009]
+print("\n", p_any(wordpress, True))

tools/process.py

@@ -0,0 +1,85 @@
+"""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:
+> p = process()
+
+Then run a command:
+> p.run("whoami")
+
+Immediately after you gain access to the return code, stdout and stderr:
+> 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 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.
+"""
+
+import re
+import subprocess
+
+class process:
+
+    def __init__(self) -> None:
+        self.reset()
+
+    def reset(self) -> None:
+        self.command = ""
+        self.returncode = -1
+        self.stdout = []
+        self.stderr = []
+
+    def __str__(self) -> str:
+        if not self.command:
+            return "<Empty tools.process object>"
+        else:
+            out = f"({self.command})->{self.returncode}\n"
+            if self.stdout:
+                out += ''.join(map(lambda x: 'O: '+x+'\n', self.stdout))
+            if self.stderr:
+                out += ''.join(map(lambda x: 'E: '+x+'\n', self.stderr))
+            return out
+
+    def run(self, comm:str, fail_if_not_ok:bool = False) -> None:
+        cp = subprocess.run(comm, shell=True, capture_output=True, text=True)
+        self.command = comm
+        self.returncode = cp.returncode
+        if cp.stdout != '':
+            self.stdout = cp.stdout.rstrip(" \n").split("\n")
+        if cp.stderr != '':
+            self.stderr = cp.stderr.rstrip(" \n").split("\n")
+        if fail_if_not_ok and not self.is_ok():
+            print(self)
+            exit(1)
+
+    def is_ok(self) -> bool:
+        return self.returncode == 0
+
+    def is_there_stdout(self) -> bool:
+        return len(self.stdout)>0
+
+    def is_there_stderr(self) -> bool:
+        return len(self.stderr)>0
+
+    def extract(self, pat:str, stdout:bool = True, join:bool = True) -> list:
+        wheretolook = self.stdout if stdout else self.stderr
+        if not wheretolook:
+            return []
+
+        pattern = re.compile(pat)
+
+        if join:
+            return pattern.findall("".join(wheretolook))
+        else:
+            lst = []
+            for line in wheretolook:
+                lst.append(pattern.findall(line))
+            return lst