id,page,ref,title,content,breadcrumbs,references
internals:datasette-render-template,internals,datasette-render-template,"await .render_template(template, context=None, request=None)","template  - string, list of strings or jinja2.Template 
                         
                             The template file to be rendered, e.g.  my_plugin.html . Datasette will search for this file first in the  --template-dir=  location, if it was specified - then in the plugin's bundled templates and finally in Datasette's set of default templates. 
                             If this is a list of template file names then the first one that exists will be loaded and rendered. 
                             If this is a Jinja  Template object  it will be used directly. 
                         
                     
                     
                         context  - None or a Python dictionary 
                         
                             The context variables to pass to the template. 
                         
                     
                     
                         request  - request object or None 
                         
                             If you pass a Datasette request object here it will be made available to the template. 
                         
                     
                 
                 Renders a  Jinja template  using Datasette's preconfigured instance of Jinja and returns the resulting string. The template will have access to Datasette's default template functions and any functions that have been made available by other plugins.","[""Internals for plugins"", ""Datasette class""]","[{""href"": ""https://jinja.palletsprojects.com/en/2.11.x/api/#jinja2.Template"", ""label"": ""Template object""}, {""href"": ""https://jinja.palletsprojects.com/en/2.11.x/"", ""label"": ""Jinja template""}]"
internals:datasette-resolve-database,internals,datasette-resolve-database,.resolve_database(request),"request  -  Request object 
                         
                             A request object 
                         
                     
                 
                 If you are implementing your own custom views, you may need to resolve the database that the user is requesting based on a URL path. If the regular expression for your route declares a  database  named group, you can use this method to resolve the database object. 
                 This returns a  Database  instance. 
                 If the database cannot be found, it raises a  datasette.utils.asgi.DatabaseNotFound  exception - which is a subclass of  datasette.utils.asgi.NotFound  with a  .database_name  attribute set to the name of the database that was requested.","[""Internals for plugins"", ""Datasette class""]",[]
internals:datasette-resolve-row,internals,datasette-resolve-row,.resolve_row(request),"request  -  Request object 
                         
                             A request object 
                         
                     
                 
                 This method assumes your route declares named groups for  database ,  table  and  pks . 
                 It returns a  ResolvedRow  named tuple instance with the following fields: 
                 
                     
                         db  -  Database 
                         
                             The database object 
                         
                     
                     
                         table  - string 
                         
                             The name of the table 
                         
                     
                     
                         sql  - string 
                         
                             SQL snippet that can be used in a  WHERE  clause to select the row 
                         
                     
                     
                         params  - dict 
                         
                             Parameters that should be passed to the SQL query 
                         
                     
                     
                         pks  - list 
                         
                             List of primary key column names 
                         
                     
                     
                         pk_values  - list 
                         
                             List of primary key values decoded from the URL 
                         
                     
                     
                         row  -  sqlite3.Row 
                         
                             The row itself 
                         
                     
                 
                 If the database or table cannot be found it raises a  datasette.utils.asgi.DatabaseNotFound  exception. 
                 If the table does not exist it raises a  datasette.utils.asgi.TableNotFound  exception. 
                 If the row cannot be found it raises a  datasette.utils.asgi.RowNotFound  exception. This has  .database_name ,  .table  and  .pk_values  attributes, extracted from the request path.","[""Internals for plugins"", ""Datasette class""]",[]
internals:datasette-resolve-table,internals,datasette-resolve-table,.resolve_table(request),"request  -  Request object 
                         
                             A request object 
                         
                     
                 
                 This assumes that the regular expression for your route declares both a  database  and a  table  named group. 
                 It returns a  ResolvedTable  named tuple instance with the following fields: 
                 
                     
                         db  -  Database 
                         
                             The database object 
                         
                     
                     
                         table  - string 
                         
                             The name of the table (or view) 
                         
                     
                     
                         is_view  - boolean 
                         
                             True  if this is a view,  False  if it is a table 
                         
                     
                 
                 If the database or table cannot be found it raises a  datasette.utils.asgi.DatabaseNotFound  exception. 
                 If the table does not exist it raises a  datasette.utils.asgi.TableNotFound  exception - a subclass of  datasette.utils.asgi.NotFound  with  .database_name  and  .table  attributes.","[""Internals for plugins"", ""Datasette class""]",[]
internals:datasette-setting,internals,datasette-setting,.setting(key),"key  - string 
                         
                             The name of the setting, e.g.  base_url . 
                         
                     
                 
                 Returns the configured value for the specified  setting . This can be a string, boolean or integer depending on the requested setting. 
                 For example: 
                 downloads_are_allowed = datasette.setting(""allow_download"")","[""Internals for plugins"", ""Datasette class""]",[]
internals:datasette-sign,internals,datasette-sign,".sign(value, namespace=""default"")","value  - any serializable type 
                         
                             The value to be signed. 
                         
                     
                     
                         namespace  - string, optional 
                         
                             An alternative namespace, see the  itsdangerous salt documentation . 
                         
                     
                 
                 Utility method for signing values, such that you can safely pass data to and from an untrusted environment. This is a wrapper around the  itsdangerous  library. 
                 This method returns a signed string, which can be decoded and verified using  .unsign(value, namespace=""default"") .","[""Internals for plugins"", ""Datasette class""]","[{""href"": ""https://itsdangerous.palletsprojects.com/en/1.1.x/serializer/#the-salt"", ""label"": ""itsdangerous salt documentation""}, {""href"": ""https://itsdangerous.palletsprojects.com/"", ""label"": ""itsdangerous""}]"
internals:datasette-track-event,internals,datasette-track-event,await .track_event(event),"event  -  Event 
                         
                             An instance of a subclass of  datasette.events.Event . 
                         
                     
                 
                 Plugins can call this to track events, using classes they have previously registered. See  Event tracking  for details. 
                 The event will then be passed to all plugins that have registered to receive events using the  track_event(datasette, event)  hook. 
                 Example usage, assuming the plugin has previously registered the  BanUserEvent  class: 
                 await datasette.track_event(
    BanUserEvent(user={""id"": 1, ""username"": ""cleverbot""})
)","[""Internals for plugins"", ""Datasette class""]",[]
internals:datasette-unsign,internals,datasette-unsign,".unsign(value, namespace=""default"")","signed  - any serializable type 
                         
                             The signed string that was created using  .sign(value, namespace=""default"") . 
                         
                     
                     
                         namespace  - string, optional 
                         
                             The alternative namespace, if one was used. 
                         
                     
                 
                 Returns the original, decoded object that was passed to  .sign(value, namespace=""default"") . If the signature is not valid this raises a  itsdangerous.BadSignature  exception.","[""Internals for plugins"", ""Datasette class""]",[]
internals:id1,internals,id1,.get_internal_database(),Returns a database object for reading and writing to the private  internal database .,"[""Internals for plugins"", ""Datasette class""]",[]
internals:internals-datasette-client,internals,internals-datasette-client,datasette.client,"Plugins can make internal simulated HTTP requests to the Datasette instance within which they are running. This ensures that all of Datasette's external JSON APIs are also available to plugins, while avoiding the overhead of making an external HTTP call to access those APIs. 
                 The  datasette.client  object is a wrapper around the  HTTPX Python library , providing an async-friendly API that is similar to the widely used  Requests library . 
                 It offers the following methods: 
                 
                     
                         await datasette.client.get(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal GET request against that path. 
                         
                     
                     
                         await datasette.client.post(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal POST request. Use  data={""name"": ""value""}  to pass form parameters. 
                         
                     
                     
                         await datasette.client.options(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal OPTIONS request. 
                         
                     
                     
                         await datasette.client.head(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal HEAD request. 
                         
                     
                     
                         await datasette.client.put(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal PUT request. 
                         
                     
                     
                         await datasette.client.patch(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal PATCH request. 
                         
                     
                     
                         await datasette.client.delete(path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal DELETE request. 
                         
                     
                     
                         await datasette.client.request(method, path, **kwargs)  - returns HTTPX Response 
                         
                             Execute an internal request with the given HTTP method against that path. 
                         
                     
                 
                 These methods can be used with  datasette.urls  - for example: 
                 table_json = (
    await datasette.client.get(
        datasette.urls.table(
            ""fixtures"", ""facetable"", format=""json""
        )
    )
).json() 
                 datasette.client  methods automatically take the current  base_url  setting into account, whether or not you use the  datasette.urls  family of methods to construct the path. 
                 For documentation on available  **kwargs  options and the shape of the HTTPX Response object refer to the  HTTPX Async documentation .","[""Internals for plugins"", ""Datasette class""]","[{""href"": ""https://www.python-httpx.org/"", ""label"": ""HTTPX Python library""}, {""href"": ""https://requests.readthedocs.io/"", ""label"": ""Requests library""}, {""href"": ""https://www.python-httpx.org/async/"", ""label"": ""HTTPX Async documentation""}]"
internals:internals-datasette-urls,internals,internals-datasette-urls,datasette.urls,"The  datasette.urls  object contains methods for building URLs to pages within Datasette. Plugins should use this to link to pages, since these methods take into account any  base_url  configuration setting that might be in effect. 
                 
                     
                         datasette.urls.instance(format=None) 
                         
                             Returns the URL to the Datasette instance root page. This is usually  ""/"" . 
                         
                     
                     
                         datasette.urls.path(path, format=None) 
                         
                             Takes a path and returns the full path, taking  base_url  into account. 
                             For example,  datasette.urls.path(""-/logout"")  will return the path to the logout page, which will be  ""/-/logout""  by default or  /prefix-path/-/logout  if  base_url  is set to  /prefix-path/ 
                         
                     
                     
                         datasette.urls.logout() 
                         
                             Returns the URL to the logout page, usually  ""/-/logout"" 
                         
                     
                     
                         datasette.urls.static(path) 
                         
                             Returns the URL of one of Datasette's default static assets, for example  ""/-/static/app.css"" 
                         
                     
                     
                         datasette.urls.static_plugins(plugin_name, path) 
                         
                             Returns the URL of one of the static assets belonging to a plugin. 
                             datasette.urls.static_plugins(""datasette_cluster_map"", ""datasette-cluster-map.js"")  would return  ""/-/static-plugins/datasette_cluster_map/datasette-cluster-map.js"" 
                         
                     
                     
                         datasette.urls.static(path) 
                         
                             Returns the URL of one of Datasette's default static assets, for example  ""/-/static/app.css"" 
                         
                     
                     
                         datasette.urls.database(database_name, format=None) 
                         
                             Returns the URL to a database page, for example  ""/fixtures"" 
                         
                     
                     
                         datasette.urls.table(database_name, table_name, format=None) 
                         
                             Returns the URL to a table page, for example  ""/fixtures/facetable"" 
                         
                     
                     
                         datasette.urls.query(database_name, query_name, format=None) 
                         
                             Returns the URL to a query page, for example  ""/fixtures/pragma_cache_size"" 
                         
                     
                 
                 These functions can be accessed via the  {{ urls }}  object in Datasette templates, for example: 
                 <a href=""{{ urls.instance() }}"">Homepage</a>
<a href=""{{ urls.database(""fixtures"") }}"">Fixtures database</a>
<a href=""{{ urls.table(""fixtures"", ""facetable"") }}"">facetable table</a>
<a href=""{{ urls.query(""fixtures"", ""pragma_cache_size"") }}"">pragma_cache_size query</a> 
                 Use the  format=""json""  (or  ""csv""  or other formats supported by plugins) arguments to get back URLs to the JSON representation. This is the path with  .json  added on the end. 
                 These methods each return a  datasette.utils.PrefixedUrlString  object, which is a subclass of the Python  str  type. This allows the logic that considers the  base_url  setting to detect if that prefix has already been applied to the path.","[""Internals for plugins"", ""Datasette class""]",[]