clarifai 9.7.0__tar.gz → 9.7.2__tar.gz

{clarifai-9.7.0 → clarifai-9.7.2}/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.0 → clarifai-9.7.2}/MANIFEST.in

@@ -1,4 +1,4 @@
 global-include *.css
 include clarifai/modules/style.css
 recursive-include clarifai *
-recursive-include clarifai_utils *
+recursive-include clarifai_utils *

clarifai-9.7.2/PKG-INFO

@@ -0,0 +1,176 @@
+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
+
+![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")
+```

clarifai-9.7.2/README.md

@@ -0,0 +1,160 @@
+![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")
+```

clarifai-9.7.2/clarifai/auth/__init__.py

@@ -0,0 +1,6 @@
+# Note: clarifai.auth is just added for backwards compatibility. It will be removed in the future.
+
+from clarifai.client.auth.register import V2Stub
+from clarifai.client.auth.stub import create_stub
+
+__all__ = ('V2Stub', 'create_stub')

{clarifai-9.7.0 → clarifai-9.7.2}/clarifai/auth/helper.py

@@ -14,12 +14,14 @@ base_https_cache = {}
 ui_https_cache = {}
 
 
-def clear_cache():
+def clear_cache() -> None:
+  """Clears the cache."""
   base_https_cache.clear()
   ui_https_cache.clear()
 
 
-def https_cache(cache, url):
+def https_cache(cache: dict, url: str) -> str:
+  """This is a helper function to cache whether a url is http or https."""
   HTTPS = True
   HTTP = False
 
@@ -72,17 +74,17 @@ class ClarifaiAuthHelper:
         Note: only one of personal access token (pat) or a session token (token) can be provided.
         Always use PATs in your code and never session tokens, those are only provided internal UI code.
 
-        Args:
-          user_id: a user id who owns the resource you want to make calls to.
-          app_id: an app id for the application that owns the resource you want to interact with
-          pat: a personal access token.
-          token: a session token (internal use only, always use a PAT).
-          base: a url to the API endpoint to hit. Examples include api.clarifai.com,
-        https://api.clarifai.com (default), https://host:port, http://host:port, host:port (will be treated as http, not https). It's highly recommended to include the http:// or https:// otherwise we need to check the endpoint to determine if it has SSL during this __init__
-          ui: a url to the UI. Examples include clarifai.com,
-        https://clarifai.com (default), https://host:port, http://host:port, host:port (will be treated as http, not https). It's highly recommended to include the http:// or https:// otherwise we need to check the endpoint to determine if it has SSL during this __init__
-          validate: whether to validate the inputs. This is useful for overriding vars then validating
-        """
+    Args:
+      user_id: a user id who owns the resource you want to make calls to.
+      app_id: an app id for the application that owns the resource you want to interact with
+      pat: a personal access token.
+      token: a session token (internal use only, always use a PAT).
+      base: a url to the API endpoint to hit. Examples include api.clarifai.com,
+    https://api.clarifai.com (default), https://host:port, http://host:port, host:port (will be treated as http, not https). It's highly recommended to include the http:// or https:// otherwise we need to check the endpoint to determine if it has SSL during this __init__
+      ui: a url to the UI. Examples include clarifai.com,
+    https://clarifai.com (default), https://host:port, http://host:port, host:port (will be treated as http, not https). It's highly recommended to include the http:// or https:// otherwise we need to check the endpoint to determine if it has SSL during this __init__
+      validate: whether to validate the inputs. This is useful for overriding vars then validating
+    """
 
     self.user_id = user_id
     self.app_id = app_id
@@ -182,10 +184,10 @@ class ClarifaiAuthHelper:
           optionally:
             base: as 'base' in query_params.
 
-        Args:
-          query_params: the streamlit.experimental_get_query_params() response or an empty dict to fall
-        back to using env vars.
-        """
+    Args:
+      query_params: the streamlit.experimental_get_query_params() response or an empty dict to fall
+    back to using env vars.
+    """
     error_description = """
 Please check the following required query params are in the url:
  - 'user_id': the user ID accessing the module.
@@ -225,7 +227,7 @@ Additionally, these optional params are supported:
           token: CLARIFAI_SESSION_TOKEN env var.
           pat: CLARIFAI_PAT env var.
         base: CLARIFAI_API_BASE env var.
-        """
+    """
     error_description = """
 Please check the following required vars are in your env:
  - 'CLARIFAI_USER_ID': the user ID accessing the module.
@@ -249,28 +251,26 @@ Additionally, these optional params are supported:
       user_id: str = None,
       app_id: str = None,
   ) -> resources_pb2.UserAppIDSet:
-    """
-        Get the gRPC metadata that contains either the session token or the PAT to use.
+    """Get the gRPC metadata that contains either the session token or the PAT to use.
 
-        Args:
-          user_id: optional user_id to override the default
-          app_id: optional app_id to override the default.
+    Args:
+      user_id: optional user_id to override the default
+      app_id: optional app_id to override the default.
 
