datatypes 0.31.0__py3-none-any.whl

datatypes/config/environ/token.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+import string
+
+from ...token.base import Tokenizer, Token, Scanner
+
+
+class EnvironToken(Token):
+    """A parsed environ variable name and value
+
+    Fields each instance should have:
+
+        * `.name` - the variable name
+        * `.value` - the variable value
+        * `.start` - the offset this token's name started
+        * `.stop` - the offset this token's value stopped
+    """
+    def __init__(self, tokenizer, name, value, start, stop):
+        super().__init__(tokenizer, start, stop)
+
+        self.name = name
+        self.value = value
+
+
+class EnvironTokenizer(Tokenizer):
+    """Parses an environment file buffer and returns the key/value pairs as
+    EnvironToken instances
+
+    An environment file is a file that contains NAME=VALUE pairs. It ignores
+    all comments starting with the number sign (#)
+
+    .. Example:
+        with open("<ENVIRON-FILE-PATH>") as fp:
+            ts = EnvironTokenizer(fp, os.environ)
+            for t in ts:
+                print(t.name, t.value)
+    """
+    token_class = EnvironToken
+
+    def __init__(self, buffer, environ=None):
+        """
+        :param buffer: io.IOBase|str
+        :param environ: Mapping
+        """
+        super().__init__(Scanner(buffer))
+        self.environ = environ
+
+    def next(self):
+        """Get the next environment variable
+
+        :returns: EnvironToken
+        """
+        token = None
+        name = ""
+        value = ""
+
+        buffer = self.buffer
+        alphanum = string.ascii_letters + string.digits + "_"
+
+        # get the variable name
+        while True:
+            start = buffer.tell()
+            ch = buffer.read(1)
+
+            if ch == "":
+                # we've exhausted the buffer
+                break
+
+            elif ch == "#":
+                # read to the end of the line and discard
+                buffer.readline()
+
+            elif ch in string.whitespace:
+                buffer.read_thru(whitespace=True)
+
+            elif ch in string.ascii_letters:
+                name = ch + buffer.read_thru(chars=alphanum)
+
+                # ignore export statements
+                if name == "export":
+                    buffer.read_thru(whitespace=True)
+                    name = ""
+
+                else:
+                    break
+
+            else:
+                raise ValueError(
+                    f"Not sure what to do with char [{ch}]"
+                    " in environ variable name"
+                )
+
+        if name:
+            equal_sign = buffer.read(1)
+            if equal_sign != "=":
+                raise ValueError(
+                    f"Equal sign [=] was expected but got [{equal_sign}]"
+                )
+
+            sentinel = ""
+            multiline = False
+
+            while True:
+                ch = buffer.read(1)
+
+                if ch == "":
+                    # we've exhausted the buffer
+                    break
+
+                elif ch == "\\":
+                    multiline = True
+                    ch = buffer.read(1)
+
+                    if ch in string.whitespace:
+                        buffer.read_thru(whitespace=True)
+                        if value.endswith(" "):
+                            ch = ""
+
+                        else:
+                            ch = " "
+
+                    value += ch
+
+                elif ch == "\"" or ch == "'":
+                    if sentinel == ch:
+                        sentinel = ""
+
+                    else:
+                        sentinel = ch
+
+                elif ch == "$":
+                    ch = buffer.read(1)
+                    if ch == "{":
+                        variable_name = buffer.read_to(delim="}")
+                        buffer.read_thru(delim="}")
+
+                    else:
+                        variable_name = ch + buffer.read_thru(chars=alphanum)
+
+                    if self.environ:
+                        value += self.environ.get(variable_name, "")
+
+                elif ch == "#":
+                    if sentinel:
+                        value += ch
+
+                    else:
+                        # ignore the rest of the line since it's a comment
+                        buffer.readline()
+
+                        if multiline:
+                            buffer.read_thru(whitespace=True)
+                            multiline = False
+
+                        else:
+                            break
+
+                elif ch == "\n":
+                    # we are done grabbing the value
+                    break
+
+                else:
+                    value += ch
+
+            token = self.token_class(
+                self,
+                name,
+                value,
+                start,
+                buffer.tell()
+            )
+
+        return token
+

