abstract-utilities 0.2.2.593__py3-none-any.whl → 0.2.2.667__py3-none-any.whl

abstract_utilities/json_utils/json_utils.py

@@ -26,6 +26,13 @@ from .imports import *
 
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+def get_keys(mapping,typ=None):
+    typ = typ or set
+    if isinstance(mapping,dict):
+        mapping = mapping.keys()
+    return typ(mapping)
+def make_key_map(dict_obj):
+    return {k:get_keys(v) for k,v in dict_obj.items()}
 def convert_and_normalize_values(values):
     for value in values:
         if isinstance(value, str):
@@ -116,10 +123,11 @@ def safe_dump_to_file(data, file_path=None, ensure_ascii=False, indent=4, *args,
     else:
         logger.error("file_path and data must be provided to safe_dump_to_file")
 
-def safe_read_from_json(*args,**kwargs):
+def safe_read_from_json(file_path,*args,**kwargs):
     is_read=True
-    file_path = args[0]
-    valid_file_path = get_file_path(*args,is_read=is_read,**kwargs)
+
+
+    valid_file_path = get_file_path(file_path,*args,is_read=is_read,**kwargs)
     if valid_file_path:
         file_path = valid_file_path
     try:

abstract_utilities/log_utils/log_file.py

@@ -1,42 +1,90 @@
 from .imports import *
-def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+import os, sys, inspect, logging
+from logging.handlers import RotatingFileHandler
+
+PACKAGE_NAME = "abstract_utilities"   # ← update if needed
+
+
+def _resolve_log_root():
     """
-    If bpName is None, use the “caller module’s basename” as the logger name.
-    Otherwise, use the explicitly provided bpName.
+    Returns a safe writable logging directory depending on environment:
+    - If running in a virtualenv → <venv>/.logs/<package>
+    - Else if user writable → ~/.cache/<package>/logs
+    - Else → /var/log/<package>
+    """
+    # 1) Virtualenv or Conda environment
+    venv = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
+    if venv:
+        root = os.path.join(venv, ".logs", PACKAGE_NAME)
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    # 2) User home cache folder
+    home = os.path.expanduser("~")
+    user_cache_root = os.path.join(home, ".cache", PACKAGE_NAME, "logs")
+    try:
+        os.makedirs(user_cache_root, exist_ok=True)
+        return user_cache_root
+    except PermissionError:
+        pass
+
+    # 3) Last resort: system log dir (requires correct service user permissions)
+    system_root = f"/var/log/{PACKAGE_NAME}"
+    try:
+        os.makedirs(system_root, exist_ok=True)
+        return system_root
+    except PermissionError:
+        # Fail-safe fallback to /tmp
+        fallback = f"/tmp/{PACKAGE_NAME}/logs"
+        os.makedirs(fallback, exist_ok=True)
+        return fallback
+
+
+LOG_ROOT = _resolve_log_root()
+
+
+def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
+    """
+    A logger that always writes to a safe OS-appropriate path.
+    Works even when installed through pip.
     """
     if bpName is None:
-        # Find the first frame outside logging_utils.py
         frame_idx = _find_caller_frame_index()
         frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename  # e.g. "/home/joe/project/app/routes.py"
+        caller_path = frame_info.filename
         bpName = os.path.splitext(os.path.basename(caller_path))[0]
         del frame_info
 
-
-
-    logger = logging.getLogger(bpName)
+    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
     logger.setLevel(logging.INFO)
 
     if not logger.handlers:
-        try:
-            log_dir = mkdirs("logs")
-            log_path = os.path.join(log_dir, f"{bpName}.log")
-            handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
-            handler.setLevel(logging.INFO)
-
-            fmt = "%(asctime)s - %(levelname)s - %(pathname)s - %(message)s"
-            formatter = logging.Formatter(fmt)
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-
-            console = logging.StreamHandler()
-            console.setLevel(logging.INFO)
-            console.setFormatter(formatter)
-            logger.addHandler(console)
-        except Exception as e:
-            print(f"{e}")
+        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
+        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+
+        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
+        formatter = logging.Formatter(fmt)
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        # Console handler (optional; can disable for gunicorn)
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(formatter)
+        logger.addHandler(console)
+
     return logger
 
+
+def _find_caller_frame_index():
+    """Find the correct caller module outside this logger."""
+    for idx, frame_info in enumerate(inspect.stack()):
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        if module and module.__name__ not in (__name__, "logging"):
+            return idx
+    return 1
 def _find_caller_frame_index():
     """
     Scan up the call stack until we find a frame whose module is NOT logging_utils.

abstract_utilities/parse_utils/parse_utils.py

@@ -64,6 +64,29 @@ def detect_language_from_text(text: str):
 
     likely = [lang for lang, score in scores.items() if score == max_score]
     return likely[0] if len(likely) == 1 else 'uncertain'
+def get_tripple_string(string):
+    nustring = ''
+    for i in range(3):
+        nustring +=string
+    return nustring
+def get_within_quotes(text,quotes=None):
+    quotes_strings = quotes or ["'",'"']
+    in_quotes = []
+    for quotes_string in quotes_strings:
+        if not isinstance(quotes_string,list):
+            tripple= get_tripple_string(quotes_string)
+            texts = [text]
+            if tripple in text:
+                texts= text.split(tripple)
+            for text_part in texts:
+                quote_count = len(text_part) - len(text_part.replace(quotes_string,''))
+                quote_spl = text_part.split(quotes_string)
+                in_quotes+=[quote_spl[i] for i in range(quote_count) if ((i == 1 or i%2 != float(0)) and len(quote_spl) > i)]
+        else:
+            texts= text.split(quotes_string[0])
+            for text in texts:
+                in_quotes.append(text.split(quotes_string[1])[0])
+    return in_quotes
 
 def search_code(code_languages, parts):
     return [data for datas in parts for data in make_list(datas)

abstract_utilities/path_utils/imports/module_imports.py

@@ -2,7 +2,7 @@ from ...string_utils import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type,MIME_TYPES
 from ...safe_utils import safe_join,get_slash
-from ...class_utils import get_caller_path,get_caller_dir
+from ...class_utils import get_caller_path,get_caller_dir,get_initial_caller,get_initial_caller_dir
 from ...file_utils import is_file,is_dir,is_exists
 from ...ssh_utils import is_file,is_dir,is_exists
 from ...directory_utils import *

abstract_utilities/path_utils/path_utils.py

@@ -107,17 +107,6 @@ def path_join(*paths, isfile=False):
         os.makedirs(final_path, exist_ok=True)      
     return final_path
 
-def is_file(*paths):
-    item_path = os.path.join(*paths)
-    return os.path.isfile(item_path)
-
-def is_dir(*paths):
-    item_path = os.path.join(*paths)
-    return os.path.isdir(item_path)
-
-def is_path(*paths):
-    item_path = os.path.join(*paths)
-    return item_path if os.path.exists(item_path) else None
 
 def get_all_directories(directory):
     dir_list = os.listdir(directory)
@@ -132,7 +121,7 @@ def get_all_files(directory=None):
 
 def get_all_items(directory):
     dir_list = os.listdir(directory)
-    file_list = [item for item in dir_list if is_path(directory,item)]
+    file_list = [item for item in dir_list if is_exists(directory,item)]
     return file_list
 
 
@@ -176,6 +165,7 @@ def get_safe_splitext(path=None,basename=None):
         basename_str = str(basename)
         filename,ext = os.path.splitext(basename_str)
         return filename,ext
+    return None,None
 def get_safe_filename(path=None,basename=None):
     filename,_ = get_safe_splitext(path=path,basename=basename)
     return filename
@@ -223,6 +213,11 @@ def create_base_dir(directory=None, child=None):
 
 
 
+def get_abs_path(path,i=None):
+    abs_dir = get_initial_caller_dir()
+    return os.path.join(abs_dir,path)
+    
+
 
 def get_file_parts(path):
     if path:

abstract_utilities/read_write_utils/imports/imports.py

@@ -1,2 +1,2 @@
 from ...imports import os,shlex
-
+import base64

abstract_utilities/read_write_utils/read_write_utils.py

@@ -194,45 +194,115 @@ def write_to_path(
 ##        f.write(str(contents))
 ##    return file_path
 # --- Core functionality -------------------------------------------------------
-def write_to_file(*args, **kwargs):
+##def write_to_file(*args, **kwargs):
+##    """
+##    Write contents to a file (create if missing).
+##
+##    Returns the file_path written.
+##    """
+##    file_path, contents = check_read_write_params(*args, **kwargs)
+##    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
+##    dirname = os.path.dirname(file_path)
+##    
+##    if contents is None:
+##        raise ValueError("Missing contents to write.")
+##    user_at_host = kwargs.get("user_at_host")
+##    if get_user_pass_host_key(**kwargs):
+##        make_dirs(dirname, exist_ok=True,**kwargs)
+##        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
+##        # sanitize for shell safety
+##        quoted_path = shlex.quote(file_path)
+##        quoted_data = shlex.quote(str(contents))
+##        # shell command that fully overwrites
+##        # (no append, replaces contents entirely)
+##        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
+##        if not kwargs.get('password') and not kwargs.get('key'):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##        result = run_pruned_func(run_cmd,**kwargs)
+##        if 'file_path' in kwargs:
+##            del kwargs['file_path']
+##        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##            result = run_pruned_func(run_cmd,**kwargs)
+##        return result
+##
+##    make_dirs(dirname or ".", exist_ok=True)
+##    with open(file_path, "w", encoding="utf-8") as f:
+##        f.write(str(contents))
+##    return file_path
+
+def _should_use_remote(**kwargs) -> bool:
+    """
+    Only use remote mode IF:
+    - user_at_host is provided
+    - AND password/key is provided
+    Otherwise: local write.
     """
-    Write contents to a file (create if missing).
+    user = kwargs.get("user_at_host")
+    if not user:
+        return False  # not remote
+
+    # If user_at_host is provided, then password or key MUST be present
+    if kwargs.get("password") or kwargs.get("key"):
+        return True
 
-    Returns the file_path written.
+    return False  # user provided but no auth → treat as local
+
+
+def _write_to_file(contents: str, file_path: str, **kwargs) -> str:
     """
-    file_path, contents = check_read_write_params(*args, **kwargs)
-    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
+    Safe writer that handles arbitrarily large files.
+    Uses native I/O for local writes and streams for remote.
+    """
+
+    remote = _should_use_remote(**kwargs)
     dirname = os.path.dirname(file_path)
-    
-    if contents is None:
-        raise ValueError("Missing contents to write.")
-    user_at_host = kwargs.get("user_at_host")
-    if get_user_pass_host_key(**kwargs):
-        make_dirs(dirname, exist_ok=True,**kwargs)
-        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
-        # sanitize for shell safety
-        quoted_path = shlex.quote(file_path)
-        quoted_data = shlex.quote(str(contents))
-        # shell command that fully overwrites
-        # (no append, replaces contents entirely)
-        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
-        if not kwargs.get('password') and not kwargs.get('key'):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-        result = run_pruned_func(run_cmd,**kwargs)
-        if 'file_path' in kwargs:
-            del kwargs['file_path']
-        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-            result = run_pruned_func(run_cmd,**kwargs)
-        return result
+    make_dirs(dirname, exist_ok=True, **kwargs)
+
+    # --- Local write (always robust) ---
+    if not remote:
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(contents)
+        return file_path
+
+    # --- Remote write ---
+    # Stream data through SSH using base64 chunks instead of huge one-liner
+    import io
+    import base64
+
+    # Write to a temporary file locally first
+    tmp_path = "/tmp/_abstract_write.tmp"
+    with open(tmp_path, "w", encoding="utf-8") as tmpf:
+        tmpf.write(contents)
+
+    user_at_host = kwargs["user_at_host"]
+    password = kwargs.get("password")
+    key = kwargs.get("key")
+
+    # Use scp for remote write — no shell arg limits
+    scp_cmd = f"scp {shlex.quote(tmp_path)} {user_at_host}:{shlex.quote(file_path)}"
+    return run_pruned_func(
+        run_local_cmd,
+        cmd=scp_cmd,
+        password=password,
+        key=key,
+        **kwargs
+    )
 
-    make_dirs(dirname or ".", exist_ok=True)
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(str(contents))
-    return file_path
 
+def write_to_file(*, contents: str, file_path: str, **kwargs):
+    """
+    Error-handled wrapper.
+    """
+
+    try:
+        result = _write_to_file(contents=contents, file_path=file_path, **kwargs)
+        return result
 
-def read_from_file(file_path,**kwargs):
+    except Exception as e:
+        print("WRITE ERROR:", e)
+        raise RuntimeError(f"Failed writing: {file_path}")
+def read_from_file(file_path=None,**kwargs):
     if get_user_pass_host_key(**kwargs):
         kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
         basename = os.path.basename(file_path)

abstract_utilities/type_utils/__init__.py

@@ -1,3 +1,7 @@
+from .imports import *
 from .alpha_utils import *
 from .num_utils import *
-from .type_utils import *
+from .is_type import *
+from .make_type import *
+from .get_type import *
+from .mime_types import *

abstract_utilities/type_utils/get_type.py

@@ -0,0 +1,116 @@
+from .imports import *
+from .alpha_utils import *
+from .num_utils import *
+from .is_type import *
+from .make_type import *
+def get_obj_obj(obj_type: str, obj: any) -> any:
+    """
+    Returns the object converted according to the given type string.
+    
+    Args:
+        obj_type: The string representing the type to convert to.
+        obj: The object to convert.
+        
+    Returns:
+        any: The object converted to the specified type.
+    """
+    if obj_type == 'str':
+        return make_str(obj)
+    elif obj_type == 'bool':
+        return make_bool(obj)
+    elif obj_type == 'float':
+        return make_float(obj)
+    elif obj_type == 'int':
+        try:
+            return int(obj)
+        except (TypeError, ValueError):
+            return obj
+    else:
+        return obj
+def get_len_or_num(obj: any) -> int:
+    """
+    Returns the length of the object if it can be converted to a string, else the integer representation of the object.
+    
+    Args:
+        obj: The object to process.
+        
+    Returns:
+        int: The length of the object as a string or the integer representation of the object.
+    """
+    if is_int(obj) or is_float(obj):
+        return int(obj)
+    else:
+        try:
+            return len(str(obj))
+        except (TypeError, ValueError):
+            return 0
+def get_types_list()->list:
+    return ['list', 'bool', 'str', 'int', 'float', 'set', 'dict', 'frozenset', 'bytearray', 'bytes', 'memoryview', 'range', 'enumerate', 'zip', 'filter', 'map', 'property', 'slice', 'super', 'type', 'Exception', 'NoneType']
+
+
+def str_lower(obj):
+    try:
+        obj=str(obj).lower()
+    except Exception as e:
+        print(f"{e}")
+    return obj
+
+def get_bool_response(bool_response,json_data):
+    if not is_instance(bool_response,bool):
+        try:
+            bool_response = json_data.get(bool_response) in [None,'',[],"",{}]
+        except:
+            pass       
+    return bool_response
+def get_alphabet_str():
+  return 'abcdefghijklmnopqrstuvwxyz'
+def get_alphabet_upper_str():
+  alphabet_str = get_alphabet_str()
+  return alphabet_str.upper()
+def get_alphabet_comp_str():
+  return get_alphabet_str() + get_alphabet_upper_str()
+
+def get_alphabet():
+  alphabet_str = get_alphabet_str()
+  return break_string(alphabet_str)
+def get_alphabet_upper():
+  alphabet_upper_str = get_alphabet_upper_str()
+  return break_string(alphabet_upper_str)
+def get_alphabet_comp():
+  alphabet_comp_str = get_alphabet_comp_str()
+  return break_string(alphabet_comp_str)
+def get_numbers_str():
+  return '0123457890'
+def get_numbers_int():
+  numbers_str = get_numbers_str()
+  return [int(number) for number in numbers_str]
+def get_numbers():
+  numbers_str = get_numbers_str()
+  return break_string(numbers_str)
+def get_numbers_comp():
+  numbers_str = get_numbers()
+  numbers_int = get_numbers_int()
+  return numbers_str + numbers_int
+def break_string(string):
+  string_str = str(string)
+  return list(string_str)
+def get_alpha_ints(ints=True,alpha=True,lower=True,capitalize=True,string=True,listObj=True):
+    objs = [] if listObj else ""
+    if ints:
+        objs+=getInts(string=string,listObj=listObj)
+    if alpha:
+        objs+=getAlphas(lower=lower,capitalize=capitalize,listObj=listObj)
+    return objs
+def if_true_get_string(data, key):
+    return key if data.get(key) else None
+def find_for_string(string, parts):
+    return [part for part in parts if string.lower() in str(part).lower()]
+
+
+def is_strings_in_string(strings, parts):
+    strings = make_list(strings)
+    for string in strings:
+        parts = find_for_string(string, parts)
+        if not parts:
+            return []
+    return parts

abstract_utilities/type_utils/imports/__init__.py

@@ -1,2 +1,3 @@
 from .imports import *
 from .module_imports import *
+from .constants import *

abstract_utilities/type_utils/imports/constants.py

@@ -0,0 +1,134 @@
+from .module_imports import *
+MIME_TYPES = {
+    'image': {
+        '.jpg':   'image/jpeg',
+        '.jpeg':  'image/jpeg',
+        '.png':   'image/png',
+        '.gif':   'image/gif',
+        '.bmp':   'image/bmp',
+        '.tiff':  'image/tiff',
+        '.webp':  'image/webp',
+        '.svg':   'image/svg+xml',
+        '.ico':   'image/vnd.microsoft.icon',
+        '.heic':  'image/heic',
+        '.psd':   'image/vnd.adobe.photoshop',
+        '.raw':   'image/x-raw',
+    },
+    'video': {
+        '.mp4':   'video/mp4',
+        '.webm':  'video/webm',
+        '.ogg':   'video/ogg',
+        '.mov':   'video/quicktime',
+        '.avi':   'video/x-msvideo',
+        '.mkv':   'video/x-matroska',
+        '.flv':   'video/x-flv',
+        '.wmv':   'video/x-ms-wmv',
+        '.3gp':   'video/3gpp',
+        '.ts':    'video/mp2t',
+        '.mpeg':  'video/mpeg',
+        '.mpg':   'video/mpg'
+    },
+    'audio': {
+        '.mp3':   'audio/mpeg',
+        '.wav':   'audio/wav',
+        '.flac':  'audio/flac',
+        '.aac':   'audio/aac',
+        '.ogg':   'audio/ogg',
+        '.m4a':   'audio/mp4',
+        '.opus':  'audio/opus',
+    },
+    'document': {
+        '.pdf':   'application/pdf',
+        '.doc':   'application/msword',
+        '.docx':  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.odt':   'application/vnd.oasis.opendocument.text',
+        '.txt':   'text/plain',
+        '.rtf':   'application/rtf',
+        '.md':    'text/markdown',
+        '.markdown': 'text/markdown',
+        '.tex':   'application/x-tex',
+        '.log':   'text/plain',
+        '.json':  'application/json',
+        '.xml':   'application/xml',
+        '.yaml':  'application/x-yaml',
+        '.yml':   'application/x-yaml',
+        '.ini':   'text/plain',
+        '.cfg':   'text/plain',
+        '.toml':  'application/toml',
+        '.csv':   'text/csv',
+        '.tsv':   'text/tab-separated-values'
+    },
+    'presentation': {
+        '.ppt':   'application/vnd.ms-powerpoint',
+        '.pptx':  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.odp':   'application/vnd.oasis.opendocument.presentation',
+    },
+    'spreadsheet': {
+        '.xls':   'application/vnd.ms-excel',
+        '.xlsx':  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ods':   'application/vnd.oasis.opendocument.spreadsheet',
+        '.csv':   'text/csv',
+        '.tsv':   'text/tab-separated-values'
+    },
+    'code': {
+        '.py':    'text/x-python',
+        '.java':  'text/x-java-source',
+        '.c':     'text/x-c',
+        '.cpp':   'text/x-c++',
+        '.h':     'text/x-c',
+        '.hpp':   'text/x-c++',
+        '.js':    'application/javascript',
+        '.cjs':   'application/javascript',
+        '.mjs':   'application/javascript',
+        '.jsx':   'application/javascript',
+        '.ts':    'application/typescript',
+        '.tsx':   'application/typescript',
+        '.rb':    'text/x-ruby',
+        '.php':   'application/x-php',
+        '.go':    'text/x-go',
+        '.rs':    'text/rust',
+        '.swift': 'text/x-swift',
+        '.kt':    'text/x-kotlin',
+        '.sh':    'application/x-shellscript',
+        '.bash':  'application/x-shellscript',
+        '.ps1':   'application/x-powershell',
+        '.sql':   'application/sql',
+        '.yml':   'application/x-yaml',
+        '.coffee':'text/coffeescript',
+        '.lua':   'text/x-lua',
+    },
+    'archive': {
+        '.zip':   'application/zip',
+        '.tar':   'application/x-tar',
+        '.gz':    'application/gzip',
+        '.tgz':   'application/gzip',
+        '.bz2':   'application/x-bzip2',
+        '.xz':    'application/x-xz',
+        '.rar':   'application/vnd.rar',
+        '.7z':    'application/x-7z-compressed',
+        '.iso':   'application/x-iso9660-image',
+        '.dmg':   'application/x-apple-diskimage',
+        '.jar':   'application/java-archive',
+        '.war':   'application/java-archive',
+        '.whl':   'application/python-wheel',
+        '.egg':   'application/python-egg',
+    },
+    'font': {
+        '.ttf':   'font/ttf',
+        '.otf':   'font/otf',
+        '.woff':  'font/woff',
+        '.woff2': 'font/woff2',
+        '.eot':   'application/vnd.ms-fontobject'
+    },
+    'executable': {
+        '.exe':   'application/vnd.microsoft.portable-executable',
+        '.dll':   'application/vnd.microsoft.portable-executable',
+        '.bin':   'application/octet-stream',
+        '.deb':   'application/vnd.debian.binary-package',
+        '.rpm':   'application/x-rpm'
+    }
+}
+
+# And just the sets, if you only need to test ext‐membership:
+MEDIA_TYPES = make_key_map(MIME_TYPES)
+