PyPI - erdscope - Versions diffs - 0.1.0__tar.gz → 0.2.0__tar.gz - Mend

erdscope 0.1.0tar.gz → 0.2.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

{erdscope-0.1.0/erdscope.egg-info → erdscope-0.2.0}/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: erdscope
-Version: 0.1.0
-Summary: Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL database — single file, zero required dependencies
+Version: 0.2.0
+Summary: Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL or PostgreSQL database — single file, zero required dependencies
 Author: tas6
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/orapli/erdscope
@@ -22,17 +22,30 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: mysql
 Requires-Dist: PyMySQL; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]; extra == "postgres"
 Provides-Extra: yaml
 Requires-Dist: PyYAML; extra == "yaml"
 Provides-Extra: all
 Requires-Dist: PyMySQL; extra == "all"
+Requires-Dist: psycopg[binary]; extra == "all"
 Requires-Dist: PyYAML; extra == "all"
 Dynamic: license-file
 # erdscope
+[![CI](https://github.com/orapli/erdscope/actions/workflows/ci.yml/badge.svg)](https://github.com/orapli/erdscope/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/erdscope)](https://pypi.org/project/erdscope/)
 Generate a **self-contained, interactive ER diagram** — and an **Excel table-definition
-workbook** — from a live MySQL database, with a single-file, zero-dependency Python CLI.
+workbook** — from a live MySQL or PostgreSQL database, with a single-file,
+zero-dependency Python CLI.
+```bash
+pip install erdscope
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
+```
 The database is the source of truth (tables, columns, comments, indexes, real foreign
 keys). Application code (Rails / Prisma / Django) can optionally be layered on top to
@@ -52,17 +65,29 @@ Regenerate it anytime with `python3 docs/gen_demo.py`.
 **[Read the user manual →](https://orapli.github.io/erdscope/manual.html)** — installation,
 CLI/config reference, a full viewer guide, and troubleshooting. ([日本語版 →](https://orapli.github.io/erdscope/manual.ja.html))
-## Usage
+## Install & usage
+`pip install erdscope` (or `pipx install erdscope`) gives you the `erdscope` command.
+Prefer not to install anything? `erd.py` is a single, dependency-free file — grab it
+and run it with any Python 3.9+:
 ```bash
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+curl -O https://raw.githubusercontent.com/orapli/erdscope/main/erd.py
+python3 erd.py ...   # identical to the erdscope command below
+```
+```bash
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+# PostgreSQL: same thing (schema defaults to public; override with ?schema=name)
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
 # enrich with association semantics parsed from application code (optional)
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --models /path/to/rails/app -o erd.html
 # also write a table-definition workbook
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --excel table_definitions.xlsx -o erd.html
 ```
@@ -70,7 +95,7 @@ Behind a bastion? Open an SSH tunnel first and point at localhost:
 ```bash
 ssh -N -L 3307:db-host:3306 bastion &
-python3 erd.py mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
+erdscope mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
 ```
 Use a read-only account, and leave the password out of the URL — if it's not in
@@ -99,8 +124,8 @@ itself is made.
 Once the flag list above gets long, put it in a config file instead — `.erdscope.json`
 (or `.yml`/`.yaml` with PyYAML) next to where you run the tool is picked up automatically.
 Most keys mirror a CLI option (an explicit flag always wins over the config); the DB
-connection is config-only as `host`/`port`/`user`/`database` — deliberately with no
-password field — and `relations` manually declares relations no FK, code, or inference
+connection is config-only as `engine`/`host`/`port`/`user`/`database` — deliberately with
+no password field — and `relations` manually declares relations no FK, code, or inference
 can find. See the [Config file chapter of the manual](https://orapli.github.io/erdscope/manual.html#config-file) for the full key
 list and semantics, and [`erdscope.example.yml`](erdscope.example.yml) for a fully
 annotated sample based on the live demo's schema.
@@ -109,14 +134,17 @@ annotated sample based on the live demo's schema.
 `erd.py` runs with **zero required dependencies** — everything below is optional, and
 the tool degrades gracefully (falls back, or fails with a clear message) when a piece
-is missing.
+is missing. If you installed via pip, extras pull them in for you:
+`pip install 'erdscope[mysql]'` (PyMySQL), `'erdscope[postgres]'` (psycopg),
+`'erdscope[yaml]'` (PyYAML), or `'erdscope[all]'`.
 | Library | Used for | If not installed |
 |---|---|---|
-| [PyMySQL](https://pypi.org/project/PyMySQL/) | The DB connection | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [PyMySQL](https://pypi.org/project/PyMySQL/) | MySQL connections | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [psycopg](https://pypi.org/project/psycopg/) (or psycopg2) | PostgreSQL connections | Falls back to shelling out to the `psql` CLI (must be on `PATH`) |
 | [PyYAML](https://pypi.org/project/PyYAML/) | Reading a `.yml`/`.yaml` config file | A `.json` config still works with no dependency; pointing `--config`/auto-discovery at a `.yml`/`.yaml` file without PyYAML installed exits with a clear error |
-Excel output (`--excel`) needs neither — it's written directly via the stdlib
+Excel output (`--excel`) needs none of these — it's written directly via the stdlib
 `zipfile`/XML, not a spreadsheet library.
 Test-only, and only if you run that particular suite:
@@ -131,7 +159,8 @@ Test-only, and only if you run that particular suite:
 Feature highlights — each link goes to the relevant [manual](https://orapli.github.io/erdscope/manual.html) chapter:
 - **Database truth** — tables, columns (full SQL types, defaults, extras), table and
-  column comments, indexes, and real FK constraints, read from `information_schema`
+  column comments, indexes, and real FK constraints, read from the database catalog
+  (`information_schema` on MySQL, `pg_catalog` on PostgreSQL)
 - **Code semantics on top** — `--models` merges Rails / Prisma / Django associations;
   declared, DB-FK, and inferred edges stay [visually distinct](https://orapli.github.io/erdscope/manual.html#viewer-edges)
 - **[Interactive exploration](https://orapli.github.io/erdscope/manual.html#viewer-guide)** — focus with depth and dependency
@@ -146,7 +175,8 @@ Feature highlights — each link goes to the relevant [manual](https://orapli.gi
 - **[Logical names](https://orapli.github.io/erdscope/manual.html#viewer-names)** — a table's DB comment doubles as a searchable
   logical name (e.g. `users（Customer accounts）`), with independent display modes for
   the live view and exports
-- **Extras** — dark mode, print stylesheet, resizable/collapsible panes
+- **Extras** — a built-in `?` shortcuts/help popup, dark mode, print stylesheet,
+  resizable/collapsible panes
 ## Tests
@@ -170,8 +200,9 @@ python3 -m unittest tests.test_e2e -v
 ## Extending
 Everything downstream (UI, layouts, exports) consumes the intermediate representation
-documented at the top of `erd.py`. Adding PostgreSQL support means adding one
-`parse_postgres()` that produces that shape.
+documented at the top of `erd.py`. Adding another database engine means adding one
+parser that produces that shape — `parse_postgres()` (which reuses the MySQL
+adapter's IR builder wholesale) is the working example of the pattern.
 ## License

{erdscope-0.1.0 → erdscope-0.2.0}/README.md RENAMED Viewed

@@ -1,7 +1,17 @@
 # erdscope
+[![CI](https://github.com/orapli/erdscope/actions/workflows/ci.yml/badge.svg)](https://github.com/orapli/erdscope/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/erdscope)](https://pypi.org/project/erdscope/)
 Generate a **self-contained, interactive ER diagram** — and an **Excel table-definition
-workbook** — from a live MySQL database, with a single-file, zero-dependency Python CLI.
+workbook** — from a live MySQL or PostgreSQL database, with a single-file,
+zero-dependency Python CLI.
+```bash
+pip install erdscope
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
+```
 The database is the source of truth (tables, columns, comments, indexes, real foreign
 keys). Application code (Rails / Prisma / Django) can optionally be layered on top to
@@ -21,17 +31,29 @@ Regenerate it anytime with `python3 docs/gen_demo.py`.
 **[Read the user manual →](https://orapli.github.io/erdscope/manual.html)** — installation,
 CLI/config reference, a full viewer guide, and troubleshooting. ([日本語版 →](https://orapli.github.io/erdscope/manual.ja.html))
-## Usage
+## Install & usage
+`pip install erdscope` (or `pipx install erdscope`) gives you the `erdscope` command.
+Prefer not to install anything? `erd.py` is a single, dependency-free file — grab it
+and run it with any Python 3.9+:
 ```bash
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+curl -O https://raw.githubusercontent.com/orapli/erdscope/main/erd.py
+python3 erd.py ...   # identical to the erdscope command below
+```
+```bash
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+# PostgreSQL: same thing (schema defaults to public; override with ?schema=name)
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
 # enrich with association semantics parsed from application code (optional)
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --models /path/to/rails/app -o erd.html
 # also write a table-definition workbook
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --excel table_definitions.xlsx -o erd.html
 ```
@@ -39,7 +61,7 @@ Behind a bastion? Open an SSH tunnel first and point at localhost:
 ```bash
 ssh -N -L 3307:db-host:3306 bastion &
-python3 erd.py mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
+erdscope mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
 ```
 Use a read-only account, and leave the password out of the URL — if it's not in
@@ -68,8 +90,8 @@ itself is made.
 Once the flag list above gets long, put it in a config file instead — `.erdscope.json`
 (or `.yml`/`.yaml` with PyYAML) next to where you run the tool is picked up automatically.
 Most keys mirror a CLI option (an explicit flag always wins over the config); the DB
-connection is config-only as `host`/`port`/`user`/`database` — deliberately with no
-password field — and `relations` manually declares relations no FK, code, or inference
+connection is config-only as `engine`/`host`/`port`/`user`/`database` — deliberately with
+no password field — and `relations` manually declares relations no FK, code, or inference
 can find. See the [Config file chapter of the manual](https://orapli.github.io/erdscope/manual.html#config-file) for the full key
 list and semantics, and [`erdscope.example.yml`](erdscope.example.yml) for a fully
 annotated sample based on the live demo's schema.
@@ -78,14 +100,17 @@ annotated sample based on the live demo's schema.
 `erd.py` runs with **zero required dependencies** — everything below is optional, and
 the tool degrades gracefully (falls back, or fails with a clear message) when a piece
-is missing.
+is missing. If you installed via pip, extras pull them in for you:
+`pip install 'erdscope[mysql]'` (PyMySQL), `'erdscope[postgres]'` (psycopg),
+`'erdscope[yaml]'` (PyYAML), or `'erdscope[all]'`.
 | Library | Used for | If not installed |
 |---|---|---|
-| [PyMySQL](https://pypi.org/project/PyMySQL/) | The DB connection | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [PyMySQL](https://pypi.org/project/PyMySQL/) | MySQL connections | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [psycopg](https://pypi.org/project/psycopg/) (or psycopg2) | PostgreSQL connections | Falls back to shelling out to the `psql` CLI (must be on `PATH`) |
 | [PyYAML](https://pypi.org/project/PyYAML/) | Reading a `.yml`/`.yaml` config file | A `.json` config still works with no dependency; pointing `--config`/auto-discovery at a `.yml`/`.yaml` file without PyYAML installed exits with a clear error |
-Excel output (`--excel`) needs neither — it's written directly via the stdlib
+Excel output (`--excel`) needs none of these — it's written directly via the stdlib
 `zipfile`/XML, not a spreadsheet library.
 Test-only, and only if you run that particular suite:
@@ -100,7 +125,8 @@ Test-only, and only if you run that particular suite:
 Feature highlights — each link goes to the relevant [manual](https://orapli.github.io/erdscope/manual.html) chapter:
 - **Database truth** — tables, columns (full SQL types, defaults, extras), table and
-  column comments, indexes, and real FK constraints, read from `information_schema`
+  column comments, indexes, and real FK constraints, read from the database catalog
+  (`information_schema` on MySQL, `pg_catalog` on PostgreSQL)
 - **Code semantics on top** — `--models` merges Rails / Prisma / Django associations;
   declared, DB-FK, and inferred edges stay [visually distinct](https://orapli.github.io/erdscope/manual.html#viewer-edges)
 - **[Interactive exploration](https://orapli.github.io/erdscope/manual.html#viewer-guide)** — focus with depth and dependency
@@ -115,7 +141,8 @@ Feature highlights — each link goes to the relevant [manual](https://orapli.gi
 - **[Logical names](https://orapli.github.io/erdscope/manual.html#viewer-names)** — a table's DB comment doubles as a searchable
   logical name (e.g. `users（Customer accounts）`), with independent display modes for
   the live view and exports
-- **Extras** — dark mode, print stylesheet, resizable/collapsible panes
+- **Extras** — a built-in `?` shortcuts/help popup, dark mode, print stylesheet,
+  resizable/collapsible panes
 ## Tests
@@ -139,8 +166,9 @@ python3 -m unittest tests.test_e2e -v
 ## Extending
 Everything downstream (UI, layouts, exports) consumes the intermediate representation
-documented at the top of `erd.py`. Adding PostgreSQL support means adding one
-`parse_postgres()` that produces that shape.
+documented at the top of `erd.py`. Adding another database engine means adding one
+parser that produces that shape — `parse_postgres()` (which reuses the MySQL
+adapter's IR builder wholesale) is the working example of the pattern.
 ## License

{erdscope-0.1.0 → erdscope-0.2.0}/erd.py RENAMED Viewed

@@ -3,6 +3,7 @@
 erdscope — interactive ER diagrams (and Excel table definitions) from a live database
 Usage:
     python3 erd.py mysql://readonly@host:3306/dbname [-o erd.html]
+    python3 erd.py postgres://readonly@host:5432/dbname[?schema=name]
                    [--models /path/to/app] [--excel defs.xlsx]
 The database is the required source of truth; --models optionally overlays
@@ -105,11 +106,14 @@ def mysql_query_rows(url, sql):
             for line in r.stdout.splitlines()]
 _MYSQL_TSV_ESCAPES = {'0': '\0', 'b': '\b', 'n': '\n', 'r': '\r', 't': '\t', '\\': '\\'}
-def _unescape_mysql_field(s):
-    """Undo mysql --batch (non-raw) tab-output escaping. \\N alone means
-    SQL NULL (mapped to '' — same convention the PyMySQL path already uses
-    for None); elsewhere \\0 \\b \\n \\r \\t \\\\ decode to their literal
+# COPY TO STDOUT (the psql CLI path) escapes the same characters plus \f \v
+_COPY_TSV_ESCAPES = {**_MYSQL_TSV_ESCAPES, 'f': '\f', 'v': '\v'}
+def _unescape_tsv_field(s, escapes):
+    """Undo tab-separated-output escaping (mysql --batch, or COPY TO STDOUT
+    text format — they share the same core contract). \\N alone means SQL
+    NULL (mapped to '' — same convention the driver paths already use for
+    None); elsewhere the entries of `escapes` decode to their literal
     characters. A single left-to-right pass (not chained .replace() calls)
     is required: independent replacements can misfire on adjacent escapes,
     e.g. an escaped backslash immediately followed by an escaped tab."""
@@ -120,14 +124,20 @@ def _unescape_mysql_field(s):
     out, i, n = [], 0, len(s)
     while i < n:
         c = s[i]
-        if c == '\\' and i + 1 < n and s[i + 1] in _MYSQL_TSV_ESCAPES:
-            out.append(_MYSQL_TSV_ESCAPES[s[i + 1]])
+        if c == '\\' and i + 1 < n and s[i + 1] in escapes:
+            out.append(escapes[s[i + 1]])
             i += 2
         else:
             out.append(c)
             i += 1
     return ''.join(out)
+def _unescape_mysql_field(s):
+    return _unescape_tsv_field(s, _MYSQL_TSV_ESCAPES)
+def _unescape_copy_field(s):
+    return _unescape_tsv_field(s, _COPY_TSV_ESCAPES)
 def mysql_ir(table_rows, col_rows, fk_rows, index_rows):
     """Build the IR from information_schema rows (pure; unit-testable).
@@ -221,6 +231,143 @@ def parse_mysql(url):
         f"ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX")
     return mysql_ir(table_rows, col_rows, fk_rows, index_rows)
+# ---------------------------------------------------------------------------
+# PostgreSQL adapter (pg_catalog via psycopg/psycopg2 or the psql CLI)
+# ---------------------------------------------------------------------------
+def postgres_query_rows(url, sql):
+    """Run a query and return rows as tuples of strings ('' for NULL).
+    Prefers psycopg (v3), then psycopg2, when installed; otherwise shells
+    out to the psql CLI — same dependency-free spirit as mysql_query_rows.
+    The CLI path wraps the query in COPY (...) TO STDOUT, whose text format
+    escapes tabs/newlines/backslashes and spells NULL as \\N — the same
+    framing contract mysql --batch provides, so free-text comments can't
+    corrupt the field/record structure."""
+    u = urlparse(url)
+    host, port, db = u.hostname or '127.0.0.1', u.port or 5432, u.path.lstrip('/')
+    password = u.password or os.environ.get('PGPASSWORD', '')
+    driver = None
+    try:
+        import psycopg as driver  # psycopg 3
+    except ImportError:
+        try:
+            import psycopg2 as driver
+        except ImportError:
+            pass
+    if driver:
+        try:
+            conn = driver.connect(host=host, port=port, user=u.username,
+                                  password=password, dbname=db)
+        except driver.Error as e:
+            sys.exit(f'Error: could not connect to PostgreSQL at {host}:{port}: {e}')
+        try:
+            with conn.cursor() as cur:
+                cur.execute(sql)
+                return [tuple('' if v is None else str(v) for v in r)
+                        for r in cur.fetchall()]
+        except driver.Error as e:
+            sys.exit(f'Error: postgres query failed: {e}')
+        finally:
+            conn.close()
+    cmd = ['psql', '-X', '-q', '-v', 'ON_ERROR_STOP=1', '-h', host, '-p', str(port)]
+    if u.username:
+        cmd += ['-U', u.username]
+    cmd += ['-d', db, '-c', f'COPY ({sql}) TO STDOUT']
+    env = dict(os.environ)
+    if password:
+        env['PGPASSWORD'] = password  # keep the password off the argv
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, env=env)
+    except FileNotFoundError:
+        sys.exit('Error: neither psycopg/psycopg2 nor the psql CLI is available '
+                 '(pip install "psycopg[binary]", or install a PostgreSQL client)')
+    if r.returncode != 0:
+        sys.exit(f'Error: postgres query failed: {r.stderr.strip()}')
+    return [tuple(_unescape_copy_field(v) for v in line.split('\t'))
+            for line in r.stdout.splitlines()]
+def parse_postgres(url):
+    """Read the schema from a live PostgreSQL database and build the IR.
+    Shapes pg_catalog query results into the exact information_schema row
+    layout mysql_ir() consumes, so the (engine-agnostic) IR builder — PK
+    detection, unique-index 1:1 promotion, index assembly — is shared, not
+    duplicated. Notes vs. MySQL:
+    - schema defaults to 'public'; override with ?schema=name in the URL
+    - partitioned parents (relkind 'p') are included, their partitions and
+      views are not — matching MySQL's BASE TABLE filter in spirit
+    - identity/serial columns land in `extra` (like auto_increment), and a
+      serial's noisy nextval(...) default is blanked for display parity
+    """
+    u = urlparse(url)
+    db = u.path.lstrip('/')
+    if not re.fullmatch(r'\w+', db or ''):
+        sys.exit('Error: the postgres URL must include a database name, '
+                 'e.g. postgres://readonly@127.0.0.1:5432/myapp_production')
+    schema = 'public'
+    for part in u.query.split('&'):
+        if part.startswith('schema='):
+            schema = part[len('schema='):]
+    if not re.fullmatch(r'\w+', schema):
+        sys.exit(f'Error: invalid schema name {schema!r} in the postgres URL')
+    # No password in the URL and none set via PGPASSWORD: prompt (interactive
+    # only, same as the MySQL path). An empty answer leaves PGPASSWORD unset
+    # so libpq's own ~/.pgpass lookup still applies.
+    if u.password is None and not os.environ.get('PGPASSWORD') and sys.stdin.isatty():
+        pw = getpass.getpass(
+            f"PostgreSQL password for {u.username or 'postgres'}@{u.hostname or '127.0.0.1'}: ")
+        if pw:
+            os.environ['PGPASSWORD'] = pw
+    base = (f"FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace "
+            f"WHERE n.nspname = '{schema}' AND c.relkind IN ('r', 'p') "
+            f"AND NOT c.relispartition")
+    table_rows = postgres_query_rows(url,
+        f"SELECT c.relname, COALESCE(obj_description(c.oid, 'pg_class'), '') "
+        f"{base} ORDER BY c.relname")
+    col_rows = postgres_query_rows(url,
+        f"SELECT c.relname, a.attname, "
+        f"format_type(a.atttypid, NULL), "
+        f"format_type(a.atttypid, a.atttypmod), "
+        f"CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END, "
+        f"CASE WHEN EXISTS (SELECT 1 FROM pg_index i WHERE i.indrelid = c.oid "
+        f"AND i.indisprimary AND a.attnum = ANY(i.indkey)) THEN 'PRI' ELSE '' END, "
+        f"CASE WHEN pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval(%' THEN '' "
+        f"ELSE COALESCE(pg_get_expr(ad.adbin, ad.adrelid), '') END, "
+        f"CASE WHEN a.attidentity <> '' THEN 'identity' "
+        f"WHEN pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval(%' THEN 'serial' "
+        f"ELSE '' END, "
+        f"COALESCE(col_description(c.oid, a.attnum), '') "
+        f"FROM pg_attribute a JOIN pg_class c ON c.oid = a.attrelid "
+        f"JOIN pg_namespace n ON n.oid = c.relnamespace "
+        f"LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum "
+        f"WHERE n.nspname = '{schema}' AND c.relkind IN ('r', 'p') "
+        f"AND NOT c.relispartition AND a.attnum > 0 AND NOT a.attisdropped "
+        f"ORDER BY c.relname, a.attnum")
+    fk_rows = postgres_query_rows(url,
+        f"SELECT conrel.relname, a.attname, confrel.relname "
+        f"FROM pg_constraint con "
+        f"JOIN pg_class conrel ON conrel.oid = con.conrelid "
+        f"JOIN pg_class confrel ON confrel.oid = con.confrelid "
+        f"JOIN pg_namespace n ON n.oid = conrel.relnamespace "
+        f"CROSS JOIN LATERAL unnest(con.conkey) AS k(attnum) "
+        f"JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = k.attnum "
+        f"WHERE con.contype = 'f' AND n.nspname = '{schema}' "
+        f"ORDER BY conrel.relname, a.attname")
+    index_rows = postgres_query_rows(url,
+        f"SELECT c.relname, i.relname, "
+        f"CASE WHEN ix.indisunique THEN 0 ELSE 1 END, k.ord, "
+        f"COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, k.ord::int, true)) "
+        f"FROM pg_index ix "
+        f"JOIN pg_class c ON c.oid = ix.indrelid "
+        f"JOIN pg_class i ON i.oid = ix.indexrelid "
+        f"JOIN pg_namespace n ON n.oid = c.relnamespace "
+        f"CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) "
+        f"LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum "
+        f"AND k.attnum > 0 "
+        f"WHERE n.nspname = '{schema}' AND c.relkind IN ('r', 'p') "
+        f"AND NOT c.relispartition "
+        f"ORDER BY c.relname, i.relname, k.ord")
+    return mysql_ir(table_rows, col_rows, fk_rows, index_rows)
 def dedupe_db_fk(tables):
     """After merging code-declared associations, drop DB-FK associations for
     pairs that an explicit association already covers (either direction).
@@ -4777,7 +4924,7 @@ CONFIG_DEFAULTS = {
 # accidentally fill in when the pieces are separate. One config file per
 # database (e.g. erdscope.staging.json / erdscope.prod.json) is the
 # intended way to point --config at different targets.
-CONFIG_CONNECTION_KEYS = {'host', 'port', 'user', 'database'}
+CONFIG_CONNECTION_KEYS = {'engine', 'host', 'port', 'user', 'database'}
 CONFIG_PASSWORD_KEYS = {'password', 'passwd', 'pwd', 'url', 'database_url'}
 # Expected type per key, checked at load time — YAML/JSON scalars are
 # exactly where a config typo goes undetected otherwise: max_rows as the
@@ -4871,15 +5018,19 @@ def _check_config_types(config, path):
 _SAFE_HOST_OR_USER = re.compile(r'[\w.\-]+')
 def assemble_config_url(config):
-    """Build a mysql:// URL from the config's host/port/user/database fields,
-    or None if `database` wasn't given (no connection info in the config at
-    all). Each part is validated against a safe charset before being pasted
+    """Build a mysql:// or postgres:// URL (per the config's `engine`, default
+    mysql) from the config's host/port/user/database fields, or None if
+    `database` wasn't given (no connection info in the config at all).
+    Each part is validated against a safe charset before being pasted
     into the URL string — host/user containing `/`, `@`, or `:` would
     silently shift what urlparse reads as the host/port/path when the
     assembled string is re-parsed downstream (verified empirically: a host
     of "x@evil" produces a URL whose username becomes "x" and whose actual
     host becomes "evil"), and there is no decoding step anywhere downstream
     to undo percent-encoding, so quoting isn't a fix either."""
+    engine = config.get('engine', 'mysql')
+    if engine not in ('mysql', 'postgres', 'postgresql'):
+        sys.exit(f'Error: config `engine` must be "mysql" or "postgres", got {engine!r}')
     db = config.get('database')
     if db is None:  # absent, or explicitly blank (e.g. a bare `database:` in YAML)
         return None
@@ -4890,7 +5041,7 @@ def assemble_config_url(config):
         sys.exit(f'Error: config `host` {host!r} has unsupported characters (letters/'
                  f'digits/./- only here — IPv6 and other exotic hosts need the CLI '
                  f'argument instead, not the config file)')
-    port = config.get('port', 3306)
+    port = config.get('port', 3306 if engine == 'mysql' else 5432)
     if isinstance(port, bool) or (isinstance(port, float) and not port.is_integer()):
         sys.exit(f'Error: config `port` {port!r} is not a valid port number')
     try:
@@ -4909,7 +5060,8 @@ def assemble_config_url(config):
             sys.exit(f'Error: config `user` {user!r} has unsupported characters '
                      f'(letters/digits/./- only)')
         auth = f'{user}@'
-    return f'mysql://{auth}{host}:{port}/{db}'
+    scheme = 'mysql' if engine == 'mysql' else 'postgres'
+    return f'{scheme}://{auth}{host}:{port}/{db}'
 # ---------------------------------------------------------------------------
 # CLI
@@ -4919,11 +5071,14 @@ def main():
         description='Generate an interactive ER diagram from a live database, '
                     'optionally enriched with association semantics parsed from '
                     'application code (Rails / Prisma / Django)')
-    p.add_argument('database', metavar='mysql://user@host:port/dbname', nargs='?',
-                   help='Database connection URL. Can also be assembled from '
-                        '`host`/`port`/`user`/`database` in the config file (no password '
-                        'field there — use MYSQL_PWD, ~/.my.cnf, or the interactive '
-                        'prompt). A read-only account is recommended')
+    p.add_argument('database', metavar='mysql://user@host/db | postgres://user@host/db',
+                   nargs='?',
+                   help='Database connection URL (postgres:// takes an optional '
+                        '?schema=name, default public). Can also be assembled from '
+                        '`engine`/`host`/`port`/`user`/`database` in the config file (no '
+                        'password field there — use MYSQL_PWD/PGPASSWORD, '
+                        '~/.my.cnf/~/.pgpass, or the interactive prompt). A read-only '
+                        'account is recommended')
     # SUPPRESS on every config-mirrorable flag so we can tell "explicitly
     # passed on the CLI" (attribute present) from "left to the config file /
     # built-in default" (attribute absent) — see the merge loop below.
@@ -4970,10 +5125,16 @@ def main():
     config = load_config(args)
     url = args.database or assemble_config_url(config)
-    if not url or not url.startswith('mysql://'):
-        sys.exit('Error: a database URL is required (currently mysql:// only) — pass it '
-                 'as the CLI argument, or set `database` (and optionally host/user/port) '
-                 'in the config file, e.g. mysql://readonly@127.0.0.1:3306/myapp_production')
+    scheme = (url or '').split('://', 1)[0]
+    if scheme == 'mysql':
+        parse_db, engine_name = parse_mysql, 'MySQL'
+    elif scheme in ('postgres', 'postgresql'):
+        parse_db, engine_name = parse_postgres, 'PostgreSQL'
+    else:
+        sys.exit('Error: a database URL is required (mysql:// or postgres://) — pass it '
+                 'as the CLI argument, or set `database` (and optionally engine/host/user/'
+                 'port) in the config file, e.g. mysql://readonly@127.0.0.1:3306/myapp or '
+                 'postgres://readonly@127.0.0.1:5432/myapp')
     if hasattr(args, 'table_map'):
         tm = {}
@@ -4991,8 +5152,8 @@ def main():
             setattr(args, key, config.get(key, default))
     relations = config.get('relations', [])  # shape already validated by load_config()
-    tables = parse_mysql(url)
-    print(f'Fetched {len(tables)} tables from MySQL', file=sys.stderr)
+    tables = parse_db(url)
+    print(f'Fetched {len(tables)} tables from {engine_name}', file=sys.stderr)
     if args.models:
         mroot = Path(args.models).expanduser().resolve()

{erdscope-0.1.0 → erdscope-0.2.0/erdscope.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: erdscope
-Version: 0.1.0
-Summary: Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL database — single file, zero required dependencies
+Version: 0.2.0
+Summary: Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL or PostgreSQL database — single file, zero required dependencies
 Author: tas6
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/orapli/erdscope
@@ -22,17 +22,30 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: mysql
 Requires-Dist: PyMySQL; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]; extra == "postgres"
 Provides-Extra: yaml
 Requires-Dist: PyYAML; extra == "yaml"
 Provides-Extra: all
 Requires-Dist: PyMySQL; extra == "all"
+Requires-Dist: psycopg[binary]; extra == "all"
 Requires-Dist: PyYAML; extra == "all"
 Dynamic: license-file
 # erdscope
+[![CI](https://github.com/orapli/erdscope/actions/workflows/ci.yml/badge.svg)](https://github.com/orapli/erdscope/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/erdscope)](https://pypi.org/project/erdscope/)
 Generate a **self-contained, interactive ER diagram** — and an **Excel table-definition
-workbook** — from a live MySQL database, with a single-file, zero-dependency Python CLI.
+workbook** — from a live MySQL or PostgreSQL database, with a single-file,
+zero-dependency Python CLI.
+```bash
+pip install erdscope
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
+```
 The database is the source of truth (tables, columns, comments, indexes, real foreign
 keys). Application code (Rails / Prisma / Django) can optionally be layered on top to
@@ -52,17 +65,29 @@ Regenerate it anytime with `python3 docs/gen_demo.py`.
 **[Read the user manual →](https://orapli.github.io/erdscope/manual.html)** — installation,
 CLI/config reference, a full viewer guide, and troubleshooting. ([日本語版 →](https://orapli.github.io/erdscope/manual.ja.html))
-## Usage
+## Install & usage
+`pip install erdscope` (or `pipx install erdscope`) gives you the `erdscope` command.
+Prefer not to install anything? `erd.py` is a single, dependency-free file — grab it
+and run it with any Python 3.9+:
 ```bash
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+curl -O https://raw.githubusercontent.com/orapli/erdscope/main/erd.py
+python3 erd.py ...   # identical to the erdscope command below
+```
+```bash
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production -o erd.html
+# PostgreSQL: same thing (schema defaults to public; override with ?schema=name)
+erdscope postgres://readonly@127.0.0.1:5432/myapp_production -o erd.html
 # enrich with association semantics parsed from application code (optional)
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --models /path/to/rails/app -o erd.html
 # also write a table-definition workbook
-python3 erd.py mysql://readonly@127.0.0.1:3306/myapp_production \
+erdscope mysql://readonly@127.0.0.1:3306/myapp_production \
         --excel table_definitions.xlsx -o erd.html
 ```
@@ -70,7 +95,7 @@ Behind a bastion? Open an SSH tunnel first and point at localhost:
 ```bash
 ssh -N -L 3307:db-host:3306 bastion &
-python3 erd.py mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
+erdscope mysql://readonly@127.0.0.1:3307/myapp_production -o erd.html
 ```
 Use a read-only account, and leave the password out of the URL — if it's not in
@@ -99,8 +124,8 @@ itself is made.
 Once the flag list above gets long, put it in a config file instead — `.erdscope.json`
 (or `.yml`/`.yaml` with PyYAML) next to where you run the tool is picked up automatically.
 Most keys mirror a CLI option (an explicit flag always wins over the config); the DB
-connection is config-only as `host`/`port`/`user`/`database` — deliberately with no
-password field — and `relations` manually declares relations no FK, code, or inference
+connection is config-only as `engine`/`host`/`port`/`user`/`database` — deliberately with
+no password field — and `relations` manually declares relations no FK, code, or inference
 can find. See the [Config file chapter of the manual](https://orapli.github.io/erdscope/manual.html#config-file) for the full key
 list and semantics, and [`erdscope.example.yml`](erdscope.example.yml) for a fully
 annotated sample based on the live demo's schema.
@@ -109,14 +134,17 @@ annotated sample based on the live demo's schema.
 `erd.py` runs with **zero required dependencies** — everything below is optional, and
 the tool degrades gracefully (falls back, or fails with a clear message) when a piece
-is missing.
+is missing. If you installed via pip, extras pull them in for you:
+`pip install 'erdscope[mysql]'` (PyMySQL), `'erdscope[postgres]'` (psycopg),
+`'erdscope[yaml]'` (PyYAML), or `'erdscope[all]'`.
 | Library | Used for | If not installed |
 |---|---|---|
-| [PyMySQL](https://pypi.org/project/PyMySQL/) | The DB connection | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [PyMySQL](https://pypi.org/project/PyMySQL/) | MySQL connections | Falls back to shelling out to the `mysql` CLI (must be on `PATH`) |
+| [psycopg](https://pypi.org/project/psycopg/) (or psycopg2) | PostgreSQL connections | Falls back to shelling out to the `psql` CLI (must be on `PATH`) |
 | [PyYAML](https://pypi.org/project/PyYAML/) | Reading a `.yml`/`.yaml` config file | A `.json` config still works with no dependency; pointing `--config`/auto-discovery at a `.yml`/`.yaml` file without PyYAML installed exits with a clear error |
-Excel output (`--excel`) needs neither — it's written directly via the stdlib
+Excel output (`--excel`) needs none of these — it's written directly via the stdlib
 `zipfile`/XML, not a spreadsheet library.
 Test-only, and only if you run that particular suite:
@@ -131,7 +159,8 @@ Test-only, and only if you run that particular suite:
 Feature highlights — each link goes to the relevant [manual](https://orapli.github.io/erdscope/manual.html) chapter:
 - **Database truth** — tables, columns (full SQL types, defaults, extras), table and
-  column comments, indexes, and real FK constraints, read from `information_schema`
+  column comments, indexes, and real FK constraints, read from the database catalog
+  (`information_schema` on MySQL, `pg_catalog` on PostgreSQL)
 - **Code semantics on top** — `--models` merges Rails / Prisma / Django associations;
   declared, DB-FK, and inferred edges stay [visually distinct](https://orapli.github.io/erdscope/manual.html#viewer-edges)
 - **[Interactive exploration](https://orapli.github.io/erdscope/manual.html#viewer-guide)** — focus with depth and dependency
@@ -146,7 +175,8 @@ Feature highlights — each link goes to the relevant [manual](https://orapli.gi
 - **[Logical names](https://orapli.github.io/erdscope/manual.html#viewer-names)** — a table's DB comment doubles as a searchable
   logical name (e.g. `users（Customer accounts）`), with independent display modes for
   the live view and exports
-- **Extras** — dark mode, print stylesheet, resizable/collapsible panes
+- **Extras** — a built-in `?` shortcuts/help popup, dark mode, print stylesheet,
+  resizable/collapsible panes
 ## Tests
@@ -170,8 +200,9 @@ python3 -m unittest tests.test_e2e -v
 ## Extending
 Everything downstream (UI, layouts, exports) consumes the intermediate representation
-documented at the top of `erd.py`. Adding PostgreSQL support means adding one
-`parse_postgres()` that produces that shape.
+documented at the top of `erd.py`. Adding another database engine means adding one
+parser that produces that shape — `parse_postgres()` (which reuses the MySQL
+adapter's IR builder wholesale) is the working example of the pattern.
 ## License

{erdscope-0.1.0 → erdscope-0.2.0}/erdscope.egg-info/requires.txt RENAMED Viewed

@@ -1,10 +1,14 @@
 [all]
 PyMySQL
+psycopg[binary]
 PyYAML
 [mysql]
 PyMySQL
+[postgres]
+psycopg[binary]
 [yaml]
 PyYAML

{erdscope-0.1.0 → erdscope-0.2.0}/pyproject.toml RENAMED Viewed

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "erdscope"
-version = "0.1.0"
-description = "Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL database — single file, zero required dependencies"
+version = "0.2.0"
+description = "Interactive, self-contained ER-diagram HTML and Excel table definitions from a live MySQL or PostgreSQL database — single file, zero required dependencies"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -24,8 +24,9 @@ classifiers = [
 [project.optional-dependencies]
 mysql = ["PyMySQL"]
+postgres = ["psycopg[binary]"]
 yaml = ["PyYAML"]
-all = ["PyMySQL", "PyYAML"]
+all = ["PyMySQL", "psycopg[binary]", "PyYAML"]
 [project.scripts]
 erdscope = "erd:main"

{erdscope-0.1.0 → erdscope-0.2.0}/tests/test_erd.py RENAMED Viewed

@@ -1449,5 +1449,152 @@ class TestAssembleConfigUrl(unittest.TestCase):
             erd.assemble_config_url({'host': 'h', 'database': 'shop', 'port': 3306.9})
+class TestPostgresQueryRows(unittest.TestCase):
+    """postgres_query_rows prefers psycopg (v3), then psycopg2; the last
+    resort is the psql CLI wrapping the query in COPY (...) TO STDOUT.
+    Mirrors TestPyMysqlErrorHandling: driver failures must exit cleanly,
+    and the CLI path must unescape COPY's text format."""
+    def setUp(self):
+        class FakePgError(Exception):
+            pass
+        self.FakePgError = FakePgError
+        self.fake_psycopg = types.SimpleNamespace(Error=FakePgError, connect=None)
+        self.addCleanup(sys.modules.pop, 'psycopg', None)
+        sys.modules['psycopg'] = self.fake_psycopg
+    def test_connect_failure_exits_cleanly(self):
+        def fail_connect(**kw):
+            raise self.FakePgError('password authentication failed for user "x"')
+        self.fake_psycopg.connect = fail_connect
+        with self.assertRaises(SystemExit) as cm:
+            erd.postgres_query_rows('postgres://x@127.0.0.1:5432/db', 'SELECT 1')
+        self.assertIn('authentication failed', str(cm.exception))
+    def test_query_failure_exits_cleanly(self):
+        class FakeCursor:
+            def __enter__(self): return self
+            def __exit__(self, *a): return False
+            def execute(self, sql):
+                raise self.outer.FakePgError('relation does not exist')
+        FakeCursor.outer = self
+        class FakeConn:
+            def cursor(self): return FakeCursor()
+            def close(self): pass
+        self.fake_psycopg.connect = lambda **kw: FakeConn()
+        with self.assertRaises(SystemExit) as cm:
+            erd.postgres_query_rows('postgres://x@127.0.0.1:5432/db', 'SELECT 1')
+        self.assertIn('relation does not exist', str(cm.exception))
+    def test_none_values_become_empty_strings(self):
+        class FakeCursor:
+            def __enter__(self): return self
+            def __exit__(self, *a): return False
+            def execute(self, sql): pass
+            def fetchall(self): return [('users', None), (None, 42)]
+        class FakeConn:
+            def cursor(self): return FakeCursor()
+            def close(self): pass
+        self.fake_psycopg.connect = lambda **kw: FakeConn()
+        rows = erd.postgres_query_rows('postgres://x@h:5432/db', 'SELECT 1')
+        self.assertEqual(rows, [('users', ''), ('', '42')])
+class TestPostgresCliFallback(unittest.TestCase):
+    """The psql path, forced by making both driver imports fail
+    (sys.modules[name] = None makes `import name` raise ImportError)."""
+    def setUp(self):
+        for mod in ('psycopg', 'psycopg2'):
+            self.addCleanup(sys.modules.pop, mod, None)
+            sys.modules[mod] = None
+    def test_missing_psql_exits_with_install_hint(self):
+        def no_psql(cmd, **kw):
+            raise FileNotFoundError('psql')
+        orig = erd.subprocess.run
+        erd.subprocess.run = no_psql
+        try:
+            with self.assertRaises(SystemExit) as cm:
+                erd.postgres_query_rows('postgres://x@h:5432/db', 'SELECT 1')
+        finally:
+            erd.subprocess.run = orig
+        self.assertIn('psycopg', str(cm.exception))
+        self.assertIn('psql', str(cm.exception))
+    def test_copy_output_is_unescaped_and_wrapped_in_copy(self):
+        captured = {}
+        def fake_run(cmd, **kw):
+            captured['cmd'] = cmd
+            return types.SimpleNamespace(
+                returncode=0,
+                stdout='users\tA comment with a\\ttab\n\\N\t\\N\n',
+                stderr='')
+        orig = erd.subprocess.run
+        erd.subprocess.run = fake_run
+        try:
+            rows = erd.postgres_query_rows('postgres://ro@h:5433/db', 'SELECT x')
+        finally:
+            erd.subprocess.run = orig
+        self.assertEqual(rows, [('users', 'A comment with a\ttab'), ('', '')])
+        joined = ' '.join(captured['cmd'])
+        self.assertIn('COPY (SELECT x) TO STDOUT', joined)
+        self.assertIn('-p 5433', joined)
+        self.assertIn('-U ro', joined)
+class TestUnescapeCopyField(unittest.TestCase):
+    """COPY TO STDOUT text format shares mysql --batch's escape contract
+    and adds \\f and \\v."""
+    def test_null_marker(self):
+        self.assertEqual(erd._unescape_copy_field('\\N'), '')
+    def test_formfeed_and_vertical_tab(self):
+        self.assertEqual(erd._unescape_copy_field('a\\fb\\vc'), 'a\fb\vc')
+    def test_shared_escapes_still_decode(self):
+        self.assertEqual(erd._unescape_copy_field('a\\tb\\nc'), 'a\tb\nc')
+    def test_escaped_backslash_then_escape_char(self):
+        self.assertEqual(erd._unescape_copy_field('a\\\\tb'), 'a\\tb')
+class TestPostgresUrlAndSchema(unittest.TestCase):
+    def test_missing_database_name_exits(self):
+        with self.assertRaises(SystemExit) as cm:
+            erd.parse_postgres('postgres://ro@h:5432/')
+        self.assertIn('database name', str(cm.exception))
+    def test_invalid_schema_param_exits(self):
+        with self.assertRaises(SystemExit) as cm:
+            erd.parse_postgres('postgres://ro@h:5432/db?schema=bad-name')
+        self.assertIn('schema', str(cm.exception))
+class TestPostgresConfigUrl(unittest.TestCase):
+    """`engine: postgres` in the config switches the assembled URL's scheme
+    and default port; mysql stays the default for existing configs."""
+    def test_engine_postgres_assembles_postgres_url_with_5432_default(self):
+        url = erd.assemble_config_url(
+            {'engine': 'postgres', 'user': 'ro', 'host': 'h', 'database': 'shop'})
+        self.assertEqual(url, 'postgres://ro@h:5432/shop')
+    def test_engine_postgresql_alias_accepted(self):
+        url = erd.assemble_config_url({'engine': 'postgresql', 'database': 'shop'})
+        self.assertEqual(url, 'postgres://127.0.0.1:5432/shop')
+    def test_engine_defaults_to_mysql(self):
+        url = erd.assemble_config_url({'database': 'shop'})
+        self.assertEqual(url, 'mysql://127.0.0.1:3306/shop')
+    def test_unknown_engine_exits(self):
+        with self.assertRaises(SystemExit) as cm:
+            erd.assemble_config_url({'engine': 'oracle', 'database': 'shop'})
+        self.assertIn('engine', str(cm.exception))
+    def test_explicit_port_wins_over_engine_default(self):
+        url = erd.assemble_config_url(
+            {'engine': 'postgres', 'database': 'shop', 'port': 6432})
+        self.assertEqual(url, 'postgres://127.0.0.1:6432/shop')
 if __name__ == '__main__':
     unittest.main()

{erdscope-0.1.0 → erdscope-0.2.0}/LICENSE RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/erdscope.egg-info/SOURCES.txt RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/erdscope.egg-info/dependency_links.txt RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/erdscope.egg-info/entry_points.txt RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/erdscope.egg-info/top_level.txt RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/setup.cfg RENAMED Viewed

File without changes

{erdscope-0.1.0 → erdscope-0.2.0}/tests/test_e2e.py RENAMED Viewed

File without changes

erdscope 0.1.0__tar.gz → 0.2.0__tar.gz

erdscope 0.1.0tar.gz → 0.2.0tar.gz