json-database 0.8.0a1__py3-none-any.whl

json_database/utils.py

@@ -0,0 +1,340 @@
+import json
+from difflib import SequenceMatcher
+
+
+class DummyLock:
+    """ A fake lock.
+
+    Arguments:
+        path (str): path to the lockfile for the lock
+    """
+    def __init__(self, path=""):
+        self.path = path
+
+    def acquire(self, blocking=True):
+        """ Acquire lock, locks thread and process lock.
+
+        Arguments:
+            blocking(bool): Set's blocking mode of acquire operation.
+                            Default True.
+
+        Returns: True if lock succeeded otherwise False
+        """
+        return True
+
+    def release(self):
+        """ Release acquired lock. """
+        pass
+
+    def __enter__(self):
+        """ Context handler, acquires lock in blocking mode. """
+        return self
+
+    def __exit__(self, _type, value, traceback):
+        """ Releases the lock. """
+        pass
+
+
+def fuzzy_match(x, against):
+    """Perform a 'fuzzy' comparison between two strings.
+    Returns:
+        float: match percentage -- 1.0 for perfect match,
+               down to 0.0 for no match at all.
+    """
+    return SequenceMatcher(None, x, against).ratio()
+
+
+def match_one(query, choices):
+    """
+        Find best match from a list or dictionary given an input
+
+        Arguments:
+            query:   string to test
+            choices: list or dictionary of choices
+
+        Returns: tuple with best match, score
+    """
+    if isinstance(choices, dict):
+        _choices = list(choices.keys())
+    elif isinstance(choices, list):
+        _choices = choices
+    else:
+        raise ValueError('a list or dict of choices must be provided')
+
+    best = (_choices[0], fuzzy_match(query, _choices[0]))
+    for c in _choices[1:]:
+        score = fuzzy_match(query, c)
+        if score > best[1]:
+            best = (c, score)
+
+    if isinstance(choices, dict):
+        return (choices[best[0]], best[1])
+    else:
+        return best
+
+
+def merge_dict(base, delta, merge_lists=True, skip_empty=True,
+               no_dupes=True, new_only=False):
+    """
+        Recursively merging configuration dictionaries.
+
+        Args:
+            base:  Target for merge
+            delta: Dictionary to merge into base
+            merge_lists: if a list is found merge contents instead of replacing
+            skip_empty: if an item in delta is empty, dont overwrite base
+            no_dupes: when merging lists deduplicate entries
+            new_only: only merge keys not yet in base
+    """
+
+    for k, d in delta.items():
+        b = base.get(k)
+        if isinstance(d, dict) and isinstance(b, dict):
+            merge_dict(b, d, merge_lists, skip_empty, no_dupes, new_only)
+        else:
+            if new_only and k in base:
+                continue
+            if skip_empty and not d and d is not False:
+                # dont replace if new entry is empty
+                pass
+            elif all((isinstance(b, list), isinstance(d, list), merge_lists)):
+                if no_dupes:
+                    base[k] += [item for item in d if item not in base[k]]
+                else:
+                    base[k] += d
+            else:
+                base[k] = d
+    return base
+
+
+def load_commented_json(filename):
+    """ Loads an JSON file, ignoring comments
+
+    Supports a trivial extension to the JSON file format.  Allow comments
+    to be embedded within the JSON, requiring that a comment be on an
+    independent line starting with '//' or '#'.
+
+    NOTE: A file created with these style comments will break strict JSON
+          parsers.  This is similar to but lighter-weight than "human json"
+          proposed at https://hjson.org
+
+    Args:
+        filename (str):  path to the commented JSON file
+
+    Returns:
+        obj: decoded Python object
+    """
+    with open(filename, encoding='utf-8') as f:
+        contents = f.read()
+
+    return json.loads(uncomment_json(contents))
+
+
+def uncomment_json(commented_json_str):
+    """ Removes comments from a JSON string.
+
+    Supporting a trivial extension to the JSON format.  Allow comments
+    to be embedded within the JSON, requiring that a comment be on an
+    independent line starting with '//' or '#'.
+
+    Example...
+       {
+         // comment
+         'name' : 'value'
+       }
+
+    Args:
+        commented_json_str (str):  a JSON string
+
+    Returns:
+        str: uncommented, legal JSON
+    """
+    lines = commented_json_str.splitlines()
+    # remove all comment lines, starting with // or #
+    nocomment = []
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith("//") or stripped.startswith("#"):
+            continue
+        nocomment.append(line)
+
+    return " ".join(nocomment)
+
+
+def is_jsonifiable(thing):
+    if not isinstance(thing, dict):
+        if isinstance(thing, str):
+            try:
+                json.loads(thing)
+                return True
+            except:
+                pass
+        else:
+            try:
+                thing.__dict__
+                return True
+            except:
+                pass
+        return False
+    return True
+
+
+def get_key_recursively(search_dict, field, filter_None=True):
+    """
+    Takes a dict with nested lists and dicts,
+    and searches all dicts for a key of the field
+    provided.
+    """
+    if not is_jsonifiable(search_dict):
+        raise ValueError("unparseable format")
+    fields_found = []
+
+    for key, value in search_dict.items():
+        if value is None and filter_None:
+            continue
+        if key == field:
+            fields_found.append(search_dict)
+
+        elif isinstance(value, dict):
+            fields_found += get_key_recursively(value, field, filter_None)
+
+        elif isinstance(value, list):
+            for item in value:
+                if not isinstance(item, dict):
+                    try:
+                        if get_key_recursively(item.__dict__, field, filter_None):
+                            fields_found.append(item)
+                    except:
+                        continue  # can't parse
+                else:
+                    fields_found += get_key_recursively(item, field, filter_None)
+
+    return fields_found
+
+
+def get_key_recursively_fuzzy(search_dict, field, thresh=0.6, filter_None=True):
+    """
+    Takes a dict with nested lists and dicts,
+    and searches all dicts for a key of the field
+    provided.
+    """
+    if not is_jsonifiable(search_dict):
+        raise ValueError("unparseable format")
+
+    fields_found = []
+
+    for key, value in search_dict.items():
+        if value is None and filter_None:
+            continue
+        score = 0
+        if isinstance(key, str):
+            score = fuzzy_match(key, field)
+
+        if score >= thresh:
+            fields_found.append((search_dict, score))
+        elif isinstance(value, dict):
+            fields_found += get_key_recursively_fuzzy(value, field, thresh, filter_None)
+
+        elif isinstance(value, list):
+            for item in value:
+                if not isinstance(item, dict):
+                    try:
+                        if get_key_recursively_fuzzy(item.__dict__, field, thresh, filter_None):
+                            fields_found.append((item, score))
+                    except:
+                        continue  # can't parse
+                else:
+                    fields_found += get_key_recursively_fuzzy(item, field, thresh, filter_None)
+    return sorted(fields_found, key = lambda i: i[1],reverse=True)
+
+
+def get_value_recursively(search_dict, field, target_value):
+    """
+    Takes a dict with nested lists and dicts,
+    and searches all dicts for a key of the field
+    provided.
+    """
+    if not is_jsonifiable(search_dict):
+        raise ValueError("unparseable format")
+    fields_found = []
+
+    for key, value in search_dict.items():
+
+        if key == field and value == target_value:
+            fields_found.append(search_dict)
+
+        elif isinstance(value, dict):
+            fields_found += get_value_recursively(value, field, target_value)
+
+        elif isinstance(value, list):
+            for item in value:
+                if not isinstance(item, dict):
+                    try:
+                        if get_value_recursively(item.__dict__, field, target_value):
+                            fields_found.append(item)
+                    except:
+                        continue  # can't parse
+                else:
+                    fields_found += get_value_recursively(item, field, target_value)
+
+    return fields_found
+
+
+def get_value_recursively_fuzzy(search_dict, field, target_value, thresh=0.6):
+    """
+    Takes a dict with nested lists and dicts,
+    and searches all dicts for a key of the field
+    provided.
+    """
+    if not is_jsonifiable(search_dict):
+        raise ValueError("unparseable format")
+    fields_found = []
+    for key, value in search_dict.items():
+        if key == field:
+            if isinstance(value, str):
+                score = fuzzy_match(target_value, value)
+                if score >= thresh:
+                    fields_found.append((search_dict, score))
+            elif isinstance(value, list):
+                for item in value:
+                    score = fuzzy_match(target_value, item)
+                    if score >= thresh:
+                        fields_found.append((search_dict, score))
+        elif isinstance(value, dict):
+            fields_found += get_value_recursively_fuzzy(value, field, target_value, thresh)
+
+        elif isinstance(value, list):
+            for item in value:
+                if not isinstance(item, dict):
+                    try:
+                        found = get_value_recursively_fuzzy(item.__dict__, field, target_value, thresh)
+                        if len(found):
+                            fields_found.append((item, found[0][1]))
+                    except:
+                        continue  # can't parse
+                else:
+                    fields_found += get_value_recursively_fuzzy(item, field, target_value, thresh)
+
+    return sorted(fields_found, key = lambda i: i[1],reverse=True)
+
+
+def jsonify_recursively(thing):
+    if isinstance(thing, list):
+        jsonified = list(thing)
+        for idx, item in enumerate(thing):
+            jsonified[idx] = jsonify_recursively(item)
+    elif isinstance(thing, dict):
+        try:
+            # can't import at top level to do proper check
+            jsonified = dict(thing.db)
+        except:
+            jsonified = dict(thing)
+        for key in jsonified.keys():
+            value = jsonified[key]
+            jsonified[key] = jsonify_recursively(value)
+    else:
+        try:
+            jsonified = thing.__dict__
+        except:
+            jsonified = thing
+    return jsonified

