Publishes all functions and classes registered in unity_server.
    The functions and classes will appear in the module turicreate.extensions

def _publish():

    import copy
    """
    Publishes all functions and classes registered in unity_server.
    The functions and classes will appear in the module turicreate.extensions
    """
    unity = _get_unity()
    fnlist = unity.list_toolkit_functions()
    # Loop through all the functions and inject it into
    # turicreate.extensions.[blah]
    # Note that [blah] may be somemodule.somefunction
    # and so the injection has to be
    # turicreate.extensions.somemodule.somefunction
    for fn in fnlist:
        props = unity.describe_toolkit_function(fn)
        # quit if there is nothing we can process
        if 'arguments' not in props:
            continue
        arguments = props['arguments']

        newfunc = _make_injected_function(fn, arguments)

        newfunc.__doc__ = "Name: " + fn + "\nParameters: " + str(arguments) + "\n"
        if 'documentation' in props:
            newfunc.__doc__ += props['documentation'] + "\n"

        newfunc.__dict__['__glmeta__'] = {'extension_name':fn}
        modpath = fn.split('.')
        # walk the module tree
        mod = _thismodule
        for path in modpath[:-1]:
            try:
                getattr(mod, path)
            except:
                _setattr_wrapper(mod, path, _types.ModuleType(name=path))
            mod = getattr(mod, path)
        _setattr_wrapper(mod, modpath[-1], newfunc)

    # Repeat for classes
    tkclasslist = unity.list_toolkit_classes()
    for tkclass in tkclasslist:
        m = unity.describe_toolkit_class(tkclass)
        # of v2 type
        if not ('functions' in m and 'get_properties' in m and 'set_properties' in m and 'uid' in m):
            continue

        # create a new class
        if _version_info.major == 3:
            new_class = _ToolkitClass.__dict__.copy()
            del new_class['__dict__']
            del new_class['__weakref__']
        else:
            new_class = copy.deepcopy(_ToolkitClass.__dict__)

        new_class['__init__'] = _types.FunctionType(new_class['__init__'].__code__,
                                                    new_class['__init__'].__globals__,
                                                    name='__init__',
                                                    argdefs=(),
                                                    closure=())

        # rewrite the init method to add the toolkit class name so it will
        # default construct correctly
        new_class['__init__'].tkclass_name = tkclass

        newclass = _class_type(tkclass, (), new_class)
        setattr(newclass, '__glmeta__', {'extension_name':tkclass})
        class_uid_to_class[m['uid']] = newclass
        modpath = tkclass.split('.')
        # walk the module tree
        mod = _thismodule
        for path in modpath[:-1]:
            try:
                getattr(mod, path)
            except:
                _setattr_wrapper(mod, path, _types.ModuleType(name=path))
            mod = getattr(mod, path)
        _setattr_wrapper(mod, modpath[-1], newclass)