fastasyncpg 0.0.1__tar.gz

fastasyncpg-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2022, fastai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

fastasyncpg-0.0.1/MANIFEST.in

@@ -0,0 +1,5 @@
+include pyproject.toml
+include LICENSE
+include CONTRIBUTING.md
+include README.md
+recursive-exclude * __pycache__

fastasyncpg-0.0.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: fastasyncpg
+Version: 0.0.1
+Summary: A simple wrapper for asyncpg
+Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/fastasyncpg
+Project-URL: Documentation, https://AnswerDotAI.github.io/fastasyncpg/
+Keywords: nbdev
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncpg
+Requires-Dist: fastcore
+Requires-Dist: sqlparse
+Dynamic: license-file
+
+# fastasyncpg
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This file will become your README and also the index of your
+documentation.
+
+## Developer Guide
+
+If you are new to using `nbdev` here are some useful pointers to get you
+started.
+
+### Install fastasyncpg in Development mode
+
+``` sh
+# make sure fastasyncpg package is installed in development mode
+$ pip install -e .
+
+# make changes under nbs/ directory
+# ...
+
+# compile to have changes apply to fastasyncpg
+$ nbdev_prepare
+```
+
+## Usage
+
+### Installation
+
+Install latest from the GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg):
+
+``` sh
+$ pip install git+https://github.com/AnswerDotAI/fastasyncpg.git
+```
+
+or from [conda](https://anaconda.org/AnswerDotAI/fastasyncpg)
+
+``` sh
+$ conda install -c AnswerDotAI fastasyncpg
+```
+
+or from [pypi](https://pypi.org/project/fastasyncpg/)
+
+``` sh
+$ pip install fastasyncpg
+```
+
+### Documentation
+
+Documentation can be found hosted on this GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg)’s
+[pages](https://AnswerDotAI.github.io/fastasyncpg/). Additionally you
+can find package manager specific guidelines on
+[conda](https://anaconda.org/AnswerDotAI/fastasyncpg) and
+[pypi](https://pypi.org/project/fastasyncpg/) respectively.
+
+## How to use
+
+Fill me in please! Don’t forget code examples:
+
+``` python
+1+1
+```
+
+    2

fastasyncpg-0.0.1/README.md

@@ -0,0 +1,67 @@
+# fastasyncpg
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This file will become your README and also the index of your
+documentation.
+
+## Developer Guide
+
+If you are new to using `nbdev` here are some useful pointers to get you
+started.
+
+### Install fastasyncpg in Development mode
+
+``` sh
+# make sure fastasyncpg package is installed in development mode
+$ pip install -e .
+
+# make changes under nbs/ directory
+# ...
+
+# compile to have changes apply to fastasyncpg
+$ nbdev_prepare
+```
+
+## Usage
+
+### Installation
+
+Install latest from the GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg):
+
+``` sh
+$ pip install git+https://github.com/AnswerDotAI/fastasyncpg.git
+```
+
+or from [conda](https://anaconda.org/AnswerDotAI/fastasyncpg)
+
+``` sh
+$ conda install -c AnswerDotAI fastasyncpg
+```
+
+or from [pypi](https://pypi.org/project/fastasyncpg/)
+
+``` sh
+$ pip install fastasyncpg
+```
+
+### Documentation
+
+Documentation can be found hosted on this GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg)’s
+[pages](https://AnswerDotAI.github.io/fastasyncpg/). Additionally you
+can find package manager specific guidelines on
+[conda](https://anaconda.org/AnswerDotAI/fastasyncpg) and
+[pypi](https://pypi.org/project/fastasyncpg/) respectively.
+
+## How to use
+
+Fill me in please! Don’t forget code examples:
+
+``` python
+1+1
+```
+
+    2

fastasyncpg-0.0.1/fastasyncpg/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

fastasyncpg-0.0.1/fastasyncpg/_modidx.py

@@ -0,0 +1,93 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/fastasyncpg',
+                'doc_host': 'https://AnswerDotAI.github.io',
+                'git_url': 'https://github.com/AnswerDotAI/fastasyncpg',
+                'lib_path': 'fastasyncpg'},
+  'syms': { 'fastasyncpg.core': { 'fastasyncpg.core.Database': ('core.html#database', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.__getattr__': ('core.html#database.__getattr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.__init__': ('core.html#database.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.__str__': ('core.html#database.__str__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database._retr_tbl': ('core.html#database._retr_tbl', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.create': ('core.html#database.create', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.get_tables': ('core.html#database.get_tables', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.item': ('core.html#database.item', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.link_dcs': ('core.html#database.link_dcs', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.q': ('core.html#database.q', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.refresh': ('core.html#database.refresh', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.set_classes': ('core.html#database.set_classes', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.t': ('core.html#database.t', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.table': ('core.html#database.table', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Database.table2glb': ('core.html#database.table2glb', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.FRecord': ('core.html#frecord', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.FRecord.__getattr__': ('core.html#frecord.__getattr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.FRecord._repr_html_': ('core.html#frecord._repr_html_', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.NotFoundError': ('core.html#notfounderror', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Results': ('core.html#results', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Results._repr_html_': ('core.html#results._repr_html_', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table': ('core.html#table', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.__call__': ('core.html#table.__call__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.__getitem__': ('core.html#table.__getitem__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.__init__': ('core.html#table.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.__repr__': ('core.html#table.__repr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.__str__': ('core.html#table.__str__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.c': ('core.html#table.c', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.cols': ('core.html#table.cols', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.count': ('core.html#table.count', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.count_where': ('core.html#table.count_where', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.delete': ('core.html#table.delete', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.delete_where': ('core.html#table.delete_where', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.drop': ('core.html#table.drop', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.get': ('core.html#table.get', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.insert': ('core.html#table.insert', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.pks': ('core.html#table.pks', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.pks_and_rows_where': ( 'core.html#table.pks_and_rows_where',
+                                                                                 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.rows_where': ('core.html#table.rows_where', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.selectone': ('core.html#table.selectone', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.update': ('core.html#table.update', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.upsert': ('core.html#table.upsert', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.Table.xtra': ('core.html#table.xtra', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Col': ('core.html#_col', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Col.__init__': ('core.html#_col.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Col.__iter__': ('core.html#_col.__iter__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Col.__repr__': ('core.html#_col.__repr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Col.__str__': ('core.html#_col.__str__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter': ('core.html#_colsgetter', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__call__': ('core.html#_colsgetter.__call__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__contains__': ( 'core.html#_colsgetter.__contains__',
+                                                                                 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__dir__': ('core.html#_colsgetter.__dir__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__getattr__': ('core.html#_colsgetter.__getattr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__init__': ('core.html#_colsgetter.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._ColsGetter.__repr__': ('core.html#_colsgetter.__repr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter': ('core.html#_getter', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__contains__': ('core.html#_getter.__contains__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__dir__': ('core.html#_getter.__dir__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__getattr__': ('core.html#_getter.__getattr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__getitem__': ('core.html#_getter.__getitem__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__init__': ('core.html#_getter.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__iter__': ('core.html#_getter.__iter__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._Getter.__repr__': ('core.html#_getter.__repr__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._TablesGetter': ('core.html#_tablesgetter', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._TablesGetter.__init__': ('core.html#_tablesgetter.__init__', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._add_xtra': ('core.html#_add_xtra', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._dataclass': ('core.html#_dataclass', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._get_flds': ('core.html#_get_flds', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._pk_where': ('core.html#_pk_where', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._prep_row': ('core.html#_prep_row', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core._process_row': ('core.html#_process_row', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.all_dcs': ('core.html#all_dcs', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.col_def': ('core.html#col_def', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.columns_info': ('core.html#columns_info', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.connect': ('core.html#connect', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.conv_placeholders': ('core.html#conv_placeholders', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.create_mod': ('core.html#create_mod', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.create_pool': ('core.html#create_pool', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.get_field': ('core.html#get_field', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.get_typ': ('core.html#get_typ', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.pk_cols': ('core.html#pk_cols', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.setup_json': ('core.html#setup_json', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.table_names': ('core.html#table_names', 'fastasyncpg/core.py'),
+                                  'fastasyncpg.core.view_names': ('core.html#view_names', 'fastasyncpg/core.py')}}}

fastasyncpg-0.0.1/fastasyncpg/core.py

@@ -0,0 +1,547 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_core.ipynb.
+
+# %% auto #0
+__all__ = ['pg_to_py', 'py_to_pg', 'Results', 'FRecord', 'table_names', 'view_names', 'columns_info', 'pk_cols', 'Database',
+           'Table', 'conv_placeholders', 'get_typ', 'setup_json', 'connect', 'all_dcs', 'NotFoundError', 'get_field',
+           'create_mod', 'col_def', 'create_pool']
+
+# %% ../nbs/00_core.ipynb #222d751e
+from fastcore.utils import *
+import asyncpg
+from asyncpg import connection,protocol
+
+# %% ../nbs/00_core.ipynb #cdb9cd9e
+class Results(list):
+    def _repr_html_(self):
+        if not self: return ""
+        ks = list(self[0].keys())
+        ths = "".join(f"<th>{k}</th>" for k in ks)
+        trs = "".join(f"<tr>{''.join(f'<td>{v}</td>' for v in r.values())}</tr>" for r in self)
+        return f'<table class="prose"><thead><tr>{ths}</tr></thead><tbody>{trs}</tbody></table>'
+
+# %% ../nbs/00_core.ipynb #25f59343
+from asyncpg.protocol.record import Record
+
+# %% ../nbs/00_core.ipynb #e9a012cd
+class FRecord(Record):
+    def __getattr__(self, k):
+        if k.startswith('_'): raise AttributeError(k)
+        return self[k]
+
+    def _repr_html_(self):
+        rows = "".join(f"<tr><td>{k}</td><td>{v}</td></tr>" for k,v in self.items())
+        return f'<table class="prose"><thead><tr><th>Field</th><th>Value</th></tr></thead><tbody>{rows}</tbody></table>'
+
+# %% ../nbs/00_core.ipynb #7c604795
+async def table_names(conn, schema='public'):
+    "List of table names in `schema`"
+    res = await conn.fetch("""
+        SELECT c.relname FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = $1 AND c.relkind = 'r' AND NOT c.relname LIKE 'pg_%'""", schema)
+    return [r['relname'] for r in res]
+
+async def view_names(conn, schema='public'):
+    "List of view names in `schema`"
+    res = await conn.fetch("""
+        SELECT c.relname FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = $1 AND c.relkind = 'v'""", schema)
+    return [r['relname'] for r in res]
+
+# %% ../nbs/00_core.ipynb #29cf6d50
+async def columns_info(conn, table, schema='public'):
+    "Dict mapping column names to data types for `table`"
+    res = await conn.fetch("""
+        SELECT a.attname, format_type(a.atttypid, a.atttypmod) as data_type
+        FROM pg_attribute a
+        JOIN pg_class c ON c.oid = a.attrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = $1 AND c.relname = $2 AND a.attnum > 0 AND NOT a.attisdropped
+        ORDER BY a.attnum""", schema, table)
+    return {r['attname']: r['data_type'] for r in res}
+
+# %% ../nbs/00_core.ipynb #f504a98b
+async def pk_cols(conn, table):
+    "Get primary key column(s) for `table`"
+    res = await conn.fetch("""
+        SELECT a.attname FROM pg_index i
+        JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+        WHERE i.indrelid = $1::regclass AND i.indisprimary""", table)
+    return [r['attname'] for r in res]
+
+# %% ../nbs/00_core.ipynb #350e6168
+class Database:
+    def __init__(self, conn, refresh=True):
+        self.conn = conn
+        self._tnames,self._vnames = [],[]
+        self._tables = {}
+        if refresh: asyncio.create_task(self.refresh())
+
+    @property
+    def t(self):
+        if not hasattr(self, '_t'): self._t = _TablesGetter(self)
+        return self._t
+
+    def __getattr__(self, k): return getattr(self.conn, k)
+
+    def table(self, name):
+        if name not in self._tables: self._tables[name] = Table(self, name)
+        return self._tables[name]
+
+    async def refresh(self):
+        "Refresh all metadata"
+        self._tnames,self._vnames = await table_names(self),await view_names(self)
+        self._cols = {o: (await columns_info(self, o)) for o in self._tnames+self._vnames}
+        self._pks = {o: (await pk_cols(self, o)) for o in self._tnames}
+    
+    def __str__(self):
+        if isinstance(self.conn, asyncpg.pool.Pool):
+            kw = self.conn._connect_kwargs
+            u,h,d,p = kw.get('user','postgres'), kw.get('host','localhost'), kw.get('database','postgres'), kw.get('port',5432)
+        else:
+            pr,a = self.conn._params, self.conn._addr
+            u,h,d,p = pr.user, a[0], pr.database, a[1]
+        return f"postgresql://{u}@{h}:{p}/{d}"
+
+
+# %% ../nbs/00_core.ipynb #ae461a23
+class Table:
+    def __init__(self, db, name):
+        store_attr()
+        self.xtra_id = {}
+
+    @property
+    def cols(self): return self.db._cols.get(self.name, {})
+    def __repr__(self): return f'Table "{self.name}"'
+    def __str__(self): return f'"{self.name}"'
+
+    def xtra(self, **kwargs):
+        "Set extra constraints for queries/inserts"
+        self.xtra_id = kwargs
+        return self
+
+    @property
+    def pks(self): return self.db._pks.get(self.name, [])
+
+# %% ../nbs/00_core.ipynb #c0374b56
+class _Getter:
+    def __init__(self, db, attr): self.db,self.attr = db,attr
+
+    def __repr__(self): return ", ".join(getattr(self.db, self.attr))
+    def __dir__(self): return getattr(self.db, self.attr)
+    def __iter__(self): return iter(self[dir(self)])
+    def __contains__(self, s): return (s if isinstance(s,str) else s.name) in dir(self)
+    def __getitem__(self, idxs):
+        if isinstance(idxs,str): return self.db.table(idxs)
+        return [self.db.table(o) for o in idxs]
+    def __getattr__(self, k):
+        if k.startswith('_'): raise AttributeError
+        return self.db.table(k)
+
+class _TablesGetter(_Getter):
+    def __init__(self, db): super().__init__(db,'_tnames')
+
+# %% ../nbs/00_core.ipynb #699ea455
+class _Col:
+    def __init__(self, t, c): self.t,self.c = t,c
+    def __str__(self):  return f'"{self.t}"."{self.c}"'
+    def __repr__(self):  return self.c
+    def __iter__(self): return iter(self.c)
+
+class _ColsGetter:
+    def __init__(self, tbl): self.tbl = tbl
+    def __dir__(self): return list(self.tbl.cols)
+    def __repr__(self): return ", ".join(dir(self))
+    def __call__(self): return [_Col(self.tbl.name,o.name) for o in self.tbl.columns]
+    def __contains__(self, s): return (s if isinstance(s,str) else s.c) in self.tbl.cols
+    def __getattr__(self, k):
+        if k[0]=='_': raise AttributeError
+        return _Col(self.tbl.name, k)
+
+@patch(as_prop=True)
+def c(self:Table): return _ColsGetter(self)
+
+# %% ../nbs/00_core.ipynb #c6a5d503
+import sqlparse
+from itertools import count
+from sqlparse import tokens
+
+# %% ../nbs/00_core.ipynb #1ca2b1b9
+def conv_placeholders(sql):
+    "Convert `?` placeholders to PostgreSQL `$n` style"
+    if '?' not in sql: return sql
+    c = count(1)
+    def _convpl1(s):
+        return ''.join(f'${next(c)}' if t.ttype is tokens.Name.Placeholder and t.value=='?' else t.value for t in s.flatten())
+    return ''.join([_convpl1(s) for s in sqlparse.parse(sql)])
+
+# %% ../nbs/00_core.ipynb #ceeb54fb
+@patch
+async def q(self:Database, sql, *args):
+    csql = conv_placeholders(sql)
+    return Results(await self.fetch(csql, *args))
+
+# %% ../nbs/00_core.ipynb #0fc7310b
+from datetime import datetime, date, time, timedelta
+from decimal import Decimal
+from uuid import UUID
+from ipaddress import IPv4Network, IPv6Network, IPv4Interface, IPv6Interface, IPv4Address, IPv6Address
+from asyncpg.types import Range, BitString, Box, Circle, Line, LineSegment, Path, Point, Polygon
+
+# %% ../nbs/00_core.ipynb #a559e812
+def get_typ(pg_type):
+    "Get Python type for PostgreSQL type string"
+    return pg_to_py[pg_type.split('(')[0].strip()]
+
+# %% ../nbs/00_core.ipynb #a17706fc
+pg_to_py = {
+    'smallint': int, 'integer': int, 'bigint': int,
+    'real': float, 'float': float, 'double precision': float,
+    'numeric': Decimal, 'decimal': Decimal,
+    
+    'char': str, 'character': str, 'name': str, 'varchar': str, 'character varying': str, 'text': str, 'xml': str,
+    'bytea': bytes,
+    'boolean': bool, 'bool': bool,
+    
+    'date': date,
+    'time': time, 'time without time zone': time, 'time with time zone': time,
+    'timestamp': datetime, 'timestamp without time zone': datetime, 'timestamp with time zone': datetime,
+    'interval': timedelta,
+    
+    'uuid': UUID,
+    'json': dict, 'jsonb': dict,
+    'money': str,
+    'macaddr': str,
+    
+    'cidr': IPv4Network, 'inet': IPv4Interface,
+    
+    'bit': BitString, 'varbit': BitString,
+    'box': Box, 'circle': Circle, 'line': Line, 'lseg': LineSegment,
+    'path': Path, 'point': Point, 'polygon': Polygon,
+    
+    'anyarray': list, 'ARRAY': list,
+    'anyrange': Range,
+    'record': tuple, 'tid': tuple,
+}
+
+# %% ../nbs/00_core.ipynb #a5c571d1
+import json
+
+# %% ../nbs/00_core.ipynb #9282bec2
+async def setup_json(conn):
+    await conn.set_type_codec('json', encoder=json.dumps, decoder=json.loads, schema='pg_catalog')
+    await conn.set_type_codec('jsonb', encoder=json.dumps, decoder=json.loads, schema='pg_catalog')
+
+# %% ../nbs/00_core.ipynb #e95ad25a
+async def connect(*args, **kwargs):
+    kwargs.setdefault('record_class', FRecord)
+    conn = await asyncpg.connect(*args, **kwargs)
+    await setup_json(conn)
+    res = Database(conn, refresh=False)
+    await res.refresh()
+    return res
+
+# %% ../nbs/00_core.ipynb #341b22b5
+from dataclasses import dataclass, field, make_dataclass, fields, Field, is_dataclass, MISSING
+
+# %% ../nbs/00_core.ipynb #8402e3b8
+def _get_flds(tbl): 
+    return [(k, get_typ(v)|None, field(default=UNSET))
+            for k,v in tbl.cols.items()]
+
+def _dataclass(self:Table, store=True, suf='')->type:
+    "Create a `dataclass` with the types and defaults of this table"
+    res = make_dataclass(self.name.title()+suf, _get_flds(self))
+    flexiclass(res)
+    if store: self.cls = res
+    return res
+
+Table.dataclass = _dataclass
+
+# %% ../nbs/00_core.ipynb #cf91a162
+def all_dcs(db, with_views=False, store=True, suf=''):
+    "dataclasses for all objects in `db`"
+    return [o.dataclass(store=store, suf=suf) for o in list(db.t) + (db.views if with_views else [])]
+
+# %% ../nbs/00_core.ipynb #b37f834d
+def _add_xtra(tbl, where, args, offset=0):
+    args = listify(args)
+    if not tbl.xtra_id: return where, args
+    xw = ' AND '.join(f'"{k}"=${len(args)+offset+i+1}' for i,k in enumerate(tbl.xtra_id))
+    where = f'({where}) AND {xw}' if where else xw
+    args.extend(tbl.xtra_id.values())
+    return where, args
+
+# %% ../nbs/00_core.ipynb #de5874df
+class NotFoundError(Exception): pass
+
+@patch
+async def __getitem__(self:Table, pk):
+    "Get row by primary key, raising NotFoundError if missing"
+    if not self.pks: raise ValueError(f"No primary key for {self.name}")
+    where, args = _add_xtra(self, f'"{self.pks[0]}" = $1', [pk])
+    return await self._rec(f'SELECT * FROM {self} WHERE {where}', *args, err=f"{self.name}[{pk}]")
+
+# %% ../nbs/00_core.ipynb #76a582ae
+@patch
+async def get(self:Table, pk):
+    "Get row by primary key, or None if missing"
+    try: return await self[pk]
+    except NotFoundError: return None
+
+# %% ../nbs/00_core.ipynb #fd2d38a2
+@patch
+async def rows_where(self:Table, where=None, where_args=None, order_by=None, select='*', limit=None, offset=None,
+    as_cls=True, debug=False):
+    "Iterate over rows matching where clause"
+    where, args = _add_xtra(self, where, where_args or [])
+    sql = f'SELECT {select} FROM {self}'
+    if where: sql += f' WHERE {where}'
+    if order_by: sql += f' ORDER BY {order_by}'
+    if limit: sql += f' LIMIT {limit}'
+    if offset: sql += f' OFFSET {offset}'
+    if debug: print(sql)
+    if as_cls: return await self._recs(sql, *args)
+    return await self.db.q(sql, *args)
+
+# %% ../nbs/00_core.ipynb #b96b3f21
+@patch
+async def count_where(self:Table, where=None, where_args=None):
+    where, args = _add_xtra(self, where, where_args)
+    sql = f'SELECT COUNT(*) FROM {self}'
+    if where: sql += f' WHERE {where}'
+    return await self.db.fetchval(sql, *args)
+
+# %% ../nbs/00_core.ipynb #481230b7
+@patch(as_prop=True)
+async def count(self:Table): return await self.count_where()
+
+# %% ../nbs/00_core.ipynb #28682469
+from collections.abc import Mapping
+
+# %% ../nbs/00_core.ipynb #8ef66a0f
+def get_field(r, k):
+    return r[k] if isinstance(r, Mapping) else getattr(r, k)
+
+# %% ../nbs/00_core.ipynb #8e6ca8d9
+@patch
+async def pks_and_rows_where(self:Table, **kwargs):
+    "Like rows_where but returns (pk, row) tuples"
+    rows = await self.rows_where(**kwargs)
+    pk = self.pks[0] if self.pks else None
+    return [(get_field(r, pk) if pk else None, r) for r in rows]
+
+# %% ../nbs/00_core.ipynb #0774d383
+@patch
+async def __call__(self:Table, where=None, where_args=None, order_by=None, limit=None, offset=None, select='*', with_pk=False,
+    as_cls=True, debug=False):
+    "Query table rows"
+    f = self.pks_and_rows_where if with_pk else self.rows_where
+    return await f(where=where, where_args=where_args, order_by=order_by, limit=limit, offset=offset, select=select,
+        as_cls=as_cls, debug=debug)
+
+# %% ../nbs/00_core.ipynb #73e88814
+@patch
+async def selectone(
+    self:Table,
+    where:str|None=None,  # SQL where fragment to use, for example `id > ?`
+    where_args: Iterable|dict|NoneType=None, # Parameters to use with `where`; iterable for `id>?`, or dict for `id>:id`
+    select:str = "*", # Comma-separated list of columns to select
+    as_cls:bool=True, # Convert returned dict to stored dataclass?
+    debug:bool=False
+)->list:
+    "Shortcut for `__call__` that returns exactly one item"
+    res = await self(where=where, where_args=where_args, select=select, as_cls=as_cls, limit=2, debug=debug)
+    if len(res)==0: raise NotFoundError
+    elif len(res) > 1: raise ValueError(f"Not unique: {len(res)} results")
+    return res[0]
+
+# %% ../nbs/00_core.ipynb #215c7630
+@patch
+async def item(self:Database, sql, args=None):
+    "Execute sql and return a single field from a single row"
+    res = await self.fetch(sql, *(args or []))
+    if len(res)==0: raise NotFoundError
+    elif len(res) > 1: raise ValueError(f"Not unique: {len(res)} results")
+    row = res[0]
+    if len(row) > 1: raise ValueError(f"Too many fields: {len(row)} fields")
+    return row[0]
+
+# %% ../nbs/00_core.ipynb #0261da8a
+def create_mod(db, mod_fn, with_views=False, store=True, suf=''):
+    "Create module for dataclasses for `db`"
+    mod_fn = str(mod_fn)
+    if not mod_fn.endswith('.py'): mod_fn+='.py'
+    dcs = all_dcs(db, with_views, store=store, suf=suf)
+    strlist = ', '.join([f'"{o.__name__}"' for o in dcs])
+    with open(mod_fn, 'w') as f:
+        print(f'__all__ = [{strlist}]', file=f)
+        print('from dataclasses import dataclass', file=f)
+        print('import datetime,decimal', file=f)
+        print('from uuid import UUID', file=f)
+        print('from fastcore.utils import UNSET', file=f)
+        for o in dcs: print(dataclass_src(o), file=f)
+
+# %% ../nbs/00_core.ipynb #2002bcaf
+@patch
+def link_dcs(self:Database, mod):
+    "Set the internal dataclass type links for tables using `mod` (created via `create_mod`)"
+    for o in mod.__all__: self.t[o.lower()].cls = getattr(mod, o)
+
+# %% ../nbs/00_core.ipynb #8de706b8
+@patch
+def set_classes(self:Database, glb):
+    "Add set all table dataclasses using types in namespace `glb`"
+    for tbl in self.t: tbl.cls = glb[tbl.name.title()]
+
+# %% ../nbs/00_core.ipynb #a25449f1
+@patch
+def get_tables(self:Database, glb):
+    "Add objects for all table objects to namespace `glb`"
+    for tbl in self.t: glb[tbl.name.lower()+'s'] = tbl
+
+# %% ../nbs/00_core.ipynb #82a57623
+from dataclasses import asdict
+from enum import Enum
+
+# %% ../nbs/00_core.ipynb #b405dc99
+def _process_row(row, kwargs):
+    if row is None: d = {}
+    elif not is_dataclass(row): d = dict(row) if hasattr(row, 'items') else {}
+    else: d = {k:(v.value if isinstance(v, Enum) else v) for k,v in asdict(row).items() if v is not UNSET}
+    return d|kwargs
+
+# %% ../nbs/00_core.ipynb #343a8cc8
+def _prep_row(record, kwargs):
+    row = _process_row(record, kwargs)
+    if not row: return None*3
+    cols = ', '.join(f'"{k}"' for k in row)
+    vals = ', '.join(f'${i+1}' for i in range(len(row)))
+    return row, cols, vals
+
+@patch
+async def insert(self:Table, record=None, **kwargs):
+    "Insert a row and return it"
+    row, cols, vals = _prep_row(record, {**kwargs, **self.xtra_id})
+    if not row: return None
+    sql = f'INSERT INTO {self} ({cols}) VALUES ({vals}) RETURNING *'
+    return await self._rec(sql, *row.values())
+
+# %% ../nbs/00_core.ipynb #8a782068
+@patch
+async def _retr_tbl(self:Database, name):
+    await self.refresh()
+    return self.t[name]
+
+# %% ../nbs/00_core.ipynb #8e5e35ab
+import inspect
+
+# %% ../nbs/00_core.ipynb #e9c78b87
+@patch
+async def table2glb(self:Database, name, glb=None):
+    "Get table by name, refreshing metadata and creating dataclass, adding to glb"
+    if glb is None: glb = inspect.currentframe().f_back.f_globals
+    tbl = await self._retr_tbl(name)
+    cls = tbl.dataclass()
+    glb[name+'s'],glb[cls.__name__] = tbl,cls
+
+# %% ../nbs/00_core.ipynb #9b261543
+def _pk_where(pks, offset=0):
+    return ' AND '.join(f'"{pk}"=${i+offset+1}' for i,pk in enumerate(pks))
+
+# %% ../nbs/00_core.ipynb #51f2edca
+@patch
+async def update(self:Table, record=None, pk_values=None, **kwargs):
+    "Update a row and return it"
+    row = _process_row(record, kwargs)
+    if not row: return None
+    if pk_values is None: pk_values = [row[o] for o in self.pks]
+    sets = ', '.join(f'"{k}"=${i+1}' for i,k in enumerate(row))
+    xwhere = _pk_where(self.pks, len(row))
+    pk_where, args = _add_xtra(self, xwhere, pk_values, len(row))
+    sql = f'UPDATE {self} SET {sets} WHERE {pk_where} RETURNING *'
+    return await self._rec(sql, *row.values(), *args, err=f"{self.name}[{pk_values}]")
+
+# %% ../nbs/00_core.ipynb #f9968e6f
+@patch
+async def delete(self:Table, pk_values):
+    "Delete row by primary key, returning the deleted row"
+    pk_where, args = _add_xtra(self, _pk_where(self.pks), listify(pk_values))
+    sql = f'DELETE FROM {self} WHERE {pk_where} RETURNING *'
+    return await self._rec(sql, *args, err=f"{self.name}[{pk_values}]")
+
+# %% ../nbs/00_core.ipynb #0fc57f94
+@patch
+async def delete_where(self:Table, where=None, where_args=None):
+    where, args = _add_xtra(self, where, where_args or [])
+    sql = f'DELETE FROM {self}' + (f' WHERE {where}' if where else '') + ' RETURNING *'
+    return await self._recs(sql, *args)
+
+# %% ../nbs/00_core.ipynb #d45f513e
+py_to_pg = {v: k for k, v in pg_to_py.items() if v not in (list, tuple, Range)}
+# Override some for cleaner defaults
+py_to_pg.update({int: 'INTEGER', str: 'TEXT', float: 'REAL', bool: 'BOOLEAN'})
+
+# %% ../nbs/00_core.ipynb #21e6d1a5
+def col_def(name, typ, pk, not_null):
+    "Build column definition SQL for CREATE TABLE"
+    pg_typ = py_to_pg.get(typ, 'TEXT')
+    if name == pk and typ == int: pg_typ = 'SERIAL'
+    parts = [f'"{name}"', pg_typ]
+    if name == pk: parts.append('PRIMARY KEY')
+    elif not_null and name in not_null: parts.append('NOT NULL')
+    return ' '.join(parts)
+
+# %% ../nbs/00_core.ipynb #2c17673d
+@patch
+async def create(self:Database, cls=None, name=None, pk='id', foreign_keys=None, defaults=None, 
+                 column_order=None, not_null=None, if_not_exists=False, replace=False):
+    "Create table from `cls`"
+    flexiclass(cls)
+    if name is None: name = camel2snake(cls.__name__)
+    typs = {o.name: o.type for o in fields(cls)}
+    if column_order: typs = {k: typs[k] for k in column_order if k in typs}
+    
+    cols = [col_def(k, v, pk, not_null) for k, v in typs.items()]
+    if defaults:
+        for i, (k, v) in enumerate(typs.items()):
+            if k in defaults: cols[i] += f' DEFAULT {defaults[k]!r}'
+    if foreign_keys:
+        for col, (ref_tbl, ref_col) in foreign_keys.items():
+            cols.append(f'FOREIGN KEY ("{col}") REFERENCES "{ref_tbl}" ("{ref_col}")')
+    
+    col_sql = ', '.join(cols)
+    exists = 'IF NOT EXISTS ' if if_not_exists else ''
+    if replace: await self.execute(f'DROP TABLE IF EXISTS "{name}" CASCADE')
+    await self.execute(f'CREATE TABLE {exists}"{name}" ( {col_sql} )')
+    tbl = await self._retr_tbl(name)
+    tbl.cls = cls
+    return tbl
+
+# %% ../nbs/00_core.ipynb #de113b34
+@patch
+async def drop(self:Table, cascade=False):
+    "Drop this table"
+    casc = ' CASCADE' if cascade else ''
+    await self.db.execute(f'DROP TABLE IF EXISTS {self}{casc}')
+    await self.db.refresh()
+
+# %% ../nbs/00_core.ipynb #c5b5bd8f
+@patch
+async def upsert(self:Table, record=None, **kwargs):
+    "Insert or update a row and return it"
+    row, cols, vals = _prep_row(record, {**kwargs, **self.xtra_id})
+    if not row: return None
+    pk = self.pks[0]
+    updates = ', '.join(f'"{k}"=EXCLUDED."{k}"' for k in row if k != pk)
+    return await self._rec(f'INSERT INTO {self} ({cols}) VALUES ({vals}) ON CONFLICT ("{pk}") DO UPDATE SET {updates} RETURNING *', *row.values())
+
+# %% ../nbs/00_core.ipynb #6be00990
+async def create_pool(*args, **kwargs):
+    kwargs.setdefault('record_class', FRecord)
+    kwargs.setdefault('init', setup_json)
+    pool = await asyncpg.create_pool(*args, **kwargs)
+    res = Database(pool, refresh=False)
+    await res.refresh()
+    return res

fastasyncpg-0.0.1/fastasyncpg.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: fastasyncpg
+Version: 0.0.1
+Summary: A simple wrapper for asyncpg
+Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/fastasyncpg
+Project-URL: Documentation, https://AnswerDotAI.github.io/fastasyncpg/
+Keywords: nbdev
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncpg
+Requires-Dist: fastcore
+Requires-Dist: sqlparse
+Dynamic: license-file
+
+# fastasyncpg
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This file will become your README and also the index of your
+documentation.
+
+## Developer Guide
+
+If you are new to using `nbdev` here are some useful pointers to get you
+started.
+
+### Install fastasyncpg in Development mode
+
+``` sh
+# make sure fastasyncpg package is installed in development mode
+$ pip install -e .
+
+# make changes under nbs/ directory
+# ...
+
+# compile to have changes apply to fastasyncpg
+$ nbdev_prepare
+```
+
+## Usage
+
+### Installation
+
+Install latest from the GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg):
+
+``` sh
+$ pip install git+https://github.com/AnswerDotAI/fastasyncpg.git
+```
+
+or from [conda](https://anaconda.org/AnswerDotAI/fastasyncpg)
+
+``` sh
+$ conda install -c AnswerDotAI fastasyncpg
+```
+
+or from [pypi](https://pypi.org/project/fastasyncpg/)
+
+``` sh
+$ pip install fastasyncpg
+```
+
+### Documentation
+
+Documentation can be found hosted on this GitHub
+[repository](https://github.com/AnswerDotAI/fastasyncpg)’s
+[pages](https://AnswerDotAI.github.io/fastasyncpg/). Additionally you
+can find package manager specific guidelines on
+[conda](https://anaconda.org/AnswerDotAI/fastasyncpg) and
+[pypi](https://pypi.org/project/fastasyncpg/) respectively.
+
+## How to use
+
+Fill me in please! Don’t forget code examples:
+
+``` python
+1+1
+```
+
+    2

fastasyncpg-0.0.1/fastasyncpg.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+fastasyncpg/__init__.py
+fastasyncpg/_modidx.py
+fastasyncpg/core.py
+fastasyncpg.egg-info/PKG-INFO
+fastasyncpg.egg-info/SOURCES.txt
+fastasyncpg.egg-info/dependency_links.txt
+fastasyncpg.egg-info/entry_points.txt
+fastasyncpg.egg-info/requires.txt
+fastasyncpg.egg-info/top_level.txt

fastasyncpg-0.0.1/fastasyncpg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastasyncpg-0.0.1/fastasyncpg.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[nbdev]
+fastasyncpg = fastasyncpg._modidx:d

fastasyncpg-0.0.1/fastasyncpg.egg-info/requires.txt

@@ -0,0 +1,3 @@
+asyncpg
+fastcore
+sqlparse

fastasyncpg-0.0.1/fastasyncpg.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastasyncpg

fastasyncpg-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastasyncpg"
+dynamic = ["version"]
+description = "A simple wrapper for asyncpg"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+authors = [{name = "Jeremy Howard", email = "github@jhoward.fastmail.fm"}]
+keywords = ['nbdev']
+classifiers = [ "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only" ]
+dependencies = [ "asyncpg", "fastcore","sqlparse" ]
+
+[project.urls]
+Repository = "https://github.com/AnswerDotAI/fastasyncpg"
+Documentation = "https://AnswerDotAI.github.io/fastasyncpg/"
+
+[project.entry-points.nbdev]
+fastasyncpg = "fastasyncpg._modidx:d"
+
+[tool.setuptools.dynamic]
+version = {attr = "fastasyncpg.__version__"}
+
+[tool.setuptools.packages.find]
+include = ["fastasyncpg"]
+
+[tool.nbdev]
+custom_sidebar = false

fastasyncpg-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+