gitdata-lib 0.0.12__tar.gz → 0.0.17__tar.gz

gitdata_lib-0.0.17/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [v0.0.17] - 2026-09-28
+- add direct `gitdata ls` and streaming `gitdata scan` for CSV, SQLite, and MariaDB refs without digestion or storage
+- allow `gitdata ls` on a MariaDB server ref to list databases visible to the user
+- accept canonical `database.table` selection in MariaDB/MySQL refs while retaining `#table` compatibility
+- use `database-file/table.column` SQLite refs without fragment selectors
+- eagerly count database rows before sampling unless `gitdata scan --no-count` is supplied
+- allow SQLite column refs to scan one column and behave as leaves under `gitdata ls`
+- format `gitdata scan` as a terminal-width-aware table with aligned numeric columns and bounded values
+- default omitted MariaDB usernames to the current OS user and attempt passwordless authentication when no password environment variable is specified
+- add reusable CSV, SQLite, and `mysqldump` examples for manual inspection
+- exit cleanly without a traceback when a command is interrupted with Ctrl+C
+- announce `gitdata scan` after ref validation and connection, immediately before sampling
+- add `gitdata ls -l` database/table statistics, column schema, and index details
+- hide database-specific system objects from `gitdata ls` unless `-a` is supplied
+- distinguish node relationships from literal values with structural predicates
+- preserve repeated predicate values when reading graph nodes
+- escape colliding source predicates and omit factless values without dangling relationships
+- verify multiple source graphs retain independent roots in memory and SQLite repositories
+- require re-ingestion of older graph facts whose unprefixed relationships cannot be distinguished from literal IDs
+
+## [v0.0.16] - 2026-09-19
+- add optional Oracle Database support with `python-oracledb` Thin mode and live CI integration tests
+- add initial encryption module and unit tests
+- refactor secrets module into a backend-agnostic core with pluggable storage
+- add `GITDATA_ENCRYPTION_KEY` and docker `/run/secrets` key resolution for secrets
+- mask secret values by default in secrets listing APIs
+- persist secrets in the local `.gitdata` repository via EntityStore
+- add `gitdata secret` command to list, get, set, and delete secrets
+- add secrets resolve API that hard-fails listing missing names
+- add `gitdata secret status`, `resolve`, and `clear` for share handoff
+- keep secret values out of logs, HTTP facts, and routine CLI output
+- rename CLI command to `gitdata secret` (`secrets` remains an alias)
+- add `gitdata init` command to initialize repositories
+- switch local repository storage to a single `.gitdata` sqlite file
+
+## [v0.0.15] - 2025-08-03
+- add secrets module stub
+
+## [v0.0.14] - 2025-08-03
+- add support for environment variable style config keys
+
+## [v0.0.13] - 2025-08-03
+- make config filename a constant
+- improve CLI help and `get` output readability
+- expand queue tests and database-specific test configuration
+
+## [v0.0.12] - 2024-05-01
+- add `scan` command and HTTP connector support
+- add SQL module and related tests
+- improve CLI behavior and test/CI setup
+
+## [v0.0.11] - 2021-12-31
+- refactor CLI and connector internals
+- add fake and local connector support
+- continue datastore and graph/facts foundation work
+
+## [v0.0.3] - 2021-10-10
+- add CLI entrypoint and related command wiring
+
+## [v0.0.1] - 2021-10-09
+- initial packaged release with config, database, stores, queues, and connectors

