ripgrep

29  @hookimpl(trylast=True)

30  def asgi_wrapper(datasette):

31      config = datasette.plugin_config("token-auth") or {}

32      secret = config.get("secret")

33      auth = config.get("auth")

285 .. _datasette_plugin_config:

286 

287 .plugin_config(plugin_name, database=None, table=None)

288 ------------------------------------------------------

289 

35  

36  ``datasette`` - :ref:`internals_datasette`

37      You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``

38  

39  This hook is called when a new SQLite database connection is created. You can

69  

70  ``datasette`` - :ref:`internals_datasette`

71      You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``

72  

73  This hook is called with the Jinja2 environment that is used to evaluate

119 

120 ``datasette`` - :ref:`internals_datasette`

121     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``

122 

123 This hook can return one of three different types:

297 The ``template``, ``database``, ``table`` and ``view_name`` options can be used to return different code depending on which template is being rendered and which database or table are being processed.

298 

299 The ``datasette`` instance is provided primarily so that you can consult any plugin configuration options that may have been set, using the ``datasette.plugin_config(plugin_name)`` method documented above.

300 

301 This function can return a string containing JavaScript, or a dictionary as described below, or a function or awaitable function that returns a string or dictionary.

402 

403 ``datasette`` - :ref:`internals_datasette`

404     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

405 

406 ``request`` - :ref:`internals_request`

471 

472 ``datasette`` - :ref:`internals_datasette`

473     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``

474 

475 Registers a new output renderer, to output data in a custom format. The hook function should return a dictionary, or a list of dictionaries, of the following shape:

580 

581 ``datasette`` - :ref:`internals_datasette`

582     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``

583 

584 Register additional view functions to execute for specified URL routes.

608 

609 ``datasette`` - :ref:`internals_datasette`

610     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

611 

612 ``request`` - :ref:`internals_request`

876     @hookimpl

877     def startup(datasette):

878         config = datasette.plugin_config("my-plugin") or {}

