abstract-utilities 0.2.2.493__py3-none-any.whl → 0.2.2.495__py3-none-any.whl

abstract_utilities/file_utils/src/initFunctionsGen.py

@@ -0,0 +1,286 @@
+# attach_functions.py  — single helper you can import anywhere
+# attach_dynamic.py
+from __future__ import annotations
+from .file_utils import define_defaults,get_files_and_dirs
+from ..imports import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
+def caller_path():
+    frame = inspect.stack()[1]
+    return os.path.abspath(frame.filename)
+def _is_defined_here(mod: types.ModuleType, obj: object) -> bool:
+    try:
+        return inspect.getmodule(obj) is mod
+    except Exception:
+        return False
+
+def _collect_callables(mod: types.ModuleType) -> Dict[str, Callable]:
+    out: Dict[str, Callable] = {}
+    names = getattr(mod, "__all__", None)
+    if names:
+        # trust the author's export list
+        for n in names:
+            fn = getattr(mod, n, None)
+            if callable(fn):
+                out[n] = fn
+        return out
+    # otherwise, discover top-level callables defined in this module
+    for n in dir(mod):
+        if n.startswith("_"):
+            continue
+        obj = getattr(mod, n, None)
+        if callable(obj) and _is_defined_here(mod, obj):
+            out[n] = obj
+    return out
+
+def _import_module_by_name(name: str) -> Optional[types.ModuleType]:
+    try:
+        return importlib.import_module(name)
+    except Exception:
+        return None
+
+def _import_module_by_path(pkg_name: str, base_dir: str, filename: str) -> Optional[types.ModuleType]:
+    mod_name = f"{pkg_name}.functions"
+    path = os.path.join(base_dir, filename)
+    spec = importlib.util.spec_from_file_location(mod_name, path)
+    if not spec or not spec.loader:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[mod_name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+def _walk_functions_package(pkg_name: str, pkg_mod: types.ModuleType) -> List[types.ModuleType]:
+    """Import all immediate submodules in the functions/ package."""
+    mods: List[types.ModuleType] = [pkg_mod]
+    pkg_dir = os.path.dirname(pkg_mod.__file__ or "")
+    for info in pkgutil.iter_modules([pkg_dir]):
+        # only import direct children (no recursion here; easy to add if you need)
+        child_name = f"{pkg_mod.__name__}.{info.name}"
+        m = _import_module_by_name(child_name)
+        if m:
+            mods.append(m)
+    return mods
+
+def _discover_functions(base_pkg: str, *, hot_reload: bool) -> List[Tuple[str, Callable, str]]:
+    """
+    Returns a list of (export_name, callable, module_basename).
+    Works if you have base_pkg.functions.py or base_pkg/functions/ package.
+    """
+    # Prefer normal import of '<base_pkg>.functions'
+    fqn = f"{base_pkg}.functions"
+    mod = _import_module_by_name(fqn)
+
+    if mod is None:
+        # fallback: sibling functions.py, even without being a package
+        base = _import_module_by_name(base_pkg)
+        if not base or not getattr(base, "__file__", None):
+            return []
+        base_dir = os.path.dirname(base.__file__)
+        if os.path.isfile(os.path.join(base_dir, "functions.py")):
+            mod = _import_module_by_path(base_pkg, base_dir, "functions.py")
+        else:
+            return []
+
+    if hot_reload:
+        try:
+            mod = importlib.reload(mod)  # type: ignore[arg-type]
+        except Exception:
+            pass
+
+    results: List[Tuple[str, Callable, str]] = []
+    modules: List[types.ModuleType]
+
+    if hasattr(mod, "__path__"):  # it's a package: import children
+        modules = _walk_functions_package(base_pkg, mod)
+    else:
+        modules = [mod]
+
+    for m in modules:
+        exported = _collect_callables(m)
+        module_basename = m.__name__.split(".")[-1]
+        for name, fn in exported.items():
+            results.append((name, fn, module_basename))
+    return results
+
+def attach_functions(
+    obj_or_cls,
+    base_pkg: str | None = None,
+    hot_reload: bool = True,
+    prefix_with_module: bool = False,
+    include_private: bool = True,
+    only_defined_here: bool = True,   # don't attach stuff imported from elsewhere
+) -> list[str]:
+    """
+    Attach all free functions found in <base_pkg>.functions (module or package)
+    to the *class* of obj_or_cls. Returns the list of attached attribute names.
+    """
+    cls = obj_or_cls if inspect.isclass(obj_or_cls) else obj_or_cls.__class__
+    # Derive "<package>.functions" from the class's module unless you pass base_pkg
+    caller_mod = cls.__module__
+    pkg_root = (base_pkg or caller_mod.rsplit(".", 1)[0]).rstrip(".")
+    funcs_pkg_name = f"{pkg_root}.functions"
+
+    def _import(name: str) -> ModuleType | None:
+        try:
+            if hot_reload and name in sys.modules:
+                return importlib.reload(sys.modules[name])
+            return importlib.import_module(name)
+        except Exception:
+            return None
+
+    def _is_pkg(m: ModuleType) -> bool:
+        return hasattr(m, "__path__")
+
+    mod = _import(funcs_pkg_name)
+    if mod is None:
+        # Nothing to attach (no functions.py or functions/ next to your class)
+        setattr(cls, "_attached_functions", tuple())
+        return []
+
+    modules: list[ModuleType] = [mod]
+    if _is_pkg(mod):
+        # attach from every submodule under functions/
+        for it in pkgutil.iter_modules(mod.__path__):
+            sub = _import(f"{funcs_pkg_name}.{it.name}")
+            if sub is not None:
+                modules.append(sub)
+
+    attached: list[str] = []
+    for m in modules:
+        for name, obj in vars(m).items():
+            # only callables (skip classes), and keep them sane
+            if not callable(obj) or isinstance(obj, type):
+                continue
+            if only_defined_here and getattr(obj, "__module__", None) != m.__name__:
+                continue
+            if not include_private and name.startswith("_"):
+                continue
+            if name.startswith("__") and name.endswith("__"):
+                continue
+            attr = f"{m.__name__.rsplit('.', 1)[-1]}__{name}" if prefix_with_module else name
+            try:
+                setattr(cls, attr, obj)  # set on CLASS → becomes bound method on instances
+                attached.append(attr)
+            except Exception:
+                # don't explode if one name collides; keep going
+                continue
+
+    # handy for debugging
+    try:
+        setattr(cls, "_attached_functions", tuple(attached))
+    except Exception:
+        pass
+    return attached
+
+
+
+
+def isTab(item):
+    item_lower =  item.lower()
+    for key in ['console','tab']:
+        if item_lower.endswith(key):
+            return True
+    return False
+def get_dir(root,item):
+    if None in [root]:
+        return None
+    path = root
+    if item != None:
+        path = os.path.join(path,item)
+    return path
+def isDir(root,item=None):
+    path = get_dir(root,item)
+    if path:
+        return os.path.isdir(path)
+def check_dir_item(root,item=None):
+    return (item and isTab(item) and isDir(root,item))
+def get_dirs(root = None):
+    root = root or ABSROOT
+    dirpaths = [get_dir(root,item) for item in os.listdir(root) if check_dir_item(root,item)]
+    return dirpaths
+def ifFunctionsInFile(root):
+    items = [os.path.join(root, "functions"),os.path.join(root, "functions.py")]
+    for item in items:
+        if os.path.exists(item):
+            return item
+        
+
+def get_for_all_tabs(root = None):
+    root = root or caller_path()
+    if os.path.isfile(root):
+        root = os.path.dirname(root)
+    all_tabs = get_dirs(root = root)
+    for ROOT in all_tabs:
+        FUNCS_DIR = ifFunctionsInFile(ROOT)
+        if FUNCS_DIR == None:
+            for ROOT in get_dirs(root = ROOT):
+                apply_inits(ROOT)
+        else: 
+            apply_inits(ROOT)
+            
+
+def apply_inits(ROOT):
+    FUNCS_DIR = ifFunctionsInFile(ROOT)
+
+    
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:
+        
+        if if_fun_dir:
+            CFG = define_defaults(allowed_exts='.py',
+                unallowed_exts = True,
+                exclude_types = True,
+                exclude_dirs = True,
+                exclude_patterns = True)
+            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
+            
+        else:
+            filepaths = [FUNCS_DIR]
+        
+        # Parse top-level def names
+        def extract_funcs(path: str):
+            funcs = []
+            for line in read_from_file(path).splitlines():
+                m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+                if m:
+                    funcs.append(m.group(1))
+            return funcs
+
+        # Build functions/__init__.py that re-exports all discovered functions
+        import_lines = []
+        all_funcs = []
+        for fp in filepaths:
+            module = os.path.splitext(os.path.basename(fp))[0]
+            funcs = extract_funcs(fp)
+            if funcs:
+                import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+                all_funcs.extend(funcs)
+        if if_fun_dir:
+            functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+
+        # Prepare the tuple literal of function names for import + loop
+        uniq_funcs = sorted(set(all_funcs))
+        func_tuple = ", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+        
+        # Generate apiConsole/initFuncs.py using the safer setattr-loop
+        init_funcs_src = textwrap.dedent(f"""\
+            
+
+            from .functions import ({func_tuple})
+
+            def initFuncs(self):
+                try:
+                    for f in ({func_tuple}):
+                        setattr(self, f.__name__, f)
+                except Exception as e:
+                    logger.info(f"{{e}}")
+                return self
+        """)
+
+        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+
+def call_for_all_tabs():
+    root = get_caller_dir(2)
+    get_for_all_tabs(root)

abstract_utilities/file_utils/src/map_utils.py

@@ -0,0 +1,29 @@
+from ..imports import MIME_TYPES,make_list,os
+from .file_filters import get_globs
+def get_file_type(file_path,types=None,default=None):
+    mime_types = {}
+    if types:
+        types = make_list(types)
+        for typ in types:
+            mime_types[typ] = MIME_TYPES.get(typ)
+    else:
+        mime_types = MIME_TYPES
+    
+    if os.path.isfile(file_path):
+        basename = os.path.basename(file_path)
+        filename,ext = os.path.splitext(basename)
+        for file_type,ext_values in mime_types.items():
+            if ext in ext_values:
+                return file_type
+def get_file_map(directory,types=None,default=None):
+    if directory and os.path.isfile(directory):
+       directory = os.path.dirname(directory)
+    all_types = {}
+    files = get_globs(directory)
+    for file in files:
+        file_type = get_file_type(file,types=types,default=default)
+        if file_type:
+            if file_type not in all_types:
+                all_types[file_type] = []
+            all_types[file_type].append(file)
+    return all_types

abstract_utilities/file_utils/src/pdf_utils.py

@@ -0,0 +1,300 @@
+from ..imports import *
+def if_none_return(obj: object, obj_2: object) -> object:
+    """
+    Return obj if obj_2 is None, otherwise return obj_2.
+    
+    Args:
+    obj (Any): Primary object to return.
+    obj_2 (Any): Secondary object to check.
+    
+    Returns:
+    Any: obj if obj_2 is None, else obj_2.
+    """
+    return obj if obj_2 is None else obj_2
+
+def write_pdf() -> PyPDF2.PdfWriter:
+    """
+    Return a new PDF writer object.
+    
+    Returns:
+    PyPDF2.PdfWriter: New PDF writer object.
+    """
+    return PyPDF2.PdfWriter()
+def read_pdf(file: str):
+    """
+    Read and return a PDF reader object from the provided file path.
+    
+    Args:
+    file (str): Path to the PDF file.
+    
+    Returns:
+    PyPDF2.PdfReader: PDF reader object.
+    """
+    return PyPDF2.PdfReader(file)
+def is_pdf_path(file: str):
+    """
+    Checks if a given file path corresponds to a PDF file.
+
+    Args:
+        file (str): A string representing the file path.
+
+    Returns:
+        bool: True if the file has a '.pdf' extension, False otherwise.
+    """
+    if is_file(file):
+        if get_ext(file) == '.pdf':
+            return True
+    return False
+
+def read_pdf(file: str):
+    """Read and return a PDF reader object from the provided file path."""
+    return PyPDF2.PdfReader(file)
+def get_pdf_obj(pdf_obj: Union[str, object]) -> object:
+    """
+    Processes and returns a PDF object. If provided with a file path to a PDF,
+    it reads and returns the PDF content as an object.
+
+    Args:
+        pdf_obj: Either a PDF file path or an existing PDF object.
+
+    Returns:
+        object: The PDF content as an object.
+    """
+    if is_str(pdf_obj):
+        if is_pdf_path(pdf_obj):
+            pdf_obj = read_pdf(pdf_obj)  # Assuming there's a function read_pdf() to read PDF content
+    return pdf_obj
+def get_separate_pages(pdf_reader, start_page:int=1, end_page:int=None):
+    """
+    Get specific pages from a PDF and return them as a new PDF object.
+
+    Args:
+        pdf_reader (object): The PDF reader object.
+        start_page (int, optional): The starting page number. Defaults to 1.
+        end_page (int, optional): The ending page number. Defaults to the last page.
+
+    Returns:
+        object: A new PDF writer object with the specified pages.
+    """
+    num_pages = get_pdf_pages(pdf_reader)
+    
+    # Handling default or out-of-bounds page values
+    if end_page is None or num_pages < end_page:
+        end_page = num_pages
+    elif num_pages < start_page:
+        return False
+    
+    pdf_writer = write_pdf()
+    
+    for page_num in range(num_pages):
+        if start_page <= page_num <= end_page:
+            pdf_writer.add_page(pdf_reader.pages[page_num])
+    return pdf_writer
+def is_pdf_path(file):
+    """
+    Check if the provided file path corresponds to a valid PDF file.
+
+    Args:
+        file (str): File path.
+
+    Returns:
+        bool: True if it's a valid PDF path, False otherwise.
+    """
+    if is_file(file) and get_ext(file).lower() == '.pdf':
+        return True
+    return False
+
+def get_pdf_pages(pdf_file):
+    """
+    Get the total number of pages in the PDF.
+
+    Args:
+        pdf_file (object/str): PDF reader object or path to a PDF file.
+
+    Returns:
+        int: Number of pages in the PDF.
+    """
+    pdf_file = get_pdf_obj(pdf_file)
+    try:
+        return len(pdf_file.pages)
+    except:
+        return False
+def save_pdf(output_file_path, pdf_writer):
+    """
+    Save a PDF writer object to a file.
+
+    Args:
+        output_file_path (str): Path to save the PDF.
+        pdf_writer (object): PDF writer object to save.
+    """
+    with open(output_file_path, 'wb') as output_file:
+        pdf_writer.write(output_file)
+def split_pdf(input_path: str, output_folder: Optional[str] = None, file_name: Optional[str] = None) -> List[str]:
+    """
+    Split a PDF file into separate files for each page.
+    
+    Args:
+        input_path (str): Path to the input PDF file.
+        output_folder (str, optional): Directory to save the split PDF files. Defaults to the directory of input_path.
+        file_name (str, optional): Base name for the output files. Defaults to the base name of input_path.
+        
+    Returns:
+        list: List of paths to the created split PDF files.
+    """
+    pdf_pages = []
+    file_name = get_file_name(input_path) if file_name is None else file_name
+    output_folder = if_none_return(get_directory(input_path), output_folder)  
+
+    print(f"Splitting PDF: {input_path}")
+    print(f"Output Folder: {output_folder}")
+    print(f"Using Filename: {file_name}")
+
+    with open(input_path, 'rb') as pdf_file:
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        num_pages = len(pdf_reader.pages)  # Replace getNumPages() with len(pdf_reader.pages)
+
+        print(f"Number of pages in PDF: {num_pages}")
+
+        for page_num in range(num_pages):
+            pdf_writer = PyPDF2.PdfWriter()
+            pdf_writer.add_page(pdf_reader.pages[page_num])  # Use the pdf_writer instance you created
+
+            output_file_path = os.path.join(output_folder, f'{file_name}_page_{page_num + 1}.pdf')
+            output_img_path = os.path.join(output_folder, f'{file_name}_page_{page_num + 1}.png')
+            print(f"Writing to: {output_file_path}")
+            pdf_pages.append(output_file_path)
+            save_pdf(output_file_path,pdf_writer)
+            
+    return pdf_pages
+def pdf_to_img_list(pdf_list: List[str], output_folder: Optional[str] = None, file_name: Optional[str] = None, 
+                    paginate: bool = False, extension: str = "png") -> List[str]:
+    """
+    Convert a list of PDF files to images.
+
+    Args:
+        pdf_list (List[str]): List of paths to PDF files.
+        output_folder (str, optional): Directory to save the images. Defaults to PDF's directory.
+        file_name (str, optional): Base name for the images. Defaults to PDF's name.
+        paginate (bool): Whether to paginate the image names. Defaults to False.
+        extension (str): Extension for the image files. Defaults to "png".
+
+    Returns:
+        List[str]: List of paths to the created image files.
+    """
+    image_list=[]
+    file_name_start = file_name
+    for i, each in enumerate(pdf_list):
+        try:
+            images = convert_from_path(each)
+        except Exception as e:
+            print("An error occurred while converting the PDF:", e)
+        
+        if output_folder is None:
+            output_folder = get_directory(each)
+        if file_name_start is None:
+            file_name = get_file_name(each)
+        if paginate:
+            file_name=f"{file_name}_Page_{i}"
+        
+        for i, image in enumerate(images):
+            image_output_path = os.path.join(output_folder, f"{file_name}.{extension}")
+            image_list.append(image_output_path)
+            save_image(image=image, image_path=image_output_path, format=extension.upper())
+    return image_list
+def img_to_txt_list(img_list: List[str], output_folder: Optional[str] = None, file_name: Optional[str] = None, 
+                    paginate: bool = False, extension: str = "txt") -> List[str]:
+    """
+    Convert a list of image files to text.
+
+    Args:
+        img_list (List[str]): List of paths to image files.
+        output_folder (str, optional): Directory to save the text files. Defaults to image's directory.
+        file_name (str, optional): Base name for the text files. Defaults to image's name.
+        paginate (bool): Whether to paginate the text filenames. Defaults to False.
+        extension (str): Extension for the text files. Defaults to "txt".
+
+    Returns:
+        List[str]: List of paths to the created text files.
+    """
+    text_list = []
+    file_name_start = file_name
+    for i, each in enumerate(img_list):
+        if output_folder is None:
+            output_folder = get_directory(each)
+        if file_name_start is None:
+            file_name = get_file_name(each)
+        if paginate:
+            file_name=f"{file_name}_Page_{i}"
+        
+        text_output = image_to_text(each)
+        text_output_path = os.path.join(output_folder, f"{get_file_name(each)}.{extension}")
+        text_list.append(text_output_path)
+        write_to_file(filepath=text_output_path, contents=text_output)
+    return text_list
+def open_pdf_file(pdf_file_path: str) -> None:
+    """
+    Open a PDF file using the default associated program.
+    
+    Args:
+        pdf_file_path (str): Path to the PDF file to open.
+    """
+    try:
+        # Open the PDF file using the default associated program
+        cmd_input("open "+pdf_file_path)
+    except FileNotFoundError:
+        print("Error: The specified file does not exist.")
+    except Exception as e:
+        print("Error:", e)
+    # use it before writing to a file
+
+
+def get_pdfs_in_directory(directory: str) -> List[str]:
+    """
+    Get a list of PDF filenames in a given directory.
+    
+    Args:
+        directory (str): Path to the directory.
+        
+    Returns:
+        list: List of PDF filenames in the directory.
+    """
+    pdfs = []
+    for filename in os.listdir(directory):
+        if is_pdf_path(filename):
+            pdfs.append(filename)
+    return pdfs
+
+def get_all_pdf_in_directory(file_directory: Optional[str] = None) -> List[str]:
+    """
+    Get a list of complete paths to PDF files in a given directory.
+    
+    Args:
+        file_directory (str, optional): Path to the directory. 
+        
+    Returns:
+        list: List of paths to PDF files in the directory.
+    """
+    pdfs=[]
+    for filename in sorted(os.listdir(file_directory)):
+        if is_pdf_path(filename):
+            pdf_path = os.path.join(file_directory, filename)
+            if is_file(pdf_path):
+                pdfs.append(pdf_path)
+    return pdfs
+
+def collate_pdfs(pdf_list: List[str], output_pdf_path: str) -> None:
+    """
+    Merge multiple PDF files into a single PDF.
+    
+    Args:
+        pdf_list (list): List of paths to PDF files to be merged.
+        output_pdf_path (str): Path to save the merged PDF.
+    """
+    pdf_writer = PyPDF2.PdfWriter()
+    for file_path in pdf_list:
+        with open(file_path, 'rb') as pdf_file:
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            for page_num in range(len(pdf_reader.pages)):
+                pdf_writer.add_page(pdf_reader.pages[page_num])
+    save_pdf(output_file_path, pdf_writer)
+

abstract_utilities/file_utils/src/type_checks.py

@@ -0,0 +1,92 @@
+from ..imports import *
+
+def get_user_pass_host_key(**kwargs):
+    args = ['password','user_at_host','host','key','user']
+    kwargs['del_kwarg']=kwargs.get('del_kwarg',False)
+    values,kwargs = get_from_kwargs(*args,**kwargs)
+    return values
+
+# --- Base remote checker -----------------------------------------------------
+def _remote_test(path: str, test_flag: str, timeout: int = 5,*args, **kwargs) -> bool:
+    """
+    Run a remote shell test (e.g. -f, -d) via SSH.
+    Returns True if test succeeds, False otherwise.
+    """
+    try:
+        kwargs['cmd']=f"[ {test_flag} {shlex.quote(path)} ] && echo 1 || echo 0"
+        kwargs['text']=True
+        kwargs['timeout']=timeout
+        kwargs['stderr']=subprocess.DEVNULL
+        result = run_pruned_func(run_cmd,**kwargs)
+        return result.strip() == "1"
+    except Exception:
+        return False
+
+
+# --- Individual path checks --------------------------------------------------
+def is_remote_file(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a file."""
+    return _remote_test(path, "-f", **kwargs)
+
+
+def is_remote_dir(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a directory."""
+    return _remote_test(path, "-d", **kwargs)
+
+
+def is_local_file(path: str) -> bool:
+    """True if local path is a file."""
+    return os.path.isfile(path)
+
+
+def is_local_dir(path: str) -> bool:
+    """True if local path is a directory."""
+    return os.path.isdir(path)
+
+
+# --- Unified interface -------------------------------------------------------
+
+def is_file(path: str,*args,**kwargs) -> bool:
+    """Determine if path is a file (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_file(path, **kwargs)
+    return is_local_file(path)
+
+
+def is_dir(path: str, *args,**kwargs) -> bool:
+    """Determine if path is a directory (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_dir(path, **kwargs)
+    return is_local_dir(path)
+
+def is_exists(path: str, *args,**kwargs) -> bool:
+    if is_file(path,**kwargs):
+        return True
+    if is_dir(path,**kwargs):
+        return True
+    return False
+# --- Optional: keep your original all-in-one wrapper ------------------------
+def check_path_type(
+    path: str,
+    *args,
+    **kwargs
+) -> str:
+    """
+    Return 'file', 'directory', 'missing', or 'unknown'.
+    Uses isolated is_file/is_dir functions.
+    """
+    if get_user_pass_host_key(**kwargs):
+        if is_remote_file(path,**kwargs):
+            return "file"
+        elif is_remote_dir(path,**kwargs):
+            return "directory"
+        else:
+            return "missing"
+    else:
+        if os.path.isfile(path):
+            return "file"
+        elif os.path.isdir(path):
+            return "directory"
+        elif not os.path.exists(path):
+            return "missing"
+        return "unknown"