id,page,ref,title,content,breadcrumbs,references
internals:internals-database,internals,internals-database,Database class,"Instances of the  Database  class can be used to execute queries against attached SQLite databases, and to run introspection against their schemas.","[""Internals for plugins""]",[]
internals:internals-datasette,internals,internals-datasette,Datasette class,"This object is an instance of the  Datasette  class, passed to many plugin hooks as an argument called  datasette . 
             You can create your own instance of this - for example to help write tests for a plugin - like so: 
             from datasette.app import Datasette

# With no arguments a single in-memory database will be attached
datasette = Datasette()

# The files= argument can load files from disk
datasette = Datasette(files=[""/path/to/my-database.db""])

# Pass metadata as a JSON dictionary like this
datasette = Datasette(
    files=[""/path/to/my-database.db""],
    metadata={
        ""databases"": {
            ""my-database"": {
                ""description"": ""This is my database""
            }
        }
    },
) 
             Constructor parameters include: 
             
                 
                     files=[...]  - a list of database files to open 
                 
                 
                     immutables=[...]  - a list of database files to open in immutable mode 
                 
                 
                     metadata={...}  - a dictionary of  Metadata 
                 
                 
                     config_dir=...  - the  configuration directory  to use, stored in  datasette.config_dir","[""Internals for plugins""]",[]
internals:internals-multiparams,internals,internals-multiparams,The MultiParams class,"request.args  is a  MultiParams  object - a dictionary-like object which provides access to query string parameters that may have multiple values. 
             Consider the query string  ?foo=1&foo=2&bar=3  - with two values for  foo  and one value for  bar . 
             
                 
                     request.args[key]  - string 
                     
                         Returns the first value for that key, or raises a  KeyError  if the key is missing. For the above example  request.args[""foo""]  would return  ""1"" . 
                     
                 
                 
                     request.args.get(key)  - string or None 
                     
                         Returns the first value for that key, or  None  if the key is missing. Pass a second argument to specify a different default, e.g.  q = request.args.get(""q"", """") . 
                     
                 
                 
                     request.args.getlist(key)  - list of strings 
                     
                         Returns the list of strings for that key.  request.args.getlist(""foo"")  would return  [""1"", ""2""]  in the above example.  request.args.getlist(""bar"")  would return  [""3""] . If the key is missing an empty list will be returned. 
                     
                 
                 
                     request.args.keys()  - list of strings 
                     
                         Returns the list of available keys - for the example this would be  [""foo"", ""bar""] . 
                     
                 
                 
                     key in request.args  - True or False 
                     
                         You can use  if key in request.args  to check if a key is present. 
                     
                 
                 
                     for key in request.args  - iterator 
                     
                         This lets you loop through every available key. 
                     
                 
                 
                     len(request.args)  - integer 
                     
                         Returns the number of keys.","[""Internals for plugins""]",[]
internals:internals-response,internals,internals-response,Response class,"The  Response  class can be returned from view functions that have been registered using the  register_routes(datasette)  hook. 
             The  Response()  constructor takes the following arguments: 
             
                 
                     body  - string 
                     
                         The body of the response. 
                     
                 
                 
                     status  - integer (optional) 
                     
                         The HTTP status - defaults to 200. 
                     
                 
                 
                     headers  - dictionary (optional) 
                     
                         A dictionary of extra HTTP headers, e.g.  {""x-hello"": ""world""} . 
                     
                 
                 
                     content_type  - string (optional) 
                     
                         The content-type for the response. Defaults to  text/plain . 
                     
                 
             
             For example: 
             from datasette.utils.asgi import Response

response = Response(
    ""<xml>This is XML</xml>"",
    content_type=""application/xml; charset=utf-8"",
) 
             The quickest way to create responses is using the  Response.text(...) ,  Response.html(...) ,  Response.json(...)  or  Response.redirect(...)  helper methods: 
             from datasette.utils.asgi import Response

html_response = Response.html(""This is HTML"")
json_response = Response.json({""this_is"": ""json""})
text_response = Response.text(
    ""This will become utf-8 encoded text""
)
# Redirects are served as 302, unless you pass status=301:
redirect_response = Response.redirect(
    ""https://latest.datasette.io/""
) 
             Each of these responses will use the correct corresponding content-type -  text/html; charset=utf-8 ,  application/json; charset=utf-8  or  text/plain; charset=utf-8  respectively. 
             Each of the helper methods take optional  status=  and  headers=  arguments, documented above.","[""Internals for plugins""]",[]
internals:internals-shortcuts,internals,internals-shortcuts,Import shortcuts,"The following commonly used symbols can be imported directly from the  datasette  module: 
             from datasette import Response
from datasette import Forbidden
from datasette import NotFound
from datasette import hookimpl
from datasette import actor_matches_allow","[""Internals for plugins""]",[]