lsst.afw.table.testUtils Namespace Reference

Functions
def	joinWords (items)
def	diffSchemas (schema1, schema2, flags=Schema.IDENTICAL)
def	assertSchemasEqual (testCase, schema1, schema2, flags=Schema.IDENTICAL)

Function Documentation

assertSchemasEqual()

def lsst.afw.table.testUtils.assertSchemasEqual	(		testCase,
			schema1,
			schema2,
			flags = Schema.IDENTICAL
	)

Assert that two Schemas are equal.

Generates a message from the difference between the schemas; see
:py:func:`diffSchemas` for more information.

Parameters
----------
testCase :
    Comparison test case that should fail is schemas differ.
schema1 : :py:class:`lsst.afw.table.Schema`
    First input schema.
schema2 : :py:class:`lsst.afw.table.Schema`
    Second input schema.
flags : `int`
    A bitwise OR of :py:class:`lsst.afw.table.Schema.ComparisonFlags`
    indicating which features of schema items to compare.

Definition at line 97 of file testUtils.py.

def assertSchemasEqual(testCase, schema1, schema2, flags=Schema.IDENTICAL):
    """Assert that two Schemas are equal.
 
    Generates a message from the difference between the schemas; see
    :py:func:`diffSchemas` for more information.
 
    Parameters
    ----------
    testCase :
        Comparison test case that should fail is schemas differ.
    schema1 : :py:class:`lsst.afw.table.Schema`
        First input schema.
    schema2 : :py:class:`lsst.afw.table.Schema`
        Second input schema.
    flags : `int`
        A bitwise OR of :py:class:`lsst.afw.table.Schema.ComparisonFlags`
        indicating which features of schema items to compare.
    """
    msg = diffSchemas(schema1, schema2, flags=flags)
    if msg:
        testCase.fail(msg)

diffSchemas()

def lsst.afw.table.testUtils.diffSchemas	(		schema1,
			schema2,
			flags = Schema.IDENTICAL
	)

Return a string diff of two schemas.

Parameters
----------
schema1 : :py:class:`lsst.afw.table.Schema`
    First schema to diff.  Items appearing only in this schema
    will be prefixed with "-" in the diff.
schema2 : :py:class:`lsst.afw.table.Schema`
    Second schema to diff.  Items appearing only in this schema
    will be prefixed with "-" in the diff.
flags : `int`
    A bitwise OR of :py:class:`lsst.afw.table.Schema.ComparisonFlags`
    indicating which features of schema items to compare.  The returned
    diff will always show all differences, but no diff will be shown if
    the only differences are not included in the flags.  Default is
    `lsst.afw.table.Schema.IDENTICAL`, which checks everything.

Returns
-------
diff : `str`
    A "unified diff" string representation of the difference between the
    schemas, or an empty string if there is no difference.

Definition at line 53 of file testUtils.py.

def diffSchemas(schema1, schema2, flags=Schema.IDENTICAL):
    """Return a string diff of two schemas.
 
    Parameters
    ----------
    schema1 : :py:class:`lsst.afw.table.Schema`
        First schema to diff.  Items appearing only in this schema
        will be prefixed with "-" in the diff.
    schema2 : :py:class:`lsst.afw.table.Schema`
        Second schema to diff.  Items appearing only in this schema
        will be prefixed with "-" in the diff.
    flags : `int`
        A bitwise OR of :py:class:`lsst.afw.table.Schema.ComparisonFlags`
        indicating which features of schema items to compare.  The returned
        diff will always show all differences, but no diff will be shown if
        the only differences are not included in the flags.  Default is
        `lsst.afw.table.Schema.IDENTICAL`, which checks everything.
 
    Returns
    -------
    diff : `str`
        A "unified diff" string representation of the difference between the
        schemas, or an empty string if there is no difference.
    """
    result = schema1.compare(schema2, flags)
    if result == flags:
        return ""
    components = []
    if not result & Schema.EQUAL_KEYS:
        components.append("keys")
    if not result & Schema.EQUAL_NAMES:
        components.append("names")
    if not result & Schema.EQUAL_DOCS:
        components.append("docs")
    if not result & Schema.EQUAL_UNITS:
        components.append("units")
    if not result & Schema.EQUAL_ALIASES:
        components.append("aliases")
    diff = "\n".join(difflib.unified_diff(
        str(schema1).split("\n"), str(schema2).split("\n")))
    return f"{joinWords(components).capitalize()} differ:\n{diff}"
 
 
@lsst.utils.tests.inTestCase

joinWords()

def lsst.afw.table.testUtils.joinWords

(

items

)

Join a sequence of words into a comma-separated, 'and'-finalized
string with correct English syntax.

Parameters
----------
items : Array of `str`
    Sequence to be joined.

Returns
-------
result : `str`
     Correct English Oxford-comma terminated string.

Definition at line 29 of file testUtils.py.

def joinWords(items):
    """Join a sequence of words into a comma-separated, 'and'-finalized
    string with correct English syntax.
 
    Parameters
    ----------
    items : Array of `str`
        Sequence to be joined.
 
    Returns
    -------
    result : `str`
         Correct English Oxford-comma terminated string.
    """
    if len(items) == 1:
        result = items[0]
    elif len(items) == 2:
        result = f"{items[0]} and {items[1]}"
    else:
        allButLast = ", ".join(items[:-1])
        result = f"{allButLast}, and items{[-1]}"
    return result