lsst.daf.persistence.utils Namespace Reference

Functions
def	listify (x)
def	iterify (x)
def	sequencify (x)
def	setify (x)
def	doImport (pythonType)

Function Documentation

doImport()

def lsst.daf.persistence.utils.doImport

(

pythonType

)

Import a python object given an importable string

Definition at line 106 of file utils.py.

def doImport(pythonType):
    """Import a python object given an importable string"""
    try:
        if not isinstance(pythonType, basestring):
            raise TypeError("Unhandled type of pythonType, val:%s" % pythonType)
        # import this pythonType dynamically
        # pythonType is sometimes unicode with Python 2 and pybind11; this breaks the interpreter
        pythonTypeTokenList = str(pythonType).split('.')
        importClassString = pythonTypeTokenList.pop()
        importClassString = importClassString.strip()
        importPackage = ".".join(pythonTypeTokenList)
        importType = __import__(importPackage, globals(), locals(), [importClassString], 0)
        pythonType = getattr(importType, importClassString)
        return pythonType
    except ImportError:
        pass
    # maybe python type is a member function, in the form: path.to.object.Class.funcname
    pythonTypeTokenList = pythonType.split('.')
    importClassString = '.'.join(pythonTypeTokenList[0:-1])
    importedClass = doImport(importClassString)
    pythonType = getattr(importedClass, pythonTypeTokenList[-1])
    return pythonType

iterify()

def lsst.daf.persistence.utils.iterify

(

x

)

Takes any object. Returns it if it is iterable. If it
is not iterable it puts the object in a list and returns
the list. None will return an empty list. If a new list
is always required use listify(). Strings will be placed
in a list with a single element.

Definition at line 51 of file utils.py.

def iterify(x):
    """Takes any object. Returns it if it is iterable. If it
    is not iterable it puts the object in a list and returns
    the list. None will return an empty list. If a new list
    is always required use listify(). Strings will be placed
    in a list with a single element.
    """
    if x is None:
        x = []
    elif isinstance(x, basestring):
        x = [x]
    elif hasattr(x, '__iter__'):
        pass
    else:
        x = [x]
    return x

listify()

def lsst.daf.persistence.utils.listify

(

x

)

Takes any object and puts that whole object in a list:
- strings will be made into a single element in the list
- tuples will be converted to list
- lists will remain as lists
- None will be made into an empty list

Definition at line 31 of file utils.py.

def listify(x):
    """Takes any object and puts that whole object in a list:
    - strings will be made into a single element in the list
    - tuples will be converted to list
    - lists will remain as lists
    - None will be made into an empty list
    """
    if x is None:
        x = []
    elif isinstance(x, basestring):
        x = [x]
    elif isinstance(x, dict):
        x = [x]
    elif hasattr(x, '__iter__'):
        x = list(x)
    else:
        x = [x]
    return x

sequencify()

def lsst.daf.persistence.utils.sequencify

(

x

)

Takes an object, if it is a sequence return it,
else put it in a tuple. Strings are not sequences.
If x is a dict, returns a sorted tuple of keys.

Definition at line 69 of file utils.py.

def sequencify(x):
    """Takes an object, if it is a sequence return it,
    else put it in a tuple. Strings are not sequences.
    If x is a dict, returns a sorted tuple of keys."""
    if isinstance(x, (Sequence, Set)) and not isinstance(x, basestring):
        pass
    elif isinstance(x, Mapping):
        x = tuple(sorted(x.keys()))
    else:
        x = (x, )
    return x

setify()

def lsst.daf.persistence.utils.setify

(

x

)

Take an object x and return it in a set.

If x is a container, will create a set from the contents of the container.
If x is an object, will create a set with a single item in it.
If x is a string, will treat the string as a single object (i.e. not as a list of chars)

Definition at line 82 of file utils.py.

def setify(x):
    """Take an object x and return it in a set.

    If x is a container, will create a set from the contents of the container.
    If x is an object, will create a set with a single item in it.
    If x is a string, will treat the string as a single object (i.e. not as a list of chars)"""
    if x is None:
        x = set()

    # Here we have to explicity for strings because the set initializer will use each character in a string as
    # a separate element. We cannot use the braces initialization because x might be a list, and we do not
    # want the list to be an item; we want each item in the list to be represented by an item in the set.
    # Then, we have to fall back to braces init because if the item is NOT a list then the set initializer
    # won't take it.
    if isinstance(x, basestring):
        x = set([x])
    else:
        try:
            x = set(x)
        except TypeError:
            x = set([x])
    return x

---

Generated on Sat Nov 16 2019 09:15:32 for LSSTApplications by   1.8.13