home

Menu
  • ripgrep search

ripgrep

Options:

For example *.py or **/templates/**/*.html or datasette/** or !setup.py

dogsheep-beta/dogsheep_beta/__init__.py

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"]

datasette-upload-dbs/datasette_upload_dbs/__init__.py

59  def startup(datasette):
60      # Load any databases located in the directory folder
61      config = datasette.plugin_config("datasette-upload-dbs") or {}
62      if config.get("skip_startup_scan"):
63          return
76  
77  def _configured(datasette):
78      return (datasette.plugin_config("datasette-upload-dbs") or {}).get("directory")
79  
80  

datasette-unsafe-expose-env/datasette_unsafe_expose_env/__init__.py

7   
8   async def env(request, datasette):
9       redact = (datasette.plugin_config("datasette-unsafe-expose-env") or {}).get(
10          "redact"
11      ) or DEFAULT_REDACT

datasette-tiles/datasette_tiles/utils.py

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:

datasette-socrata/datasette_socrata/__init__.py

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 

datasette-sitemap/datasette_sitemap/__init__.py

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(

datasette-sentry/datasette_sentry.py

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:

datasette-seaborn/datasette_seaborn/__init__.py

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  

datasette-scale-to-zero/datasette_scale_to_zero/__init__.py

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

datasette-render-timestamps/datasette_render_timestamps/__init__.py

18  def render_cell(value, column, table, database, datasette):
19      config = (
20          datasette.plugin_config(
21              "datasette-render-timestamps", database=database, table=table
22          )

datasette-ripgrep/README.md

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`

datasette-ripgrep/datasette_ripgrep/__init__.py

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
139 async def view_file(request, datasette):
140     await check_permission(request, datasette)
141     config = datasette.plugin_config("datasette-ripgrep") or {}
142     subpath = urllib.parse.unquote(request.url_vars["subpath"])
143     path = config.get("path")
187 @hookimpl
188 def menu_links(datasette, actor):
189     config = datasette.plugin_config("datasette-ripgrep") or {}
190     if not config.get("path"):
191         return

datasette-render-images/datasette_render_images.py

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

datasette-render-markdown/datasette_render_markdown/__init__.py

19      should_convert = False
20      config = (
21          datasette.plugin_config(
22              "datasette-render-markdown", database=database, table=table
23          )

datasette-render-html/datasette_render_html.py

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       )

datasette-remote-metadata/datasette_remote_metadata/__init__.py

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  

datasette-redirect-to-https/datasette_redirect_to_https/__init__.py

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"

datasette-redirect-forbidden/datasette_redirect_forbidden/__init__.py

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:

datasette-public/datasette_public/__init__.py

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)

datasette-permissions-sql/datasette_permissions_sql/__init__.py

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")

datasette-notebook/datasette_notebook/__init__.py

101 
102 def config_notebook(datasette):
103     config = datasette.plugin_config("datasette-notebook") or {}
104     return config.get("database") or "notebook"

datasette-media/datasette_media/__init__.py

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:

datasette-mask-columns/datasette_mask_columns/__init__.py

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:

datasette-llm/datasette_llm/__init__.py

26          pass
27  
28      config = datasette.plugin_config("llm") or {}
29      db_path = config.get("db_path") or (llm.user_dir() / "logs.db")
30      db_path = pathlib.Path(db_path)

datasette-llm-embed/datasette_llm_embed.py

5   
6   def llm_embed_factory(datasette):
7       config = datasette.plugin_config("datasette-llm-embed") or {}
8       keys = config.get("keys") or {}
9   

datasette-leaflet-geojson/datasette_leaflet_geojson/__init__.py

61  def extra_body_script(datasette, database, table):
62      config = (
63          datasette.plugin_config(
64              "datasette-leaflet-geojson", database=database, table=table
65          )

datasette-insert/datasette_insert/__init__.py

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"])

datasette-init/datasette_init/__init__.py

6   def startup(datasette):
7       async def inner():
8           config = datasette.plugin_config("datasette-init")
9           if not config:
10              return

datasette-indieauth/datasette_indieauth/__init__.py

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

datasette-hashed-urls/datasette_hashed_urls/__init__.py

109         return
110     else:
111         plugin_config = datasette.plugin_config("datasette-hashed-urls") or {}
112         max_age = plugin_config.get("max_age", 31536000)
113 

datasette-graphql/datasette_graphql/utils.py

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     )

datasette-graphql/datasette_graphql/__init__.py

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():

datasette-faiss/datasette_faiss/__init__.py

13      # Create indexes for configured tables
14      async def inner():
15          config = datasette.plugin_config("datasette-faiss")
16          if not config:
17              return

datasette-expose-env/datasette_expose_env/__init__.py

6   
7   async def env(request, datasette):
8       expose = datasette.plugin_config("datasette-expose-env") or []
9       if not expose:
10          return Response.text(

datasette-ephemeral-tables/datasette_ephemeral_tables/__init__.py

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"),

datasette-edit-templates/datasette_edit_templates/__init__.py

77  @hookimpl
78  def menu_links(datasette, actor):
79      config = datasette.plugin_config("datasette-edit-templates") or {}
80      if "menu_label" not in config:
81          menu_label = "Edit templates"
101 
102 def get_database(datasette):
103     plugin_config = datasette.plugin_config("datasette-edit-templates") or {}
104     if plugin_config.get("internal_db"):
105         return datasette.get_internal_database()
114 @hookimpl
115 def prepare_jinja2_environment(env, datasette):
116     config = datasette.plugin_config("datasette-edit-templates") or {}
117     if config.get("skip_prepare_jinja2_environment"):
118         return

datasette-cors/datasette_cors.py

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 []

datasette-copy-to-memory/datasette_copy_to_memory/__init__.py

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")

datasette-configure-asgi/datasette_configure_asgi.py

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)

datasette-cluster-map/datasette_cluster_map/__init__.py

32          return []
33      config = (
34          datasette.plugin_config("datasette-cluster-map", database=database, table=table)
35          or {}
36      )
89  
90      config = (
91          datasette.plugin_config("datasette-cluster-map", database=database, table=table)
92          or {}
93      )

datasette-block-robots/datasette_block_robots/__init__.py

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")

datasette-block/datasette_block/__init__.py

5   @hookimpl
6   def asgi_wrapper(datasette):
7       config = datasette.plugin_config("datasette-block") or {}
8       prefixes = config.get("prefixes") or []
9   

datasette-big-local/datasette_big_local/__init__.py

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 ".",

datasette-auth0/datasette_auth0/__init__.py

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)

datasette-auth-passwords/datasette_auth_passwords/utils.py

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

datasette-auth-passwords/datasette_auth_passwords/__init__.py

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

datasette-auth-tokens/datasette_auth_tokens/views.py

371 class Config:
372     def __init__(self, datasette):
373         self._plugin_config = datasette.plugin_config("datasette-auth-tokens") or {}
374         self._datasette = datasette
375         self.enabled = self._plugin_config.get("manage_tokens")

datasette-auth-github/datasette_auth_github/views.py

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"):

datasette-auth-existing-cookies/datasette_auth_existing_cookies/__init__.py

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:

datasette-atom/datasette_atom/__init__.py

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(

datasette/tests/test_plugins.py

58      )
59      assert [
60          "database=fixtures, datasette.plugin_config(\"name-of-plugin\")={'depth': 'root'}"
61      ] == response.json()
62  
216 @pytest.mark.asyncio
217 async def test_plugin_config(ds_client):
218     assert {"depth": "table"} == ds_client.ds.plugin_config(
219         "name-of-plugin", database="fixtures", table="sortable"
220     )
221     assert {"depth": "database"} == ds_client.ds.plugin_config(
222         "name-of-plugin", database="fixtures", table="unknown_table"
223     )
224     assert {"depth": "database"} == ds_client.ds.plugin_config(
225         "name-of-plugin", database="fixtures"
226     )
227     assert {"depth": "root"} == ds_client.ds.plugin_config(
228         "name-of-plugin", database="unknown_database"
229     )
230     assert {"depth": "root"} == ds_client.ds.plugin_config("name-of-plugin")
231     assert None is ds_client.ds.plugin_config("unknown-plugin")
232 
233 
235 async def test_plugin_config_env(ds_client):
236     os.environ["FOO_ENV"] = "FROM_ENVIRONMENT"
237     assert {"foo": "FROM_ENVIRONMENT"} == ds_client.ds.plugin_config("env-plugin")
238     del os.environ["FOO_ENV"]
239 
242 async def test_plugin_config_env_from_list(ds_client):
243     os.environ["FOO_ENV"] = "FROM_ENVIRONMENT"
244     assert [{"in_a_list": "FROM_ENVIRONMENT"}] == ds_client.ds.plugin_config(
245         "env-plugin-list"
246     )
252     with open(TEMP_PLUGIN_SECRET_FILE, "w") as fp:
253         fp.write("FROM_FILE")
254     assert {"foo": "FROM_FILE"} == ds_client.ds.plugin_config("file-plugin")
255     os.remove(TEMP_PLUGIN_SECRET_FILE)
256 

datasette/tests/test_cli.py

255     assert (
256         json.loads(result.output).get("rows")[0].get("prepare_connection_args()")
257         == 'database=_memory, datasette.plugin_config("name-of-plugin")=None'
258     )
259 
273     assert (
274         json.loads(result.output).get("rows")[0].get("prepare_connection_args()")
275         == 'database=_memory, datasette.plugin_config("name-of-plugin")=OVERRIDE'
276     )
277 

datasette/tests/plugins/my_plugin.py

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(

datasette/tests/plugins/my_plugin_2.py

187 @hookimpl
188 def register_routes(datasette):
189     config = datasette.plugin_config("register-route-demo")
190     if not config:
191         return

datasette/docs/writing_plugins.rst

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     )

datasette/docs/plugin_hooks.rst

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:
586 
587 ``datasette`` - :ref:`internals_datasette`
588     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``
589 
590 Register additional view functions to execute for specified URL routes.
614 
615 ``datasette`` - :ref:`internals_datasette`
616     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
617 
618 ``request`` - :ref:`internals_request`
884     @hookimpl
885     def startup(datasette):
886         config = datasette.plugin_config("my-plugin") or {}
887         assert (
888             "required-setting" in config
933 
934 ``datasette`` - :ref:`internals_datasette`
935     You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
936 
937 ``database`` - string
1012
1013``datasette`` - :ref:`internals_datasette`
1014    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1015
1016``request`` - :ref:`internals_request`
1078
1079``datasette`` - :ref:`internals_datasette`
1080    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1081
1082``actor_ids`` - list of strings or integers
1188
1189``datasette`` - :ref:`internals_datasette`
1190    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1191
1192This 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.
1237
1238``datasette`` - :ref:`internals_datasette`
1239    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1240
1241``actor`` - dictionary
1302
1303``datasette`` - :ref:`internals_datasette`
1304    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``.
1305
1306: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.
1345
1346``datasette`` - :ref:`internals_datasette`
1347    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to render templates or execute SQL queries.
1348
1349``request`` - :ref:`internals_request`
1395
1396``datasette`` - :ref:`internals_datasette`
1397    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to render templates or execute SQL queries.
1398
1399``request`` - :ref:`internals_request`
1438
1439``datasette`` - :ref:`internals_datasette`
1440    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1441
1442``actor`` - dictionary or None
1481
1482``datasette`` - :ref:`internals_datasette`
1483    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1484
1485``actor`` - dictionary or None
1528
1529``datasette`` - :ref:`internals_datasette`
1530    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1531
1532``actor`` - dictionary or None
1579
1580``datasette`` - :ref:`internals_datasette`
1581    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``, or to execute SQL queries.
1582
1583``scope`` - dictionary
1605
1606``datasette`` - :ref:`internals_datasette`
1607    You can use this to access plugin configuration options via ``datasette.plugin_config(your_plugin_name)``.
1608
1609``actor`` - dictionary or None

datasette/docs/internals.rst

285 .. _datasette_plugin_config:
286 
287 .plugin_config(plugin_name, database=None, table=None)
288 ------------------------------------------------------
289 

big-local-datasette/plugins/token_auth.py

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")
Powered by Datasette