abstract-utilities 0.2.2.442__py3-none-any.whl → 0.2.2.688__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}
+    ]

abstract_utilities/type_utils/num_utils.py

@@ -0,0 +1,19 @@
+from .imports import *
+def get_num_list() -> list:
+    """
+    Generates a list of numbers as strings.
+    
+    Returns:
+        list: A list of numbers as strings.
+    """
+    return list('0123456789')
+
+def getInts(string=False,listObj=False):
+    obj=12345678909
+    if string:
+        obj = str(obj)
+    if listObj:
+        obj = list(obj)
+    return obj
+
+

abstract_utilities/type_utils/type_utils.py

@@ -0,0 +1,104 @@
+"""
+type_utils.py
+
+This module provides a collection of utility functions for type checking and conversion.
+It includes functions to determine the type of an object, check if an object is a specific type,
+and perform type conversions. These functions help simplify the process of handling different
+types of data and ensure consistent behavior across different data types.
+
+Usage:
+    import abstract_utilities.type_utils as type_utils
+
+Functions:
+- is_iterable(obj: any) -> bool
+- is_number(obj: any) -> bool
+- is_str(obj: any) -> bool
+- is_int(obj: any) -> bool
+- is_float(obj: any) -> bool
+- is_bool(obj: any) -> bool
+- is_list(obj: any) -> bool
+- is_tuple(obj: any) -> bool
+- is_set(obj: any) -> bool
+- is_dict(obj: any) -> bool
+- is_frozenset(obj: any) -> bool
+- is_bytearray(obj: any) -> bool
+- is_bytes(obj: any) -> bool
+- is_memoryview(obj: any) -> bool
+- is_range(obj: any) -> bool
+- is_enumerate(obj: any) -> bool
+- is_zip(obj: any) -> bool
+- is_filter(obj: any) -> bool
+- is_map(obj: any) -> bool
+- is_property(obj: any) -> bool
+- is_slice(obj: any) -> bool
+- is_super(obj: any) -> bool
+- is_type(obj: any) -> bool
+- is_Exception(obj: any) -> bool
+- is_none(obj: any) -> bool
+- is_str_convertible_dict(obj: any) -> bool
+- is_dict_or_convertable(obj: any) -> bool
+- dict_check_conversion(obj: any) -> Union[dict, any]
+- make_list(obj: any) -> list
+- make_list_lower(ls: list) -> list
+- make_float(obj: Union[str, float, int]) -> float
+- make_bool(obj: Union[bool, int, str]) -> Union[bool, str]
+- make_str(obj: any) -> str
+- get_obj_obj(obj_type: str, obj: any) -> any
+- get_len_or_num(obj: any) -> int
+- get_types_list() -> list
+- det_bool_F(obj: (tuple or list or bool) = False) -> bool
+- det_bool_T(obj: (tuple or list or bool) = False) -> bool
+- T_or_F_obj_eq(event: any = '', obj: any = '') -> bool
+
+This module is part of the `abstract_utilities` package.
+
+Author: putkoff
+Date: 05/31/2023
+Version: 0.1.2
+"""
+
+
+
+
+
+
+
+
+
+# Function: is_number
+# Function: is_str
+# Function: is_int
+# Function: get_type
+# Function: is_float
+# Function: is_object
+# Function: is_bool
+# Function: is_list
+# Function: is_tuple
+# Function: is_set
+# Function: is_dict
+# Function: is_frozenset
+# Function: is_bytearray
+# Function: is_bytes
+# Function: is_memoryview
+# Function: is_range
+# Function: is_enumerate
+# Function: is_zip
+# Function: is_filter
+# Function: is_map
+# Function: is_property
+# Function: is_slice
+# Function: is_super
+# Function: is_type
+# Function: is_Exception
+# Function: is_none
+# Function: is_str_convertible_dict
+# Function: is_dict_or_convertable
+# Function: dict_check_conversion
+# Function: make_list
+# Function: make_list_lower
+# Function: make_float
+# Function: make_bool
+# Function: make_str
+# Function: get_obj_obj
+# Function: get_len_or_num
+# Function: get_types_list

abstract_utilities/type_utils.py

@@ -60,6 +60,7 @@ import os
 from pathlib import Path
 from typing import Union
 from .list_utils import make_list
+
 # A big, but by no means exhaustive, map of extensions to mime‐types by category:
 MIME_TYPES = {
     'image': {
@@ -936,7 +937,30 @@ def is_any_instance(value):
     for each in [dict, list, int, float]:
         if is_instance(value, each):
             return True
-
+def getAlphas(lower=True,capitalize=False,listObj=False):
+    obj = ''
+    alphas = 'abcdefghijklmoprstuvwxyz'
+    if lower:
+        obj+=alphas
+    if capitalize:
+        obj+=alphas.upper()
+    if listObj:
+        obj = list(obj)
+    return obj
+def getInts(string=False,listObj=False):
+    obj=12345678909
+    if string:
+        obj = str(obj)
+    if listObj:
+        obj = list(obj)
+    return obj
+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
 # Function: is_number
 # Function: is_str
 # Function: is_int

{abstract_utilities-0.2.2.442.dist-info → abstract_utilities-0.2.2.688.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.442
+Version: 0.2.2.688
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff