agilicus 1.289.5__py3-none-any.whl → 1.401.1__py3-none-any.whl

agilicus/orgs.py

@@ -24,6 +24,8 @@ from . import get_many_entries
 from .input_helpers import strip_none
 from . import pop_utils
 
+from .licensing.licenses import apply_constraint_and_vars
+
 
 def get_org_by_dictionary(ctx, org_id):
     if org_id:
@@ -41,7 +43,7 @@ def get_org_by_dictionary(ctx, org_id):
     return (org_dict_by_id, org_dict_by_name)
 
 
-def query(ctx, org_id=None, created_since=None, page_size=None, **kwargs):
+def query(ctx, org_id=None, created_since=None, page_size=None, name=None, **kwargs):
     token = context.get_token(ctx)
 
     org_id = get_org_from_input_or_ctx(ctx, org_id)
@@ -52,6 +54,9 @@ def query(ctx, org_id=None, created_since=None, page_size=None, **kwargs):
     if org_id:
         params["org_id"] = org_id
 
+    if name is not None:
+        params["organisation"] = name
+
     apiclient = context.get_apiclient(ctx, token)
     if kwargs.get("page_at_id", None) is not None:
         resp = get_many_entries(
@@ -148,7 +153,8 @@ def update(  # noqa: max-complexity: 19
 
     data = get(ctx, org_id)
 
-    del data["created"]
+    if "created" in data:
+        del data["created"]
     if "updated" in data:
         del data["updated"]
 
@@ -237,12 +243,24 @@ def add(ctx, **kwargs):
     except agilicus_api.ApiException as e:
         if e.status == 409:
             print(f"error creating org reason: {e.reason}", file=sys.stderr)
-            # If there's a conflict
-            return json.loads(e.body)
+            org = _get_org_by_name_helper(apiclient, kwargs.get("organisation", ""))
+            if not org:
+                return json.loads(e.body)
+            return org
         else:
             raise
 
 
+def _get_org_by_name_helper(apiclient, organisation):
+    params = {}
+    params["organisation"] = organisation
+    orgs = apiclient.org_api.list_orgs(**params)["orgs"]
+    for org in orgs:
+        if org.organisation == organisation:
+            return {"id": org.id}
+    return {}
+
+
 def add_suborg(
     ctx, organisation, contact_id=None, auto_create=True, subdomain=None, org_id=None
 ):
@@ -311,15 +329,31 @@ def get_system_options(ctx, org_id=None):
         org_id = context.get_org_id(ctx, token)
 
     apiclient = context.get_apiclient_from_ctx(ctx)
-    return apiclient.org_api.get_system_options(org_id).to_dict()
+    return apiclient.org_api.get_system_options(org_id)
 
 
-def replace_system_options(ctx, org_id, allowed_domains):
+def replace_system_options(
+    ctx,
+    org_id,
+    allowed_domains,
+    license_constraints,
+    constraint_vars,
+    replace_constraints,
+    replace_vars,
+):
     apiclient = context.get_apiclient(ctx)
     system_options = get_system_options(ctx, org_id)
 
     if allowed_domains is not None:
-        system_options["allowed_domains"] = allowed_domains
+        system_options.allowed_domains = allowed_domains
+
+    apply_constraint_and_vars(
+        system_options,
+        license_constraints,
+        constraint_vars,
+        replace_constraints,
+        replace_vars,
+    )
 
     return apiclient.org_api.replace_system_options(
         org_id=org_id, organisation_system_options=system_options
@@ -548,3 +582,10 @@ def add_org_pop(ctx, pop, **kwargs):
 
 def remove_org_pop(ctx, pop, **kwargs):
     return _update_pop_setting(ctx, pop, pop_utils.remove_pop_from_str, **kwargs)
+
+
+def fixup(ctx, org_id, **kwargs):
+    apiclient = context.get_apiclient(ctx)
+    kwargs = strip_none(kwargs)
+    org_fixup = agilicus_api.OrgFixup(org_id=org_id, **kwargs)
+    return apiclient.org_api.org_fixup(org_id, org_fixup).to_dict()

agilicus/output/json.py

@@ -21,14 +21,14 @@ def json_output_default(o):
     return None
 
 
-def convert_to_json(ctx, entry):
+def convert_to_json(ctx, entry, indent=2):
     return json.dumps(
-        jsonify(ctx, entry), sort_keys=True, indent=2, default=json_output_default
+        jsonify(ctx, entry), sort_keys=True, indent=indent, default=json_output_default
     )
 
 
-def output_json(ctx, entry):
-    print(convert_to_json(ctx, entry))
+def output_json(ctx, entry, indent=2):
+    print(convert_to_json(ctx, entry, indent=indent))
 
 
 def output_json_to_file(ctx, doc, outfile):

agilicus/output/table.py

@@ -9,7 +9,7 @@ from agilicus.output.json import convert_to_json
 from dataclasses import dataclass
 from typing import Callable
 
-from prettytable import PrettyTable
+from prettytable import PrettyTable, TableStyle
 from . import column_builder
 
 
@@ -21,9 +21,11 @@ def format_date_only(date_input):
     return date_input.strftime("%Y-%m-%d")
 
 
-def date_else_identity(input_obj):
+def date_else_identity(input_obj, ctx=None):
     if isinstance(input_obj, datetime):
         return format_date(input_obj)
+    if ctx and not context.output_console(ctx):
+        return input_obj
     if isinstance(input_obj, list):
         list_as_str = ""
         for obj in input_obj:
@@ -43,11 +45,11 @@ def date_else_identity(input_obj):
     return input_obj
 
 
-def format_timestamp(input_obj):
+def format_timestamp(input_obj, ctx=None):
     return datetime.fromtimestamp(input_obj)
 
 
-def format_currency_from_cents(cents, currency=None):
+def format_currency_from_cents(cents, currency=None, ctx=None):
     currency_symbol = ""
     if currency:
         currency_symbol = numbers.get_currency_symbol(currency.upper(), locale="en")
@@ -97,8 +99,12 @@ def subtable(
     if not out_name:
         out_name = in_name
 
-    def format_fn(records):
-        return format_table(ctx, records, columns, getter=table_getter)
+    outer_ctx = ctx
+
+    def format_fn(records, ctx=None):
+        return format_table(
+            outer_ctx, records, columns, getter=table_getter, nested=True
+        )
 
     def getter(record, base_getter):
         subobject = base_getter(subobject_name)(record)
@@ -125,6 +131,7 @@ def subobject_column(
     max_size=None,
     json_dump=None,
     formatter=None,
+    subobject_keys=None,
     **kwargs,
 ):
     if not out_name:
@@ -136,7 +143,9 @@ def subobject_column(
         return val
 
     def getter(record, base_getter):
-        names = in_name
+        names = subobject_keys
+        if not names:
+            names = in_name
         if not isinstance(names, list):
             names = [names]
 
@@ -178,25 +187,87 @@ def status_column(in_name, out_name=None, **kwargs):
     return subobject_column(in_name, out_name, "status", **kwargs)
 
 
-def constant_if_exists(column: OutputColumn, constant):
+def constant_if_exists(column: OutputColumn, constant, default=None):
     orig = column.format_fn
 
-    def check(val):
+    def check(val, ctx=None):
         if orig:
-            val = orig(val)
+            val = orig(val, ctx=ctx)
 
         if val:
             return constant
-        return None
+        return default
 
     column.format_fn = check
     return column
 
 
+def list_count(column: OutputColumn):
+    orig = column.format_fn
+
+    def formatter(val, ctx=None):
+        if isinstance(val, list):
+            return len(val)
+        if orig:
+            val = orig(val, ctx=ctx)
+        return val
+
+    column.format_fn = formatter
+    return column
+
+
+def list_map(column: OutputColumn, mapfn: Callable):
+    orig = column.getter
+
+    def getter(record, getter):
+        if orig:
+            val = orig(record, getter)
+        else:
+            val = getter(column.in_name)(record)
+        if isinstance(val, list):
+            val = [mapfn(v) for v in val]
+        return val
+
+    column.getter = getter
+    return column
+
+
+def expand_dict(column: OutputColumn):
+    orig = column.getter
+
+    def getter(record, getter):
+        if orig:
+            val = orig(record, getter)
+        else:
+            val = getter(column.in_name)(record)
+        if val is None:
+            return val
+        if not isinstance(val, dict):
+            val = val.to_dict()
+        return list(val.items())
+
+    column.getter = getter
+    return column
+
+
 def summarize(column: OutputColumn, max_length: int):
     orig = column.format_fn
 
-    def formatter(val):
+    def format_list(val, ctx=None):
+        if len(val) <= max_length:
+            if orig:
+                val = orig(val, ctx=ctx)
+            return val
+
+        val = val[:max_length]
+        if orig:
+            val = orig(val)
+        return val + "[truncated]"
+
+    def formatter(val, ctx=None):
+        if isinstance(val, list):
+            return format_list(val, ctx=ctx)
+
         if orig:
             val = orig(val)
 
@@ -221,7 +292,7 @@ def short_circuit_attrgetter(item):
     return func
 
 
-def _dump_json(ctx, to_dump):
+def _dump_json(ctx, to_dump, indent=2):
     # Sometimes a compound table can be a dict at its root. When formatting as json
     # handle that case
     if not isinstance(to_dump, list):
@@ -234,35 +305,43 @@ def _dump_json(ctx, to_dump):
             for record in to_dump
         ]
 
-    return convert_to_json(ctx, to_dump_as_dict)
+    return convert_to_json(ctx, to_dump_as_dict, indent=indent)
+
+
+def output_is_formatted(ctx):
+    return context.get_value(ctx, "output_format") in ("console", "csv")
 
 
 def get_table_style(ctx):
     table_style_str = context.get_value(ctx, "output_format")
     table_style = None
-    if table_style_str and table_style_str != "console":
+    if table_style_str and not output_is_formatted(ctx):
         from prettytable import (
             DEFAULT,
-            MARKDOWN,
             PLAIN_COLUMNS,
-            MSWORD_FRIENDLY,
+            TableStyle,
         )
 
         if table_style_str == "default":
             table_style = DEFAULT
         elif table_style_str == "markdown":
-            table_style = MARKDOWN
+            table_style = TableStyle.MARKDOWN
         elif table_style_str == "plain":
             table_style = PLAIN_COLUMNS
         elif table_style_str == "msword":
-            table_style = MSWORD_FRIENDLY
+            table_style = TableStyle.MSWORD_FRIENDLY
         else:
             raise Exception(f"invalid table style {table_style_str}")
     return table_style
 
 
 def format_table(
-    ctx, records, columns, getter=short_circuit_attrgetter, row_filter=None
+    ctx,
+    records,
+    columns,
+    getter=short_circuit_attrgetter,
+    row_filter=None,
+    nested=False,
 ):
     if context.output_json(ctx):
         return _dump_json(ctx, records)
@@ -273,7 +352,7 @@ def format_table(
         table.set_style(table_style)
 
     if not records:
-        return table
+        records = []
 
     if not isinstance(records, list):
         records = [records]
@@ -301,11 +380,22 @@ def format_table(
 
             out_value = "---"
             if in_value is not None:
-                out_value = column.format_fn(in_value)
+                out_value = column.format_fn(in_value, ctx=ctx)
             row.append(out_value)
 
         table.add_row(row)
     table.align = "l"
+
+    return _table_to_console(ctx, table, nested)
+
+
+def _table_to_console(ctx, table: PrettyTable, nested):
+    if context.output_csv(ctx):
+        if nested:
+            return table.get_json_string(header=False, indent=None, default=str)
+        return table.get_csv_string()
+    if context.output_markdown(ctx):
+        table.set_style(TableStyle.MARKDOWN)
     return table
 
 
@@ -343,3 +433,79 @@ def output_entry(ctx, entry, headers=None):
 
 def make_columns(*args, **kwargs):
     return column_builder.make_columns(*args, **kwargs)
+
+
+def _get_with_default(column, record):
+    getter = column.getter
+    if not getter:
+        getter = short_circuit_attrgetter
+    return getter(column.in_name)(record)
+
+
+def object_subtable(
+    ctx,
+    in_name,
+    columns,
+    out_name=None,
+    subobject_name=None,
+    table_getter=operator.itemgetter,
+    optional=False,
+):
+    """
+    converts an object with columns defined by "columns" into a subtable.
+    """
+    if not out_name:
+        out_name = in_name
+
+    def scalar_name(column, idx):
+        return column.out_name
+
+    def list_name(column, idx):
+        return f"{column.out_name}.{idx}"
+
+    subtable_columns = [column("name"), column("value")]
+
+    outer_ctx = ctx
+
+    def format_fn(records, ctx=None):
+        subtable_records = []
+        namer = scalar_name
+        if isinstance(records, list):
+            namer = list_name
+        else:
+            records = [records]
+
+        for idx, record in enumerate(records):
+            subtable_records.extend(
+                [
+                    {
+                        "name": namer(column, idx),
+                        "value": _get_with_default(column, record),
+                    }
+                    for column in columns
+                ]
+            )
+
+        return format_table(
+            outer_ctx,
+            subtable_records,
+            subtable_columns,
+            getter=table_getter,
+            nested=True,
+        )
+
+    def getter(record, base_getter):
+        subobject = base_getter(subobject_name)(record)
+        return base_getter(in_name)(subobject)
+
+    col_getter = None
+    if subobject_name:
+        col_getter = getter
+
+    return OutputColumn(
+        in_name=in_name,
+        out_name=out_name,
+        format_fn=format_fn,
+        getter=col_getter,
+        optional=optional,
+    )

agilicus/pagination/__init__.py

@@ -0,0 +1,3 @@
+from .input import normalize_page_args
+
+__all__ = ["normalize_page_args"]

agilicus/pagination/auto_iterator.py

@@ -0,0 +1,173 @@
+"""
+AutoIterator for paginating API client list functions.
+"""
+
+import json
+from agilicus_api.exceptions import ApiException
+
+_page_on_preference = ["name", "created", "id"]
+_default_page_on = "id"
+
+
+def get_page_on(list_function):
+    """
+    tries to figure out the pagination key to use based on the endpoint:
+     - If it's an enum, uses the preferred one in the list, otherwise the first
+     - If it's not an enum, just tries the 'default', which is id.
+    """
+    # yes, the key here is a tuple or some reason
+    result = list(list_function.allowed_values.get(("page_on",), {}).values())
+    if not result and "page_on" in list_function.params_map["all"]:
+        return [_default_page_on]
+    return result
+
+
+def _determine_page_on(list_function):
+    page_on_list = get_page_on(list_function)
+    if not page_on_list:
+        raise NotImplementedError("pagination not implemented on this endpoint")
+    for page_on in _page_on_preference:
+        if page_on in page_on_list:
+            return [page_on]
+
+    return [page_on_list[0]]
+
+
+def patch_endpoint(list_function):
+    setattr(list_function, "auto_paging_iter", AutoIteratorWrapper(list_function))
+
+
+class AutoIteratorWrapper:
+    def __init__(self, list_function):
+        self.list_function = list_function
+
+    def __call__(self, *args, limit=None, page_size=100, page_sort=None, **kwargs):
+        return AutoIterator(
+            self.list_function, limit, page_size, page_sort, *args, **kwargs
+        )
+
+
+class AutoIterator:
+    def __init__(
+        self, list_function, limit, page_size, page_sort, *args, page_on=None, **kwargs
+    ):
+        """
+        Initializes the AutoIterator.
+
+        :param list_function: The API client list function to paginate.
+        :param args: Positional arguments to pass to the list_function.
+        :param kwargs: Keyword arguments to pass to the list_function.
+        """
+        self._list_function = list_function
+        self._args = args
+        self._kwargs = kwargs
+        self.page_sort = page_sort or []
+        self.limit = limit
+        self.page_size = page_size
+        self.configured_page_on = page_on or _determine_page_on(self._list_function)
+        self._reset()
+
+    def _reset(self):
+        self._total_items = 0
+        self._page_on = self.configured_page_on
+        self._next_page = []
+        self._has_more = True
+        self._current_page_items = []
+
+    def __iter__(self):
+        """
+        Returns the iterator object itself.
+        """
+        return self
+
+    def __next__(self):
+        """
+        Fetches the next item from the paginated results.
+        """
+        if not self._current_page_items and self._has_more:
+            self._fetch_next_page()
+
+        if self._current_page_items:
+            return self._current_page_items.pop(0)
+        else:
+            raise StopIteration
+
+    def _get_page_list(self, response):
+        for key in response.attribute_map:
+            if isinstance(response.get(key), list):
+                return response.get(key)
+        return []
+
+    def _fetch_next_page(self):
+        limit = self.page_size
+        if self.limit is not None:
+            limit = min(limit, self.limit - self._total_items)
+
+        try:
+            response = self._list_function(
+                page_on=self._page_on,
+                page_at_key=self._next_page,
+                limit=limit,
+                page_sort=self.page_sort,
+                **self._kwargs,
+            )
+        except ApiException as exc:
+            if exc.status != 400:
+                raise
+
+            _handle_page_failure(exc.body)
+            # Shut up the linter, which thinks the above doesn't always throw even
+            # though it does
+            assert False
+
+        self._current_page_items = self._get_page_list(response)
+        self._total_items = self._total_items + len(self._current_page_items)
+        page_info = response.page_info
+        if (
+            not page_info
+            or not self._current_page_items
+            or (self.limit and self._total_items >= self.limit)
+        ):
+            self._has_more = False
+            return
+
+        self._next_page = page_info.page_at_key
+        self._page_on = page_info.page_on.value
+
+    # Additional functionality when interacted with as an object
+    def all(self):
+        """
+        Returns all items by iterating through all pages.
+        """
+        all_items = []
+        for item in self:
+            all_items.append(item)
+        return all_items
+
+    def first(self):
+        """
+        Returns the first item, or None if no items.
+        """
+        self._reset()
+        try:
+            return next(self)
+        except StopIteration:
+            return None
+
+    def __repr__(self):
+        return f"<AutoIterator for {self._list_function.__name__}>"
+
+
+def _handle_page_failure(body):
+    if not body:
+        raise
+    result = {}
+    try:
+        result = json.loads(body)
+    except Exception:
+        pass
+    error_message = result.get("error_message", "")
+    if "pagination key" not in error_message:
+        raise
+
+    raise NotImplementedError("Pagination not implemented on this key") from None

agilicus/pagination/input.py

@@ -0,0 +1,8 @@
+def normalize_page_args(kwargs):
+    page_sort = kwargs.get("page_sort")
+    if isinstance(page_sort, tuple):
+        kwargs["page_sort"] = list(page_sort)
+    page_on = kwargs.get("page_on")
+    if isinstance(page_on, tuple):
+        kwargs["page_on"] = list(page_on)
+    return kwargs

agilicus/patches.py

@@ -5,6 +5,8 @@ import certifi
 from .agilicus_api.api_client import ApiClient
 from .agilicus_api.configuration import Configuration
 
+from agilicus.pagination.auto_iterator import get_page_on, patch_endpoint
+
 
 class _ApiClientWrapper(ApiClient):
     def __init__(self, configuration: Configuration = None, **kwargs):
@@ -43,3 +45,18 @@ def patched_api_client():
 class _Response:
     def __init__(self, data):
         self.data = data
+
+
+def patch_endpoint_class(endpoint_class):
+    """
+    patches the Endpoint class to inject the AutoIterator into itself if needed.
+    """
+    original_init = endpoint_class.__init__
+
+    def init_wrapper(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        if not get_page_on(self):
+            return
+        patch_endpoint(self)
+
+    endpoint_class.__init__ = init_wrapper

agilicus/regions.py

@@ -66,6 +66,7 @@ def update_point_of_presence(
     master_cluster_id=None,
     requests_enabled=None,
     org_domain=None,
+    overwrite_org_domains=False,
     public=None,
     restrict_by_user_id=None,
     add_permitted_user_id=None,
@@ -102,6 +103,13 @@ def update_point_of_presence(
                 to_write.append(domain)
         domains = to_write
 
+    if not overwrite_org_domains:
+        to_write = original.spec.routing.org_domains
+        for domain in org_domains:
+            if domain not in to_write:
+                to_write.append(domain)
+        org_domains = to_write
+
     original.spec.routing.domains = domains
     original.spec.routing.org_domains = org_domains
     if name is not None:
@@ -154,7 +162,7 @@ def format_point_of_presences_as_text(ctx, tags):
         metadata_column("id"),
         spec_column("name"),
         spec_column("tags"),
-        spec_column("routing.domains", "domains"),
+        spec_column("routing", "routing"),
         spec_column("master_cluster_id"),
         status_column("clusters"),
     ]