Skip to main content

DAS CLI and Python SDK

das-cli is both:

  • a command-line tool (das) for day-to-day DAS operations, and
  • a Python package for scripts, automations, and integrations.

This README is organized around how people actually use the project:

  1. CLI workflows — Authentication · Search and Read · Entries · Digital Objects · Downloads · Other CLI groups
  2. Programmatic workflows — Pattern A · Pattern B
  3. Manager-layer API reference — EntryManager · SearchManager · DownloadManager · DigitalObjectsManager

Install

Requirements

  • Python 3.13+

Install from PyPI

pip install das-cli

Install from source

git clone https://git.nioz.nl/ict-projects/das-cli.git
cd das-cli
pip install -e .

To exercise or debug the CLI from the repo without relying on the installed das console script, run it as a module:

# From the repo root (after pip install -e ., or with PYTHONPATH set to the repo)
python -m das.cli --help

On PowerShell, if you have not done an editable install yet:

$env:PYTHONPATH = "C:\Workspace\das-cli"   # path to your clone
python -m das.cli --help

Quickstart (CLI)

# 1) Authenticate (choose one)
das login --api-url https://your-das-instance/api
das login --api-url https://your-das-instance/api --api-key <your-api-key>

# 2) Search
das search entries --attribute Cores --query "name(*64*)" --max-results 10 --page 1

# 3) Get one entry
das entry get --code zb.b.1ub

CLI Usage

Authentication

Username/password

das login --api-url https://your-das-instance/api --username your_user --password your_password

If --username or --password is omitted, the CLI prompts securely.

API key

das login --api-url https://your-das-instance/api --api-key <your-api-key>

# Save the key without contacting the server
das login --api-url https://your-das-instance/api --api-key <your-api-key> --skip-verify

Generate the key in DAS Web UI: My Settings -> API Keys.

The key is stored and checked against the server, so you find out immediately whether it works and which account it belongs to:

✓ API key saved and verified.
  Authenticated as: alovelace (Ada Lovelace, ada@example.org)

A key the server refuses (mistyped, revoked, expired, or issued for a different DAS environment) is still saved — so nothing is lost if the URL was wrong — but reported clearly:

✓ API key saved.
❌ The server did not accept this API key.

If the server cannot be reached the key is saved with a warning instead of a verdict. Use --skip-verify to skip the check altogether.

OAuth / Azure Entra

das oauth configure --client-id <client-id> --authority https://login.microsoftonline.com/<tenant>/v2.0
das login --api-url https://your-das-instance/api --oauth

Who am I?

das whoami answers two questions: which credential the CLI sends, and whose it is according to the server.

# Which credential is used, and is it still valid?
das whoami

# Local information only, no server call
das whoami --offline

# Machine-readable (the credential itself is never printed, only a masked form)
das whoami --format json
Current DAS credential
────────────────────────────────────────
  API URL      : https://your-das-instance/api
  Auth type    : api_key
  Credential   : das_2702…fe84
  Source       : DAS_API_KEY environment variable
  Defined in   : C:\Workspace\my-project\.env
  ⚠ DAS_API_KEY overrides the credential saved by 'das login' (eyJhbGci…zZt0).

  Server
    Status     : ✓ credential accepted
    User name  : alovelace
    Full name  : Ada Lovelace
    Email      : ada@example.org
    User ID    : 42
    Tenant     : Default (id 1)
    DAS version: 12.3.0.0
────────────────────────────────────────

Credential precedence. A DAS_API_KEY in your environment or .env file always wins over whatever das login saved. That is the usual reason commands run as someone else than expected, so das whoami (and das config show) name the source, point at the .env file that defines it, and warn when the environment variable shadows a different stored credential.

Search and Read

# Search with paging/sorting/formatting
das search entries --attribute Cores --query "name(*64*)" --max-results 10 --page 1 --sort-by Name --sort-order asc --format table

# Get details of one entry by ID
das search entry 6b0e68e6-00cd-43a7-9c51-d56c9c091123 --format json

# Query syntax help
das search help

Entries

# Get by code
das entry get --code ENT001

# Delete by code (with prompt)
das entry delete --code ENT001