gitdata_lib-0.0.17/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: gitdata-lib
+Version: 0.0.17
+Summary: Data extraction and analysis library
+Home-page: https://github.com/gitdata/gitdata-lib
+Author: DSI Labs
+Author-email: support@gitdata.com
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.9,<3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-decouple>=3.4
+Requires-Dist: Unipath>=1.1
+Requires-Dist: PyMySQL==0.10.1
+Requires-Dist: psycopg2-binary==2.9.1
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: docopt
+Requires-Dist: faker
+Requires-Dist: cryptography
+Provides-Extra: oracle
+Requires-Dist: oracledb<4,>=1.3; extra == "oracle"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# GitData Lib
+Data Wrangling for Everyone.
+
+GitData is a fast, scalable, distributed data exploration system
+with a rich set of commands that provide ways to gather, manage and query data in an unusually straightforward way.
+
+## Development installation
+
+Install the checkout into a Python 3.9 virtual environment so the `gitdata`
+command works without setting `PYTHONPATH`:
+
+```bash
+python3.9 -m venv .venv
+. .venv/bin/activate
+python -m pip install -e .
+gitdata --help
+```
+
+The editable installation continues to use code from the checkout, so source
+changes do not require reinstalling it. Activate `.venv` in each new shell.
+Alternatively, if `pipx` is installed, put the editable command on your normal
+`PATH` without activating a project environment:
+
+```bash
+pipx install --python python3.9 --editable .
+```
+
+## Direct inspection
+
+`ls` and `scan` inspect live Connector output directly. They do not initialize a
+repository, digest the data into facts, or write to a store.
+
+The repository includes ready-to-use examples. Run these commands from the
+repository root:
+
+```bash
+# List tables, list one table's columns, scan the table, and scan one column.
+gitdata ls examples/inspection.sqlite
+# Add -l for table row/column counts and estimated sizes.
+gitdata ls -l examples/inspection.sqlite
+gitdata ls examples/inspection.sqlite/customers
+# On a table, -l shows schema details and indexes.
+gitdata ls -l examples/inspection.sqlite/customers
+gitdata scan --limit 2 examples/inspection.sqlite/customers
+gitdata scan --limit 2 examples/inspection.sqlite/customers.email
+
+# A headered CSV can be inspected in the same way.
+gitdata ls examples/locations-headered.csv
+gitdata scan --limit 10 examples/locations-headered.csv
+```
+
+Database scans issue `COUNT(*)` before sampling so the report normally includes
+an exact table row count. Use `--no-count` to skip that query when counting would
+be expensive; if the sample does not exhaust the rows, the report then shows a
+lower bound. Row sampling remains lazy and never reads beyond `--limit`. Once a
+ref has been validated and connected, the command writes `Scanning...` to standard
+error before sampling begins. Invalid and server-only refs are rejected without
+first claiming that a scan has started. Pressing Ctrl+C stops any command cleanly
+without a Python traceback.
+
+`gitdata ls -l` follows the detailed listings from `datascan`: server refs show
+database table/row/size statistics, database refs show table column/row/size
+statistics, and table refs show column schema and index details. Plain `ls`
+continues to print names only. Database-specific system objects are hidden by
+default: MariaDB/MySQL omits `information_schema`, `mysql`,
+`performance_schema`, and `sys`, while SQLite omits `sqlite_*` tables. Add
+`-a`/`--all` to include them; `-la` combines system objects with the long
+listing. SQLite sizes are estimated from up to 100 rows; MariaDB/MySQL uses
+`information_schema` statistics.
+
+SQLite refs form a hierarchy beneath the database filename:
+
+```text
+path/to/database.sqlite                 database
+path/to/database.sqlite/table           table
+path/to/database.sqlite/table.column    column
+```
+
+`ls` lists immediate children: tables below a database and columns below a table.
+A column is a leaf, so `ls` on a column produces no entries. `scan` on a column
+profiles only that column while still counting rows in its table by default.
+Literal dots in table or column identifiers must be percent-encoded as `%2E`.
+
+### MariaDB example
+
+`examples/mariadb.sql` is a `mysqldump` of a `gitdata_example` database with
+`customers`, `orders`, and `products` tables. Load it into a disposable MariaDB
+container:
+
+```bash
+docker run --name gitdata-example-mariadb \
+  -e MARIADB_ROOT_PASSWORD=example \
+  -p 3307:3306 \
+  -d mariadb:10.7@sha256:9a48ac9f196f3d4fd6fea2cab59a49df9e7ca459bf14b2f7b85a0e38a5454571
+
+until docker exec gitdata-example-mariadb \
+  mariadb-admin ping -h 127.0.0.1 -uroot -pexample --silent
+do
+  sleep 1
+done
+
+docker exec -i gitdata-example-mariadb \
+  mariadb -uroot -pexample < examples/mariadb.sql
+```
+
+Keep the password out of the ref by naming an environment variable:
+
+```bash
+export GITDATA_EXAMPLE_MARIADB_PASSWORD=example
+MARIADB_SERVER_REF='mysql://root@127.0.0.1:3307?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+MARIADB_REF='mysql://root@127.0.0.1:3307/gitdata_example?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+MARIADB_TABLE_REF='mysql://root@127.0.0.1:3307/gitdata_example.customers?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+
+gitdata ls "$MARIADB_SERVER_REF"     # databases visible to root
+gitdata ls -l "$MARIADB_SERVER_REF"  # database statistics
+gitdata ls "$MARIADB_REF"            # tables in gitdata_example
+gitdata ls -l "$MARIADB_REF"         # table statistics
+gitdata ls -l "$MARIADB_TABLE_REF"   # column schema and indexes
+gitdata scan --limit 2 "$MARIADB_TABLE_REF"
+```
+
+If the username is omitted, the connector uses the current operating-system
+username. If `password_env` is omitted, it attempts a passwordless connection.
+For example:
+
+```bash
+gitdata ls 'mysql://zeno'
+```
+
+Inline passwords remain unsupported; use `password_env` when a password is
+required.
+
+MariaDB/MySQL refs follow the SQL qualification users already expect:
+
+```text
+mysql://host                         server
+mysql://host/database                database
+mysql://host/database.table          table
+```
+
+The earlier `database#table` form used a URI fragment as a generic nested-resource
+selector. It remains accepted for MariaDB/MySQL compatibility, but
+`database.table` is canonical. A literal dot inside an identifier must be
+percent-encoded as `%2E`. SQLite does not use fragments; its `/table.column`
+hierarchy follows the database filename.
+
+Remove the disposable database when finished:
+
+```bash
+docker rm -f gitdata-example-mariadb
+```
+
+## Running the complete test suite locally
+
+Docker is the only host dependency for the complete Python 3.9 test matrix:
+
+```bash
+bash tests/run_with_docker.sh
+```
+
+The runner builds a disposable test image, runs the general and SQLite suites,
+and then starts MariaDB, PostgreSQL, and Oracle Free Lite one at a time. Each
+database container and network is removed before the next service starts and is
+also cleaned up if a test fails.
+
+The service images are pinned by digest. They can be replaced without editing
+the script by setting `GITDATA_TEST_MARIADB_IMAGE`,
+`GITDATA_TEST_POSTGRES_IMAGE`, or `GITDATA_TEST_ORACLE_IMAGE`.
+
+## Oracle Database
+
+Oracle support uses the Python DB-API driver `python-oracledb`, which defaults
+to Thin mode. The adapter does not initialize Thick mode, so Oracle Instant
+Client is not required. The driver is optional and is loaded only when an
+Oracle connection is requested:
+
+```bash
+pip install 'gitdata-lib[oracle]'
+```
+
+Connect with an Oracle service name:
+
+```python
+import os
+
+from gitdata.database import connect
+
+db = connect(
+    'oracle',
+    host='127.0.0.1',
+    port=1521,
+    service_name='FREEPDB1',
+    user='app',
+    password=os.environ['ORACLE_PASSWORD'],
+)
+
+rows = list(db('SELECT 1 FROM dual'))
+```
+
+A complete `dsn` can be supplied instead of `host`, `port`, and
+`service_name`. Installing `gitdata-lib` without the `oracle` extra does not
+install or import `python-oracledb`; requesting an Oracle connection in that
+case reports the extra that must be installed.
+
+The Oracle integration tests use these environment variables:
+
+- `GITDATA_TEST_ORACLE_USER`
+- `GITDATA_TEST_ORACLE_PASSWORD`
+- `GITDATA_TEST_ORACLE_SERVICE_NAME`
+- `GITDATA_TEST_ORACLE_HOST` (defaults to `127.0.0.1`)
+- `GITDATA_TEST_ORACLE_PORT` (defaults to `1521`)
+
+They have been exercised against Oracle Free using the
+`container-registry.oracle.com/database/free:latest` container image.

