oks-cli 1.18__tar.gz → 1.19__tar.gz

{oks_cli-1.18 → oks_cli-1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oks-cli
-Version: 1.18
+Version: 1.19
 Author: Outscale SAS
 Author-email: opensource@outscale.com
 License: BSD
@@ -223,6 +223,7 @@ oks-cli/
 │   ├── cache.py
 │   ├── cluster.py
 │   ├── main.py
+│   ├── netpeering.py
 │   ├── profile.py
 │   ├── project.py
 │   ├── quotas.py

{oks_cli-1.18 → oks_cli-1.19}/README.md

@@ -180,6 +180,7 @@ oks-cli/
 │   ├── cache.py
 │   ├── cluster.py
 │   ├── main.py
+│   ├── netpeering.py
 │   ├── profile.py
 │   ├── project.py
 │   ├── quotas.py

{oks_cli-1.18 → oks_cli-1.19}/oks_cli/cluster.py

@@ -23,7 +23,7 @@ from .utils import cluster_completer, do_request, print_output,
                    ctx_update, set_cluster_id, get_cluster_id, get_project_id,  \
                    get_template, get_cluster_name, format_changed_row,          \
                    is_interesting_status, profile_completer, project_completer, \
-                   kubeconfig_parse_fields, print_table, format_row
+                   kubeconfig_parse_fields, print_table, format_row, apply_set_fields
 
 from .profile import add_profile
 from .project import project_create, project_login
@@ -81,7 +81,7 @@ def cluster_logout(ctx, profile):
 @cluster.command('list', help="List all clusters")
 @click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
 @click.option('--cluster-name', '--name', '-c', required=False, help="Cluster Name", shell_complete=cluster_completer)
-@click.option('--deleted', '-x', is_flag=True, help="List deleted clusters")  # x pour "deleted" / "removed"
+@click.option('--deleted', '-x', is_flag=True, deprecated="List deleted clusters - Will be removed")  # x pour "deleted" / "removed"
 @click.option('--plain', is_flag=True, help="Plain table format")
 @click.option('--msword', is_flag=True, help="Microsoft Word table format")
 @click.option('--watch', '-w', is_flag=True, help="Watch the changes")
@@ -140,7 +140,7 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
         table.set_style(TableStyle.PLAIN_COLUMNS)
 
     if msword:
-        table.set_style(prettytable.MSWORD_FRIENDLY)
+        table.set_style(TableStyle.MSWORD_FRIENDLY)
 
     initial_clusters = {}
 
@@ -371,8 +371,9 @@ def _create_cluster(project_name, cluster_config, output):
 @click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format, by default is json")
 @click.option('--filename', '-f', type=click.File("r"), help="Path to file to use to create the cluster ")
 @click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--set', 'set_fields', multiple=True, help="Set arbitrary nested fields, e.g. auth.oidc.issuer-url=value")
 @click.pass_context
-def cluster_create_command(ctx, project_name, cluster_name, description, admin, version, cidr_pods, cidr_service, control_plane, zone, enable_admission_plugins, disable_admission_plugins, quirk, tags, disable_api_termination, cp_multi_az, dry_run, output, filename, profile):
+def cluster_create_command(ctx, project_name, cluster_name, description, admin, version, cidr_pods, cidr_service, control_plane, zone, enable_admission_plugins, disable_admission_plugins, quirk, tags, disable_api_termination, cp_multi_az, dry_run, output, filename, profile, set_fields):
     """CLI command to create a new Kubernetes cluster with optional configuration parameters."""
     project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
     login_profile(profile)
@@ -440,9 +441,11 @@ def cluster_create_command(ctx, project_name, cluster_name, description, admin,
     if disable_api_termination is not None:
         cluster_config["disable_api_termination"] = disable_api_termination
     
-    if cp_multi_az is not None:
+    if cp_multi_az:
         cluster_config["cp_multi_az"] = cp_multi_az
 
+    apply_set_fields(cluster_config, set_fields)
+
     if not dry_run:
         _create_cluster(project_name, cluster_config, output)
     else:
@@ -466,8 +469,9 @@ def cluster_create_command(ctx, project_name, cluster_name, description, admin,
 @click.option('--output', '-o',  type=click.Choice(["json", "yaml"]), help="Specify output format, by default is json")
 @click.option('--filename', '-f', type=click.File("r"), help="Path to file to use to update the cluster ")
 @click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--set', 'set_fields', multiple=True, help="Set arbitrary nested fields, e.g. auth.oidc.issuer-url=value")
 @click.pass_context
-def cluster_update_command(ctx, project_name, cluster_name, description, admin, version, tags, enable_admission_plugins, disable_admission_plugins, quirk, disable_api_termination, control_plane, dry_run, output, filename, profile):
+def cluster_update_command(ctx, project_name, cluster_name, description, admin, version, tags, enable_admission_plugins, disable_admission_plugins, quirk, disable_api_termination, control_plane, dry_run, output, filename, profile, set_fields):
     """CLI command to update an existing Kubernetes cluster with new configuration options."""
     project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
     login_profile(profile)
@@ -504,7 +508,7 @@ def cluster_update_command(ctx, project_name, cluster_name, description, admin,
                         raise click.ClickException(f"Unable to resolve 'my-ip': {e}")
                 else:
                     resolved_ips.append(ip)
-            cluster_config['admin_whitelist'] = resolved_ips
+            cluster_config['admin_whitelist'] = list(dict.fromkeys(resolved_ips))
 
     if version is not None:
         cluster_config['version'] = version
@@ -545,6 +549,8 @@ def cluster_update_command(ctx, project_name, cluster_name, description, admin,
 
     if control_plane:
         cluster_config['control_planes'] = control_plane
+    
+    apply_set_fields(cluster_config, set_fields)
 
     if dry_run:
         print_output(cluster_config, output)
@@ -700,7 +706,7 @@ def cluster_kubeconfig_command(ctx, project_name, cluster_name, print_path, outp
             click.echo(kubeconfig)
 
 
-def _run_kubectl(project_id, cluster_id, user, group, args, input=None):
+def _run_kubectl(project_id, cluster_id, user, group, args, input=None, capture=False):
     """Run a kubectl command using the cached kubeconfig for the specified cluster, refreshing it if needed."""
     # @TODO: check expiration in get_cache() code, etc
     kubeconfig_path = get_cache(project_id, cluster_id, 'kubeconfig', user, group)
@@ -733,9 +739,9 @@ def _run_kubectl(project_id, cluster_id, user, group, args, input=None):
     cmd += list(args)
     logging.info("running %s", cmd)
     if not input:
-        return subprocess.run(cmd, env = env)
+        return subprocess.run(cmd, env=env, capture_output=capture)
     else:
-        return subprocess.run(cmd, input=input, text=True, env = env)
+        return subprocess.run(cmd, input=input, text=True, env=env, capture_output=capture)
 
 
 @cluster.command('kubectl', help='Fetch the kubeconfig for a cluster and run kubectl against it', context_settings={"ignore_unknown_options": True})
@@ -822,8 +828,21 @@ def setup_worker_pool(ctx, nodepool_name, count, vmtype, zone, output, dry_run,
 
 @nodepool.command('delete')
 @click.option('--nodepool-name', '-n', required=True, help="Nodepool Name")
+@click.option('--force', is_flag=True, help="Delete without confirmation")
 @click.pass_context
-def delete_worker_pool(ctx, nodepool_name):
+def delete_worker_pool(ctx, nodepool_name, force):
     """Delete a nodepool by name from the cluster."""
-    _run_kubectl(ctx.obj['project_id'], ctx.obj['cluster_id'], ctx.obj['user'], ctx.obj['group'], [
-                 'delete', 'nodepool', nodepool_name])
+
+    if not force:
+        click.confirm(
+            f"Are you sure you want to delete the nodepool '{nodepool_name}'?",
+            abort=True
+        )
+
+    _run_kubectl(
+        ctx.obj['project_id'],
+        ctx.obj['cluster_id'],
+        ctx.obj['user'],
+        ctx.obj['group'],
+        ['delete', 'nodepool', nodepool_name]
+    )

{oks_cli-1.18 → oks_cli-1.19}/oks_cli/main.py

@@ -8,6 +8,7 @@ from .cluster import cluster
 from .profile import profile
 from .cache import cache
 from .quotas import quotas
+from .netpeering import netpeering
 
 from .utils import ctx_update, install_completions, profile_completer, cluster_completer, project_completer
 
@@ -60,6 +61,7 @@ cli.add_command(cluster)
 cli.add_command(profile)
 cli.add_command(cache)
 cli.add_command(quotas)
+cli.add_command(netpeering)
 
 def recursive_help(cmd, parent=None):
     """Recursively prints help for all commands and subcommands."""

oks_cli-1.19/oks_cli/netpeering.py

@@ -0,0 +1,293 @@
+import click
+import json
+import yaml
+import time
+import ipaddress
+import uuid
+from subprocess import CalledProcessError
+
+from .utils import cluster_completer, print_output, find_project_id_by_name,   \
+                   find_cluster_id_by_name, login_profile, ctx_update,         \
+                   profile_completer, project_completer, find_project_by_name, \
+                   do_request, get_cluster_name, get_project_name, get_template
+from .cluster import _run_kubectl
+
+@click.group(help="NetPeering related commands.")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--cluster-name', '-c', required=False, help="Cluster Name", shell_complete=cluster_completer)
+@click.option("--profile", help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--user', type=click.STRING, help="User for the kubeconfig of the source cluster")
+@click.option('--group', type=click.STRING, help="Group for the kubeconfig of the source cluster")
+@click.pass_context
+def netpeering(ctx, project_name, cluster_name, profile, user, group):
+    """Group of commands related to netpeering management"""
+    project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
+
+    ctx.obj['user'] = user
+    ctx.obj['group'] = group
+
+@netpeering.command('list', help="List NetPeering from a project/cluster")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--cluster-name', '-c', required=False, help="Cluster Name", shell_complete=cluster_completer)
+@click.option("--profile", help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--output', '-o', type=click.Choice(["json", "yaml", "wide"]), help="Specify output format")
+@click.pass_context
+def netpeering_list(ctx, project_name, cluster_name, profile, output):
+    """List netpeering in the specified cluster"""
+    project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+    cluster_id = find_cluster_id_by_name(project_id, cluster_name)
+
+    cmd = ['get', 'netpeerings']
+    if output:
+        cmd.extend(['-o', output])
+
+    _run_kubectl(project_id, cluster_id, ctx.obj['user'], ctx.obj['group'], cmd)
+
+
+@netpeering.command('get', help="Get information about a NetPeering")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--cluster-name', '-c', required=False, help="Cluster Name", shell_complete=cluster_completer)
+@click.option("--profile", help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--netpeering-id', required=True, type=click.STRING, help="NetPeering to get information from")
+@click.option('--output', '-o', default='json', required=False, type=click.Choice(["json", "yaml", "wide"]), help="Specify output format, default json")
+@click.pass_context
+def netpeering_get(ctx, project_name, cluster_name, profile, netpeering_id, output):
+    """Retrieve information about a NetPeering"""
+    project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+    cluster_id = find_cluster_id_by_name(project_id, cluster_name)
+
+    _run_kubectl(project_id, cluster_id, ctx.obj['user'], ctx.obj['group'],
+                   ['get', 'netpeering', netpeering_id, '-o', output])
+
+
+@netpeering.command('delete', help="Delete a NetPeering from a project/cluster")
+@click.option('--project-name', '-p', required=False, type=click.STRING, help="Source project name to create netpeering from", shell_complete=project_completer)
+@click.option('--cluster-name', '-c', required=False, type=click.STRING, help="Source cluster to create netpeering from", shell_complete=cluster_completer)
+@click.option('--netpeering-id', required=True, type=click.STRING, help="NetPeering to remove")
+@click.option('--dry-run', required=False, is_flag=True, help="Run without any action")
+@click.option('--force', is_flag=True, help="Force deletion without confirmation")
+@click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.pass_context
+def netpeering_delete(ctx, project_name, cluster_name, netpeering_id, dry_run, force, profile):
+    """Delete a NetPeering between 2 projects"""
+    project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+    cluster_id = find_cluster_id_by_name(project_id, cluster_name)
+
+    if dry_run:
+        message = {"message": f"Dry run: The netpeering {netpeering_id} would be deleted."}
+        print_output(message, 'json')
+        return
+
+    if force or click.confirm(f"Are you sure you want to delete NetPeering with id {netpeering_id}?", abort=True):
+        try:
+            cmd = _run_kubectl(project_id, cluster_id, ctx.obj['user'], ctx.obj['group'],
+                        ['delete', 'netpeering', netpeering_id], capture=True)
+            if cmd.returncode:
+                raise click.ClickException(f"Could not delete NetPeering {netpeering_id}: {cmd.stderr.decode('utf-8')}")
+            click.echo(f"It may take some times for NetPeering {netpeering_id} to automatically disappear from both projects. Please be patient")
+        except CalledProcessError as e:
+            raise click.ClickException(f"Could not delete NetPeering {netpeering_id}: {e}")
+
+
+def _gather_info(project: str=None, cluster: str=None) -> dict:
+    """
+        Gather information about project and cluster required to create a NetPeering
+        Set:
+        - cluster_name
+        - project_name
+        - project_id
+        - cluster_id
+        - project_cidr
+    """
+    info = dict()
+
+    if not project or not cluster:
+        raise click.ClickException("Project and cluster name are required")
+
+    project_data = find_project_by_name(project)
+    info.update({'cluster_name': cluster, 'project_name': project})
+    info.update({'project_id': project_data.get('id'), 'project_cidr': project_data.get('cidr')})
+    info.update({'cluster_id': find_cluster_id_by_name(info.get('project_id'), info.get('cluster_name'))})
+    return info
+
+
+def _netpeering_exists(source: dict=None, target: dict=None, user: str=None, group: str=None) -> bool:
+    """
+        Checks if an existing NetPeering already exists between similar project/cluster id
+    """
+    # We check if there's not already a NetPeering available and active
+    if not source or not target:
+        raise AttributeError("source and target must be passesd as dict")
+
+    try:
+        netpeerings = json.loads(_run_kubectl(source.get('project_id'), source.get('cluster_id'), user, group,
+                                            ['get', 'netpeering', '-o', 'json'],
+                                            capture=True).stdout.decode('utf-8'))
+
+        for item in netpeerings.get('items'):
+            status = item.get('status')
+            if status.get('accepterNetId')   == target.get('network_id') and \
+               status.get('accepterOwnerId') == target.get('account_id') and \
+               status.get('sourceNetId')     == source.get('network_id') and \
+               status.get('sourceOwnerId')   == source.get('account_id') and \
+               status.get('netPeeringState') == 'active':
+
+                return True
+
+    except CalledProcessError as e:
+        raise click.ClickException(f"Cannot list NetPeerings: {e}")
+
+    return False
+
+def _get_vpc_id(project_id: str):
+    response = do_request("GET", f"projects/{project_id}/nets")
+
+    if len(response) == 0:
+        raise click.ClickException("Cannot get vpc id")
+
+    return response[0]["NetId"]
+
+def _get_iaas_owner_id(project_id: str):
+    response = do_request("GET", f"projects/{project_id}/quotas")["data"]
+
+    if len(response["quotas"]) == 0:
+        raise click.ClickException("Cannot get iaas owner id")
+
+    return response["quotas"][0]["AccountId"]
+
+def _create_netpeering_request(name: str, source: dict, target: dict, user, group):
+    netpeering_request = get_template("netpeeringrequest")
+    netpeering_request['metadata']['name'] = name
+    netpeering_request['spec']['accepterNetId'] = target.get('network_id')
+    netpeering_request['spec']['accepterOwnerId'] = target.get('account_id')
+
+    _run_kubectl(source.get('project_id'), source.get('cluster_id'), user, group,
+                    ['create', '-o', 'json', '-f', '-'], input=json.dumps(netpeering_request), capture=True)
+
+    # For security, we wait a bit for the status to be availabe
+    time.sleep(3)
+
+    netpeering_request_cmd = _run_kubectl(source.get('project_id'), source.get('cluster_id'), user, group,
+                                    ['get', 'netpeeringrequests', '-o', 'json', f"{name}"],
+                                    capture=True)
+    if netpeering_request_cmd.returncode:
+        raise click.ClickException(f"Cannot create NetPeeringRequest: {netpeering_request_cmd.stderr}")
+
+    netpeering_request = json.loads(netpeering_request_cmd.stdout.decode('utf-8'))
+
+    return netpeering_request
+
+def _create_netpeering_acceptance(name: str, netpeering_request_status: dict, target: dict, user, group):
+
+    netpeering_acceptance = get_template("netpeeringacceptance")
+    netpeering_id = netpeering_request_status.get('netPeeringId')
+    netpeering_acceptance['metadata']['name'] = name
+    netpeering_acceptance['spec']['netPeeringId'] = netpeering_id
+
+    netpeering_request_status = netpeering_request_status.get('netPeeringState')
+    if netpeering_request_status != 'pending-acceptance':
+        raise click.ClickException(f"NetPeeringAcceptance is in wrong state: {netpeering_request_status}")
+
+    netpeering_acceptance_cmd = _run_kubectl(target.get('project_id'), target.get('cluster_id'), user, group,
+                                            ["create", "-f", "-"], input=json.dumps(netpeering_acceptance),
+                                            capture=True)
+
+    if netpeering_acceptance_cmd.returncode:
+        raise click.ClickException(f"Could not create NetPeeringAcceptance object {netpeering_id}: {netpeering_acceptance_cmd.stderr}")
+
+def _dry_run(name_nr: str, name_na: str, output: str):
+    netpeering_request = get_template("netpeeringrequest")
+    netpeering_request['metadata']['name'] = name_nr
+
+    netpeering_acceptance = get_template("netpeeringacceptance")
+    netpeering_acceptance['metadata']['name'] = name_na
+
+    manifests = [netpeering_request, netpeering_acceptance]
+
+    if output == "yaml":
+        # print multiple yaml, separated by --- (kubernetes friendly format for multiple manifests)
+        output_data = yaml.dump_all(manifests, sort_keys=False)
+        click.echo(output_data)
+    else:
+        print_output([netpeering_request, netpeering_acceptance], output)
+
+@netpeering.command('create', help="Create a NetPeering between 2 projects")
+@click.option('--project-name', '--source-project', '-p', required=False, type=click.STRING, help="Source project name to create netpeering from", shell_complete=project_completer)
+@click.option('--cluster-name', '--source-cluster', '-c', required=False, type=click.STRING, help="Source cluster to create netpeering from", shell_complete=cluster_completer)
+@click.option('--target-project', required=True, type=click.STRING, help="Project name to create netpeering to", shell_complete=project_completer)
+@click.option('--target-cluster', required=True, type=click.STRING, help="Target cluster to create netpeering to")
+@click.option('--netpeering-name', required=False, type=click.STRING, help="Name of the NetPeeringRequest, default to '{from-project}-to-{to-project}",
+              default=None)
+@click.option('--force', required=False, is_flag=True, help="Create netpeering resources without confirmation")
+@click.option('--user', type=click.STRING, help="User for the kubeconfig of the source cluster")
+@click.option('--group', type=click.STRING, help="Group for the kubeconfig of the source cluster")
+@click.option('--dry-run', is_flag=True, help="Client dry-run, only print the object that would be sent, without sending it")
+@click.option('--output', '-o', type=click.Choice(['json', 'yaml']), default="json", help="Specify output format, by default is json")
+@click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.pass_context
+def netpeering_create(ctx, project_name, cluster_name, target_project, target_cluster, netpeering_name, force,
+                      user, group, dry_run, output, profile):
+    """Create NetPeering between 2 projects"""
+    project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
+    login_profile(profile)
+
+    project_name = get_project_name(project_name)
+    cluster_name = get_cluster_name(cluster_name)
+
+    source = _gather_info(project=project_name, cluster=cluster_name)
+    target = _gather_info(project=target_project, cluster=target_cluster)
+
+    # Generate name
+    if not netpeering_name:
+        netpeering_name = f"{source.get('project_name')}-to-{target.get('project_name')}"
+
+    netpeering_name += f"-{str(uuid.uuid4().fields[-1])[:6]}"
+    netpeering_request_name = f"{netpeering_name}-npr"
+    netpeering_acceptance_name = f"{netpeering_name}-npa"
+
+    if dry_run:
+        _dry_run(netpeering_request_name, netpeering_acceptance_name, output)
+        return
+
+    source_cidr = ipaddress.ip_network(source.get('project_cidr'))
+    target_cidr = ipaddress.ip_network(target.get('project_cidr'))
+
+    if source_cidr.overlaps(target_cidr) or target_cidr.overlaps(source_cidr):
+        raise click.ClickException(f"Source network {source.get('project_cidr')} and target network {target.get('project_cidr')} overlap, you can't create netpeering. Aborted!")
+
+    source_vpc_id = _get_vpc_id(source.get('project_id'))
+    source_iaas_owner_id = _get_iaas_owner_id(source.get('project_id'))
+
+    target_vpc_id = _get_vpc_id(target.get('project_id'))
+    target_iaas_owner_id = _get_iaas_owner_id(target.get('project_id'))
+
+    source.update({'network_id': source_vpc_id, 'account_id': source_iaas_owner_id})
+    target.update({'network_id': target_vpc_id, 'account_id': target_iaas_owner_id})
+
+    if _netpeering_exists(source=source, target=target, user=user, group=group):
+        raise click.ClickException(f"A NetPeering already exists between projects {source.get('project_name')} and {target.get('project_name')}. Aborting!")
+
+    if not force and \
+        not click.confirm(f"Are you sure you want to create NetPeering between projects {source.get('project_name')} and {target.get('project_name')}?", abort=False):
+        return "Abort."
+
+    netpeering_request = _create_netpeering_request(netpeering_request_name, source, target, user, group)
+    netpeering_id = netpeering_request.get('status').get('netPeeringId')
+
+    _create_netpeering_acceptance(netpeering_acceptance_name, netpeering_request.get('status'), target, user, group)
+
+    # Wait a bit for NetPeering to appear
+    time.sleep(3)
+
+    _run_kubectl(target.get('project_id'), target.get('cluster_id'), user, group,
+                                        ['get', 'netpeering', '-o', output, netpeering_id,])
+

{oks_cli-1.18 → oks_cli-1.19}/oks_cli/project.py

@@ -10,7 +10,7 @@ from prettytable import TableStyle
 from .utils import do_request, print_output, print_table, find_project_id_by_name, get_project_id, set_project_id, \
                    detect_and_parse_input, transform_tuple, ctx_update, set_cluster_id, get_template, get_project_name, \
                    format_changed_row, is_interesting_status, login_profile, profile_completer, project_completer, \
-                   format_row
+                   format_row, apply_set_fields
 
 # DEIFNE THE PROJECT COMMAND GROUP
 @click.group(help="Project related commands.")
@@ -63,7 +63,7 @@ def project_logout(ctx, profile):
 # LIST PROJECTS
 @project.command('list', help="List all projects")
 @click.option('--project-name', '-p', help="Name of project", type=click.STRING, shell_complete=project_completer)
-@click.option('--deleted', '-x', is_flag=True, help="List deleted projects")
+@click.option('--deleted', '-x', is_flag=True, deprecated="List deleted projects - Will be removed")
 @click.option('--plain', is_flag=True, help="Plain table format")
 @click.option('--msword', is_flag=True, help="Microsoft Word table format")
 @click.option('--uuid', is_flag=True, help="Show UUID")
@@ -106,7 +106,7 @@ def project_list(ctx, project_name, deleted, plain, msword, uuid, watch, output,
         table.set_style(TableStyle.PLAIN_COLUMNS)
 
     if msword:
-        table.set_style(prettytable.MSWORD_FRIENDLY)
+        table.set_style(TableStyle.MSWORD_FRIENDLY)
 
     initial_projects = {}
 
@@ -188,8 +188,9 @@ def project_list(ctx, project_name, deleted, plain, msword, uuid, watch, output,
 @click.option('--output', '-o', type=click.Choice(["json", "yaml", "silent"]), help="Specify output format, by default is json")
 @click.option('--filename', '-f', type=click.File("r"), help="Path to file to use to create the project")
 @click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--set', 'set_fields', multiple=True, help="Set arbitrary nested fields, e.g. auth.oidc.issuer-url=value")
 @click.pass_context
-def project_create(ctx, project_name, description, cidr, quirk, tags, disable_api_termination, dry_run, output, filename, profile):
+def project_create(ctx, project_name, description, cidr, quirk, tags, disable_api_termination, dry_run, output, filename, profile, set_fields):
     """Create a new project from options or file, with support for dry-run and output formatting."""
     project_name, _, profile = ctx_update(ctx, project_name, None, profile)
     login_profile(profile)
@@ -230,6 +231,8 @@ def project_create(ctx, project_name, description, cidr, quirk, tags, disable_ap
 
     if disable_api_termination is not None:
         project_config["disable_api_termination"] = disable_api_termination
+    
+    apply_set_fields(project_config, set_fields)
 
     if not dry_run:
         data = do_request("POST", 'projects', json=project_config)
@@ -295,8 +298,9 @@ def project_delete_command(ctx, project_name, output, dry_run, force, profile):
 @click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format, by default is json")
 @click.option('--dry-run', is_flag=True, help="Run without any action")
 @click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.option('--set', 'set_fields', multiple=True, help="Set arbitrary nested fields, e.g. auth.oidc.issuer-url=value")
 @click.pass_context
-def project_update_command(ctx, project_name, description, quirk, tags, disable_api_termination, output, dry_run, profile):
+def project_update_command(ctx, project_name, description, quirk, tags, disable_api_termination, output, dry_run, profile, set_fields):
     """Update project details by name, supporting dry-run and output formatting."""
     project_name, _, profile = ctx_update(ctx, project_name, None, profile)
     login_profile(profile)
@@ -326,6 +330,8 @@ def project_update_command(ctx, project_name, description, quirk, tags, disable_
                 parsed_tags[key.strip()] = value.strip()
 
         project_config['tags'] = parsed_tags
+    
+    apply_set_fields(project_config, set_fields)
 
     if dry_run:
         print_output(project_config, output)