# Delete by ID (no prompt)
das entry delete --id e1987f3e-7db7-11f0-a7e8-0edcca226f3d --force

Create entries

# From file (.json/.csv/.xlsx)
das entry create --attribute Cores c:\data\entries.json

# Single object from --data
das entry create --attribute Cores --data "{ 'Alias': 'test.entry.001', 'Event': '64PE428-02PC' }"

# Bulk from --data
das entry create --attribute Cores --data "[{ 'Alias': 'a1' }, { 'Alias': 'a2' }]"

Update entries

# Single by code
das entry update --code ENT001 --data "{ 'Comment': 'Updated by CLI' }"

# Single by id
das entry update --id e1987f3e-7db7-11f0-a7e8-0edcca226f3d --data "{ 'Comment': 'Updated by id' }"

# Bulk from file (each item should include Id/Code)
das entry update c:\data\entries-to-update.json

# Recalculate the auto-generated name after changing a field it is built from
das entry update --code 4.b.rdg --data "{ 'Cast No.': '02' }" --regenerate-name
das entry update c:\data\events.xlsx --regenerate-name

An auto-generated name (an Event is <station>_<cast><device acronym>) is kept as stored on update, even when the update changes the cast number or the device. Pass --regenerate-name to have the server rebuild it from the updated values. The flag applies to every entry of a bulk update, overrides a Name given in the data, and is ignored for attributes whose name has no formula.

Logs and ownership

# Audit logs
das entry logs --code ENT001 --max-results 50 --skip 0 --format table

# Change owner
das entry chown --user alice --code ENT001 --code ENT002

Digital Objects

# Upload + link to entry
das entry upload-digital-object --entry-code ENT001 --type Dataset --description "CTD raw" c:\data\ctd.zip

# Link existing digital objects
das entry link-digital-objects --entry-code ENT001 -d DO001 -d DO002

# Unlink
das entry link-digital-objects --entry-code ENT001 -d DO002 --unlink

# Direct download by codes
das entry direct-download-digital-object --entry-code ENT001 --digital-object-code DO001 --out C:\Downloads\

Downloads

# Create request for all files from entry
das download request --entry ENT001 --name "My request"

# Create request selecting files
das download request --entry ENT001 --file FILE001 --file FILE002

# List your requests
das download my-requests --format table

# Download completed bundle
das download files 6b0e68e6-00cd-43a7-9c51-d56c9c091123 --out C:\Downloads

# Delete request
das download delete-request 6b0e68e6-00cd-43a7-9c51-d56c9c091123

Other CLI groups

# Attribute lookup
das attribute get --name "Cores"
das attribute get-id "Cores"
das attribute get-name 126

# Cache
das cache list
das cache clear "attributes"
das cache clear-all

# Hangfire (background jobs) — needs the Hangfire dashboard permission
das hangfire list                          # recurring jobs: ID, cron, queue, last/next run
das hangfire list --format json
das hangfire trigger "5. harvest-archive"  # run a recurring job now (quote IDs with spaces)
das hangfire sync-doi <entry-id>

# Config
das config ssl-verify true
das config ssl-status
das config show
das config reset --force

# Logging
das config log-level DEBUG          # TRACE, DEBUG, INFO, WARN (default), ERROR, FATAL
das config log-file C:\logs\das.log # also write logs to a file
das config log-file --clear         # back to console only

Logging

The CLI logs diagnostics (HTTP requests and error details) through the das logger. Control how much is shown and where it goes:

  • Level — from most to least verbose: TRACE, DEBUG, INFO, WARN (default), ERROR, FATAL. Set with das config log-level <LEVEL> or the DAS_LOG_LEVEL environment variable.
  • Destination — logs go to the console by default. Also write them to a file with das config log-file <path> (parent folders are created automatically) or the DAS_LOG_FILE environment variable; use das config log-file --clear to go back to console-only. The file log includes timestamps and logger names while the console stays terse.
# Verbose troubleshooting session written to a file
das config log-level DEBUG
das config log-file C:\logs\das.log
das search entries --attribute Cruise --query "cruisecode(*64PE*)"

Tip: this is the diagnostic log for the CLI itself. For an entry's change/audit history, use das entry logs instead.