gitdata_lib-0.0.17/README.md

@@ -0,0 +1,214 @@
+# GitData Lib
+Data Wrangling for Everyone.
+
+GitData is a fast, scalable, distributed data exploration system
+with a rich set of commands that provide ways to gather, manage and query data in an unusually straightforward way.
+
+## Development installation
+
+Install the checkout into a Python 3.9 virtual environment so the `gitdata`
+command works without setting `PYTHONPATH`:
+
+```bash
+python3.9 -m venv .venv
+. .venv/bin/activate
+python -m pip install -e .
+gitdata --help
+```
+
+The editable installation continues to use code from the checkout, so source
+changes do not require reinstalling it. Activate `.venv` in each new shell.
+Alternatively, if `pipx` is installed, put the editable command on your normal
+`PATH` without activating a project environment:
+
+```bash
+pipx install --python python3.9 --editable .
+```
+
+## Direct inspection
+
+`ls` and `scan` inspect live Connector output directly. They do not initialize a
+repository, digest the data into facts, or write to a store.
+
+The repository includes ready-to-use examples. Run these commands from the
+repository root:
+
+```bash
+# List tables, list one table's columns, scan the table, and scan one column.
+gitdata ls examples/inspection.sqlite
+# Add -l for table row/column counts and estimated sizes.
+gitdata ls -l examples/inspection.sqlite
+gitdata ls examples/inspection.sqlite/customers
+# On a table, -l shows schema details and indexes.
+gitdata ls -l examples/inspection.sqlite/customers
+gitdata scan --limit 2 examples/inspection.sqlite/customers
+gitdata scan --limit 2 examples/inspection.sqlite/customers.email
+
+# A headered CSV can be inspected in the same way.
+gitdata ls examples/locations-headered.csv
+gitdata scan --limit 10 examples/locations-headered.csv
+```
+
+Database scans issue `COUNT(*)` before sampling so the report normally includes
+an exact table row count. Use `--no-count` to skip that query when counting would
+be expensive; if the sample does not exhaust the rows, the report then shows a
+lower bound. Row sampling remains lazy and never reads beyond `--limit`. Once a
+ref has been validated and connected, the command writes `Scanning...` to standard
+error before sampling begins. Invalid and server-only refs are rejected without
+first claiming that a scan has started. Pressing Ctrl+C stops any command cleanly
+without a Python traceback.
+
+`gitdata ls -l` follows the detailed listings from `datascan`: server refs show
+database table/row/size statistics, database refs show table column/row/size
+statistics, and table refs show column schema and index details. Plain `ls`
+continues to print names only. Database-specific system objects are hidden by
+default: MariaDB/MySQL omits `information_schema`, `mysql`,
+`performance_schema`, and `sys`, while SQLite omits `sqlite_*` tables. Add
+`-a`/`--all` to include them; `-la` combines system objects with the long
+listing. SQLite sizes are estimated from up to 100 rows; MariaDB/MySQL uses
+`information_schema` statistics.
+
+SQLite refs form a hierarchy beneath the database filename:
+
+```text
+path/to/database.sqlite                 database
+path/to/database.sqlite/table           table
+path/to/database.sqlite/table.column    column
+```
+
+`ls` lists immediate children: tables below a database and columns below a table.
+A column is a leaf, so `ls` on a column produces no entries. `scan` on a column
+profiles only that column while still counting rows in its table by default.
+Literal dots in table or column identifiers must be percent-encoded as `%2E`.
+
+### MariaDB example
+
+`examples/mariadb.sql` is a `mysqldump` of a `gitdata_example` database with
+`customers`, `orders`, and `products` tables. Load it into a disposable MariaDB
+container:
+
+```bash
+docker run --name gitdata-example-mariadb \
+  -e MARIADB_ROOT_PASSWORD=example \
+  -p 3307:3306 \
+  -d mariadb:10.7@sha256:9a48ac9f196f3d4fd6fea2cab59a49df9e7ca459bf14b2f7b85a0e38a5454571
+
+until docker exec gitdata-example-mariadb \
+  mariadb-admin ping -h 127.0.0.1 -uroot -pexample --silent
+do
+  sleep 1
+done
+
+docker exec -i gitdata-example-mariadb \
+  mariadb -uroot -pexample < examples/mariadb.sql
+```
+
+Keep the password out of the ref by naming an environment variable:
+
+```bash
+export GITDATA_EXAMPLE_MARIADB_PASSWORD=example
+MARIADB_SERVER_REF='mysql://root@127.0.0.1:3307?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+MARIADB_REF='mysql://root@127.0.0.1:3307/gitdata_example?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+MARIADB_TABLE_REF='mysql://root@127.0.0.1:3307/gitdata_example.customers?password_env=GITDATA_EXAMPLE_MARIADB_PASSWORD'
+
+gitdata ls "$MARIADB_SERVER_REF"     # databases visible to root
+gitdata ls -l "$MARIADB_SERVER_REF"  # database statistics
+gitdata ls "$MARIADB_REF"            # tables in gitdata_example
+gitdata ls -l "$MARIADB_REF"         # table statistics
+gitdata ls -l "$MARIADB_TABLE_REF"   # column schema and indexes
+gitdata scan --limit 2 "$MARIADB_TABLE_REF"
+```
+
+If the username is omitted, the connector uses the current operating-system
+username. If `password_env` is omitted, it attempts a passwordless connection.
+For example:
+
+```bash
+gitdata ls 'mysql://zeno'
+```
+
+Inline passwords remain unsupported; use `password_env` when a password is
+required.
+
+MariaDB/MySQL refs follow the SQL qualification users already expect:
+
+```text
+mysql://host                         server
+mysql://host/database                database
+mysql://host/database.table          table
+```
+
+The earlier `database#table` form used a URI fragment as a generic nested-resource
+selector. It remains accepted for MariaDB/MySQL compatibility, but
+`database.table` is canonical. A literal dot inside an identifier must be
+percent-encoded as `%2E`. SQLite does not use fragments; its `/table.column`
+hierarchy follows the database filename.
+
+Remove the disposable database when finished:
+
+```bash
+docker rm -f gitdata-example-mariadb
+```
+
+## Running the complete test suite locally
+
+Docker is the only host dependency for the complete Python 3.9 test matrix:
+
+```bash
+bash tests/run_with_docker.sh
+```
+
+The runner builds a disposable test image, runs the general and SQLite suites,
+and then starts MariaDB, PostgreSQL, and Oracle Free Lite one at a time. Each
+database container and network is removed before the next service starts and is
+also cleaned up if a test fails.
+
+The service images are pinned by digest. They can be replaced without editing
+the script by setting `GITDATA_TEST_MARIADB_IMAGE`,
+`GITDATA_TEST_POSTGRES_IMAGE`, or `GITDATA_TEST_ORACLE_IMAGE`.
+
+## Oracle Database
+
+Oracle support uses the Python DB-API driver `python-oracledb`, which defaults
+to Thin mode. The adapter does not initialize Thick mode, so Oracle Instant
+Client is not required. The driver is optional and is loaded only when an
+Oracle connection is requested:
+
+```bash
+pip install 'gitdata-lib[oracle]'
+```
+
+Connect with an Oracle service name:
+
+```python
+import os
+
+from gitdata.database import connect
+
+db = connect(
+    'oracle',
+    host='127.0.0.1',
+    port=1521,
+    service_name='FREEPDB1',
+    user='app',
+    password=os.environ['ORACLE_PASSWORD'],
+)
+
+rows = list(db('SELECT 1 FROM dual'))
+```
+
+A complete `dsn` can be supplied instead of `host`, `port`, and
+`service_name`. Installing `gitdata-lib` without the `oracle` extra does not
+install or import `python-oracledb`; requesting an Oracle connection in that
+case reports the extra that must be installed.
+
+The Oracle integration tests use these environment variables:
+
+- `GITDATA_TEST_ORACLE_USER`
+- `GITDATA_TEST_ORACLE_PASSWORD`
+- `GITDATA_TEST_ORACLE_SERVICE_NAME`
+- `GITDATA_TEST_ORACLE_HOST` (defaults to `127.0.0.1`)
+- `GITDATA_TEST_ORACLE_PORT` (defaults to `1521`)
+
+They have been exercised against Oracle Free using the
+`container-registry.oracle.com/database/free:latest` container image.

