abstract-utilities 0.2.2.627__py3-none-any.whl → 0.2.2.700__py3-none-any.whl

abstract_utilities/type_utils/make_type.py

@@ -0,0 +1,126 @@
+from .imports import *
+from .alpha_utils import *
+from .num_utils import *
+from .is_type import *
+def make_list(obj:any) -> list:
+    """
+    Converts the input object to a list. If the object is already a list, it is returned as is.
+    
+    Args:
+        obj: The object to convert.
+        
+    Returns:
+        list: The object as a list.
+    """
+    if isinstance(obj,str):
+        if ',' in obj:
+            obj = obj.split(',')
+    if isinstance(obj,set) or isinstance(obj,tuple):
+        return list(obj)
+    if isinstance(obj, list):
+        return obj
+    return [obj]
+def get_if_None(obj,default):
+    return obj if obj != None else default
+def dict_check_conversion(obj:any) -> Union[dict,any]:
+    """
+    Converts the input object to a dictionary if possible.
+
+    Args:
+        obj: The object to convert.
+
+    Returns:
+        The object converted to a dictionary if possible, otherwise the original object.
+    """
+    import json
+
+    if is_dict_or_convertable(obj):
+        if is_dict(obj):
+            return obj
+        return json.loads(obj)
+    
+    return obj
+
+    
+def make_list_lower(ls: list) -> list:
+    """
+    Converts all elements in a list to lowercase. Ignores None values.
+    
+    Args:
+        ls: The list to convert.
+        
+    Returns:
+        list: The list with all strings converted to lowercase.
+    """
+    return [item.lower() if is_instance(item, str) else item for item in ls]
+
+
+def make_float(obj:Union[str,float,int]) -> float:
+    """
+    Converts the input object to a float.
+    
+    Args:
+        x: The object to convert.
+        
+    Returns:
+        float: The float representation of the object.
+    """
+    try:
+        return float(obj)
+    except (TypeError, ValueError):
+        return 1.0
+
+def make_bool(obj: Union[bool, int, str]) -> Union[bool, str]:
+    """
+    Converts the input object to a boolean representation if possible.
+
+    The function attempts to convert various objects, including integers and strings, to their boolean equivalents. 
+    If the conversion is not possible, the original object is returned.
+
+    Args:
+        obj: The object to be converted.
+
+    Returns:
+        bool or original type: The boolean representation of the object if conversion is possible. Otherwise, it returns the original object.
+
+    Examples:
+        make_bool("true") -> True
+        make_bool(1)      -> True
+        make_bool("0")    -> False
+        make_bool(2)      -> 2
+    """
+    if is_instance(obj, bool):
+        return obj
+    if is_instance(obj, int):
+        if obj == 0:
+            return False
+        if obj == 1:
+            return True
+    if is_instance(obj, str):
+        if obj.lower() in ['0', "false"]:
+            return False
+        if obj.lower() in ['1', "true"]:
+            return True
+    return obj
+
+def make_str(obj: any) -> str:
+    """
+    Converts the input object to a string.
+    
+    Args:
+        obj: The object to convert.
+        
+    Returns:
+        str: The string representation of the object.
+    """
+    return str(obj)
+def convert_to_number(value):
+    value_str = str(value)
+    if is_number(value_str):
+        return float(value_str) if '.' in value_str else int(value_str)
+    return value_str
+
+def makeInt(obj):
+    if is_number(obj):
+       return int(obj)
+    return obj

abstract_utilities/type_utils/mime_types.py

@@ -0,0 +1,68 @@
+from .imports import *
+# A big, but by no means exhaustive, map of extensions to mime‐types by category:
+def get_media_map(categories=None):
+    """
+    Return a sub‐dict of MEDIA_TYPES for the given categories.
+    If categories is None or empty, return the whole MEDIA_TYPES.
+    """
+    if not categories:
+        return MEDIA_TYPES
+    cats = {str(c) for c in categories}
+    return {c: MEDIA_TYPES[c] for c in cats if c in MEDIA_TYPES}
+
+
+def get_media_exts(categories=None):
+    """
+    Return a flat, sorted list of all extensions for the given categories.
+    """
+    media_map = get_media_map(categories)
+    return sorted({ext for exts in media_map.values() for ext in exts})
+
+
+def confirm_type(path_or_ext, categories=None,**kwargs):
+    """
+    Given a file‐path or extension, return its media category (e.g. "image"), or None.
+    """
+    categories = categories or kwargs.get('media_types')
+    ext = Path(path_or_ext).suffix.lower()
+    media_map = get_media_map(categories)
+    for category, exts in media_map.items():
+        if ext in exts:
+            return category
+    return None
+
+
+def is_media_type(path_or_ext, categories=None,**kwargs):
+    """
+    True if the given file‐path or extension belongs to one of the categories.
+    """
+    categories = categories or kwargs.get('media_types')
+    return confirm_type(path_or_ext, categories) is not None
+
+
+def get_mime_type(path_or_ext):
+    """
+    Look up the MIME type by extension in MIME_TYPES; fall back to octet‐stream.
+    """
+    ext = Path(path_or_ext).suffix.lower()
+    for mapping in MIME_TYPES.values():
+        if ext in mapping:
+            return mapping[ext]
+    return 'application/octet-stream'
+
+
+def get_all_file_types(categories=None, directory=None,**kwargs):
+    """
+    Recursively glob for files under `directory` whose extension belongs to `categories`.
+    Returns a list of full paths.
+    """
+    categories = categories or kwargs.get('media_types')
+    base = Path(directory)
+    if not base.is_dir():
+        return []
+    wanted = get_media_map(categories)
+    return [
+        str(p)
+        for p in base.rglob('*')
+        if p.is_file() and Path(p).suffix.lower() in {e for exts in wanted.values() for e in exts}
+    ]