tator 0.0.0.dev0__tar.gz

tator-0.0.0.dev0/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2019 CVision AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tator-0.0.0.dev0/MANIFEST.in

@@ -0,0 +1,3 @@
+include tator/transcode/black.mp4
+include tator/util/tator-symbol.png
+include tator/util/tator-symbol.gif

tator-0.0.0.dev0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: tator
+Version: 0.0.0.dev0
+Summary: Python client for Tator
+Home-page: https://github.com/cvisionai/tator-py
+Author: CVision AI, Inc.
+Author-email: info@cvisionai.com
+License: UNKNOWN
+Keywords: OpenAPI,OpenAPI-Generator,Tator
+Platform: UNKNOWN
+License-File: LICENSE.md
+
+    Python client for Tator.
+    
+

tator-0.0.0.dev0/README.md

@@ -0,0 +1,39 @@
+# tator
+
+Python client for [Tator](https://github.com/cvisionai/tator).
+
+## Requirements
+
+Python 3.6+
+
+## Installation
+
+### From pypi
+```
+pip install tator
+```
+
+### From source
+```
+pip3 install -r requirements.txt --user
+python3 setup.py install --user
+```
+
+## Example usage
+```
+import tator
+
+api = tator.get_api('https://cloud.tator.io', 'MY_TOKEN')
+api.get_media_list(1) # Pass a project ID
+```
+
+Visit the [examples](examples) for more.
+
+## API documentation
+
+Documentation for all API functions and models can be found in the [OpenAPI documentation](https://tator.io/api).
+
+## Authors
+
+Tator and tator-py are developed by [CVision AI](https://www.cvisionai.com).
+

tator-0.0.0.dev0/pyproject.toml

@@ -0,0 +1,3 @@
+[tool.black]
+line-length = 100
+include = '\.pyi?$'

tator-0.0.0.dev0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tator-0.0.0.dev0/setup.py

@@ -0,0 +1,126 @@
+import os
+import subprocess
+import shutil
+
+from setuptools import setup, find_packages
+import requests
+import yaml
+import json
+
+REQUIRES = [
+    "certifi >= 14.05.14",
+    "Pillow >= 10.0.1",
+    "progressbar2 >= 3.51.4",
+    "psutil >= 5.9.5",
+    "python-dateutil >= 2.5.3",
+    "pyyaml >= 5.3.1",
+    "requests >= 2.25",
+    "six >= 1.10",
+    "urllib3 >= 1.26",
+]
+
+SCHEMA_FILENAME = 'schema.yaml'
+CONFIG_FILENAME = 'config.json'
+
+def get_version():
+    with open(CONFIG_FILENAME, 'r') as f:
+        config = json.load(f)
+    return config['packageVersion']
+
+def remove_oneof(data):
+    """ Removes oneOf key from a dict and recursively calls this function on
+        other dict values.
+    """
+    if 'oneOf' in data:
+        del data['oneOf']
+    for key in data:
+        if isinstance(data[key], dict):
+            remove_oneof(data[key])
+    return data
+
+class NoAliasDumper(yaml.Dumper):
+    def ignore_aliases(self, data):
+        return True
+
+def codegen():
+    """ Fetches a schema from cloud.tator.io if one does not exist, then 
+        use openapi-generator to generate openapi code from it.
+    """
+    # Retrieve schema if it does not exist.
+    if not os.path.exists(SCHEMA_FILENAME):
+        response = requests.get("https://cloud.tator.io/schema")
+        assert response.status_code == 200
+        with open(SCHEMA_FILENAME, 'wb') as f:
+            f.write(response.content)
+
+    # Remove any oneOf entries from the schema, as they are not handled
+    # well by openapi generator.
+    with open(SCHEMA_FILENAME, 'r') as f:
+        schema = yaml.safe_load(f)
+    schema = remove_oneof(schema)
+    with open(SCHEMA_FILENAME, 'w') as f:
+        yaml.dump(schema, f, Dumper=NoAliasDumper)
+
+    # Get the git SHA ID.
+    cmd = ['git', 'rev-parse', 'HEAD']
+    git_rev = subprocess.check_output(cmd).strip().decode('utf-8')
+
+    # Generate code using openapi generator docker image.
+    pwd = os.path.dirname(os.path.abspath(__file__))
+    cmd = [
+        'docker', 'run', '--rm',
+        '-v', f"{pwd}:/pwd",
+        '-v', f"{pwd}/out:/out",
+        'openapitools/openapi-generator-cli:v4.3.1', 'generate',
+        '-c', f'/pwd/{CONFIG_FILENAME}',
+        '-i', f'/pwd/{SCHEMA_FILENAME}',
+        '-g', 'python',
+        '-o', f'/out/tator-py-{git_rev}',
+        '-t', '/pwd/templates',
+    ]
+    subprocess.run(cmd, check=True)
+
+    # Remove the schema.
+    os.remove(SCHEMA_FILENAME)
+
+    # Copy relevant directories into openapi.
+    out_dir = os.path.join(pwd, 'tator/openapi')
+    os.makedirs(out_dir, exist_ok=True)
+    for subpath in ['README.md', 'tator_openapi', 'docs']:
+        src = f'{pwd}/out/tator-py-{git_rev}/{subpath}'
+        dst = os.path.join(out_dir, f'{subpath}')
+        if os.path.isfile(src):
+            shutil.copy(src, dst)
+        else:
+            if os.path.exists(dst):
+                shutil.rmtree(dst)
+            shutil.copytree(src, dst)
+    pwd = os.path.dirname(os.path.abspath(__file__))
+
+    # need to delete from within docker
+    cmd = [
+        'docker', 'run', '--rm',
+        '-v', f"{pwd}/out:/out",
+         'openapitools/openapi-generator-cli:v4.3.1',
+        'rm', '-fr',
+        '/out/*'
+    ]
+    subprocess.run(cmd, check=True)
+
+codegen()
+setup(
+    name="tator",
+    version=get_version(),
+    description="Python client for Tator",
+    author="CVision AI, Inc.",
+    author_email="info@cvisionai.com",
+    url="https://github.com/cvisionai/tator-py",
+    keywords=["OpenAPI", "OpenAPI-Generator", "Tator"],
+    install_requires=REQUIRES,
+    packages=find_packages(exclude=["test", "tests"]),
+    package_data={"tator": ["tator/util/tator-symbol.png", "tator/util/tator-symbol.gif"]},
+    include_package_data=True,
+    long_description="""\
+    Python client for Tator.
+    """
+)

tator-0.0.0.dev0/tator/__init__.py

@@ -0,0 +1,23 @@
+"""
+Python Bindings and associated utilities for tator
+online platform
+"""
+
+# import submodule to top-level first
+import tator.openapi as openapi
+
+# Shortcuts
+from .util.get_api import get_api
+from .util.get_parser import get_parser
+from .util.download_media import download_media
+
+from .version import __version__ as __version__
+
+# Generated code imports to top-level
+import tator.openapi.tator_openapi.models as models
+import tator.openapi.tator_openapi.exceptions as exceptions
+from tator.openapi.tator_openapi import TatorApi as api
+
+
+# Finally import utility functions
+import tator.util as util

tator-0.0.0.dev0/tator/extractor/__main__.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import sys
+import tempfile
+import uuid
+
+import tator
+
+from .extractor import process_file
+
+
+if __name__ == "__main__":
+    """ CLI Frontend to extractor """
+    parser = argparse.ArgumentParser(description="Thumbnail Extractor")
+    tator.get_parser(parser)
+    parser.add_argument("--mode",
+                        required=True,
+                        type=str,
+                        choices=['state',
+                                 'localization_keyframe',
+                                 'localization_thumbnail',
+                                 'track_thumbnail'],
+                        help="""
+                        state : Whole frame capture based on state's frame
+                        localization_keyframe : Whole frame on localization frame
+                        localization_thumbnail : Thumbnail of localization
+                        track_thumbnail : Thumbnail of track (mp4)"""
+                        )
+    parser.add_argument("--metadata-type-id",
+                        type=int,
+                        required=True)
+    parser.add_argument("--output-local",
+                        type=str)
+    parser.add_argument("--output-tator-section",
+                        type=str)
+    parser.add_argument("--output-type-id",
+                        type=int)
+    parser.add_argument("--project",
+                        required=True,
+                        type=int)
+    parser.add_argument('--work-dir',
+                        help='Optional hint to work directory',
+                        type=str)
+    parser.add_argument("media_ids",
+                        nargs="+")
+
+    args = parser.parse_args()
+
+    api = tator.get_api(args.host, args.token)
+
+    if args.mode in ['state', 'track_thumbnail']:
+        print("Using States")
+        meta_ep = api.get_state_list
+    else:
+        print("Using Localizations")
+        meta_ep = api.get_localization_list
+
+    if not any([args.output_local, args.output_tator_section]):
+        print("Must supply at least one output")
+        sys.exit(-1)
+
+    if args.output_local:
+        os.makedirs(args.output_local, exist_ok=True)
+    upload_gid = str(uuid.uuid1())
+    for media_id in args.media_ids:
+        media_element = api.get_media(media_id)
+        metadata = meta_ep(args.project,
+                           type=args.metadata_type_id,
+                           media_id=[media_id])
+        metadata = [m for m in metadata if m.attributes.get('_extracted', None) is None]
+        if len(metadata) == 0:
+            print(f"No non-extracted metadata for '{media_element.name}'({media_id})")
+            continue
+
+        with tempfile.TemporaryDirectory(dir=args.work_dir) as td:
+            print(f"Downloading {media_element.name}")
+            for p in tator.download_media(api,
+                                          media_element,
+                                          os.path.join(td, media_element.name)):
+                print(f"\r{p}", end='', flush=True)
+            print('')
+            print(f"Processing {media_element.name}")
+            process_file(api,
+                         args.project,
+                         os.path.join(td, media_element.name),
+                         media_element,
+                         args.mode,
+                         metadata,
+                         args.output_local if args.output_local else td,
+                         args.output_tator_section,
+                         output_type_id=args.output_type_id,
+                         upload_gid=upload_gid,
+                         work_dir=args.work_dir)

tator-0.0.0.dev0/tator/extractor/env_launcher.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+
+""" Uses ENV variables to dispatch the frame extractor 
+
+Generic TATOR workflow env variables this module expects:
+
+TATOR_API_SERVICE : URL to host, e.g. https://cloud.tator.io
+TATOR_AUTH_TOKEN : Token to use for authentication
+TATOR_PROJECT_ID : numerical id of the project this algorithm is being run
+TATOR_MEDIA_IDS : Comma-seperated list of media ids to process
+
+:Workflow variables:
+`python3 -m tator.extractor --help` for more information on the following
+options:
+EXTRACT_MODE : Maps to the `--mode` argument
+METADATA_TYPE_ID : Maps to the `--metadata-type-id` argument
+OUTPUT_SECTION : Maps to the `--tator-output-section` argument
+OUTPUT_TYPE_ID : Maps to the `--output-type-id` argument  
+
+"""
+    
+import os
+import pandas as pd
+import subprocess
+import json
+import sys
+import shutil
+
+if __name__=="__main__":
+    media_ids = os.getenv('TATOR_MEDIA_IDS').split(',')
+    cmd = ["python3",
+           "-m", "tator.extractor",
+           '--host', os.getenv("TATOR_API_SERVICE").replace('/rest',''),
+           "--token",
+           os.getenv("TATOR_AUTH_TOKEN"),
+           "--mode", os.getenv("EXTRACT_MODE"),
+           "--metadata-type-id", os.getenv("METADATA_TYPE_ID"),
+           "--project", os.getenv("TATOR_PROJECT_ID"),
+           "--output-tator-section", os.getenv("OUTPUT_SECTION"),
+           "--output-type-id", os.getenv("OUTPUT_TYPE_ID"),
+           # Assume PVC is located at work
+           "--work-dir", "/work",
+           *media_ids]
+
+    p=subprocess.Popen(cmd)
+    p.wait()
+    sys.exit(p.returncode)
+