datatypes/config/parser.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from configparser import ConfigParser, ExtendedInterpolation
+import re
+
+from ..compat import *
+
+
+class ConfigInterpolation(ExtendedInterpolation):
+    """Internal class used by Config
+
+    https://github.com/python/cpython/blob/3.11/Lib/configparser.py#L361
+    """
+    def before_set_dict(self, parser, section, option, value):
+        if parser.path.endswith(".toml"):
+            values = []
+            for key, val in value.items():
+                val = self.before_set_value(parser, section, key, val)
+                values.append(f"{key} = {val}")
+
+            return "{" + ", ".join(values) + "}"
+
+        else:
+            return value
+
+    def before_get_dict(self, parser, section, option, value, defaults):
+        if parser.path.endswith(".toml"):
+            d = {}
+            regex = r"([a-zA-Z0-9_-]+)\s*=\s*([\"\[\{])"
+            for m in re.finditer(regex, value):
+                key = m.group(1)
+                sentinel = value[m.regs[2][0]:m.regs[2][1]]
+                start = m.regs[2][0]
+                stop = start + 1
+                while value[stop] != sentinel:
+                    if value[stop] == "\\":
+                        # skip escaped characters
+                        stop += 1
+                    stop += 1
+                stop += 1
+
+                d[key] = self.before_get(
+                    parser,
+                    section,
+                    key,
+                    value[start:stop],
+                    defaults
+                )
+
+            return d
+
+        else:
+            return value
+
+    def before_get_str(self, parser, section, option, value, defaults):
+        if parser.path.endswith(".toml"):
+            return value.strip("\"")
+
+        else:
+            return value
+
+    def before_set_str(self, parser, section, option, value):
+        if parser.path.endswith(".toml"):
+            return f"\"{value}\""
+
+        else:
+            return value
+
+    def before_set_list(self, parser, section, option, value):
+        if parser.path.endswith(".toml"):
+            values = []
+            for val in value:
+                val = self.before_set_value(parser, section, option, val)
+                values.append(f"  {val}")
+
+            return "[\n" + ",\n".join(values) + "\n]"
+
+        else:
+            return value
+
+    def before_get_list(self, parser, section, option, value, defaults):
+        if parser.path.endswith(".toml"):
+            l = []
+            cv = value.strip("[]").strip()
+            while cv:
+                sentinel = cv[0]
+                start = 0
+                stop = start + 1
+                while cv[stop] != sentinel:
+                    if cv[stop] == "\\":
+                        # skip escaped characters
+                        stop += 1
+                    stop += 1
+                stop += 1
+
+                l.append(self.before_get(
+                    parser,
+                    section,
+                    option,
+                    cv[start:stop],
+                    defaults
+                ))
+
+                cv = cv[stop:].strip(",").strip()
+
+            return l
+
+        else:
+            return value
+
+    def before_set_value(self, parser, section, option, value):
+        if value is not None:
+            if isinstance(value, Mapping):
+                value = self.before_set_dict(
+                    parser,
+                    section,
+                    option,
+                    value
+                )
+
+            elif isinstance(value, str):
+                value = self.before_set_str(
+                    parser,
+                    section,
+                    option,
+                    value
+                )
+
+            elif isinstance(value, Sequence):
+                value = self.before_set_list(
+                    parser,
+                    section,
+                    option,
+                    value
+                )
+
+            else:
+                value = str(value)
+
+        return value
+
+    def optionxform(self, parser, optionstr):
+        if parser.path.endswith(".toml"):
+            return optionstr
+
+        else:
+            return optionstr.lower()
+
+    def before_write(self, parser, section, option, value):
+        return super().before_write(parser, section, option, value)
+
+    def before_get(self, parser, section, option, value, defaults):
+        if value.startswith("{"):
+            return self.before_get_dict(
+                parser,
+                section,
+                option,
+                value,
+                defaults
+            )
+
+        elif value.startswith("["):
+            return self.before_get_list(
+                parser,
+                section,
+                option,
+                value,
+                defaults
+            )
+
+        elif value.startswith("\""):
+            return value.strip("\"")
+
+        else:
+            return super().before_get(parser, section, option, value, defaults)
+
+    def before_set(self, parser, section, option, value):
+        return super().before_set(parser, section, option, value)
+
+    def before_read(self, parser, section, option, value):
+        return super().before_read(parser, section, option, value)
+
+
+class Config(ConfigParser):
+    """Parse a configuration file
+
+    :Example:
+        c = Config("<PATH-TO-CONFIG-FILE>")
+        c["<SECTION-NAME>"]["<VALUE>"]
+
+    https://docs.python.org/3/library/configparser.html
+    """
+    def __init__(self, path, **kwargs):
+        from ..path import Filepath # avoid circular dependency
+        self.path = Filepath(path)
+        super().__init__(
+            interpolation=ConfigInterpolation()
+        )
+
+        if self.path.is_file():
+            self.read(path)
+
+    def optionxform(self, optionstr):
+        """Overrides parent to allow customization of the option value"""
+        return self._interpolation.optionxform(self, optionstr)
+
+    def read_dict(self, dictionary, source='<dict>'):
+        """Overrides parent to allow customization of the raw value
+
+        I had to copy this whole method body just to change one line because it
+        just casts value to str instead of allowing the value to be manipulated
+        in ._interpolation.before_set(). Sigh
+        """
+        elements_added = set()
+        for section, keys in dictionary.items():
+            section = str(section)
+            try:
+                self.add_section(section)
+
+            except (DuplicateSectionError, ValueError):
+                if self._strict and section in elements_added:
+                    raise
+
+            elements_added.add(section)
+            for key, value in keys.items():
+                key = self.optionxform(str(key))
+
+                # ADDED BY JAY
+                value = self._interpolation.before_set_value(
+                    self,
+                    section,
+                    key,
+                    value
+                )
+
+                if self._strict and (section, key) in elements_added:
+                    raise DuplicateOptionError(section, key, source)
+
+                elements_added.add((section, key))
+                self.set(section, key, value)
+
+    def write(self):
+        with self.path.open("w") as fp:
+            super().write(fp)
+
+    def _write_section(self, fp, section_name, section_items, delimiter):
+        """Overrides parent to ignore empty sections"""
+        if section_items:
+            super()._write_section(fp, section_name, section_items, delimiter)
+
+    def jsonable(self):
+        d = {}
+        for k in self:
+            d[k] = dict(self[k])
+
+        return d
+