Programmatic Usage (Python)

Two common patterns are supported.

Pattern A: login once with CLI, then use managers in Python

from das.managers.entries_manager import EntryManager
from das.managers.search_manager import SearchManager

entries = EntryManager()
search = SearchManager()

core = entries.get(code="zb.b.1ub")
results = search.search_entries(attribute="Cores", query="name(*64*)", max_results=5)

Pattern B: authenticate in Python with Das

from das.app import Das
from das.managers.entries_manager import EntryManager

# Username/password
client = Das("https://your-das-instance/api")
client.authenticate("your_user", "your_password")

# Or API key — validate=True returns the user the key belongs to (None if refused)
# client = Das("https://your-das-instance/api")
# user = client.set_api_key("your-api-key", validate=True)
# if user is None:
#     raise SystemExit("The server did not accept this API key.")

entry_manager = EntryManager()
entry = entry_manager.get(code="zb.b.1ub")
print(entry.get("Name"))

Checking the active credential

Das.whoami() is the programmatic form of das whoami: it reports which credential will be sent, where it came from, and who the server says that is.

from das.app import Das

info = Das("https://your-das-instance/api").whoami()

print(info["status"])         # 'valid' | 'invalid' | 'no-credential' | 'unreachable'
print(info["source"])         # 'env' (DAS_API_KEY) | 'keyring' | 'file'
print(info["masked"])         # 'das_2702…fe84' — never the raw credential
if info["status"] == "valid":
    print(info["user"]["userName"], info["user"]["emailAddress"])

whoami(verify=False) skips the server call and reports local information only (status is then "unverified"). Lower-level access is available through client.session (SessionService): get_current_login_information(), get_current_user() and validate_api_key(key) — the last one checks a key without storing it.

Recurring Hangfire jobs

Every recurring job the DAS worker registers can be listed and run on demand — the equivalent of Trigger now in the /hangfire dashboard. Triggering enqueues one extra run; the job's schedule is not changed. Your account needs the Hangfire dashboard permission (Pages.Administration.HangfireDashboard).

from das.app import Das

das = Das()  # uses the URL + credential saved by `das login`

for job in das.hangfire.get_recurring_jobs():
    print(job["id"], job["cron"], job["queue"], job["nextExecution"], job["lastJobState"])

result = das.hangfire.trigger_recurring_job("5. harvest-archive")
print(result["jobId"])  # id of the background job that was enqueued

# Case-insensitive lookup; raises ValueError listing the valid ids when unknown
job = das.hangfire.find_recurring_job("system health check")

Each job is a dict with id, cron, queue, timeZoneId, job (Type.Method), nextExecution, lastExecution, lastJobId, lastJobState, createdAt and error; timestamps are UTC. Failures raise a DasApiError subclass (e.g. DasPermissionError without the permission, DasNotFoundError when the server is too old to have these endpoints).

Manager Layer API Reference (Domain Layer)

Managers are the recommended Python API. They translate user-friendly field names, codes, and query syntax into the lower-level DAS API calls.

Prerequisite: authenticate first (see Programmatic Usage), then instantiate any manager:

from das.managers.entries_manager import EntryManager

entries = EntryManager()  # reads API URL + token from stored config

All managers raise ValueError when the API URL is not configured or when required parameters are missing.


EntryManager

Import: from das.managers.entries_manager import EntryManager

Method Returns
get(code=..., id=...) dict — entry with display field names
get_entry(entry_id) dict — same as get(id=...)
create(attribute, entry=..., entries=...) list[dict] — per-item status with id, code, status
update(id=..., code=..., entry=..., entries=..., regenerate_name=False) list[dict] — per-item status
delete(id=..., code=...) bool
create_from_file(attribute, file_path) None
chown(user_name, entry_code_list) API response
get_entry_logs(entry_id=..., entry_code=..., ...) dict with totalCount and items
get_direct_relations(entry_code=..., entry_id=..., ...) dict with relation items

get / get_entry — fetch one entry

entries = EntryManager()

# By code (returns display field names like "Name", "Code", "Event", etc.)
entry = entries.get(code="zb.b.1ub")
print(entry["Name"], entry["Code"])

