def relimport(destination, start):
    """
    Return a relative import path from the `start` module's view'.
    This is a path computation: the filesystem is not accessed to confirm the existence or nature of `destination` or `start`.

    Here are some examples:

        >>> relimport(destination='foo.bar.batz', start='foo.bar')  # in foo.bar: from . import batz: .batz
        '.batz'

        >>> relimport(destination='foo.bar.batz.gneeh', start='foo.bar')
        '.batz.gneeh'

        >>> relimport(destination='foo.bar', start='foo.bar.batz')  # in foo.bar.batz: from ... import batz
        '...bar'

        >>> relimport(destination='foo.bar', start='foo.bar.batz.gneeh')  # in foo.bar: from . import batz: .batz
        '....bar'

        >>> relimport(destination='foo.bar.c', start='foo.bar.batz')
        '.c'

        >>> relimport(destination='foo.b.c', start='foo.bar.batz')
        '..b.c'

        >>> relimport(destination='package.subpackage1.moduleY.spam', start='package.subpackage1.moduleX')
        '.moduleY.spam'

        >>> relimport(destination='package.subpackage1.moduleY', start='package.subpackage1.moduleX')
        '.moduleY'

        >>> relimport(destination='package.subpackage2.moduleZ.eggs', start='package.subpackage1.moduleX')
        '..subpackage2.moduleZ.eggs'

        >>> relimport(destination='moduleA.foo', start='package.subpackage1.moduleX')
        '...moduleA.foo'

        >>> relimport(destination='sys.path', start='package.subpackage1.moduleX')
        '...sys.path'

        >>> relimport(destination='foo.bar.batz', start='foo.bar')
        '.batz'

    Note: Those examples above are also used as part of the unit tests, via the doctest system.
    Note: This is called the same way as `os.path.relpath(path, start)` would be, and is compatible in calling,
          except the `path` parameter called `destination` to be more clear, and `start` (not yet) being optional.

    :param destination: the destination path
    :type  destination: str

    :param start: our current module where we call the import. You can supply the current module with `start=__NAME__`.
    :type  start: str

    :return: the relative path. `'...foo.bar'`
    :rtype: str
    """
    destination_parts = destination.split('.')
    start_parts = start.split('.')
    original_destination_parts = destination.split('.')
    for i in range(min(len(start_parts), len(destination_parts))):
        if start_parts[0] == destination_parts[0]:
            start_parts.pop(0)
            destination_parts.pop(0)
            continue
        else:
            break
    if destination_parts == [] and start_parts == []:
        return None
    if start_parts == [] and destination_parts:
        return '.' + '.'.join(destination_parts)
    if start_parts and destination_parts == []:
        return '.' + '.' * len(start_parts) + '.' + original_destination_parts[
            -1]
    if start_parts and destination_parts:
        return '.' + '.' * (len(start_parts) - 1) + '.'.join(destination_parts)