json_database/version.py

@@ -0,0 +1,6 @@
+# START_VERSION_BLOCK
+VERSION_MAJOR = 0
+VERSION_MINOR = 8
+VERSION_BUILD = 0
+VERSION_ALPHA = 1
+# END_VERSION_BLOCK

json_database/xdg_utils.py

@@ -0,0 +1,174 @@
+# Copyright © 2016-2021 Scott Stevenson <scott@stevenson.io>
+#
+# Permission to use, copy, modify, and/or distribute this software for
+# any purpose with or without fee is hereby granted, provided that the
+# above copyright notice and this permission notice appear in all
+# copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+# AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+# DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+# PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+
+"""XDG Base Directory Specification variables.
+
+xdg_cache_home(), xdg_config_home(), xdg_data_home(), and xdg_state_home()
+return pathlib.Path objects containing the value of the environment variable
+named XDG_CACHE_HOME, XDG_CONFIG_HOME, XDG_DATA_HOME, and XDG_STATE_HOME
+respectively, or the default defined in the specification if the environment
+variable is unset, empty, or contains a relative path rather than absolute
+path.
+
+xdg_config_dirs() and xdg_data_dirs() return a list of pathlib.Path
+objects containing the value, split on colons, of the environment
+variable named XDG_CONFIG_DIRS and XDG_DATA_DIRS respectively, or the
+default defined in the specification if the environment variable is
+unset or empty. Relative paths are ignored, as per the specification.
+
+xdg_runtime_dir() returns a pathlib.Path object containing the value of
+the XDG_RUNTIME_DIR environment variable, or None if the environment
+variable is not set, or contains a relative path rather than absolute path.
+
+"""
+
+# pylint: disable=fixme
+
+import os
+from pathlib import Path
+from typing import List, Optional
+
+__all__ = [
+    "xdg_cache_home",
+    "xdg_config_dirs",
+    "xdg_config_home",
+    "xdg_data_dirs",
+    "xdg_data_home",
+    "xdg_runtime_dir",
+    "xdg_state_home",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_DIRS",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_DIRS",
+    "XDG_DATA_HOME",
+    "XDG_RUNTIME_DIR",
+]
+
+
+def _path_from_env(variable: str, default: Path) -> Path:
+    """Read an environment variable as a path.
+
+    The environment variable with the specified name is read, and its
+    value returned as a path. If the environment variable is not set, is
+    set to the empty string, or is set to a relative rather than
+    absolute path, the default value is returned.
+
+    Parameters
+    ----------
+    variable : str
+        Name of the environment variable.
+    default : Path
+        Default value.
+
+    Returns
+    -------
+    Path
+        Value from environment or default.
+
+    """
+    # TODO(srstevenson): Use assignment expression in Python 3.8.
+    value = os.environ.get(variable)
+    if value and os.path.isabs(value):
+        return Path(value)
+    return default
+
+
+def _paths_from_env(variable: str, default: List[Path]) -> List[Path]:
+    """Read an environment variable as a list of paths.
+
+    The environment variable with the specified name is read, and its
+    value split on colons and returned as a list of paths. If the
+    environment variable is not set, or set to the empty string, the
+    default value is returned. Relative paths are ignored, as per the
+    specification.
+
+    Parameters
+    ----------
+    variable : str
+        Name of the environment variable.
+    default : List[Path]
+        Default value.
+
+    Returns
+    -------
+    List[Path]
+        Value from environment or default.
+
+    """
+    # TODO(srstevenson): Use assignment expression in Python 3.8.
+    value = os.environ.get(variable)
+    if value:
+        paths = [
+            Path(path) for path in value.split(":") if os.path.isabs(path)
+        ]
+        if paths:
+            return paths
+    return default
+
+
+def xdg_cache_home() -> Path:
+    """Return a Path corresponding to XDG_CACHE_HOME."""
+    return _path_from_env("XDG_CACHE_HOME", Path.home() / ".cache")
+
+
+def xdg_config_dirs() -> List[Path]:
+    """Return a list of Paths corresponding to XDG_CONFIG_DIRS."""
+    return _paths_from_env("XDG_CONFIG_DIRS", [Path("/etc/xdg")])
+
+
+def xdg_config_home() -> Path:
+    """Return a Path corresponding to XDG_CONFIG_HOME."""
+    return _path_from_env("XDG_CONFIG_HOME", Path.home() / ".config")
+
+
+def xdg_data_dirs() -> List[Path]:
+    """Return a list of Paths corresponding to XDG_DATA_DIRS."""
+    return _paths_from_env(
+        "XDG_DATA_DIRS",
+        [Path(path) for path in "/usr/local/share/:/usr/share/".split(":")],
+    )
+
+
+def xdg_data_home() -> Path:
+    """Return a Path corresponding to XDG_DATA_HOME."""
+    return _path_from_env("XDG_DATA_HOME", Path.home() / ".local" / "share")
+
+
+def xdg_runtime_dir() -> Optional[Path]:
+    """Return a Path corresponding to XDG_RUNTIME_DIR.
+
+    If the XDG_RUNTIME_DIR environment variable is not set, None will be
+    returned as per the specification.
+
+    """
+    value = os.getenv("XDG_RUNTIME_DIR")
+    if value and os.path.isabs(value):
+        return Path(value)
+    return None
+
+
+def xdg_state_home() -> Path:
+    """Return a Path corresponding to XDG_STATE_HOME."""
+    return _path_from_env("XDG_STATE_HOME", Path.home() / ".local" / "state")
+
+
+# The following variables are deprecated, but remain for backward compatibility.
+XDG_CACHE_HOME = xdg_cache_home()
+XDG_CONFIG_DIRS = xdg_config_dirs()
+XDG_CONFIG_HOME = xdg_config_home()
+XDG_DATA_DIRS = xdg_data_dirs()
+XDG_DATA_HOME = xdg_data_home()
+XDG_RUNTIME_DIR = xdg_runtime_dir()

json_database-0.8.0a1.dist-info/LICENSE

@@ -0,0 +1,19 @@
+The MIT License
+
+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.