clarifai 11.2.3rc1__py3-none-any.whl → 11.2.3rc2__py3-none-any.whl

clarifai/runners/utils/serializers.py

@@ -0,0 +1,222 @@
+import json
+from typing import Dict, Iterable
+
+import numpy as np
+from clarifai_grpc.grpc.api import resources_pb2
+
+from clarifai.runners.utils import data_types
+
+
+class Serializer:
+
+  def serialize(self, data_proto, value):
+    pass
+
+  def deserialize(self, data_proto):
+    pass
+
+  def handles_list(self):
+    return False
+
+
+def is_repeated_field(field_name):
+  descriptor = resources_pb2.Data.DESCRIPTOR.fields_by_name.get(field_name)
+  return descriptor and descriptor.label == descriptor.LABEL_REPEATED
+
+
+class AtomicFieldSerializer(Serializer):
+
+  def __init__(self, field_name):
+    self.field_name = field_name
+
+  def serialize(self, data_proto, value):
+    try:
+      setattr(data_proto, self.field_name, value)
+    except TypeError as e:
+      raise TypeError(f"Incompatible type for {self.field_name}: {type(value)}") from e
+
+  def deserialize(self, data_proto):
+    return getattr(data_proto, self.field_name)
+
+
+class MessageSerializer(Serializer):
+
+  def __init__(self, field_name, message_class):
+    self.field_name = field_name
+    self.message_class = message_class
+    self.is_repeated_field = is_repeated_field(field_name)
+
+  def handles_list(self):
+    return self.is_repeated_field
+
+  def serialize(self, data_proto, value):
+    value = self.message_class.from_value(value).to_proto()
+    dst = getattr(data_proto, self.field_name)
+    try:
+      if self.is_repeated_field:
+        dst.add().CopyFrom(value)
+      else:
+        dst.CopyFrom(value)
+    except TypeError as e:
+      raise TypeError(f"Incompatible type for {self.field_name}: {type(value)}") from e
+
+  def serialize_list(self, data_proto, values):
+    assert self.is_repeated_field
+    dst = getattr(data_proto, self.field_name)
+    dst.extend([self.message_class.from_value(value).to_proto() for value in values])
+
+  def deserialize(self, data_proto):
+    src = getattr(data_proto, self.field_name)
+    if self.is_repeated_field:
+      values = [self.message_class.from_proto(x) for x in src]
+      if len(values) == 1:
+        return values[0]
+      return values if values else None
+    else:
+      if not data_proto.HasField(self.field_name):
+        return None
+      return self.message_class.from_proto(src)
+
+  def deserialize_list(self, data_proto):
+    assert self.is_repeated_field
+    src = getattr(data_proto, self.field_name)
+    return [self.message_class.from_proto(x) for x in src]
+
+
+class NDArraySerializer(Serializer):
+
+  def __init__(self, field_name, as_list=False):
+    self.field_name = field_name
+    self.as_list = as_list
+
+  def serialize(self, data_proto, value):
+    if self.as_list and not isinstance(value, Iterable):
+      raise TypeError(f"Expected list, got {type(value)}")
+    value = np.asarray(value)
+    if not np.issubdtype(value.dtype, np.number):
+      raise TypeError(f"Expected number array, got {value.dtype}")
+    proto = getattr(data_proto, self.field_name)
+    proto.buffer = value.tobytes()
+    proto.shape.extend(value.shape)
+    proto.dtype = str(value.dtype)
+
+  def deserialize(self, data_proto):
+    proto = getattr(data_proto, self.field_name)
+    if not proto.buffer:
+      return None
+    array = np.frombuffer(proto.buffer, dtype=np.dtype(proto.dtype)).reshape(proto.shape)
+    if self.as_list:
+      return array.tolist()
+    return array
+
+
+class JSONSerializer(Serializer):
+
+  def __init__(self, field_name, type=None):
+    self.field_name = field_name
+    self.type = type
+
+  def serialize(self, data_proto, value):
+    #if self.type is not None and not isinstance(value, self.type):
+    #  raise TypeError(f"Expected {self.type}, got {type(value)}")
+    try:
+      setattr(data_proto, self.field_name, json.dumps(value))
+    except TypeError as e:
+      raise TypeError(f"Incompatible type for {self.field_name}: {type(value)}") from e
+
+  def deserialize(self, data_proto):
+    value = getattr(data_proto, self.field_name)
+    if not value:
+      return None
+    return json.loads(value)
+
+
+class ListSerializer(Serializer):
+
+  def __init__(self, inner_serializer):
+    self.field_name = 'parts'
+    self.inner_serializer = inner_serializer
+
+  def handles_list(self):
+    # if handles_list() is called on this serializer, it means that we're
+    # trying to serialize a list of lists. In this case, we need to use
+    # parts[] for the outer list, so we return False here (we can't inline it).
+    return False
+
+  def serialize(self, data_proto, value):
+    if not isinstance(value, Iterable):
+      raise TypeError(f"Expected iterable, got {type(value)}")
+    if self.inner_serializer.handles_list():
+      self.inner_serializer.serialize_list(data_proto, value)
+    else:
+      for item in value:
+        part = data_proto.parts.add()
+        self.inner_serializer.serialize(part.data, item)
+
+  def deserialize(self, data_proto):
+    if self.inner_serializer.handles_list():
+      return self.inner_serializer.deserialize_list(data_proto)
+    return [self.inner_serializer.deserialize(part.data) for part in data_proto.parts]
+
+
+class TupleSerializer(Serializer):
+
+  def __init__(self, inner_serializers):
+    self.field_name = 'parts'
+    self.inner_serializers = inner_serializers
+
+  def serialize(self, data_proto, value):
+    if not isinstance(value, (tuple, list)):
+      raise TypeError(f"Expected tuple, got {type(value)}")
+    if len(value) != len(self.inner_serializers):
+      raise ValueError(f"Expected tuple of length {len(self.inner_serializers)}, got {len(value)}")
+    for i, (serializer, item) in enumerate(zip(self.inner_serializers, value)):
+      part = data_proto.parts.add()
+      part.id = str(i)
+      serializer.serialize(part.data, item)
+
+  def deserialize(self, data_proto):
+    if not data_proto.parts and self.inner_serializers:
+      return None
+    if len(data_proto.parts) != len(self.inner_serializers):
+      raise ValueError(
+          f"Expected tuple of length {len(self.inner_serializers)}, got {len(data_proto.parts)}")
+    return tuple(
+        serializer.deserialize(part.data)
+        for serializer, part in zip(self.inner_serializers, data_proto.parts))
+
+
+class NamedFieldsSerializer(Serializer):
+
+  def __init__(self, named_field_serializers: Dict[str, Serializer]):
+    self.field_name = 'parts'
+    self.named_field_serializers = named_field_serializers
+
+  def serialize(self, data_proto, value):
+    for name, serializer in self.named_field_serializers.items():
+      if name not in value:
+        raise TypeError(f"Missing field {name}")
+      part = self._get_part(data_proto, name, add=True)
+      serializer.serialize(part.data, value[name])
+
+  def deserialize(self, data_proto):
+    if not data_proto.parts and self.named_field_serializers:
+      return None
+    value = data_types.NamedFields()
+    for name, serializer in self.named_field_serializers.items():
+      part = self._get_part(data_proto, name)
+      value[name] = serializer.deserialize(part.data)
+    return value
+
+  def _get_part(self, data_proto, name, add=False):
+    for part in data_proto.parts:
+      if part.id == name:
+        return part
+    if add:
+      part = data_proto.parts.add()
+      part.id = name
+      return part
+    raise TypeError(f"Missing part with key {name}")
+
+
+# TODO dict serializer, maybe json only?

