How to use the datasette.app.Datasette function in datasette

sqlite3.connect(extra_filepath).executescript(extra_sql)
                files.append(extra_filepath)
        os.chdir(os.path.dirname(filepath))
        plugins_dir = os.path.join(tmpdir, "plugins")
        os.mkdir(plugins_dir)
        open(os.path.join(plugins_dir, "my_plugin.py"), "w").write(PLUGIN1)
        open(os.path.join(plugins_dir, "my_plugin_2.py"), "w").write(PLUGIN2)
        config = config or {}
        config.update(
            {
                "default_page_size": 50,
                "max_returned_rows": max_returned_rows or 100,
                "sql_time_limit_ms": sql_time_limit_ms or 200,
            }
        )
        ds = Datasette(
            files,
            immutables=immutables,
            memory=memory,
            cors=cors,
            metadata=METADATA,
            plugins_dir=plugins_dir,
            config=config,
            inspect_data=inspect_data,
            static_mounts=static_mounts,
            template_dir=template_dir,
        )
        ds.sqlite_functions.append(("sleep", 1, lambda n: time.sleep(float(n))))
        client = TestClient(ds.app())
        client.ds = ds
        yield client

async def test_require_auth_is_true_when_used_as_datasette_plugin():
    app = Datasette(
        [],
        memory=True,
        metadata={
            "plugins": {
                "datasette-auth-github": {
                    "client_id": "client_x",
                    "client_secret": "client_secret_x",
                }
            }
        },
    ).app()
    assert isinstance(app, GitHubAuthOriginal)
    assert True == app.require_auth

async def test_datasette_plugin_installed():
    instance = ApplicationCommunicator(
        Datasette([], memory=True).app(),
        {
            "type": "http",
            "http_version": "1.0",
            "method": "GET",
            "path": "/-/plugins.json",
        },
    )
    await instance.send_input({"type": "http.request"})
    response_start = await instance.receive_output(1)
    assert "http.response.start" == response_start["type"]
    assert 200 == response_start["status"]
    body = await instance.receive_output(1)
    data = json.loads(body["body"].decode("utf8"))
    assert "datasette-auth-github" == data[0]["name"]

def app_client_no_files():
    ds = Datasette([])
    client = TestClient(ds.app())
    client.ds = ds
    yield client

async def inspect_(files, sqlite_extensions):
    app = Datasette([], immutables=files, sqlite_extensions=sqlite_extensions)
    data = {}
    for name, database in app.databases.items():
        counts = await database.table_counts(limit=3600 * 1000)
        data[name] = {
            "hash": database.hash,
            "size": database.size,
            "file": database.path,
            "tables": {
                table_name: {"count": table_count}
                for table_name, table_count in counts.items()
            },
        }
    return data

def plugins(all, plugins_dir):
    "List currently available plugins"
    app = Datasette([], plugins_dir=plugins_dir)
    click.echo(json.dumps(app.plugins(all), indent=4))

reloader.watch_files(files)
        if metadata:
            reloader.watch_files([metadata.name])

    inspect_data = None
    if inspect_file:
        inspect_data = json.load(open(inspect_file))

    metadata_data = None
    if metadata:
        metadata_data = json.loads(metadata.read())

    click.echo(
        "Serve! files={} (immutables={}) on port {}".format(files, immutable, port)
    )
    ds = Datasette(
        files,
        immutables=immutable,
        cache_headers=not debug and not reload,
        cors=cors,
        inspect_data=inspect_data,
        metadata=metadata_data,
        sqlite_extensions=sqlite_extensions,
        template_dir=template_dir,
        plugins_dir=plugins_dir,
        static_mounts=static,
        config=dict(config),
        memory=memory,
        version_note=version_note,
    )
    # Run async sanity checks - but only if we're not under pytest
    asyncio.get_event_loop().run_until_complete(ds.run_sanity_checks())

def inspect(files, inspect_file, sqlite_extensions):
    app = Datasette([], immutables=files, sqlite_extensions=sqlite_extensions)
    if inspect_file == "-":
        out = sys.stdout
    else:
        out = open(inspect_file, "w")
    loop = asyncio.get_event_loop()
    inspect_data = loop.run_until_complete(inspect_(files, sqlite_extensions))
    out.write(json.dumps(inspect_data, indent=2))