# By ID (GUID)
entry = entries.get(id="6b0e68e6-00cd-43a7-9c51-d56c9c091123")

# Convenience alias — same result as get(id=...)
entry = entries.get_entry("6b0e68e6-00cd-43a7-9c51-d56c9c091123")

Digital objects are always included, under the single key "Digital Object(s)" — regardless of what the attribute calls its digital-object field (Persons calls it Files) and even when the entry-field metadata does not expose the field at all:

for obj in entry.get("Digital Object(s)", []):
    print(obj["Id"], obj["Name"], obj["Type"], obj["Links"])
# 1715e27d-bc89-4f9c-8fdf-36ad2da333c6 zeynep.erdem.jpg Image 4d.b.cb

das entry get and das search entry <id> print the same objects as a block below the field list (or inline in the payload with --format json).

create — create one or many entries

entries = EntryManager()

# Single entry (field keys can be display names or column names)
result = entries.create(attribute="Cores", entry={
    "Alias": "test.entry.001",
    "Event": "64PE428-02PC",
    "Number": 1,
    "Number Alias": "001",
    "Start Depth": 576,
    "End Depth": 600,
    "Comment": "Created from Python",
})
# result -> [{"id": "<guid>", "code": "zb.b.xxx", "status": "success"}]
new_id = result[0]["id"]

# The code is generated by the server and read back with a second request.
# Skip that request when only the id is needed (imports, benchmarks):
result = entries.create(attribute="Cores", entry={...}, fetch_code=False)
# result -> [{"id": "<guid>", "status": "success"}]

# Bulk create
results = entries.create(attribute="Cores", entries=[
    {"Alias": "bulk.001", "Event": "64PE428-02PC", "Number": 1},
    {"Alias": "bulk.002", "Event": "64PE428-02PC", "Number": 2},
])
for item in results:
    print(item.get("id"), item.get("status"), item.get("error"))

# Entry with relation fields (comma-separated codes or GUIDs)
entries.create(attribute="Cruise", entry={
    "Cruise Code": "TEST-Cruise-001",
    "Project(s)": "3d.b.q,3d.b.r",   # multiple project codes
    "Vessel": "Algoa",
    "Start Date": "2026-01-01",
    "End Date": "2026-01-02",
})

warm_select_cache — pre-resolve select values before an import

Every select field value ("Event": "64PE428-02PC", "Device": "CTD") is resolved with one search request the first time the manager sees it. An import that references many different stations, devices or cruises pays one request per distinct value. warm_select_cache loads the options of every select field of an attribute up front and caches them by code, display name and id, so the rows that follow resolve without a request:

entries = EntryManager()
cached = entries.warm_select_cache("Event")          # one request per select field (per 1000 options)
print(f"{cached} select options cached")

for row in rows:
    entries.create(attribute="Event", entry=row, fetch_code=False)   # one request per row

Values must match the server's spelling and case; anything else still falls back to a search. Fields with more than max_results options (default 1000) are warmed partially. The cache lives as long as the manager instance.

update — update one or many entries

entries = EntryManager()

# Partial update by code (only changed fields needed)
entries.update(code="zb.b.0", entry={
    "Availability": "pc.b.c",
    "Number": 2,
    "Comment": "Updated from Python",
})

# Partial update by ID
entries.update(id="c4c6dff6-5ccb-11f0-a78d-a84a63c8db73", entry={
    "description": "New description text",
    "jobtitle": "Head of National Marine Facilities",
})

# Bulk update (each item must include Code or Id)
entries.update(entries=[
    {"Code": "ENT001", "Comment": "Updated 1"},
    {"Code": "ENT002", "Comment": "Updated 2"},
])

# Rebuild the auto-generated name from the updated values (kept as stored by default)
entries.update(code="4.b.rdg", entry={"Cast No.": "02"}, regenerate_name=True)

delete — delete one entry

entries = EntryManager()

entries.delete(id="6b0e68e6-00cd-43a7-9c51-d56c9c091123")  # -> True
entries.delete(code="zb.b.1ub")                             # -> True

create_from_file — bulk create from file

entries = EntryManager()