gitdata_lib-0.0.17/gitdata/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.0.17'

gitdata_lib-0.0.17/gitdata/cli/__init__.py

@@ -0,0 +1,114 @@
+"""
+usage: gitdata [options] <command> [<args>...]
+
+options:
+    -h, --help      show help
+    -V, --version   print version
+    -d, --debug     debug
+
+The most commonly used gitdata commands are:
+    init        initialize a local gitdata repository
+    fetch       fetch data to the local reposotiry
+    get         get data
+    ls          list immediate children of a ref
+    scan        scan data
+    secret      manage repository secrets
+
+See 'gitdata help <command>' for more information on a specific command.
+"""
+
+import importlib
+import logging
+import sys
+
+from docopt import docopt
+
+import gitdata
+from gitdata.utils import trim
+
+
+root_logger = logging.getLogger()
+
+
+def print_help(doc):
+    """Print help text"""
+    print(trim(doc))
+
+
+def get_module_doc(name):
+    if name == 'secret':
+        name = 'secrets'
+    module_name = 'gitdata.cli.gitdata_' + name
+    try:
+        result = importlib.import_module(module_name).__doc__
+    except ModuleNotFoundError:
+        result = f'no help on topic {name!r}'
+    return result
+
+
+def main():
+    """CLI entry point with clean interrupt handling."""
+    try:
+        _main()
+    except KeyboardInterrupt:
+        print('\nInterrupted.', file=sys.stderr)
+        raise SystemExit(130)
+
+
+def _main():
+    """Parse and dispatch a CLI command."""
+
+    if len(sys.argv) == 1:
+        print_help(__doc__)
+        sys.exit()
+
+    args = docopt(
+        __doc__,
+        version='gitdata version {}'.format(gitdata.__version__),
+        options_first=True
+    )
+
+    if args['--debug']:
+        print(args)
+        root_logger.setLevel(logging.DEBUG)
+
+    argv = [args['<command>']] + args['<args>']
+    command = args['<command>']
+
+    if command == 'help':
+        if args['<args>']:
+            topic = args['<args>'][0]
+            doc = get_module_doc(topic)
+        else:
+            doc = __doc__
+        print_help(doc)
+        sys.exit()
+
+    elif command == 'init':
+        from gitdata.cli.gitdata_init import init, __doc__ as doc
+        args = docopt(doc, argv=argv)
+        init(args)
+
+    elif command == 'get':
+        from gitdata.cli.gitdata_get import get, __doc__ as doc
+        args = docopt(doc, argv=argv)
+        get(args)
+
+    elif command == 'ls':
+        from gitdata.cli.gitdata_ls import ls_to_console, __doc__ as doc
+        args = docopt(doc, argv=argv)
+        ls_to_console(args)
+
+    elif command == 'scan':
+        from gitdata.cli.gitdata_scan import scan_to_console, __doc__ as doc
+        args = docopt(doc, argv=argv)
+        scan_to_console(args)
+
+    elif command in ('secret', 'secrets'):
+        from gitdata.cli.gitdata_secrets import secrets, __doc__ as doc
+        argv[0] = 'secret'
+        args = docopt(doc, argv=argv)
+        secrets(args)
+
+    else:
+        exit("%r is not a gitdata command. See 'gitdata help'." % args['<command>'])

