media-tagging 0.2.0.dev2__tar.gz → 0.3.0.dev1__tar.gz

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: media-tagging
-Version: 0.2.0.dev2
+Version: 0.3.0.dev1
 Author: Google Inc. (gTech gPS CSE team)
 Author-email: no-reply@google.com
 License: Apache 2.0
@@ -11,3 +11,15 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Description-Content-Type: text/markdown
+Requires-Dist: fastapi==0.111.0
+Requires-Dist: pillow
+Requires-Dist: google-cloud-vision
+Requires-Dist: google-cloud-videointelligence
+Requires-Dist: smart_open
+Requires-Dist: google-ads-api-report-fetcher==1.14.3
+Requires-Dist: langchain==0.2.7
+Requires-Dist: langchain-core==0.2.21
+Requires-Dist: langchain-community==0.2.7
+Requires-Dist: langchain-google-genai==1.0.7
+Requires-Dist: langchain-google-vertexai
+Requires-Dist: jq

media_tagging-0.3.0.dev1/README.md

@@ -0,0 +1,72 @@
+# Media Tagger
+
+## Problem statement
+
+When analyzing large amount of creatives of any nature (being images and videos)
+it might be challenging to quickly and reliably understand their content
+and gain insights.
+
+## Solution
+
+`media-tagger` performs tagging of image and videos based on various taggers
+- simply provide a path to your media files and `media-tagger` will do the rest.
+
+## Deliverable (implementation)
+
+`media-tagger` is implemented as a:
+
+* **library** - Use it in your projects with a help of `media_tagging.tagger.create_tagger` function.
+* **CLI tool** - `media-tagger` tool is available to be used in the terminal.
+* **HTTP endpoint** - `media-tagger` can be easily exposed as HTTP endpoint.
+* **Langchain tool**  - integrated `media-tagger` into your Langchain applications.
+
+## Deployment
+
+### Prerequisites
+
+- Python 3.11+
+- A GCP project with billing account attached
+- [Video Intelligence API](https://console.cloud.google.com/apis/library/videointelligence.googleapis.com) and [Vision API](https://console.cloud.google.com/apis/library/vision.googleapis.com) enabled.
+* [API key](https://support.google.com/googleapi/answer/6158862?hl=en) to access to access Google Gemini.
+  - Once you created API key export it as an environmental variable
+
+    ```
+    export GOOGLE_API_KEY=<YOUR_API_KEY_HERE>
+    ```
+
+
+### Installation
+
+Install `media-tagger` with `pip install media-tagging` command.
+
+### Usage
+
+> This section is focused on using `media-tagger` as a CLI tool.
+> Check [library](docs/how-to-use-media-tagger-as-a-library.md),
+> [http endpoint](docs/how-to-use-media-tagger-as-a-http-endpoint.md),
+> [langchain tool](docs/how-to-use-media-tagger-as-a-langchain-tool.md)
+> sections to learn more.
+
+Once `media-tagger` is installed you can call it:
+
+```
+media-tagger --media-path MEDIA_PATH --tagger TAGGER_TYPE --writer WRITER_TYPE
+```
+where:
+* MEDIA_PATH - comma-separated names of files for tagging (can be urls).
+* TAGGER_TYPE - name of tagger, supported options:
+  * `vision-api` - tags images based on [Google Cloud Vision API](https://cloud.google.com/vision/),
+  * `video-api` for videos based on [Google Cloud Video Intelligence API](https://cloud.google.com/video-intelligence/)
+  * `gemini-image` - Uses Gemini to tags images. Add `--tagger.n_tags=<N_TAGS>`
+     parameter to control number of tags returned by tagger.
+  * `gemini-structured-image`  - Uses Gemini to find certain tags in the images.
+    Add `--tagger.tags='tag1, tag2, ..., tagN` parameter to find certain tags
+    in the image.
+  * `gemini-description-image` - Provides brief description of the image,
+* WRITER_TYPE - name of writer, one of `csv`, `json`
+
+By default script will create a single file with tagging results for each media_path.
+If you want to combine results into a single file add `--output OUTPUT_NAME` flag (without extension, i.e. `--output tagging_sample`.
+
+## Disclaimer
+This is not an officially supported Google product.

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/entrypoints/cli.py

@@ -15,48 +15,10 @@
 
 import argparse
 import logging
-import os
 
-import smart_open
 from gaarf.cli import utils as gaarf_utils
 
-from media_tagging import tagger, utils, writer
-from media_tagging.taggers import base as base_tagger
-
-
-def tag_media(
-  media_path: str | os.PathLike,
-  tagger_type: base_tagger.BaseTagger,
-  writer_type: writer.BaseWriter = writer.JsonWriter(),
-  single_output_name: str | None = None,
-  tagging_parameters: dict[str, str] | None = None,
-) -> None:
-  """Runs media tagging algorithm.
-
-  Args:
-    media_path: Local or remote path to media file.
-    tagger_type: Initialized tagger.
-    writer_type: Initialized writer for saving tagging results.
-    single_output_name: Parameter for saving results to a single file.
-    tagging_parameters: Optional keywords arguments to be sent for tagging.
-  """
-  media_paths = media_path.split(',')
-  if not tagging_parameters:
-    tagging_parameters = {}
-  results = []
-  for path in media_paths:
-    media_name = utils.convert_path_to_media_name(path)
-    logging.info('Processing media: %s', path)
-    with smart_open.open(path, 'rb') as f:
-      media_bytes = f.read()
-    results.append(
-      tagger_type.tag(
-        media_name,
-        media_bytes,
-        tagging_options=base_tagger.TaggingOptions(**tagging_parameters),
-      )
-    )
-  writer_type.write(results, single_output_name)
+from media_tagging import tagger, writer
 
 
 def main():
@@ -80,13 +42,13 @@ def main():
   )
   logging.getLogger(__file__)
 
-  tag_media(
-    media_path=args.media_path,
+  logging.info('Initializing tagger: %s', args.tagger)
+  tagging_results = tagger.tag_media(
+    media_paths=args.media_path.split(','),
     tagger_type=concrete_tagger,
-    writer_type=concrete_writer,
-    single_output_name=args.output,
     tagging_parameters=tagging_parameters.get('tagger'),
   )
+  concrete_writer.write(tagging_results, args.output)
 
 
 if __name__ == '__main__':

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/entrypoints/server.py

@@ -16,7 +16,6 @@
 import logging
 
 import fastapi
-import smart_open
 from typing_extensions import TypedDict
 
 from media_tagging import tagger, utils
@@ -30,10 +29,12 @@ class MediaPostRequest(TypedDict):
   """Specifies structure of request for tagging media.
 
   Attributes:
+    tagger_type: Type of tagger.
     media_url: Local or remote URL of media.
   """
 
   media_url: str
+  tagger_type: str
   tagging_parameters: dict[str, int | list[str]]
 
 
@@ -49,24 +50,7 @@ async def tag_with_llm(
   Returns:
     Json results of tagging.
   """
-  if not (llm_tagger := taggers.get('gemini-image')):
-    llm_tagger = tagger.create_tagger('gemini-image')
-    taggers['gemini-image'] = llm_tagger
-  if media_url := data.get('media_url'):
-    media_name = utils.convert_path_to_media_name(media_url)
-    logging.info('Processing media: %s', media_url)
-    with smart_open.open(media_url, 'rb') as f:
-      media_bytes = f.read()
-    tagging_options = base_tagger.TaggingOptions(
-      **data.get('tagging_parameters')
-    )
-    tagging_result = llm_tagger.tag(
-      name=media_name, content=media_bytes, tagging_options=tagging_options
-    )
-    return fastapi.responses.JSONResponse(
-      content=fastapi.encoders.jsonable_encoder(tagging_result.dict())
-    )
-  raise ValueError('No path to media is provided.')
+  return process_post_request(data)
 
 
 @app.post('/tagger/api')
@@ -81,18 +65,32 @@ async def tag_with_api(
   Returns:
     Json results of tagging.
   """
-  if not (api_tagger := taggers.get('vision-api')):
-    api_tagger = tagger.create_tagger('vision-api')
-    taggers['vision-api'] = api_tagger
+  return process_post_request(data)
+
+
+def process_post_request(
+  data: MediaPostRequest,
+) -> fastapi.responses.JSONResponse:
+  """Helper method for performing tagging.
+
+  Args:
+    data: Post request for media tagging.
+
+  Returns:
+    Json results of tagging.
+  """
+  tagger_type = data.get('tagger_type')
+  if not (concrete_tagger := taggers.get(tagger_type)):
+    concrete_tagger = tagger.create_tagger(tagger_type)
+    taggers[tagger_type] = concrete_tagger
   if media_url := data.get('media_url'):
     media_name = utils.convert_path_to_media_name(media_url)
+    media_bytes = utils.read_media_as_bytes(media_url)
     logging.info('Processing media: %s', media_url)
-    with smart_open.open(media_url, 'rb') as f:
-      media_bytes = f.read()
     tagging_options = base_tagger.TaggingOptions(
       **data.get('tagging_parameters')
     )
-    tagging_result = api_tagger.tag(
+    tagging_result = concrete_tagger.tag(
       name=media_name, content=media_bytes, tagging_options=tagging_options
     )
     return fastapi.responses.JSONResponse(

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging/tagger.py

@@ -17,6 +17,11 @@ Media tagging sends API requests to tagging engine (i.e. Google Vision API)
 and returns tagging results that can be easily written.
 """
 
+import logging
+import os
+from collections.abc import Sequence
+
+from media_tagging import utils
 from media_tagging.taggers import api, base, llm
 
 _TAGGERS = {
@@ -25,12 +30,18 @@ _TAGGERS = {
   'gemini-image': llm.GeminiImageTagger,
   'gemini-structured-image': llm.GeminiImageTagger,
   'gemini-description-image': llm.GeminiImageTagger,
+  'gemini-video': llm.GeminiVideoTagger,
+  'gemini-structured-video': llm.GeminiVideoTagger,
+  'gemini-description-video': llm.GeminiVideoTagger,
 }
 
 _LLM_TAGGERS_TYPES = {
   'gemini-image': llm.LLMTaggerTypeEnum.UNSTRUCTURED,
   'gemini-structured-image': llm.LLMTaggerTypeEnum.STRUCTURED,
   'gemini-description-image': llm.LLMTaggerTypeEnum.DESCRIPTION,
+  'gemini-video': llm.LLMTaggerTypeEnum.UNSTRUCTURED,
+  'gemini-structured-video': llm.LLMTaggerTypeEnum.STRUCTURED,
+  'gemini-description-video': llm.LLMTaggerTypeEnum.DESCRIPTION,
 }
 
 
@@ -58,3 +69,35 @@ def create_tagger(
     f'Incorrect tagger {type} is provided, '
     f'valid options: {list(_TAGGERS.keys())}'
   )
+
+
+def tag_media(
+  media_paths: Sequence[str | os.PathLike],
+  tagger_type: base.BaseTagger,
+  tagging_parameters: dict[str, str] | None = None,
+) -> list[base.TaggingResult]:
+  """Runs media tagging algorithm.
+
+  Args:
+    media_paths: Local or remote path to media file.
+    tagger_type: Initialized tagger.
+    tagging_parameters: Optional keywords arguments to be sent for tagging.
+
+  Returns:
+    Results of tagging for all media.
+  """
+  if not tagging_parameters:
+    tagging_parameters = {}
+  results = []
+  for path in media_paths:
+    media_name = utils.convert_path_to_media_name(path)
+    logging.info('Processing media: %s', path)
+    media_bytes = utils.read_media_as_bytes(path)
+    results.append(
+      tagger_type.tag(
+        media_name,
+        media_bytes,
+        tagging_options=base.TaggingOptions(**tagging_parameters),
+      )
+    )
+  return results

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging/taggers/base.py

@@ -46,6 +46,8 @@ class Tag(pydantic.BaseModel):
     score: Score assigned to the tag.
   """
 
+  model_config = pydantic.ConfigDict(frozen=True)
+
   name: str = pydantic.Field(description='tag_name')
   score: float = pydantic.Field(description='tag_score from 0 to 1')
 

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging/taggers/llm.py

@@ -14,10 +14,14 @@
 """Module for performing media tagging with LLMs."""
 
 import base64
+import dataclasses
 import enum
+import json
 import logging
+import tempfile
 from typing import Final
 
+import google.generativeai as google_genai
 import langchain_google_genai as genai
 from langchain_core import (
   language_models,
@@ -59,6 +63,9 @@ _UNSTRUCTURED_PROMPT: Final[prompts.ChatPromptTemplate] = (
   )
 )
 
+_UNSTRUCTURED_PROMPT_VIDEO: Final[str] = (
+  'Generate {n_tags} tags for the following video.'
+)
 _STRUCTURED_PROMPT: Final[prompts.ChatPromptTemplate] = (
   prompts.ChatPromptTemplate.from_messages(
     [
@@ -72,6 +79,11 @@ _STRUCTURED_PROMPT: Final[prompts.ChatPromptTemplate] = (
   )
 )
 
+_STRUCTURED_PROMPT_VIDEO: Final[str] = (
+  'Find whether the following tags can be found in the video: {tags}.'
+)
+
+
 _DESCRIPTION_PROMPT: Final[prompts.ChatPromptTemplate] = (
   prompts.ChatPromptTemplate.from_messages(
     [
@@ -84,6 +96,7 @@ _DESCRIPTION_PROMPT: Final[prompts.ChatPromptTemplate] = (
   )
 )
 
+_DESCRIPTION_PROMPT_VIDEO: Final[str] = 'Describe the following video.'
 
 llm_tagger_promps: dict[LLMTaggerTypeEnum, prompts.ChatPromptTemplate] = {
   LLMTaggerTypeEnum.UNSTRUCTURED: _UNSTRUCTURED_PROMPT,
@@ -91,6 +104,12 @@ llm_tagger_promps: dict[LLMTaggerTypeEnum, prompts.ChatPromptTemplate] = {
   LLMTaggerTypeEnum.DESCRIPTION: _DESCRIPTION_PROMPT,
 }
 
+video_llm_tagger_promps: dict[LLMTaggerTypeEnum, str] = {
+  LLMTaggerTypeEnum.UNSTRUCTURED: _UNSTRUCTURED_PROMPT_VIDEO,
+  LLMTaggerTypeEnum.STRUCTURED: _STRUCTURED_PROMPT_VIDEO,
+  LLMTaggerTypeEnum.DESCRIPTION: _DESCRIPTION_PROMPT_VIDEO,
+}
+
 
 class LLMTagger(base.BaseTagger):
   """Tags media via LLM."""
@@ -190,3 +209,95 @@ class GeminiImageTagger(LLMTagger):
       llm_tagger_type=tagger_type,
       llm=genai.ChatGoogleGenerativeAI(model=model_name),
     )
+
+
+class GeminiVideoTagger(LLMTagger):
+  """Tags video based on Gemini."""
+
+  def __init__(
+    self,
+    tagger_type: LLMTaggerTypeEnum,
+    model_name: str = 'models/gemini-1.5-flash',
+  ) -> None:
+    """Initializes GeminiVideoTagger.
+
+    Args:
+      tagger_type: Type of LLM tagger.
+      model_name: Name of the model to perform the tagging.
+    """
+    self.llm_tagger_type = tagger_type
+    self.model_name = model_name
+
+  @property
+  def model(self) -> google_genai.GenerativeModel:
+    """Initializes GenerativeModel."""
+    return google_genai.GenerativeModel(model_name=self.model_name)
+
+  @override
+  def tag(
+    self,
+    name: str,
+    content: bytes,
+    tagging_options: base.TaggingOptions = base.TaggingOptions(),
+  ):
+    logging.debug('Tagging video "%s" with GeminiVideoTagger', name)
+    with tempfile.NamedTemporaryFile(suffix='.mp4') as f:
+      f.write(content)
+      try:
+        video_file = google_genai.upload_file(f.name)
+
+        result = self.model.generate_content(
+          [
+            video_file,
+            '\n\n',
+            f'{self.format_prompt(tagging_options)} ',
+          ],
+          generation_config=google_genai.GenerationConfig(
+            response_mime_type='application/json',
+            response_schema=self.response_schema,
+          ),
+        )
+      finally:
+        video_file.delete()
+
+      if self.llm_tagger_type == LLMTaggerTypeEnum.DESCRIPTION:
+        return base.TaggingResult(
+          identifier=name,
+          type='video',
+          content=base.Description(text=json.loads(result.text).get('text')),
+        )
+      tags = [
+        base.Tag(name=r.get('name'), score=r.get('score'))
+        for r in json.loads(result.text)
+      ]
+      return base.TaggingResult(identifier=name, type='video', content=tags)
+
+  def format_prompt(self, tagging_options: base.TaggingOptions) -> str:
+    """Builds correct prompt to send to LLM.
+
+    Prompt contains format instructions to get output result.
+
+    Args:
+      tagging_options: Parameters to refine the prompt.
+
+    Returns:
+      Formatted prompt.
+    """
+    base_prompt = video_llm_tagger_promps[self.llm_tagger_type]
+    formatting_instructions = (
+      ' For each tag provide name and a score from 0 to 1 '
+      'where 0 is tag absence and 1 complete tag presence.'
+    )
+    prompt = base_prompt.format(**dataclasses.asdict(tagging_options))
+    if self.llm_tagger_type == LLMTaggerTypeEnum.DESCRIPTION:
+      return prompt
+    return prompt + formatting_instructions
+
+  @property
+  def response_schema(self) -> list[base.Tag] | base.Description:
+    """Generates correct response schema based on type of LLM tagger."""
+    return (
+      base.Description
+      if self.llm_tagger_type == LLMTaggerTypeEnum.DESCRIPTION
+      else list[base.Tag]
+    )

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging/tools.py

@@ -14,14 +14,13 @@
 """Exposes media tagger as a tool for Langchain agents."""
 
 import langchain_core
-import smart_open
 
 from media_tagging import tagger, utils
 from media_tagging.taggers import base as base_tagger
 
 
 class MediaTaggingInput(langchain_core.pydantic_v1.BaseModel):
-  """Input for text categorization."""
+  """Input for media tagging."""
 
   tagger_type: str = langchain_core.pydantic_v1.Field(
     description='Type of media tagger'
@@ -32,16 +31,14 @@ class MediaTaggingInput(langchain_core.pydantic_v1.BaseModel):
 
 
 class MediaTaggingResults(langchain_core.tools.BaseTool):
-  """Tools that performs text categorization.
+  """Tools that performs media tagging.
 
   Attributes:
-    llm_parameters: Parameter for LLM initialization.
     name: Name of the tool.
     description: Description the tool.
     args_schema: Input model for the tool.
   """
 
-  llm_parameters: dict[str, str] = {'model': 'gemini-1.5-flash'}
   name: str = 'media_tagging_results_json'
   description: str = 'tag media (image or videos)'
   args_schema: type[langchain_core.pydantic_v1.BaseModel] = MediaTaggingInput
@@ -51,7 +48,7 @@ class MediaTaggingResults(langchain_core.tools.BaseTool):
     tagger_type: str,
     media_url: str,
   ) -> list[dict[str, str]]:
-    """Performs media tagging based on LLM and vectorstore.
+    """Performs media tagging based on selected tagger.
 
     Args:
       tagger_type: Type of tagger to use for media tagging.
@@ -62,8 +59,7 @@ class MediaTaggingResults(langchain_core.tools.BaseTool):
     """
     media_tagger = tagger.create_tagger(tagger_type)
     media_name = utils.convert_path_to_media_name(media_url)
-    with smart_open.open(media_url, 'rb') as f:
-      media_bytes = f.read()
+    media_bytes = utils.read_media_as_bytes(media_url)
     tagging_options = base_tagger.TaggingOptions()
     return media_tagger.tag(
       name=media_name, content=media_bytes, tagging_options=tagging_options

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging/utils.py

@@ -13,8 +13,18 @@
 # limitations under the License.
 """Various utils."""
 
+import os
+
+import smart_open
+
 
 def convert_path_to_media_name(media_path: str) -> str:
   """Extracts file name without extension."""
   base_name = media_path.split('/')[-1]
   return base_name.split('.')[0]
+
+
+def read_media_as_bytes(media_path: str | str | os.PathLike) -> bytes:
+  """Reads media content from local or remote storage."""
+  with smart_open.open(media_path, 'rb') as f:
+    return f.read()

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: media-tagging
-Version: 0.2.0.dev2
+Version: 0.3.0.dev1
 Author: Google Inc. (gTech gPS CSE team)
 Author-email: no-reply@google.com
 License: Apache 2.0
@@ -11,3 +11,15 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Description-Content-Type: text/markdown
+Requires-Dist: fastapi==0.111.0
+Requires-Dist: pillow
+Requires-Dist: google-cloud-vision
+Requires-Dist: google-cloud-videointelligence
+Requires-Dist: smart_open
+Requires-Dist: google-ads-api-report-fetcher==1.14.3
+Requires-Dist: langchain==0.2.7
+Requires-Dist: langchain-core==0.2.21
+Requires-Dist: langchain-community==0.2.7
+Requires-Dist: langchain-google-genai==1.0.7
+Requires-Dist: langchain-google-vertexai
+Requires-Dist: jq

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/media_tagging.egg-info/requires.txt

@@ -1,11 +1,12 @@
+fastapi==0.111.0
 google-ads-api-report-fetcher==1.14.3
 google-cloud-videointelligence
 google-cloud-vision
 jq
-langchain
-langchain-community
-langchain-core
-langchain-google-genai
+langchain-community==0.2.7
+langchain-core==0.2.21
+langchain-google-genai==1.0.7
 langchain-google-vertexai
+langchain==0.2.7
 pillow
 smart_open

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/setup.py

@@ -17,7 +17,7 @@ from setuptools import find_packages, setup
 
 setup(
   name='media-tagging',
-  version='0.2.0dev2',
+  version='0.3.0dev1',
   long_description_content_type='text/markdown',
   author='Google Inc. (gTech gPS CSE team)',
   author_email='no-reply@google.com',
@@ -32,15 +32,16 @@ setup(
   ],
   packages=find_packages(),
   install_requires=[
+    'fastapi==0.111.0',
     'pillow',
     'google-cloud-vision',
     'google-cloud-videointelligence',
     'smart_open',
     'google-ads-api-report-fetcher==1.14.3',
-    'langchain',
-    'langchain-core',
-    'langchain-community',
-    'langchain-google-genai',
+    'langchain==0.2.7',
+    'langchain-core==0.2.21',
+    'langchain-community==0.2.7',
+    'langchain-google-genai==1.0.7',
     'langchain-google-vertexai',
     'jq',
   ],

{media-tagging-0.2.0.dev2 → media_tagging-0.3.0.dev1}/tests/end_to_end/test_main.py

@@ -15,8 +15,7 @@
 import json
 import pathlib
 
-from entrypoints import cli
-from media_tagging import writer
+from media_tagging import tagger, writer
 from media_tagging.taggers import api
 
 _SCRIPT_DIR = pathlib.Path(__file__).parent
@@ -32,13 +31,13 @@ def test_image_tagging(fake_tagger, mocker):
   concrete_writer = writer.JsonWriter()
   image_path = f'{_SCRIPT_DIR}/../unit/data/test_image.jpg'
   image_name = 'test'
-  cli.tag_media(
-    media_path=image_path,
+  tagging_results = tagger.tag_media(
+    media_paths=[image_path],
     tagger_type=concrete_tagger,
-    writer_type=concrete_writer,
   )
+  concrete_writer.write(tagging_results, 'test')
   with open('test.json', 'r', encoding='utf-8') as f:
-    data = json.load(f)
+    data = json.load(f)[0]
 
   assert data.get('identifier') == image_name
   assert data.get('type') == 'image'

media-tagging-0.2.0.dev2/README.md

@@ -1,48 +0,0 @@
-# Welltech Media Tagging
-
-## Prerequisites
-
-* Google Cloud project with billing enabled.
-* [Video Intelligence API](https://console.cloud.google.com/apis/library/videointelligence.googleapis.com) and [Vision API](https://console.cloud.google.com/apis/library/vision.googleapis.com) enabled.
-* Python3.8+
-* Access to repository configured. In order to clone this repository you need
-	to do the following:
-	*   Visit https://professional-services.googlesource.com/new-password and
-			login with your account.
-    * Once authenticated please copy all lines in box
-        and paste them in the terminal.
-
-
-## Run
-
-
-1. Install `media-tagger`
-
-```
-pip install media-tagging
-```
-
-2. Perform tagging
-
-```
-media-tagger --media-path MEDIA_PATH --tagger TAGGER_TYPE --writer WRITER_TYPE
-```
-where:
-* MEDIA_PATH - comma-separated names of files for tagging (can be urls).
-* TAGGER_TYPE - name of tagger, supported options:
-  * `vision-api` - tags images based on [Google Cloud Vision API](https://cloud.google.com/vision/),
-  * `video-api` for videos based on [Google Cloud Video Intelligence API](https://cloud.google.com/video-intelligence/)
-  * `gemini-image` - Uses Gemini to tags images. Add `--tagger.n_tags=<N_TAGS>`
-     parameter to control number of tags returned by tagger.
-  * `gemini-structured-image`  - Uses Gemini to find certain tags in the images.
-    Add `--tagger.tags='tag1, tag2, ..., tagN` parameter to find certain tags
-    in the image.
-  * `gemini-description-image` - Provides brief description of the image,
-* WRITER_TYPE - name of writer, one of `csv`, `json`
-
-By default script will create a single file with tagging results for each media_path.
-If you want to combine results into a single file add `--output OUTPUT_NAME` flag (without extension, i.e. `--output tagging_sample`.
-
-
-## Disclaimer
-This is not an officially supported Google product.