entries.create_from_file(attribute="Cores", file_path=r"c:\data\entries.json")
entries.create_from_file(attribute="Cores", file_path=r"c:\data\entries.csv")
entries.create_from_file(attribute="Cores", file_path=r"c:\data\entries.xlsx")

Supported formats: .json (list of objects), .csv (one row per entry), .xlsx (one row per entry).

chown — transfer ownership

entries = EntryManager()

result = entries.chown(
    user_name="alice",
    entry_code_list=["ENT001", "ENT002"],
)

get_entry_logs — audit / change history

entries = EntryManager()

# By code
logs = entries.get_entry_logs(entry_code="ENT001", max_result_count=50, skip_count=0)

# By ID
logs = entries.get_entry_logs(entry_id="d7b99f36-5ccb-11f0-87f3-a84a63c8db73")

print(logs["totalCount"])
for log in logs["items"]:
    print(log["fieldName"], log["valueFrom"], "->", log["valueTo"], log["modifierUserName"])
entries = EntryManager()

relations = entries.get_direct_relations(entry_code="6.b.sy")
for rel in relations["items"]:
    print(rel["id"], rel.get("displayname"))

SearchManager

Import: from das.managers.search_manager import SearchManager

Method Returns
search_entries(attribute, query, max_results, page, sort_by, sort_order, includeRelationsId) dict with items and totalCount

Query and sort field names are automatically converted from display names to internal column names.

search_entries — search within an attribute

search = SearchManager()

# Basic search
results = search.search_entries(
    attribute="Cores",
    query="name(*64*)",
    max_results=10,
    page=1,
)
print(results["totalCount"])
for item in results["items"]:
    print(item.get("Name"), item.get("Code"))

# Composite query (AND / OR)
results = search.search_entries(
    attribute="Cores",
    query="name(64PE320-03BC#01) or code(zb.b.1ub)",
    max_results=5,
    sort_by="Name",
    sort_order="asc",
)

# Search all entries in an attribute (empty query)
results = search.search_entries(
    attribute="Cores",
    query="",
    max_results=1000,
    page=1,
)

# Find stations by cruise code
stations = search.search_entries(
    attribute="Station",
    query="Cruise(64PE514)",
    max_results=5,
    sort_by="Code",
)

# Wildcard search on display name
projects = search.search_entries(
    attribute="Cruise",
    query="displayname(*64PE514*)",
    max_results=5,
    sort_by="displayname",
)

# Paginate to page 2
page2 = search.search_entries(
    attribute="Cores",
    query="name(*64*)",
    max_results=50,
    page=2,
)

DownloadManager

Import: from das.managers.download_manager import DownloadManager

Method Returns
create_download_request(request_data) str (request ID) or dict with errors
get_my_requests() dict or list of download requests
delete_download_request(request_id) API response
download_files(request_id) requests.Response (streaming)
save_download(request_id, output_path, overwrite) str — saved file path

The request_data dict uses entry codes as keys. Values are lists of digital-object codes; an empty list means all files from that entry.

create_download_request — request files for download

downloads = DownloadManager()

# Specific files from one entry
request_id = downloads.create_download_request({
    "name": "My download",
    "zb.b.dc": ["h.b.z0pg", "h.b.s3pg"],
})

# All files from one entry (empty list)
request_id = downloads.create_download_request({
    "name": "All files",
    "zb.b.lu": [],
})

# Mixed: selected files from one entry, all files from another
request_id = downloads.create_download_request({
    "name": "Mixed download",
    "zb.b.dc": ["h.b.z0pg", "h.b.s3pg"],
    "zb.b.lu": [],
})

# Handle validation errors
result = downloads.create_download_request({"name": "Bad", "INVALID": []})
if isinstance(result, dict) and "errors" in result:
    for err in result["errors"]:
        print(err)

get_my_requests — list your download requests

downloads = DownloadManager()

requests = downloads.get_my_requests()
items = requests.get("items", []) if isinstance(requests, dict) else requests
for req in items:
    print(req["id"], req.get("status"), len(req.get("files", [])))

delete_download_request — remove a request

downloads = DownloadManager()

downloads.delete_download_request("6b0e68e6-00cd-43a7-9c51-d56c9c091123")

download_files — get streaming response

downloads = DownloadManager()

