from s3 import S3Analyzer, S3View

ui = S3View(S3Analyzer(profile="dev", region="eu-west-1"))   # another AWS profile or region
ui = S3View(mode="text")          # plain text, e.g. in a terminal or a script
ui = S3View(max_rows=0)           # show every row of long tables (default: 50)
ui = S3View(progress="plain")     # a plain progress line instead of tqdm bars ("off" for none)

Every View takes the same options. Commands that take a while show a progress bar as they run: a tqdm bar (a widget in Jupyter when ipywidgets is installed) with the rate and the time left, when tqdm is installed, as it usually is on SageMaker. Without it you get a plain line with the same numbers.

IPython, used for the HTML output, comes with Jupyter. If a package is missing, the command tells you which one to install instead of failing; install it and run the cell again.

from s3 import S3Analyzer
from s3_explorer import S3Explorer, S3Navigator

S3Explorer("s3://my-bucket/", profile="dev")          # another AWS profile (or region=)
S3Explorer(core=S3Analyzer(region="eu-west-1"))       # an S3Analyzer or S3View you already have
S3Explorer(height=720, page_size=200)                 # taller panes, more rows before "Show more"

x = S3Explorer("s3://my-bucket/")
x.open("s3://my-bucket/raw/"); x.back(); x.up(); x.refresh()   # the toolbar, from code
x.ui.summary(x.location)                              # any S3View report about where you are, in its own cell

nav = S3Navigator()                                   # the same navigation as data, with no UI
folder = nav.open("s3://my-bucket/data/")             # Folder: entries, more, error
nav.more(), nav.back(), nav.up(), nav.lookup("2024-")