{gitdata_lib-0.0.12 → gitdata_lib-0.0.17}/gitdata/cli/gitdata_get.py

@@ -14,9 +14,11 @@ def get(args):
     if args['<ref>']:
         for ref in args['<ref>']:
             print('getting', ref)
-            pprint(
-                gitdata.connectors.common.get(ref),
-            )
+            result = gitdata.connectors.common.get(ref)
+            if isinstance(result, dict):
+                max_len = max(map(len, result.keys())) + 3
+                for k, v in result.items():
+                    print('%s%s: %s' % (k, '.' * (max_len - len(k)), v))
     else:
         print(__doc__)
         print(args)

gitdata_lib-0.0.17/gitdata/cli/gitdata_init.py

@@ -0,0 +1,22 @@
+"""
+usage: gitdata init [<path>]
+
+options:
+    -h, --help
+"""
+
+import gitdata.repositories
+
+
+def init(args):
+    """Initialize a gitdata repository."""
+    path = args['<path>'] or '.'
+    try:
+        repository_path, created = gitdata.repositories.init_repository(path)
+    except ValueError as error:
+        raise SystemExit('fatal: {}'.format(error))
+
+    if created:
+        print('Initialized empty GitData repository in {}'.format(repository_path))
+    else:
+        print('GitData repository already initialized in {}'.format(repository_path))