clarifai 9.7.0__py3-none-any.whl → 9.7.2__py3-none-any.whl

clarifai/errors.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+import json
+import time
+
+import requests  # noqa
+from google.protobuf.json_format import MessageToDict
+
+from clarifai.versions import CLIENT_VERSION, OS_VER, PYTHON_VERSION
+
+
+class TokenError(Exception):
+  pass
+
+
+class ApiError(Exception):
+  """ API Server error """
+
+  def __init__(self, resource: str, params: dict, method: str,
+               response: requests.Response = None) -> None:
+    self.resource = resource
+    self.params = params
+    self.method = method
+    self.response = response
+
+    self.error_code = 'N/A'
+    self.error_desc = 'N/A'
+    self.error_details = 'N/A'
+    response_json = 'N/A'
+
+    if response is not None:
+      response_json_dict = MessageToDict(response)
+
+      self.error_code = response_json_dict.get('status', {}).get('code', None)
+      self.error_desc = response_json_dict.get('status', {}).get('description', None)
+      self.error_details = response_json_dict.get('status', {}).get('details', None)
+      response_json = json.dumps(response_json_dict['status'], indent=2)
+
+    current_ts_str = str(time.time())
+
+    msg = """%(method)s %(resource)s FAILED(%(time_ts)s).  error_code: %(error_code)s, error_description: %(error_desc)s, error_details: %(error_details)s
+ >> Python client %(client_version)s with Python %(python_version)s on %(os_version)s
+ >> %(method)s %(resource)s
+ >> REQUEST(%(time_ts)s) %(request)s
+ >> RESPONSE(%(time_ts)s) %(response)s""" % {
+        'baseurl': '%s/v2/' % _base_url(self.resource),
+        'method': method,
+        'resource': resource,
+        'error_code': self.error_code,
+        'error_desc': self.error_desc,
+        'error_details': self.error_details,
+        'request': json.dumps(params, indent=2),
+        'response': response_json,
+        'time_ts': current_ts_str,
+        'client_version': CLIENT_VERSION,
+        'python_version': PYTHON_VERSION,
+        'os_version': OS_VER
+    }
+
+    super(ApiError, self).__init__(msg)
+
+
+class ApiClientError(Exception):
+  """ API Client Error """
+
+
+class UserError(Exception):
+  """ User Error """
+
+
+class AuthError(Exception):
+  """Raised when a client has missing or invalid authentication."""
+
+
+def _base_url(url: str) -> str:
+  """
+  Extracts the base URL from the url, which is everything before the 4th slash character.
+  https://www.clarifai.com/v2/models/1/output -> https://www.clarifai.com/v2/
+  """
+  try:
+    return url[:_find_nth(url, '/', 4) + 1]
+  except:
+    return ''
+
+
+def _find_nth(haystack: str, needle: str, n: int) -> int:
+  start = haystack.find(needle)
+  while start >= 0 and n > 1:
+    start = haystack.find(needle, start + len(needle))
+    n -= 1
+  return start

clarifai/urls/helper.py

@@ -6,9 +6,9 @@ class ClarifaiUrlHelper(object):
 
   def __init__(self, auth, module_manager_imv_id="module_manager_install"):
     """
-        Args:
-          auth: a ClarifaiAuthHelper object.
-        """
+    Args:
+      auth: a ClarifaiAuthHelper object.
+    """
     self._auth = auth
     self._module_manager_imv_id = module_manager_imv_id
 
@@ -39,12 +39,12 @@ class ClarifaiUrlHelper(object):
   def clarifai_url(self, user_id, app_id, resource_type, resource_id, version_id: str = None):
     """This is the path to the resource in community.
 