Outside Jupyter, without ipywidgets, or with mode="text", each folder prints as a table and open(...) moves around. The pure functions work on their own: parse_location (s3:// paths, bucket/key, console links and object URLs), breadcrumbs, parent_uri, sort_entries (folders first, part-2 before part-10), filter_entries and folder_stats.

ui.core is the S3Analyzer. Every UI command has a data method on it, and there are a few more:

s3 = ui.core                                        # or S3Analyzer(region="us-east-1", profile="dev")

summary = s3.summarize("s3://my-bucket/data/")      # PrefixSummary dataclass
summary.by_extension["parquet"].size                # bytes

files = s3.find("s3://my-bucket/data/", extensions=["csv"], modified_after="7d")
df = objects_to_df(files)                           # key, size, last_modified, storage_class, ...

df = s3.read_df("s3://my-bucket/data/big.parquet", nrows=1000, columns=["id", "ts"])
df = s3.read_df("s3://my-bucket/reports/q1.xlsx", sheet_name="Summary")
df = s3.read_df("s3://my-bucket/spark/part-00000", fmt="parquet")   # no extension: say what it is
s3.parquet_info("s3://my-bucket/data/big.parquet")  # rows, row groups, schema (reads only the footer)
s3.list_archive("s3://my-bucket/job/output/model.tar.gz").entries   # files inside, without extracting
details = s3.file_details("s3://my-bucket/docs/", extensions="pdf")   # FileDetailsReport: .files, bytes_read
details.to_df()                                     # one row per file: format, size, summary, pages, title, rows, ...
s3.describe_objects(s3.find("s3://my-bucket/", min_size="1GB"))     # the same, for files you picked
s3.read_avro("s3://my-bucket/events.avro", n=100), s3.read_npy(uri, nrows=10), s3.safetensors_info(uri)
doc = s3.read_document("s3://my-bucket/docs/policy.pdf")   # also .docx / .pptx: doc.text, doc.parts, doc.title
s3.read_pdf(uri, pages=[1, 2]), s3.read_docx(uri).headings, s3.read_pptx(uri).notes
pages = s3.render_pdf(uri, pages=[1, 2])            # [Picture]: each one shows itself in a notebook; .data is PNG / JPEG
s3.read_docx(uri, pictures=True).pictures           # the pictures in a Word file, in reading order
s3.read_lines("s3://my-bucket/logs/app.log.gz", 50)
s3.read_json(...), s3.read_jsonl(..., n=100), s3.read_text(...), s3.read_bytes(uri, 0, 1023)
with s3.open("s3://my-bucket/data/x.csv.gz") as f: ...   # streaming, decompressed

for obj in s3.iter_objects("s3://my-bucket/"):      # stream a listing without holding it in memory
    ...

reports = s3.bucket_reports(match="sagemaker-*")    # BucketConfig + CloudWatch size per bucket
explain_policy(s3.bucket_policy("my-bucket"), s3.account_id())   # [PolicyStatement], plain English
impact = s3.simulate_lifecycle("s3://my-bucket/logs/", move_after=30, to="STANDARD_IA")
impact.monthly_savings, impact.rule()               # USD per month, the rule as a dict
s3.deleted_files("s3://my-bucket/data/", deleted_after="7d").files   # [DeletedObject]
dupes = s3.find_duplicates("s3://my-bucket/data/")  # DuplicateReport: groups, copies, reclaimable, monthly_cost
dupes.to_df()                                       # one row per file: group, role ('keep' / 'copy'), key, sha256, ...
s3.download_folder("s3://my-bucket/data/", "data")  # FolderDownload; s3.download(uri, path) for one file
plan = s3.plan_zip("s3://my-bucket/data/")          # ZipPlan: files, size, disk / memory free, can_download
s3.download_zip("s3://my-bucket/data/", max_size="1GB").plan.path   # ZipDownload; nothing written if a check fails

The aggregation functions are pure (no AWS calls), so they also work on your own lists of ObjectInfo, for example rows loaded from an S3 Inventory report: summarize_objects, build_folder_tree, make_filter, find_duplicate_groups, compare_objects, simulate_lifecycle_objects, summary_findings, bucket_findings, explain_policy, policy_findings, object_monthly_cost, cloudwatch_cost, the duplicate finder's steps (files_to_hash says which files need reading, group_duplicates groups them given the hashes you have, then duplicate_folders and duplicate_findings), zip_checks and zip_findings (on a ZipPlan), and the file parsers parse_docx (pictures=True for its pictures), parse_pptx, parse_pdf, parse_avro, and render_pdf_pages, which draws a PDF's pages from a local file or bytes. describe_file("local.pdf") (or a binary file object and its name) says what's inside a file the way file_details does, and file_details_findings works on a FileDetailsReport.

preview and read_df pick the reader from the file name, and from the first bytes when the name has no extension or the wrong one (Spark's part-00000, a Firehose object, a .gz that isn't gzipped).

Any of them can also be compressed: .gz, .bz2, .xz, or .zst (Python 3.14+, or pip install zstandard). Packages in the table are optional; without them preview says what to install.

Each file's format comes from its name and is checked against its first bytes, so a file with no extension is still described and one with the wrong extension is flagged ("report.pdf is text, not a PDF"). Counts marked ≈ are estimates from the start of the file, and + marks a lower bound.

Costs are storage only (no requests, retrievals or data transfer), at us-east-1 list prices for the first 50 TB (S3_PRICES). They follow S3's billing rules: STANDARD_IA, ONEZONE_IA and GLACIER_IR bill at least 128 KB per object, and GLACIER / DEEP_ARCHIVE add 40 KB of index data per object. Listings don't say which Intelligent-Tiering tier an object is in, so it's priced at the frequent-access rate; CloudWatch does, so bucket_info and overview price each tier. For another region, pass your prices:

ui = S3View(S3Analyzer(prices={"STANDARD": 0.025, "STANDARD_IA": 0.0138}))

• summary, tree, find, duplicates and compare list every key under the prefix (1,000 per request), so expect about 1 to 3 minutes per million objects. A progress bar shows while they run. Pass limit= to sample.
• duplicates also downloads files that share a size but not an ETag: 64 KB of each, then whole files only where those match, 16 at a time, biggest possible saving first, and it stops at max_read (10 GB by default). It says how much it read. That download is free inside the bucket's region; from outside AWS it's billed as data transfer. method="etag" reads nothing.
• download_zip counts at most max_files keys (10,000 by default) before it decides, so it answers quickly even on a huge folder, and it only downloads once every check passes.
• what_if lists every key too; deleted and versions list every version.
• bucket_info reads the bucket's size from CloudWatch without listing anything. Use it first on huge buckets.
• overview makes about 15 read calls per bucket, 8 buckets at a time, and lists no keys.
• file_details looks inside the first 200 files (limit=), 8 at a time, in 256 KB ranged requests, reading only what each format needs (a PDF's page tree, a parquet footer, a picture's header), at most 128 MB of one file, and stops at max_read (1 GB by default). It says how much it read.
• ls only lists one level, so it's fast anywhere. ls(details=True) also reads a little of each file listed.

Read-only. Grant what you need:

Anything you can't read shows up as a note instead of an error. The S3 guide has a ready-made IAM policy that covers every command.

ui.core is the DynamoDBAnalyzer. Every UI command has a data method on it:

ddb = ui.core                                       # or DynamoDBAnalyzer(region="eu-west-1", profile="dev")

page = ddb.scan("orders", n=5000, where={"status": "failed"})   # ItemPage
page.items                                          # list of plain dicts
df = page.to_df()                                   # DataFrame: keys first, nested maps as 'address.city'
page.stats                                          # items read, items returned, read units, seconds
more = ddb.scan("orders", n=5000, where={"status": "failed"}, start_key=page.last_key)

ddb.query("orders", "USER#42", sort=("between", "ORDER#2024-01", "ORDER#2024-12"), descending=True)
ddb.query("orders", "failed", index="by-status").to_df()
ddb.sample("orders", 500).items                     # spread over the key space
ddb.get("orders", "USER#42", "ORDER#0017")          # dict, or None
ddb.sql('SELECT * FROM "orders" WHERE pk = ?', "USER#42").items

profile = ddb.profile("orders", 2000)               # TableProfile (what schema() shows)
profile.attributes["total"].types                   # Counter({'N': 1990, 'S': 10})
profile.to_df()                                     # one row per attribute

ddb.value_counts("orders", "status").counts         # {'paid': Stat(count=..., size=...), ...}
ddb.count("orders", where={"status": "failed"}).matched
ddb.describe("orders")                              # TableInfo: keys, indexes, capacity, TTL, backups, tags
ddb.table_metrics("orders", hours=24)               # consumed units, busiest period, throttle events
ddb.table_reports(match="prod-*")                   # [TableReport]: describe() + usage for every table

for item in ddb.iter_items("orders", limit=None):   # stream a full scan without holding it in memory
    ...

The analysis functions are pure (no AWS calls), so they also work on items you already have, for example a DynamoDB export to S3: from_dynamo_item, to_dynamo, items_to_df, flatten_item, profile_items, count_values, item_size, key_pattern, build_filter, table_findings, profile_findings, table_monthly_cost, capacity_cost, request_cost.

rows = S3Analyzer().read_jsonl("s3://my-bucket/AWSDynamoDB/01234-abcd/data/part.json.gz")   # from s3.py
profile_items([from_dynamo_item(row["Item"]) for row in rows], keys=["pk", "sk"])

• DynamoDB bills every item a scan reads, and a scan competes with your application for the table's capacity. So the commands that scan stop early by default: value_counts and largest read the first 10,000 items (limit=None reads everything), schema profiles about 1,000, and ui.scan with a filter reads at most 100,000 items per page (scan_limit=).
• count always reads the whole table: Select=COUNT returns no items but still reads, and bills, every one. For an instant estimate, tables() and table_info() show DynamoDB's own item count and size, which it refreshes about every 6 hours.
• Every report shows the read units it used and, where it matters, what they cost on-demand.
• Costs are estimates at us-east-1 list prices for the standard table class, before the free tier (DYNAMODB_PRICES): storage, provisioned capacity and point-in-time recovery per month, and on-demand reads and writes per million. For another region, pass your prices: DynamoDBAnalyzer(prices={"storage": 0.285, "read_request": 0.1425}).

Read-only. Grant what you need:

Reading an index needs the permission on its ARN too (arn:aws:dynamodb:<region>:<account>:table/orders/index/*), and a table encrypted with a customer managed KMS key needs kms:Decrypt. Anything you can't read shows up as a note instead of an error. The DynamoDB guide has a ready-made IAM policy that covers every command.

ui.core is the BedrockKBAnalyzer. Every UI command has a data method on it, and its methods take the knowledge base first:

kb = ui.core                                        # or BedrockKBAnalyzer(region="us-west-2", profile="dev")

info = kb.describe("support-docs")                  # KnowledgeBaseInfo: settings, data sources, last syncs, tags
info.data_sources[0].chunking                       # the chunkingConfiguration AWS returned
kb.list_knowledge_bases()                           # [KnowledgeBaseInfo], described in parallel
kb.ingestion_jobs("support-docs", n=20)             # [IngestionJob], newest first, with failure reasons
docs, summary = kb.documents("support-docs", status="FAILED")   # [KBDocument], DocumentSummary
kb.unsynced("support-docs")                         # [SyncFreshness]: changed S3 files per data source

r = kb.retrieve("support-docs", "refund window", n=10, where={"team": "billing"})   # Retrieval
r.passages[0].text, r.passages[0].source, r.passages[0].metadata
df = r.to_df()                                      # one row per passage

a = kb.ask("support-docs", "How long do refunds take?")          # Answer (RetrieveAndGenerate)
a.text, a.citations, a.sources, a.grounded_share
a = kb.generate("refund window?", r.passages, model="opus", prompt=MY_TEMPLATE)   # Converse on your passages
a = kb.generate("refund window?", ["my own chunk", "another chunk"])             # ...or on plain strings
a.input_tokens, a.output_tokens                     # exact, from Converse

kb.compare("support-docs", "refund window for EU orders").overlap   # SearchComparison
report = kb.evaluate("support-docs", [("refund window?", "refund-policy.pdf")])
report.hit_rate, report.mrr, report.to_df()         # EvalReport
kb.models("claude")                                 # [ModelInfo]: what to pass as model=, and its price

The analysis functions are pure (no AWS calls), so they also work on responses and passages you already have: parse_knowledge_base, parse_data_source, parse_ingestion_job, parse_retrieve, parse_rag, parse_converse, describe_chunking, describe_parsing, describe_vector_store, build_filter, describe_filter, build_prompt (and DEFAULT_PROMPT), parse_citation_markers, question_terms, best_snippet, retrieval_metrics, match_expected, compare_retrievals, summarize_documents, changed_since, generation_cost, vector_store_monthly_cost, query_cost, and the findings: kb_findings, sync_findings, retrieval_findings, answer_findings, eval_findings.

• Costs are estimates at us-east-1 list prices, read from the Bedrock and OpenSearch pricing pages on 2026-09-25 and checked against the AWS Price List API on 2026-09-27, and every report says whether it used list prices or yours. BEDROCK_PRICES holds the OpenSearch Serverless OCU-hour, its idle minimum, reranking per 1,000 queries (Cohere Rerank 3.5, and Amazon Rerank at half that) and question embedding; MODEL_PRICES holds $ per 1M input and output tokens by model family, and GLOBAL_MODEL_PRICES the lower prices of global. profiles (a price you set in model_prices applies to every profile of that model). Pass your own: BedrockKBAnalyzer(prices={"opensearch_min_ocus": 1}, model_prices={"my-model": (1.0, 5.0)}).
• The idle cost is only estimated for OpenSearch Serverless: a classic vector collection bills 2 OCUs (about $350/month) even with no traffic. Collections that share a KMS key share those OCUs, dev-test collections bill half, and NextGen collections scale to zero, so check your collection type. Other vector stores are billed by their own service and show "not estimated".
• ask() with the default engine estimates tokens from characters, since RetrieveAndGenerate doesn't return them; engine="converse" shows exact counts. A model that isn't in MODEL_PRICES shows its cost as unknown.
• evaluate() and compare() only retrieve, so they cost a question embedding per search (well under a cent), plus reranking when you ask for it.
• documents() reads at most 10,000 documents and unsynced() lists at most 100,000 objects by default; both say when they stopped early (.core.documents(..., limit=None) reads everything).

Read-only, per command:

A model also has to be enabled for the account under Model access in the Bedrock console. Anything you can't read shows up as a note instead of an error. The Knowledge Bases guide has a ready-made IAM policy that covers every command.

a = ui.answers[-1]                    # Answer: the conversation's answers, oldest first
a.text, a.citations, a.sources, a.grounded_share
a.request, a.response                 # exactly what was sent and what came back
a.to_df()                             # one row per cited source
ui.values                             # the settings: {'n': 8, 'temperature': 0.2, ...}

core = ui.core                        # or BedrockChatAnalyzer(region="us-west-2", profile="dev")
params = core.request("support-docs", "refund window?", {"n": 8})        # the request, without sending it
a = core.ask("support-docs", "refund window?", {"n": 8, "temperature": 0.2}, model="sonnet")
a = core.ask("support-docs", "and for EU orders?", session_id=a.session_id)  # a follow-up
core.ask("support-docs", "refund window?", stream=True, on_text=show)    # show(text) gets the answer so far
core.schema().fields["temperature"]   # Field: path, type, range, what it does

The analysis functions don't call AWS: request_schema, normalize_settings, coerce_setting, build_request, settings_from_request, validate_request, python_call, parse_rag, collect_stream, as_filter, describe_filter, describe_setting, answer_cost, and the findings: settings_findings and answer_findings.

• RetrieveAndGenerate doesn't report tokens, so they're estimated from characters (the question, the prompt and the passages retrieved; only the cited ones come back, so their average size stands in for the rest) and labelled as estimates. The estimate adds the question's embedding and, with a reranker, the reranking.
• Prices are the same us-east-1 list prices as bedrock_kb.py (MODEL_PRICES, GLOBAL_MODEL_PRICES, BEDROCK_PRICES); pass your own with BedrockChatAnalyzer(model_prices={...}, prices={...}). A model that isn't in the table shows its cost as unknown.
• Bedrock takes questions of up to 1,000 characters; the chat says so before sending a longer one.

A model also has to be enabled under Model access in the Bedrock console. A list the role can't read becomes a box to type into instead of a picker, with a note naming the missing permission. The chat guide has a ready-made IAM policy.

ui.core is the SageMakerAnalyzer. Every UI command has a data method on it:

sm = ui.core                                          # or SageMakerAnalyzer(region="eu-west-1", profile="dev")

report = sm.instance()                                # InstanceReport: .env, .notebook, .machine, .identity
report.notebook.instance_type, report.notebook.idle   # 'ml.g5.2xlarge', 'off'
report.machine.memory_share, report.machine.gpus      # 0.37, [GPUInfo(name='NVIDIA A10G', busy=0.0, ...)]
sm.notebook("old-experiment")                         # NotebookInfo for any notebook instance or Studio space
sm.environment()                                      # Environment: where this code runs, from SageMaker's metadata
sm.machine()                                          # Machine: this machine right now (local reads only)

d = sm.disk("~/SageMaker", limit=None)                # DiskReport: folders, largest files, caches you can clear
d.to_df()                                             # one row per folder

r = sm.running(days=30)                               # RunningReport: .resources, .stopped, .errors
r.to_df()                                             # one row per notebook, app, endpoint and job

The analysis functions are pure (no AWS calls), so they also work on responses you already have: parse_metadata, parse_notebook_instance, parse_app, apply_studio_settings, studio_idle, lifecycle_idle, parse_endpoint, parse_training_job, parse_processing_job, parse_meminfo, parse_loadavg, parse_gpus, parse_process, hourly_price, describe_instance, notebook_costs, smaller_type, folder_tree, idle_shutdown_commands, stop_command, and the findings: instance_findings, disk_findings, running_findings.

• Costs are estimates at us-east-1 on-demand list prices, read from the AWS Price List API on 2026-09-27. INSTANCE_TYPES holds the price per hour of 134 instance types, with their vCPUs, memory and GPUs; a type costs the same per hour as a notebook instance, a Studio app, an endpoint or a job. SAGEMAKER_PRICES adds storage per GB-month: $0.14 for a notebook instance's volume, $0.112 for a Studio space's, and S3 Standard's $0.023 to compare with. For another region or a discount, pass your own: SageMakerAnalyzer(prices={"ml.g5.xlarge": 1.21, "notebook_storage": 0.15}). A type that isn't in the table shows its cost as unknown, and every report says whether it used list prices or yours.
• "Cost since start" is the price per hour times how long it has run: since boot for the notebook instance you're in, since the app started for a Studio app, and since its last change (about when it last started) for any other notebook instance. Spot training jobs cost less than the on-demand price shown.
• instance() reads CPU load (the 15-minute average) and memory as they are now, so the suggestion of a smaller instance says "if that's typical". Whether a notebook instance stops when idle is read from its lifecycle configuration script: AWS's auto-stop-idle sample and scripts like it.
• disk() stops after 200,000 files by default and says so (limit=None measures everything). It stays on one disk and doesn't follow links.

Read-only, per command:

sts:GetCallerIdentity (who you're signed in as) needs no permission, and disk() only reads local files. Anything you can't read shows up as a note instead of an error. The AmazonSageMakerFullAccess managed policy, which many execution roles have, includes the sagemaker: permissions. The SageMaker guide has a ready-made IAM policy that covers every command.