879         assert (

880             "required-setting" in config

925 

926 ``datasette`` - :ref:`internals_datasette`

927     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

928 

929 ``database`` - string

1004

1005``datasette`` - :ref:`internals_datasette`

1006    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1007

1008``request`` - :ref:`internals_request`

1079

1080``datasette`` - :ref:`internals_datasette`

1081    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1082

1083This hook runs on the :ref:`table <TableView>` page, and can influence the ``where`` clause of the SQL query used to populate that page, based on query string arguments on the incoming request.

1128

1129``datasette`` - :ref:`internals_datasette`

1130    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1131

1132``actor`` - dictionary

1193

1194``datasette`` - :ref:`internals_datasette`

1195    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``.

1196

1197:ref:`canned_queries_magic_parameters` can be used to add automatic parameters to :ref:`canned queries <canned_queries>`. This plugin hook allows additional magic parameters to be defined by plugins.

1236

1237``datasette`` - :ref:`internals_datasette`

1238    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to render templates or execute SQL queries.

1239

1240``request`` - :ref:`internals_request`

1286

1287``datasette`` - :ref:`internals_datasette`

1288    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to render templates or execute SQL queries.

1289

1290``request`` - :ref:`internals_request`

1329

1330``datasette`` - :ref:`internals_datasette`

1331    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1332

1333``actor`` - dictionary or None

1372

1373``datasette`` - :ref:`internals_datasette`

1374    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1375

1376``actor`` - dictionary or None

1419

1420``datasette`` - :ref:`internals_datasette`

1421    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1422

1423``actor`` - dictionary or None

1440

1441``datasette`` - :ref:`internals_datasette`

1442    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.

1443

1444``scope`` - dictionary

1466

1467``datasette`` - :ref:`internals_datasette`

1468    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``.

1469

1470``actor`` - dictionary or None

177 When you are writing plugins, you can access plugin configuration like this using the ``datasette plugin_config()`` method. If you know you need plugin configuration for a specific table, you can access it like this::

178 

179     plugin_config = datasette.plugin_config(

180         "datasette-cluster-map", database="sf-trees", table="Street_Tree_List"

181     )

21  

22      def prepare_connection_args():

23          return 'database={}, datasette.plugin_config("name-of-plugin")={}'.format(

24              database, datasette.plugin_config("name-of-plugin")

25          )

26  

79                      "database": database,

80                      "table": table,

81                      "config": datasette.plugin_config(

82                          "name-of-plugin",

83                          database=database,

108                 "table": table,

109                 "database": database,

110                 "config": datasette.plugin_config(

111                     "name-of-plugin",

112                     database=database,

412 @hookimpl

413 def register_permissions(datasette):

414     extras = datasette.plugin_config("datasette-register-permissions") or {}

415     permissions = [

416         Permission(

186 @hookimpl

187 def register_routes(datasette):

188     config = datasette.plugin_config("register-route-demo")

189     if not config:

190         return

57      )

58      assert [

59          "database=fixtures, datasette.plugin_config(\"name-of-plugin\")={'depth': 'root'}"

60      ] == response.json()

61  

214 @pytest.mark.asyncio

215 async def test_plugin_config(ds_client):

216     assert {"depth": "table"} == ds_client.ds.plugin_config(

217         "name-of-plugin", database="fixtures", table="sortable"

218     )

219     assert {"depth": "database"} == ds_client.ds.plugin_config(

220         "name-of-plugin", database="fixtures", table="unknown_table"

221     )

222     assert {"depth": "database"} == ds_client.ds.plugin_config(

223         "name-of-plugin", database="fixtures"

224     )

225     assert {"depth": "root"} == ds_client.ds.plugin_config(

226         "name-of-plugin", database="unknown_database"

227     )

228     assert {"depth": "root"} == ds_client.ds.plugin_config("name-of-plugin")

229     assert None is ds_client.ds.plugin_config("unknown-plugin")

230 

231 

233 async def test_plugin_config_env(ds_client):

234     os.environ["FOO_ENV"] = "FROM_ENVIRONMENT"

235     assert {"foo": "FROM_ENVIRONMENT"} == ds_client.ds.plugin_config("env-plugin")

236     # Ensure secrets aren't visible in /-/metadata.json

237     metadata = await ds_client.get("/-/metadata.json")

243 async def test_plugin_config_env_from_list(ds_client):

244     os.environ["FOO_ENV"] = "FROM_ENVIRONMENT"

245     assert [{"in_a_list": "FROM_ENVIRONMENT"}] == ds_client.ds.plugin_config(

246         "env-plugin-list"

247     )

258     with open(TEMP_PLUGIN_SECRET_FILE, "w") as fp:

259         fp.write("FROM_FILE")

260     assert {"foo": "FROM_FILE"} == ds_client.ds.plugin_config("file-plugin")

261     # Ensure secrets aren't visible in /-/metadata.json

262     metadata = await ds_client.get("/-/metadata.json")

51      if query_name:

52          # Check allow_unsafe_html_in_canned_queries

53          plugin_config = datasette.plugin_config("datasette-atom")

54          if plugin_config:

55              allow_unsafe_html_in_canned_queries = plugin_config.get(

6   @hookimpl

7   def actor_from_request(datasette, request):

8       config = datasette.plugin_config("datasette-auth-existing-cookies") or {}

9       api_url = config.get("api_url")

10      if api_url is None:

15  

16  async def github_auth_start(datasette):

17      config = datasette.plugin_config("datasette-auth-github")

18      verify_config(config)

19      if config.get("load_teams") or config.get("load_orgs"):

39  

40  async def github_auth_callback(datasette, request, scope, receive, send):

41      config = datasette.plugin_config("datasette-auth-github")

42      verify_config(config)

43      if not request.args.get("code"):

25  

26  async def password_login(request, datasette):

27      config = datasette.plugin_config("datasette-auth-passwords") or {}

28      accounts = {

29          key.split("_password_hash")[0]: value

66  @hookimpl

67  def asgi_wrapper(datasette):

68      config = datasette.plugin_config("datasette-auth-passwords") or {}

69      if not config.get("http_basic_auth"):

70          return lambda asgi: asgi

30  

31  def scope_has_valid_authorization(scope, datasette):

32      config = datasette.plugin_config("datasette-auth-passwords") or {}

33      accounts = {

34          key.split("_password_hash")[0]: value

6   def actor_from_request(datasette, request):

7       async def inner():

8           config = datasette.plugin_config("datasette-auth-tokens") or {}

9           allowed_tokens = config.get("tokens") or []

10          query_param = config.get("param")

106 

107 def _config(datasette):

108     config = datasette.plugin_config("datasette-auth0")

109     missing = [

110         key for key in ("domain", "client_id", "client_secret") if not config.get(key)

33  

34  def get_settings(datasette):

35      plugin_config = datasette.plugin_config("datasette-big-local") or {}

36      return Settings(

37          root_dir=plugin_config.get("root_dir") or ".",

5   @hookimpl

6   def asgi_wrapper(datasette):

7       config = datasette.plugin_config("datasette-block") or {}

8       prefixes = config.get("prefixes") or []

9   

9   

10  async def robots_txt(datasette, request):

11      config = datasette.plugin_config("datasette-block-robots") or {}

12      literal = config.get("literal")

13      disallow = []

47  @hookimpl

48  def startup(datasette):

49      config = datasette.plugin_config("datasette-block-robots") or {}

50      assert not (

51          config.get("disallow") and config.get("literal")

30          return []

31      config = (

32          datasette.plugin_config("datasette-cluster-map", database=database, table=table)

33          or {}

34      )

76      columns = [column.lower() for column in columns]

77      config = (

78          datasette.plugin_config("datasette-cluster-map", database=database, table=table)

79          or {}

80      )

6   def asgi_wrapper(datasette):

7       def wrap_with_classes(app):

8           configs = datasette.plugin_config("datasette-configure-asgi") or []

9           for config in configs:

10              module_path, class_name = config["class"].rsplit(".", 1)

5   @hookimpl

6   def startup(datasette):

7       plugin_config = datasette.plugin_config("datasette-copy-to-memory") or {}

8       databases = plugin_config.get("databases")

9       replace = plugin_config.get("replace")

5   @hookimpl

6   def asgi_wrapper(datasette):

7       config = datasette.plugin_config("datasette-cors") or {}

8       allow_all = config.get("allow_all") or False

9       hosts = config.get("hosts") or []

73  

74  def get_database(datasette):

75      plugin_config = datasette.plugin_config("datasette-edit-templates") or {}

76      return datasette.get_database(plugin_config.get("database"))

77  

52  

53  def _settings(datasette):

54      plugin_config = datasette.plugin_config("datasette-ephemeral-tables") or {}

55      return Settings(

56          name=plugin_config.get("name", "ephemeral"),

6   

7   async def env(request, datasette):

8       expose = datasette.plugin_config("datasette-expose-env") or []

9       if not expose:

10          return Response.text(

13      # Create indexes for configured tables

14      async def inner():

15          config = datasette.plugin_config("datasette-faiss")

16          if not config:

17              return

107         )

108 

109     config = datasette.plugin_config("datasette-graphql") or {}

110     context = {

111         "time_started": time.monotonic(),

166 

167 def _graphql_path(datasette):

168     config = datasette.plugin_config("datasette-graphql") or {}

169     graphql_path = None

170     if "path" not in config:

214 def startup(datasette):

215     # Validate configuration

216     config = datasette.plugin_config("datasette-graphql") or {}

217     if "databases" in config:

218         for database_name in config["databases"].keys():

244         schema=graphene.Schema(

245             query=Query,

246             auto_camelcase=(datasette.plugin_config("datasette-graphql") or {}).get(

247                 "auto_camelcase", False

248             ),

369     fks_by_column = {fk.column: fk for fk in meta.foreign_keys}

370 

371     table_plugin_config = datasette.plugin_config(

372         "datasette-graphql", database=db.name, table=table

373     )

109         return

110     else:

111         plugin_config = datasette.plugin_config("datasette-hashed-urls") or {}

112         max_age = plugin_config.get("max_age", 31536000)

113 

230     if action != "view-instance":

231         return None

232     plugin_config = datasette.plugin_config("datasette-indieauth") or {}

233     if plugin_config.get("restrict_access") is None:

234         return None

6   def startup(datasette):

7       async def inner():

8           config = datasette.plugin_config("datasette-init")

9           if not config:

10              return

115     if action != "insert:all":

116         return None

117     plugin_config = datasette.plugin_config("datasette-insert") or {}

118     if "allow" in plugin_config:

119         return actor_matches_allow(actor, plugin_config["allow"])

61  def extra_body_script(datasette, database, table):

62      config = (

63          datasette.plugin_config(

64              "datasette-leaflet-geojson", database=database, table=table

65          )

9               return sqlite3.SQLITE_OK

10          masks = (

11              datasette.plugin_config("datasette-mask-columns", database=database) or {}

12          )

13          columns_to_mask = masks.get(table) or None

29  @hookimpl()

30  def render_cell(column, table, database, datasette):

31      masks = datasette.plugin_config("datasette-mask-columns", database=database) or {}

32      columns_to_mask = masks.get(table) or set()

33      if column in columns_to_mask:

24  async def serve_media(datasette, request, send):

25      global transform_executor

26      plugin_config = datasette.plugin_config("datasette-media") or {}

27      pool_size = plugin_config.get("transform_threads") or 4

28      if transform_executor is None:

101 

102 def config_notebook(datasette):

103     config = datasette.plugin_config("datasette-notebook") or {}

104     return config.get("database") or "notebook"

20                  value = json.dumps(value, default=repr)

21              params["actor_{}".format(key)] = value

22          for rule in datasette.plugin_config("datasette-permissions-sql") or []:

23              sql = rule["sql"]

24              rule_action = rule.get("action")

140 

141 def db_from_config(datasette):

142     config = datasette.plugin_config("datasette-public") or {}

143     db_name = config.get("database") or None

144     return datasette.get_database(db_name)

5   @hookimpl

6   def forbidden(datasette):

7       config = datasette.plugin_config("datasette-redirect-forbidden") or {}

8       redirect_to = config.get("redirect_to")

9       if redirect_to:

12  @hookimpl

13  def asgi_wrapper(datasette):

14      config = datasette.plugin_config("datasette-redirect-to-https") or {}

15      if_headers = config.get("if_headers") or {}

16      check = lambda scope: scope["scheme"] == "http"

12      # when it hits time limit. If the time limit is hit it will still

13      # perform the update once the request has completed

14      config = datasette.plugin_config("datasette-remote-metadata") or {}

15      url = config.get("url")

16      if not url:

59  def asgi_wrapper(datasette):

60      # Refresh stale (over X seconds old) remote metadata on every request

61      config = datasette.plugin_config("datasette-remote-metadata") or {}

62      ttl = config.get("ttl") or 30

63  

5   @hookimpl

6   def render_cell(value, column, table, database, datasette):

7       config = datasette.plugin_config(

8           "datasette-render-html", database=database, table=table

9       )

11      size_limit = DEFAULT_SIZE_LIMIT

12      if datasette:

13          plugin_config = datasette.plugin_config("datasette-render-images") or {}

14          size_limit = plugin_config.get("size_limit") or DEFAULT_SIZE_LIMIT

15      # Only act on byte columns

18      should_convert = False

19      config = (

20          datasette.plugin_config(

21              "datasette-render-markdown", database=database, table=table

22          )

18  def render_cell(value, column, table, database, datasette):

19      config = (

20          datasette.plugin_config(

21              "datasette-render-timestamps", database=database, table=table

22          )

17  

18  - [with.\*AsyncClient](https://ripgrep.datasette.io/-/ripgrep?pattern=with.*AsyncClient) - regular expression search for `with.*AsyncClient`

19  - [.plugin_config, literal=on](https://ripgrep.datasette.io/-/ripgrep?pattern=.plugin_config\(&literal=on) - a non-regular expression search for `.plugin_config(`

20  - [with.\*AsyncClient glob=datasette/\*\*](https://ripgrep.datasette.io/-/ripgrep?pattern=with.*AsyncClient&glob=datasette%2F%2A%2A) - search for that pattern only within the `datasette/` top folder

21  - ["sqlite-utils\[">\] glob=setup.py](https://ripgrep.datasette.io/-/ripgrep?pattern=%22sqlite-utils%5B%22%3E%5D&glob=setup.py) - a regular expression search for packages that depend on either `sqlite-utils` or `sqlite-utils>=some-version`

81      globs = [g.strip() for g in request.args.getlist("glob") if g.strip()]

82  

83      config = datasette.plugin_config("datasette-ripgrep") or {}

84      time_limit = config.get("time_limit") or 1.0

85      max_lines = config.get("max_lines") or 2000

138 async def view_file(request, datasette):

139     await check_permission(request, datasette)

140     config = datasette.plugin_config("datasette-ripgrep") or {}

141     subpath = urllib.parse.unquote(request.url_vars["subpath"])

142     path = config.get("path")

71  

72  def get_config(datasette, key):

73      duration_s = (datasette.plugin_config("datasette-scale-to-zero") or {}).get(key)

74      if duration_s is None:

75          return None

28      }

29  

30      plugin_config = datasette.plugin_config("datasette-seaborn") or {}

31      render_time_limit = plugin_config.get("render_time_limit") or DEFAULT_TIME_LIMIT

32  

6   @hookimpl

7   def asgi_wrapper(datasette):

8       config = datasette.plugin_config("datasette-sentry") or {}

9       dsn = config.get("dsn")

10      if dsn is not None:

15  

16  def _sitemap_config(datasette):

17      plugin_config = datasette.plugin_config("datasette-sitemap") or {}

18      if plugin_config.get("sql") or plugin_config.get("base_url"):

19          return SitemapConfig(

101 

102     # Config can be used to restrict to a named database

103     config = datasette.plugin_config("datasette-socrata") or {}

104     configured_database = config.get("database")

105 

32  

33  async def tiles_stack_database_order(datasette):

34      config = datasette.plugin_config("datasette-tiles") or {}

35      stack_order = config.get("tiles-stack-order")

36      if not stack_order:

7   

8   async def env(request, datasette):

9       redact = (datasette.plugin_config("datasette-unsafe-expose-env") or {}).get(

10          "redact"

11      ) or DEFAULT_REDACT

56  

57  def _configured(datasette):

58      return (datasette.plugin_config("datasette-upload-dbs") or {}).get("directory")

59  

60  

57      from datasette.utils import path_with_removed_args, path_with_replaced_args

58  

59      config = datasette.plugin_config("dogsheep-beta") or {}

60      database_name = config.get("database") or datasette.get_database().name

61      dogsheep_beta_config_file = config["config_file"]