-        Args:
-          user_id: the author of the resource.
-          app_id: the author's app the resource was created in.
-          resource_type: the type of resource. One of "modules", "models", "concepts", "inputs", "workflows", "tasks", "installed_module_versions"
-          resource_id: the resource ID
-          version_id: the version of the resource.
+    Args:
+      user_id: the author of the resource.
+      app_id: the author's app the resource was created in.
+      resource_type: the type of resource. One of "modules", "models", "concepts", "inputs", "workflows", "tasks", "installed_module_versions"
+      resource_id: the resource ID
+      version_id: the version of the resource.
     """
     if resource_type not in [
         "modules", "models", "concepts", "inputs", "workflows", "tasks",
@@ -85,15 +85,14 @@ class ClarifaiUrlHelper(object):
 
   @classmethod
   def split_module_ui_url(cls, install):
-    """Takes in a path like https://clarifai.com/zeiler/app/modules/module1/versions/2
-        to split it apart into it's IDs.
+    """Takes in a path like https://clarifai.com/zeiler/app/modules/module1/versions/2 to split it apart into it's IDs.
 
-        Returns:
-          user_id: the author of the module.
-          app_id: the author's app the module was created in.
-          module_id: the module ID
-          module_version_id: the version of the module.
-        """
+    Returns:
+      user_id: the author of the module.
+      app_id: the author's app the module was created in.
+      module_id: the module ID
+      module_version_id: the version of the module.
+    """
     user_id, app_id, resource_type, resource_id, resource_version_id = cls.split_clarifai_url(
         install)
 

clarifai/utils/logging.py

@@ -0,0 +1,40 @@
+import logging
+from typing import Optional
+
+from rich.logging import RichHandler
+from rich.table import Table
+from rich.traceback import install
+
+install()
+
+
+def table_from_dict(data, column_names, title="") -> Table:
+  """Use this function for printing tables from a list of dicts."""
+  table = Table(title=title, show_header=True, header_style="bold blue")
+  for column_name in column_names:
+    table.add_column(column_name)
+  for row in data:
+    req_row = [row.get(column_name, "") for column_name in column_names]
+    table.add_row(*req_row)
+  return table
+
+
+def _get_library_name() -> str:
+  return __name__.split(".")[0]
+
+
+def _configure_logger(logger_level: str = "ERROR") -> None:
+  logging.basicConfig(
+      level=logger_level,
+      datefmt='%Y-%m-%d %H:%M:%S',
+      handlers=[RichHandler(rich_tracebacks=True)])
+
+
+def get_logger(logger_level: str = "ERROR", name: Optional[str] = None) -> logging.Logger:
+  """Return a logger with the specified name."""
+
+  if name is None:
+    name = _get_library_name()
+
+  _configure_logger(logger_level)
+  return logging.getLogger(name)

clarifai/utils/misc.py

@@ -0,0 +1,33 @@
+from typing import List
+
+
+class Chunker:
+  """Split an input sequence into small chunks."""
+
+  def __init__(self, seq: List, size: int) -> None:
+    self.seq = seq
+    self.size = size
+
+  def chunk(self) -> List[List]:
+    """Chunk input sequence."""
+    return [self.seq[pos:pos + self.size] for pos in range(0, len(self.seq), self.size)]
+
+
+class BackoffIterator:
+  """Iterator that returns a sequence of backoff values."""
+
+  def __init__(self):
+    self.count = 0
+
+  def __iter__(self):
+    return self
+
+  def __next__(self):
+    if self.count < 1:
+      self.count += 1
+      return 0.1
+    elif self.count < 7:
+      self.count += 1
+      return 0.01 * (2**(self.count + 4))
+    else:
+      return 0.01 * (2**10)  # 10 seconds

clarifai/versions.py

@@ -0,0 +1,6 @@
+import os
+
+CLIENT_VERSION = '9.7.2'
+OS_VER = os.sys.platform
+PYTHON_VERSION = '.'.join(
+    map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro]))

{clarifai-9.7.0.dist-info → clarifai-9.7.2.dist-info}/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2020 Clarifai, Inc.
+Copyright 2023 Clarifai, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

clarifai-9.7.2.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.1
+Name: clarifai
+Version: 9.7.2
+Summary: Clarifai Python SDK
+Home-page: https://github.com/Clarifai/clarifai-python
+Author: Clarifai
+Author-email: support@clarifai.com
+License: Apache 2.0
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: clarifai-grpc (>=9.7.3)
+Requires-Dist: tritonclient (==2.34.0)
+Requires-Dist: packaging
+
+![Clarifai logo](docs/logo.png)
+
+
+
+# Clarifai API Python Client
+
+This is the official Python client for interacting with our powerful recognition [API](https://docs.clarifai.com).
+The Clarifai Python SDK offers a comprehensive set of tools to integrate Clarifai's AI-powered image, video, and text recognition capabilities into your applications. With just a few lines of code, you can leverage cutting-edge artificial intelligence to unlock valuable insights from visual and textual content.
+
+* Try the Clarifai demo at: https://clarifai.com/demo
+* Sign up for a free account at: https://clarifai.com/developer/account/signup/
+* Read the developer guide at: https://clarifai.com/developer/guide/
+
+## Getting started
+Clarifai uses Personal Access Tokens(PATs) to validate requests. You can create and manage PATs under your Clarifai account security settings.
+
+Export your PAT as an environment variable. Then, import and initialize the API Client.
+
+
+```cmd
+export CLARIFAI_PAT={your personal access token}
+```
+
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+from clarifai.client.user import User
+client = User(user_id="user_id")
+
+# Get all apps
+apps = client.list_apps()
+
+# Create app and dataset
+app = client.create_app(app_id="demo_app", base_workflow="Universal")
+dataset = app.create_dataset(dataset_id="demo_dataset")
+
+# execute data upload to Clarifai app dataset
+dataset.upload_dataset(task='visual_segmentation', split="train", dataset_loader='coco_segmentation')
+
+#upload text from csv
+dataset.upload_from_csv(csv_path='csv_path', labels=True)
+
+#upload data from folder
+dataset.upload_from_folder(folder_path='folder_path', input_type='text', labels=True)
+```
+
+
+## Interacting with Inputs
+
+```python
+from clarifai.client.user import User
+app = User(user_id="user_id").app(app_id="app_id")
+input_obj = app.inputs()
+
+#input upload from url
+input_obj.upload_from_url(input_id = 'demo', image_url='https://samples.clarifai.com/metro-north.jpg')
+
+#input upload from filename
+input_obj.upload_from_file(input_id = 'demo', video_file='demo.mp4')
+
+#listing inputs
+input_obj.list_inputs()
+
+# text upload
+input_obj.upload_text(input_id = 'demo', raw_text = 'This is a test')
+```
+
+
+## Interacting with Models
+
+### Model Predict
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+from clarifai.client.model import Model
+
+# Model Predict
+model = Model("https://clarifai.com/anthropic/completion/models/claude-v2").predict_by_bytes(b"Write a tweet on future of AI", "text")
+
+model = Model(user_id="user_id", app_id="app_id", model_id="model_id")
+model_prediction = model.predict_by_url(url="url", input_type="image") # Supports image, text, audio, video
+
+# Customizing Model Inference Output
+model = Model(user_id="user_id", app_id="app_id", model_id="model_id",
+                  output_config={"min_value": 0.98}) # Return predictions having prediction confidence > 0.98
+model_prediction = model.predict_by_filepath(filepath="local_filepath", input_type="text") # Supports image, text, audio, video
+
+model = Model(user_id="user_id", app_id="app_id", model_id="model_id",
+                    output_config={"sample_ms": 2000}) # Return predictions for specified interval
+model_prediction = model.predict_by_url(url="VIDEO_URL", input_type="video")
+```
+### Models Listing
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+
+# List all model versions
+all_model_versions = model.list_versions()
+
+# Go to specific model version
+model_v1 = client.app("app_id").model(model_id="model_id", model_version_id="model_version_id")
+
+# List all models in an app
+all_models = app.list_models()
+
+# List all models in community filtered by model_type, description
+all_llm_community_models = App().list_models(filter_by={"query": "LLM",
+                                                        "model_type_id": "text-to-text"}, only_in_app=False)
+```
+
+## Interacting with Workflows
+
+### Workflow Predict
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+from clarifai.client.workflow import Workflow
+
+# Workflow Predict
+workflow = Workflow("workflow_url") # Example: https://clarifai.com/clarifai/main/workflows/Face-Sentiment
+workflow_prediction = workflow.predict_by_url(url="url", input_type="image") # Supports image, text, audio, video
+
+# Customizing Workflow Inference Output
+workflow = Workflow(user_id="user_id", app_id="app_id", workflow_id="workflow_id",
+                  output_config={"min_value": 0.98}) # Return predictions having prediction confidence > 0.98
+workflow_prediction = workflow.predict_by_filepath(filepath="local_filepath", input_type="text") # Supports image, text, audio, video
+```
+
+### Workflows Listing
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+
+# List all workflow versions
+all_workflow_versions = workflow.list_versions()
+
+# Go to specific workflow version
+workflow_v1 = Workflow(workflow_id="workflow_id", workflow_version=dict(id="workflow_version_id"), app_id="app_id", user_id="user_id")
+
+# List all workflow in an app
+all_workflow = app.list_workflow()
+
+# List all workflow in community filtered by description
+all_face_community_workflows = App().list_workflows(filter_by={"query": "face"}, only_in_app=False) # Get all face related workflows
+```
+
+## Interacting with Modules
+
+```python
+# Note: CLARIFAI_PAT must be set as env variable.
+from clarifai.client.app import App
+app = App(user_id="user_id", app_id="app_id")
+
+# create a new module
+module = app.create_module(module_id="module_id", description="module_description")
+
+# List all modules in an app
+all_modules = app.list_modules()
+
+# List all module versions
+all_module_versions = module.list_versions()
+
+# Delete a module
+app.delete_module(module_id="module_id")
+```