cortexapps-cli 1.3.0__tar.gz → 1.5.0__tar.gz

{cortexapps_cli-1.3.0 → cortexapps_cli-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexapps-cli
-Version: 1.3.0
+Version: 1.5.0
 Summary: Command Line Interface for cortexapps
 License: MIT
 License-File: LICENSE

{cortexapps_cli-1.3.0 → cortexapps_cli-1.5.0}/cortexapps_cli/cli.py

@@ -24,6 +24,8 @@ import cortexapps_cli.commands.deploys as deploys
 import cortexapps_cli.commands.discovery_audit as discovery_audit
 import cortexapps_cli.commands.docs as docs
 import cortexapps_cli.commands.entity_types as entity_types
+import cortexapps_cli.commands.entity_relationship_types as entity_relationship_types
+import cortexapps_cli.commands.entity_relationships as entity_relationships
 import cortexapps_cli.commands.gitops_logs as gitops_logs
 import cortexapps_cli.commands.groups as groups
 import cortexapps_cli.commands.initiatives as initiatives
@@ -36,6 +38,7 @@ import cortexapps_cli.commands.queries as queries
 import cortexapps_cli.commands.rest as rest
 import cortexapps_cli.commands.scim as scim
 import cortexapps_cli.commands.scorecards as scorecards
+import cortexapps_cli.commands.secrets as secrets
 import cortexapps_cli.commands.teams as teams
 import cortexapps_cli.commands.workflows as workflows
 
@@ -58,6 +61,8 @@ app.add_typer(deploys.app, name="deploys")
 app.add_typer(discovery_audit.app, name="discovery-audit")
 app.add_typer(docs.app, name="docs")
 app.add_typer(entity_types.app, name="entity-types")
+app.add_typer(entity_relationship_types.app, name="entity-relationship-types")
+app.add_typer(entity_relationships.app, name="entity-relationships")
 app.add_typer(gitops_logs.app, name="gitops-logs")
 app.add_typer(groups.app, name="groups")
 app.add_typer(initiatives.app, name="initiatives")
@@ -70,6 +75,7 @@ app.add_typer(queries.app, name="queries")
 app.add_typer(rest.app, name="rest")
 app.add_typer(scim.app, name="scim")
 app.add_typer(scorecards.app, name="scorecards")
+app.add_typer(secrets.app, name="secrets")
 app.add_typer(teams.app, name="teams")
 app.add_typer(workflows.app, name="workflows")
 
@@ -81,7 +87,8 @@ def global_callback(
     url: str = typer.Option(None, "--url", "-u", help="Base URL for the API", envvar="CORTEX_BASE_URL"),
     config_file: str = typer.Option(os.path.join(os.path.expanduser('~'), '.cortex', 'config'), "--config", "-c", help="Config file path", envvar="CORTEX_CONFIG"),
     tenant: str = typer.Option("default", "--tenant", "-t", help="Tenant alias", envvar="CORTEX_TENANT_ALIAS"),
-    log_level: Annotated[str, typer.Option("--log-level", "-l", help="Set the logging level")] = "INFO"
+    log_level: Annotated[str, typer.Option("--log-level", "-l", help="Set the logging level")] = "INFO",
+    rate_limit: int = typer.Option(None, "--rate-limit", "-r", help="API rate limit in requests per minute (default: 1000)", envvar="CORTEX_RATE_LIMIT")
 ):
     if not ctx.obj:
         ctx.obj = {}
@@ -129,7 +136,7 @@ def global_callback(
     api_key = api_key.strip('"\' ')
     url = url.strip('"\' /')
 
-    ctx.obj["client"] = CortexClient(api_key, tenant, numeric_level, url)
+    ctx.obj["client"] = CortexClient(api_key, tenant, numeric_level, url, rate_limit)
 
 @app.command()
 def version():

{cortexapps_cli-1.3.0 → cortexapps_cli-1.5.0}/cortexapps_cli/commands/backup.py

@@ -5,6 +5,10 @@ from typing_extensions import Annotated
 import typer
 import json
 import os
+import tempfile
+import sys
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
 from rich import print, print_json
 from rich.console import Console
 from enum import Enum
@@ -14,6 +18,8 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import cortexapps_cli.commands.scorecards as scorecards
 import cortexapps_cli.commands.catalog as catalog
 import cortexapps_cli.commands.entity_types as entity_types
+import cortexapps_cli.commands.entity_relationship_types as entity_relationship_types
+import cortexapps_cli.commands.entity_relationships as entity_relationships
 import cortexapps_cli.commands.ip_allowlist as ip_allowlist
 import cortexapps_cli.commands.plugins as plugins
 import cortexapps_cli.commands.workflows as workflows
@@ -93,15 +99,39 @@ def _export_entity_types(ctx, directory):
 
     for definition in definitions_sorted:
         tag = definition['type']
-        json_string = json.dumps(definition, indent=4)
-        _file_name(directory, tag, json_string, "json")
+        _file_name(directory, tag, definition, "json")
 
 def _export_ip_allowlist(ctx, directory):
     directory = _directory_name(directory, "ip-allowlist")
     file = directory + "/ip-allowlist.json"
 
     content = ip_allowlist.get(ctx, page=None, page_size=None, _print=False)
-    _file_name(directory, "ip-allowlist", str(content), "json") 
+    _file_name(directory, "ip-allowlist", content, "json")
+
+def _export_entity_relationship_types(ctx, directory):
+    directory = _directory_name(directory, "entity-relationship-types")
+
+    data = entity_relationship_types.list(ctx, page=None, page_size=250, _print=False)
+    relationship_types_sorted = sorted(data['relationshipTypes'], key=lambda x: x["tag"])
+
+    for rel_type in relationship_types_sorted:
+        tag = rel_type['tag']
+        _file_name(directory, tag, rel_type, "json")
+
+def _export_entity_relationships(ctx, directory):
+    directory = _directory_name(directory, "entity-relationships")
+
+    # First get all relationship types
+    rel_types_data = entity_relationship_types.list(ctx, page=None, page_size=250, _print=False)
+    rel_types = [rt['tag'] for rt in rel_types_data['relationshipTypes']]
+
+    # For each relationship type, export all relationships
+    for rel_type in sorted(rel_types):
+        data = entity_relationships.list(ctx, relationship_type=rel_type, page=None, page_size=250, _print=False)
+        relationships = data.get('relationships', [])
+
+        if relationships:
+            _file_name(directory, rel_type, relationships, "json")
 
 def _export_plugins(ctx, directory):
     directory = _directory_name(directory, "plugins")
@@ -179,6 +209,8 @@ def _export_workflows(ctx, directory):
 backupTypes = {
         "catalog",
         "entity-types",
+        "entity-relationship-types",
+        "entity-relationships",
         "ip-allowlist",
         "plugins",
         "scorecards",
@@ -226,6 +258,8 @@ def export(
     Exports the following objects:
     - catalog
     - entity-types
+    - entity-relationship-types
+    - entity-relationships
     - ip-allowlist
     - plugins
     - scorecards
@@ -240,14 +274,13 @@ def export(
     cortex backup export --export-types catalog --catalog-types AWS::S3::Bucket
 
     It does not back up everything in the tenant.  For example these objects are not backed up:
-    - api-keys 
+    - api-keys
     - custom-events
     - custom-metadata created by the public API
     - custom-metrics
     - dependencies created by the API
     - deploys
     - docs created by the API
-    - entity-relationships created by the API
     - groups added by the API
     - packages
     - secrets
@@ -265,6 +298,10 @@ def export(
         _export_catalog(ctx, directory, catalog_types)
     if "entity-types" in export_types:
         _export_entity_types(ctx, directory)
+    if "entity-relationship-types" in export_types:
+        _export_entity_relationship_types(ctx, directory)
+    if "entity-relationships" in export_types:
+        _export_entity_relationships(ctx, directory)
     if "ip-allowlist" in export_types:
         _export_ip_allowlist(ctx, directory)
     if "plugins" in export_types:
@@ -278,22 +315,161 @@ def export(
     print("Contents available in " + directory)
 
 def _import_ip_allowlist(ctx, directory):
+    imported = 0
+    failed = []
     if os.path.isdir(directory):
         print("Processing: " + directory)
         for filename in os.listdir(directory):
             file_path = os.path.join(directory, filename)
             if os.path.isfile(file_path):
-                print("   Importing: " + filename)
-                ip_allowlist.replace(ctx, file_input=open(file_path), addresses=None, force=False, _print=False)
+                try:
+                    print("   Importing: " + filename)
+                    ip_allowlist.replace(ctx, file_input=open(file_path), addresses=None, force=False, _print=False)
+                    imported += 1
+                except Exception as e:
+                    print(f"   Failed to import {filename}: {type(e).__name__} - {str(e)}")
+                    failed.append((file_path, type(e).__name__, str(e)))
+    return ("ip-allowlist", imported, failed)
 
 def _import_entity_types(ctx, force, directory):
+    imported = 0
+    failed = []
     if os.path.isdir(directory):
         print("Processing: " + directory)
         for filename in sorted(os.listdir(directory)):
             file_path = os.path.join(directory, filename)
             if os.path.isfile(file_path):
-                print("   Importing: " + filename)
-                entity_types.create(ctx, file_input=open(file_path), force=force)
+                try:
+                    print("   Importing: " + filename)
+                    entity_types.create(ctx, file_input=open(file_path), force=force)
+                    imported += 1
+                except Exception as e:
+                    print(f"   Failed to import {filename}: {type(e).__name__} - {str(e)}")
+                    failed.append((file_path, type(e).__name__, str(e)))
+    return ("entity-types", imported, failed)
+
+def _import_entity_relationship_types(ctx, directory):
+    results = []
+    failed_count = 0
+
+    if os.path.isdir(directory):
+        print("Processing: " + directory)
+
+        # Get list of existing relationship types
+        existing_rel_types_data = entity_relationship_types.list(ctx, page=None, page_size=250, _print=False)
+        existing_tags = {rt['tag'] for rt in existing_rel_types_data.get('relationshipTypes', [])}
+
+        files = [(filename, os.path.join(directory, filename))
+                 for filename in sorted(os.listdir(directory))
+                 if os.path.isfile(os.path.join(directory, filename))]
+
+        def import_rel_type_file(file_info):
+            filename, file_path = file_info
+            tag = filename.replace('.json', '')
+            try:
+                # Check if relationship type already exists
+                if tag in existing_tags:
+                    # Update existing relationship type
+                    entity_relationship_types.update(ctx, tag=tag, file_input=open(file_path), _print=False)
+                else:
+                    # Create new relationship type
+                    entity_relationship_types.create(ctx, file_input=open(file_path), _print=False)
+                return (tag, file_path, None, None)
+            except typer.Exit as e:
+                return (tag, file_path, "HTTP", "Validation or HTTP error")
+            except Exception as e:
+                return (tag, file_path, type(e).__name__, str(e))
+
+        # Import all files in parallel
+        with ThreadPoolExecutor(max_workers=30) as executor:
+            futures = {executor.submit(import_rel_type_file, file_info): file_info[0] for file_info in files}
+            results = []
+            for future in as_completed(futures):
+                results.append(future.result())
+
+        # Print results in alphabetical order
+        failed_count = 0
+        for tag, file_path, error_type, error_msg in sorted(results, key=lambda x: x[0]):
+            if error_type:
+                print(f"   Failed to import {tag}: {error_type} - {error_msg}")
+                failed_count += 1
+            else:
+                print(f"   Importing: {tag}")
+
+        if failed_count > 0:
+            print(f"\n   Total entity relationship type import failures: {failed_count}")
+
+    return ("entity-relationship-types", len(results) - failed_count, [(fp, et, em) for tag, fp, et, em in results if et])
+
+def _import_entity_relationships(ctx, directory):
+    results = []
+    failed_count = 0
+
+    if os.path.isdir(directory):
+        print("Processing: " + directory)
+
+        files = [(filename, os.path.join(directory, filename))
+                 for filename in sorted(os.listdir(directory))
+                 if os.path.isfile(os.path.join(directory, filename))]
+
+        def import_relationships_file(file_info):
+            filename, file_path = file_info
+            rel_type = filename.replace('.json', '')
+            try:
+                # Read the relationships file
+                with open(file_path) as f:
+                    relationships = json.load(f)
+
+                # Convert list format to the format expected by update-bulk
+                # The export saves the raw relationships list, but update-bulk needs {"relationships": [...]}
+                if isinstance(relationships, list):
+                    data = {"relationships": []}
+                    for rel in relationships:
+                        # Extract source and destination tags from sourceEntity and destinationEntity
+                        source_tag = rel.get("sourceEntity", {}).get("tag")
+                        dest_tag = rel.get("destinationEntity", {}).get("tag")
+                        data["relationships"].append({
+                            "source": source_tag,
+                            "destination": dest_tag
+                        })
+
+                    # Use update-bulk to replace all relationships for this type
+                    # Create a temporary file to pass the data
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as temp_file:
+                        json.dump(data, temp_file)
+                        temp_file_name = temp_file.name
+
+                    try:
+                        entity_relationships.update_bulk(ctx, relationship_type=rel_type, file_input=open(temp_file_name), force=True, _print=False)
+                    finally:
+                        os.unlink(temp_file_name)
+
+                return (rel_type, file_path, None, None)
+            except typer.Exit as e:
+                return (rel_type, file_path, "HTTP", "Validation or HTTP error")
+            except Exception as e:
+                return (rel_type, file_path, type(e).__name__, str(e))
+
+        # Import all files in parallel
+        with ThreadPoolExecutor(max_workers=30) as executor:
+            futures = {executor.submit(import_relationships_file, file_info): file_info[0] for file_info in files}
+            results = []
+            for future in as_completed(futures):
+                results.append(future.result())
+
+        # Print results in alphabetical order
+        failed_count = 0
+        for rel_type, file_path, error_type, error_msg in sorted(results, key=lambda x: x[0]):
+            if error_type:
+                print(f"   Failed to import {rel_type}: {error_type} - {error_msg}")
+                failed_count += 1
+            else:
+                print(f"   Importing: {rel_type}")
+
+        if failed_count > 0:
+            print(f"\n   Total entity relationship import failures: {failed_count}")
+
+    return ("entity-relationships", len(results) - failed_count, [(fp, et, em) for rt, fp, et, em in results if et])
 
 def _import_catalog(ctx, directory):
     if os.path.isdir(directory):
@@ -304,12 +480,16 @@ def _import_catalog(ctx, directory):
 
         def import_catalog_file(file_info):
             filename, file_path = file_info
+            print(f"   Importing: {filename}")
             try:
                 with open(file_path) as f:
                     catalog.create(ctx, file_input=f, _print=False)
-                return (filename, None)
+                return (filename, file_path, None, None)
+            except typer.Exit as e:
+                # typer.Exit is raised by the HTTP client on errors
+                return (filename, file_path, "HTTP", "Validation or HTTP error")
             except Exception as e:
-                return (filename, str(e))
+                return (filename, file_path, type(e).__name__, str(e))
 
         # Import all files in parallel
         with ThreadPoolExecutor(max_workers=30) as executor:
@@ -318,12 +498,13 @@ def _import_catalog(ctx, directory):
             for future in as_completed(futures):
                 results.append(future.result())
 
-        # Print results in alphabetical order
-        for filename, error in sorted(results, key=lambda x: x[0]):
-            if error:
-                print(f"   Failed to import {filename}: {error}")
-            else:
-                print(f"   Importing: {filename}")
+        # Count failures
+        failed_count = sum(1 for filename, file_path, error_type, error_msg in results if error_type)
+
+        if failed_count > 0:
+            print(f"\n   Total catalog import failures: {failed_count}")
+
+    return ("catalog", len(results) - failed_count, [(fp, et, em) for fn, fp, et, em in results if et])
 
 def _import_plugins(ctx, directory):
     if os.path.isdir(directory):
@@ -337,9 +518,11 @@ def _import_plugins(ctx, directory):
             try:
                 with open(file_path) as f:
                     plugins.create(ctx, file_input=f, force=True)
-                return (filename, None)
+                return (filename, file_path, None, None)
+            except typer.Exit as e:
+                return (filename, file_path, "HTTP", "Validation or HTTP error")
             except Exception as e:
-                return (filename, str(e))
+                return (filename, file_path, type(e).__name__, str(e))
 
         # Import all files in parallel
         with ThreadPoolExecutor(max_workers=30) as executor:
@@ -349,12 +532,16 @@ def _import_plugins(ctx, directory):
                 results.append(future.result())
 
         # Print results in alphabetical order
-        for filename, error in sorted(results, key=lambda x: x[0]):
-            if error:
-                print(f"   Failed to import {filename}: {error}")
+        failed_count = 0
+        for filename, file_path, error_type, error_msg in sorted(results, key=lambda x: x[0]):
+            if error_type:
+                print(f"   Failed to import {filename}: {error_type} - {error_msg}")
+                failed_count += 1
             else:
                 print(f"   Importing: {filename}")
 
+    return ("plugins", len(results) - failed_count, [(fp, et, em) for fn, fp, et, em in results if et])
+
 def _import_scorecards(ctx, directory):
     if os.path.isdir(directory):
         print("Processing: " + directory)
@@ -367,9 +554,11 @@ def _import_scorecards(ctx, directory):
             try:
                 with open(file_path) as f:
                     scorecards.create(ctx, file_input=f, dry_run=False)
-                return (filename, None)
+                return (filename, file_path, None, None)
+            except typer.Exit as e:
+                return (filename, file_path, "HTTP", "Validation or HTTP error")
             except Exception as e:
-                return (filename, str(e))
+                return (filename, file_path, type(e).__name__, str(e))
 
         # Import all files in parallel
         with ThreadPoolExecutor(max_workers=30) as executor:
@@ -379,12 +568,16 @@ def _import_scorecards(ctx, directory):
                 results.append(future.result())
 
         # Print results in alphabetical order
-        for filename, error in sorted(results, key=lambda x: x[0]):
-            if error:
-                print(f"   Failed to import {filename}: {error}")
+        failed_count = 0
+        for filename, file_path, error_type, error_msg in sorted(results, key=lambda x: x[0]):
+            if error_type:
+                print(f"   Failed to import {filename}: {error_type} - {error_msg}")
+                failed_count += 1
             else:
                 print(f"   Importing: {filename}")
 
+    return ("scorecards", len(results) - failed_count, [(fp, et, em) for fn, fp, et, em in results if et])
+
 def _import_workflows(ctx, directory):
     if os.path.isdir(directory):
         print("Processing: " + directory)
@@ -397,9 +590,11 @@ def _import_workflows(ctx, directory):
             try:
                 with open(file_path) as f:
                     workflows.create(ctx, file_input=f)
-                return (filename, None)
+                return (filename, file_path, None, None)
+            except typer.Exit as e:
+                return (filename, file_path, "HTTP", "Validation or HTTP error")
             except Exception as e:
-                return (filename, str(e))
+                return (filename, file_path, type(e).__name__, str(e))
 
         # Import all files in parallel
         with ThreadPoolExecutor(max_workers=30) as executor:
@@ -409,12 +604,16 @@ def _import_workflows(ctx, directory):
                 results.append(future.result())
 
         # Print results in alphabetical order
-        for filename, error in sorted(results, key=lambda x: x[0]):
-            if error:
-                print(f"   Failed to import {filename}: {error}")
+        failed_count = 0
+        for filename, file_path, error_type, error_msg in sorted(results, key=lambda x: x[0]):
+            if error_type:
+                print(f"   Failed to import {filename}: {error_type} - {error_msg}")
+                failed_count += 1
             else:
                 print(f"   Importing: {filename}")
 
+    return ("workflows", len(results) - failed_count, [(fp, et, em) for fn, fp, et, em in results if et])
+
 @app.command("import")
 def import_tenant(
     ctx: typer.Context,
@@ -427,9 +626,67 @@ def import_tenant(
 
     client = ctx.obj["client"]
 
-    _import_ip_allowlist(ctx, directory + "/ip-allowlist")
-    _import_entity_types(ctx, force, directory + "/entity-types")
-    _import_catalog(ctx, directory + "/catalog")
-    _import_plugins(ctx, directory + "/plugins")
-    _import_scorecards(ctx, directory + "/scorecards")
-    _import_workflows(ctx, directory + "/workflows")
+    # Collect statistics from each import
+    all_stats = []
+    all_stats.append(_import_ip_allowlist(ctx, directory + "/ip-allowlist"))
+    all_stats.append(_import_entity_types(ctx, force, directory + "/entity-types"))
+    all_stats.append(_import_entity_relationship_types(ctx, directory + "/entity-relationship-types"))
+    all_stats.append(_import_catalog(ctx, directory + "/catalog"))
+    all_stats.append(_import_entity_relationships(ctx, directory + "/entity-relationships"))
+    all_stats.append(_import_plugins(ctx, directory + "/plugins"))
+    all_stats.append(_import_scorecards(ctx, directory + "/scorecards"))
+    all_stats.append(_import_workflows(ctx, directory + "/workflows"))
+
+    # Print summary
+    print("\n" + "="*80)
+    print("IMPORT SUMMARY")
+    print("="*80)
+
+    total_imported = 0
+    total_failed = 0
+    all_failures = []
+
+    for import_type, imported, failed in all_stats:
+        if imported > 0 or len(failed) > 0:
+            total_imported += imported
+            total_failed += len(failed)
+            print(f"\n{import_type}:")
+            print(f"  Imported: {imported}")
+            if len(failed) > 0:
+                print(f"  Failed:   {len(failed)}")
+                all_failures.extend([(import_type, f, e, m) for f, e, m in failed])
+
+    print(f"\nTOTAL: {total_imported} imported, {total_failed} failed")
+
+    if len(all_failures) > 0:
+        print("\n" + "="*80)
+        print("FAILED IMPORTS")
+        print("="*80)
+        print("\nThe following files failed to import:\n")
+
+        for import_type, file_path, error_type, error_msg in all_failures:
+            print(f"  {file_path}")
+            print(f"    Error: {error_type} - {error_msg}")
+
+        print("\n" + "="*80)
+        print("RETRY COMMANDS")
+        print("="*80)
+        print("\nTo retry failed imports, run these commands:\n")
+
+        for import_type, file_path, error_type, error_msg in all_failures:
+            if import_type == "catalog":
+                print(f"cortex catalog create -f \"{file_path}\"")
+            elif import_type == "entity-types":
+                print(f"cortex entity-types create --force -f \"{file_path}\"")
+            elif import_type == "entity-relationship-types":
+                tag = os.path.basename(file_path).replace('.json', '')
+                print(f"cortex entity-relationship-types create -f \"{file_path}\"")
+            elif import_type == "entity-relationships":
+                # These need special handling - would need the relationship type
+                print(f"# Manual retry needed for entity-relationships: {file_path}")
+            elif import_type == "plugins":
+                print(f"cortex plugins create --force -f \"{file_path}\"")
+            elif import_type == "scorecards":
+                print(f"cortex scorecards create -f \"{file_path}\"")
+            elif import_type == "workflows":
+                print(f"cortex workflows create -f \"{file_path}\"")

cortexapps_cli-1.5.0/cortexapps_cli/commands/entity_relationship_types.py

@@ -0,0 +1,121 @@
+import typer
+import json
+from typing_extensions import Annotated
+from cortexapps_cli.utils import print_output_with_context
+from cortexapps_cli.command_options import CommandOptions, ListCommandOptions
+
+app = typer.Typer(
+    help="Entity Relationship Types commands",
+    no_args_is_help=True
+)
+
+@app.command()
+def list(
+    ctx: typer.Context,
+    _print: CommandOptions._print = True,
+    page: ListCommandOptions.page = None,
+    page_size: ListCommandOptions.page_size = 250,
+    table_output: ListCommandOptions.table_output = False,
+    csv_output: ListCommandOptions.csv_output = False,
+    columns: ListCommandOptions.columns = [],
+    no_headers: ListCommandOptions.no_headers = False,
+    filters: ListCommandOptions.filters = [],
+    sort: ListCommandOptions.sort = [],
+):
+    """
+    List entity relationship types
+    """
+    client = ctx.obj["client"]
+
+    params = {
+       "page": page,
+       "pageSize": page_size
+    }
+
+    if (table_output or csv_output) and not ctx.params.get('columns'):
+        ctx.params['columns'] = [
+            "Tag=tag",
+            "Name=name",
+            "Description=description",
+        ]
+
+    # remove any params that are None
+    params = {k: v for k, v in params.items() if v is not None}
+
+    if page is None:
+        r = client.fetch("api/v1/relationship-types", params=params)
+    else:
+        r = client.get("api/v1/relationship-types", params=params)
+
+    if _print:
+        print_output_with_context(ctx, r)
+    else:
+        return r
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    tag: str = typer.Option(..., "--tag", "-t", help="Relationship type tag"),
+):
+    """
+    Get a relationship type by tag
+    """
+    client = ctx.obj["client"]
+    r = client.get(f"api/v1/relationship-types/{tag}")
+    print_output_with_context(ctx, r)
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    file_input: Annotated[typer.FileText, typer.Option("--file", "-f", help="File containing relationship type definition; can be passed as stdin with -, example: -f-")] = ...,
+    _print: CommandOptions._print = True,
+):
+    """
+    Create a relationship type
+
+    Provide a JSON file with the relationship type definition including required fields:
+    - tag: unique identifier
+    - name: human-readable name
+    - definitionLocation: SOURCE, DESTINATION, or BOTH
+    - allowCycles: boolean
+    - createCatalog: boolean
+    - isSingleSource: boolean
+    - isSingleDestination: boolean
+    - sourcesFilter: object with include/types configuration
+    - destinationsFilter: object with include/types configuration
+    - inheritances: array of inheritance settings
+    """
+    client = ctx.obj["client"]
+    data = json.loads("".join([line for line in file_input]))
+    r = client.post("api/v1/relationship-types", data=data)
+    if _print:
+        print_output_with_context(ctx, r)
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    tag: str = typer.Option(..., "--tag", "-t", help="Relationship type tag"),
+    file_input: Annotated[typer.FileText, typer.Option("--file", "-f", help="File containing relationship type definition; can be passed as stdin with -, example: -f-")] = ...,
+    _print: CommandOptions._print = True,
+):
+    """
+    Update a relationship type
+
+    Provide a JSON file with the relationship type definition to update.
+    """
+    client = ctx.obj["client"]
+    data = json.loads("".join([line for line in file_input]))
+    r = client.put(f"api/v1/relationship-types/{tag}", data=data)
+    if _print:
+        print_output_with_context(ctx, r)
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    tag: str = typer.Option(..., "--tag", "-t", help="Relationship type tag"),
+):
+    """
+    Delete a relationship type
+    """
+    client = ctx.obj["client"]
+    client.delete(f"api/v1/relationship-types/{tag}")