clarifai/utils/cli.py

@@ -1,16 +1,14 @@
 import importlib
 import os
 import pkgutil
-import sys
-import typing as t
-from collections import defaultdict
-from typing import OrderedDict
 
 import click
 import yaml
-from tabulate import tabulate
 
-from clarifai.utils.logging import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.style import Style
+from rich.text import Text
 
 
 def from_yaml(filename: str):
@@ -30,6 +28,19 @@ def dump_yaml(data, filename: str):
     click.echo(f"Error writing YAML file: {e}", err=True)
 
 
+def set_base_url(env):
+  environments = {
+      'prod': 'https://api.clarifai.com',
+      'staging': 'https://api-staging.clarifai.com',
+      'dev': 'https://api-dev.clarifai.com'
+  }
+
+  if env in environments:
+    return environments[env]
+  else:
+    raise ValueError("Invalid environment. Please choose from 'prod', 'staging', 'dev'.")
+
+
 # Dynamically find and import all command modules from the cli directory
 def load_command_modules():
   package_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'cli')
@@ -39,131 +50,21 @@ def load_command_modules():
       importlib.import_module(f'clarifai.cli.{module_name}')
 
 
-def display_co_resources(response,
-                         custom_columns={
-                             'ID': lambda c: c.id,
-                             'USER_ID': lambda c: c.user_id,
-                             'DESCRIPTION': lambda c: c.description,
-                         }):
+def display_co_resources(response, resource_type):
   """Display compute orchestration resources listing results using rich."""
 