-        Returns:
-          metadata: the metadata need to send with all grpc API calls in the API client.
-        """
+    Returns:
+      metadata: the metadata need to send with all grpc API calls in the API client.
+    """
     user_id = self.user_id if user_id is None else user_id
     app_id = self.app_id if app_id is None else app_id
     return resources_pb2.UserAppIDSet(user_id=user_id, app_id=app_id)
 
   @property
   def metadata(self):
-    """
-        Get the gRPC metadata that contains either the session token or the PAT to use.
+    """Get the gRPC metadata that contains either the session token or the PAT to use.
 
-        Returns:
-          metadata: the metadata need to send with all grpc API calls in the API client.
-        """
+    Returns:
+      metadata: the metadata need to send with all grpc API calls in the API client.
+    """
     if self._pat != "":
       return (("authorization", "Key %s" % self._pat),)
     elif self._token != "":
@@ -279,12 +279,11 @@ Additionally, these optional params are supported:
       raise Exception("'token' or 'pat' needed to be provided in the query params or env vars.")
 
   def get_stub(self) -> service_pb2_grpc.V2Stub:
-    """
-        Get the API gRPC stub using the right channel based on the API endpoint base.
+    """Get the API gRPC stub using the right channel based on the API endpoint base.
 
-        Returns:
-          stub: The service_pb2_grpc.V2Stub stub for the API.
-        """
+    Returns:
+      stub: The service_pb2_grpc.V2Stub stub for the API.
+    """
     if self._base not in base_https_cache:
       raise Exception("Cannot determine if base %s is https" % self._base)
 

clarifai-9.7.0/clarifai_utils/client/abc.py → clarifai-9.7.2/clarifai/auth/register.py

@@ -5,11 +5,11 @@ from clarifai_grpc.grpc.api import service_pb2_grpc
 
 
 class V2Stub(abc.ABC):
-  '''Abstract base class of clarifai api rpc client stubs'''
+  """Abstract base class of clarifai api rpc client stubs"""
 
 
 class RpcCallable(abc.ABC):
-  '''Abstract base class of clarifai api rpc callables'''
+  """Abstract base class of clarifai api rpc callables"""
 
 
 # add grpc classes as subclasses of the abcs, so they also succeed in isinstance calls

{clarifai-9.7.0/clarifai_utils/client → clarifai-9.7.2/clarifai/auth}/stub.py

@@ -5,8 +5,8 @@ from concurrent.futures import ThreadPoolExecutor
 import grpc
 from clarifai_grpc.grpc.api.status import status_code_pb2
 
-from clarifai.auth.helper import ClarifaiAuthHelper
-from clarifai.client.abc import RpcCallable, V2Stub
+from clarifai.client.auth.helper import ClarifaiAuthHelper
+from clarifai.client.auth.register import RpcCallable, V2Stub
 
 throttle_status_codes = {
     status_code_pb2.CONN_THROTTLED,
@@ -20,15 +20,15 @@ retry_codes_grpc = {
 _threadpool = ThreadPoolExecutor(100)
 
 
-def create_stub(auth_helper=None, max_retry_attempts=10):
-  '''
+def create_stub(auth_helper: ClarifaiAuthHelper = None, max_retry_attempts: int = 10) -> V2Stub:
+  """
   Create client stub that handles authorization and basic retries for
   unavailable or throttled connections.
 
   Args:
     auth_helper:  ClarifaiAuthHelper to use for auth metadata (default: from env)
     max_retry_attempts:  max attempts to retry rpcs with retryable failures
-  '''
+  """
   stub = AuthorizedStub(auth_helper)
   if max_retry_attempts > 0:
     return RetryStub(stub, max_retry_attempts)
@@ -36,9 +36,7 @@ def create_stub(auth_helper=None, max_retry_attempts=10):
 
 
 class AuthorizedStub(V2Stub):
-  '''
-  V2Stub proxy that inserts metadata authorization in rpc calls.
-  '''
+  """V2Stub proxy that inserts metadata authorization in rpc calls."""
 
   def __init__(self, auth_helper: ClarifaiAuthHelper = None):
     if auth_helper is None:
@@ -54,6 +52,7 @@ class AuthorizedStub(V2Stub):
 
 
 class _AuthorizedRpcCallable(RpcCallable):
+  """Adds metadata(authorization header) to rpc calls"""
 
   def __init__(self, func, metadata):
     self.f = func
@@ -75,9 +74,9 @@ class _AuthorizedRpcCallable(RpcCallable):
 
 
 class RetryStub(V2Stub):
-  '''
+  """
   V2Stub proxy that retries requests (currently on unavailable server or throttle codes)
-  '''
+  """
 
   def __init__(self, stub, max_attempts=10, backoff_time=5):
     self.stub = stub
@@ -92,6 +91,7 @@ class RetryStub(V2Stub):
 
 
 class _RetryRpcCallable(RpcCallable):
+  """Retries rpc calls on unavailable server or throttle codes"""
 
   def __init__(self, func, max_attempts, backoff_time):
     self.f = func

clarifai-9.7.2/clarifai/client/__init__.py

@@ -0,0 +1 @@
+# Note: This is just added for backwards compatibility. It will be removed in the future.