response = downloads.download_files("6b0e68e6-00cd-43a7-9c51-d56c9c091123")

# Manual save from stream
with open(r"C:\Downloads\bundle.zip", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            f.write(chunk)

save_download — download and save in one step

downloads = DownloadManager()

# Save to directory (filename taken from server response)
path = downloads.save_download(
    request_id="6b0e68e6-00cd-43a7-9c51-d56c9c091123",
    output_path=r"C:\Downloads",
)

# Save to explicit file path, overwrite if exists
path = downloads.save_download(
    request_id="6b0e68e6-00cd-43a7-9c51-d56c9c091123",
    output_path=r"C:\Downloads\bundle.zip",
    overwrite=True,
)

DigitalObjectsManager

Import: from das.managers.digital_objects_manager import DigitalObjectsManager

Method Returns
upload_digital_object(entry_code, file_description, digital_object_type, file_path) str — digital object ID
link_existing_digital_objects(entry_code, digital_object_code_list, is_unlink) bool
download_digital_object(output_path, digital_object_id, digital_object_code) str — saved file path
direct_download_digital_object(...) str — saved file path

upload_digital_object — upload file and link to entry

digital_objects = DigitalObjectsManager()

do_id = digital_objects.upload_digital_object(
    entry_code="zb.b.f7",
    file_description="CTD raw data",
    digital_object_type="Dataset",
    file_path=r"c:\data\ctd.zip",
)
print(do_id)  # GUID of the new digital object
digital_objects = DigitalObjectsManager()

# Link
digital_objects.link_existing_digital_objects(
    entry_code="4d.b.1l",
    digital_object_code_list=["h.b.ac0j"],
    is_unlink=False,
)

# Unlink
digital_objects.link_existing_digital_objects(
    entry_code="4d.b.1l",
    digital_object_code_list=["h.b.ac0j"],
    is_unlink=True,
)

download_digital_object — download by digital object code or ID

digital_objects = DigitalObjectsManager()

# By code (output_path can be a directory or a file path)
path = digital_objects.download_digital_object(
    output_path=r"c:\temp\",
    digital_object_code="h.b.8j2h",
)

# By ID
path = digital_objects.download_digital_object(
    output_path=r"c:\temp\file.bin",
    digital_object_id="b47c3de3-d754-4a25-8528-c4fd88e1fdbb",
)

direct_download_digital_object — download from a specific entry

digital_objects = DigitalObjectsManager()

# By entry code + digital object code
path = digital_objects.direct_download_digital_object(
    entry_code="4d.b.1l",
    digital_object_code="h.b.ac0j",
    output_path=r"c:\temp\",
)

# By IDs (when you already have them)
path = digital_objects.direct_download_digital_object(
    entry_id="e1987f3e-7db7-11f0-a7e8-0edcca226f3d",
    attribute_id=126,
    digital_object_id="cf335b17-80e3-4151-aa80-40b69fe0567e",
    output_path=r"c:\temp\file.bin",
)

Complete end-to-end script

from das.app import Das
from das.managers.entries_manager import EntryManager
from das.managers.search_manager import SearchManager
from das.managers.download_manager import DownloadManager
from das.managers.digital_objects_manager import DigitalObjectsManager

# 1. Authenticate
client = Das("https://your-das-instance/api")
client.authenticate("your_user", "your_password")

# 2. Instantiate managers
entries = EntryManager()
search = SearchManager()
downloads = DownloadManager()
digital_objects = DigitalObjectsManager()

# 3. Search
hits = search.search_entries(attribute="Cores", query="name(*64*)", max_results=5)
print(f"Found {hits['totalCount']} cores")

# 4. Read one entry
core = entries.get(code="zb.b.1ub")
print(core["Name"])

# 5. Create a new entry
created = entries.create(attribute="Cores", entry={
    "Alias": "api.test.001",
    "Event": "64PE428-02PC",
    "Number": 1,
})
print(f"Created {created[0]['code']}")

# 6. Upload a file
do_id = digital_objects.upload_digital_object(
    entry_code=created[0]["code"],
    file_description="Test file",
    digital_object_type="Dataset",
    file_path=r"c:\data\sample.zip",
)

# 7. Request download and save
request_id = downloads.create_download_request({
    "name": "API test download",
    created[0]["code"]: [],
})
saved = downloads.save_download(request_id, output_path=r"C:\Downloads")
print(f"Saved to {saved}")

# 8. Clean up
entries.delete(id=created[0]["id"])
downloads.delete_download_request(request_id)

Configuration and Environment Variables

You can configure values through CLI commands and/or .env.

# Connection
DAS_API_URL=https://your-das-instance/api
DAS_API_KEY=
VERIFY_SSL=True

# Logging
DAS_LOG_LEVEL=WARN
DAS_LOG_FILE=

# Test credentials (for integration tests)
API_URL=https://your-das-instance/api
USER_NAME=
USER_PASSWORD=

# AI feature
OPENAI_API_KEY=
OPEN_AI_MODEL_ID=gpt-4o-mini
  • DAS_API_URL: default API URL for app/managers when no explicit URL is provided.
  • DAS_API_KEY: API key auth (takes precedence over stored token in auth layer).
  • VERIFY_SSL: TLS verification (True/False).
  • DAS_LOG_LEVEL: diagnostic log level (TRACE/DEBUG/INFO/WARN/ERROR/FATAL); overrides das config log-level.
  • DAS_LOG_FILE: path to also write logs to a file; overrides das config log-file.
  • API_URL, USER_NAME, USER_PASSWORD: used by integration tests.

Unit Tests and Integration Tests

Run complete suite:

python run_tests.py

Run a single test module:

python -m pytest tests/entries_manager_test.py

The tests are a good source of realistic payload examples, especially:

  • tests/entries_manager_test.py
  • tests/search_manager_test.py
  • tests/download_manager_test.py
  • tests/digital_object_manager_test.py

Troubleshooting

  • Authentication errors:
    • verify the URL includes your DAS API base (often ending in /api).
    • run das login again to refresh stored auth.
  • SSL errors in local/dev environments:
    • temporarily disable with das config ssl-verify false (avoid in production).
  • PowerShell quoting:
    • prefer double quotes around query arguments containing *, ;, and parentheses.
  • No API URL configured:
    • set DAS_API_URL, pass URL to Das(...), or run das login --api-url ....
  • Need more detail on any error:
    • raise verbosity with das config log-level DEBUG (optionally das config log-file <path>) to see the full HTTP requests and error details. See Logging.
  • Debug or inspect the CLI from source:
    • run python -m das.cli --help from the repo root (after pip install -e ., or with PYTHONPATH pointing at the clone) to confirm the package loads and list available commands without using the das console script.

Contributing

Contributions are welcome through pull requests.

For bugs or feature requests, use the project issue tracker:

License

MIT License

Metadata

Release files for das-cli 1.9.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for das-cli 1.9.0
File Size Uploaded Provenance Actions
das_cli-1.9.0.tar.gz 95.8 kB Without provenance Details for das_cli-1.9.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for das-cli 1.9.0
File Interpreter ABI Platform Actions
das_cli-1.9.0-py3-none-any.whl Python 3 none any Details for das_cli-1.9.0-py3-none-any.whl

Total release size: 182.6 kB

Release files / das_cli-1.9.0.tar.gz

Download URL das_cli-1.9.0.tar.gz
Size 95.8 kB
Tags Source
SHA-256 checksum
How to use checksums
ba4275871149558197b5470ae675c05b3a495c63844450e6b771e03227cf3e2e
BLAKE2b-256 checksum
How to use checksums
ec2b48aff2e9e85c7ca668012bc3141a19da91081ac01e89c2fb1449ca0b17e3
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.14.6

Release files / das_cli-1.9.0-py3-none-any.whl

Download URL das_cli-1.9.0-py3-none-any.whl
Size 86.8 kB
Tags Python 3
SHA-256 checksum
How to use checksums
5456fbf07eca9f67b1be9aff4f548c2c0b975912be6fd6316e7dbe208706948d
BLAKE2b-256 checksum
How to use checksums
4c33d4eb875d347290872372fee4105218071ef1275a12fca085fca1ca02a981
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.14.6

Security for das-cli 1.9.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

1.9.0 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page