-  formatter = TableFormatter(custom_columns)
-  print(formatter.format(list(response), fmt="plain"))
-
-
-class TableFormatter:
-
-  def __init__(self, custom_columns: OrderedDict):
-    """
-        Initializes the TableFormatter with column headers and custom column mappings.
-
-        :param headers: List of column headers for the table.
-        """
-    self.custom_columns = custom_columns
-
-  def format(self, objects, fmt='plain'):
-    """
-        Formats a list of objects into a table with custom columns.
-
-        :param objects: List of objects to format into a table.
-        :return: A string representing the table.
-        """
-    # Prepare the rows by applying the custom column functions to each object
-    rows = []
-    for obj in objects:
-      #   row = [self.custom_columns[header](obj) for header in self.headers]
-      row = [f(obj) for f in self.custom_columns.values()]
-      rows.append(row)
-
-    # Create the table
-    table = tabulate(rows, headers=self.custom_columns.keys(), tablefmt=fmt)
-    return table
-
-
-class AliasedGroup(click.Group):
-
-  def __init__(self,
-               name: t.Optional[str] = None,
-               commands: t.Optional[t.Union[t.MutableMapping[str, click.Command], t.Sequence[
-                   click.Command]]] = None,
-               **attrs: t.Any) -> None:
-    super().__init__(name, commands, **attrs)
-    self.alias_map = {}
-    self.command_to_aliases = defaultdict(list)
-
-  def add_alias(self, cmd: click.Command, alias: str) -> None:
-    self.alias_map[alias] = cmd
-    if alias != cmd.name:
-      self.command_to_aliases[cmd].append(alias)
-
-  def command(self, aliases=None, *args,
-              **kwargs) -> t.Callable[[t.Callable[..., t.Any]], click.Command]:
-    cmd_decorator = super().command(*args, **kwargs)
-    if aliases is None:
-      aliases = []
-
-    def aliased_decorator(f):
-      cmd = cmd_decorator(f)
-      if cmd.name:
-        self.add_alias(cmd, cmd.name)
-      for alias in aliases:
-        self.add_alias(cmd, alias)
-      return cmd
-
-    f = None
-    if args and callable(args[0]):
-      (f,) = args
-    if f is not None:
-      return aliased_decorator(f)
-    return aliased_decorator
-
-  def group(self, aliases=None, *args,
-            **kwargs) -> t.Callable[[t.Callable[..., t.Any]], click.Group]:
-    cmd_decorator = super().group(*args, **kwargs)
-    if aliases is None:
-      aliases = []
-
-    def aliased_decorator(f):
-      cmd = cmd_decorator(f)
-      if cmd.name:
-        self.add_alias(cmd, cmd.name)
-      for alias in aliases:
-        self.add_alias(cmd, alias)
-      return cmd
-
-    f = None
-    if args and callable(args[0]):
-      (f,) = args
-    if f is not None:
-      return aliased_decorator(f)
-    return aliased_decorator
-
-  def get_command(self, ctx: click.Context, cmd_name: str) -> t.Optional[click.Command]:
-    rv = click.Group.get_command(self, ctx, cmd_name)
-    if rv is not None:
-      return rv
-    return self.alias_map.get(cmd_name)
-
-  def format_commands(self, ctx, formatter):
-    sub_commands = self.list_commands(ctx)
-
-    rows = []
-    for sub_command in sub_commands:
-      cmd = self.get_command(ctx, sub_command)
-      if cmd is None or getattr(cmd, 'hidden', False):
-        continue
-      if cmd in self.command_to_aliases:
-        aliases = ', '.join(self.command_to_aliases[cmd])
-        sub_command = f'{sub_command} ({aliases})'
-      cmd_help = cmd.help
-      rows.append((sub_command, cmd_help))
-
-    if rows:
-      with formatter.section("Commands"):
-        formatter.write_dl(rows)
-
-
-def validate_context(ctx):
-  if ctx.obj == {}:
-    logger.error("CLI config file missing. Run `clarifai login` to set up the CLI config.")
-    sys.exit(1)
+  console = Console()
+  panel = Panel(
+      Text(f"List of {resource_type}s", justify="center"),
+      title="",
+      style=Style(color="blue", bold=True),
+      border_style="green",
+      width=60)
+  console.print(panel)
+  for indx, item in enumerate(list(response)):
+    panel = Panel(
+        "\n".join([f"{'ID'}: {item.id}", f"{'Description'}: {item.description}"]),
+        title=f"{resource_type} {(indx + 1)}",
+        border_style="green",
+        width=60)
+    console.print(panel)

clarifai/utils/constants.py

@@ -1,7 +1,3 @@
-import os
-
 CLARIFAI_PAT_ENV_VAR = "CLARIFAI_PAT"
 CLARIFAI_SESSION_TOKEN_ENV_VAR = "CLARIFAI_SESSION_TOKEN"
 CLARIFAI_USER_ID_ENV_VAR = "CLARIFAI_USER_ID"
-
-DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'

clarifai/utils/misc.py

@@ -12,8 +12,6 @@ RETRYABLE_CODES = [
     status_code_pb2.MODEL_BUSY_PLEASE_RETRY
 ]
 
-DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'
-
 
 def status_is_retryable(status_code: int) -> bool:
   """Check if a status code is retryable."""

{clarifai-11.2.3rc1.dist-info → clarifai-11.2.3rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: clarifai
-Version: 11.2.3rc1
+Version: 11.2.3rc2
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -21,7 +21,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: clarifai-grpc>=11.2.6
-Requires-Dist: clarifai-protocol>=0.0.21
+Requires-Dist: clarifai-protocol>=0.0.22
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: rich>=13.4.2
@@ -35,6 +35,17 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
 Provides-Extra: all
 Requires-Dist: pycocotools==2.0.6; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <h1 align="center">
   <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://github.com/user-attachments/assets/623b883b-7fe5-4b95-bbfa-8691f5779af4"></a>