[PYTHON] Réfléchissez à la façon d'écrire un filtre avec les versions Shotgun API-Contact

Qu'est-ce que c'est?

Je souhaite utiliser l'API Shotgun pour obtenir des informations sur l'entité "Versions".

supposition

Basé sur le flux jusqu'à présent http://qiita.com/it_ks/items/e026f61fb8c3683ac035

--Shotgun API a été installé dans l'environnement Python --Création d'un utilisateur de script sur Shotgun

Je voudrais partir de là.

Entité Versions

En termes de Shotgun, les livrables (vidéos / images, y compris le milieu) qui sont soumis lors de la réception des avis ou des rapports de progrès aux clients sont appelés «versions». (À propos, le délimiteur que le travailleur met à l'étape de travail appropriée est conservé par le nom «instantané») Le premier est géré / partagé en le téléchargeant sur le cloud, mais le second est dans la catégorie des travailleurs ou à la discrétion des travailleurs.

--Vérifier la version cible = "version" = vers le cloud --In-worker version = "snapshot" = limité à la main

Une entité est une table de données sur Shotgun. Différents types tels que Shot, Asset et Task sont disponibles, et la version est l'un d'entre eux.

Utilisez la méthode schema_entity_read () lors de l'examen d'une entité.

>>> sg.schema_entity_read().keys()
['Candidate', 'MocapTake', 'ActionMenuItem', 'Asset', 'Department', 'RevisionTicketConnection', 'Revision', 'CutVersionC
onnection', 'PublishedFileDependency', 'Step', 'MocapPass', 'Icon', 'Task', 'ApiUser', 'Launch', 'Ticket_sg_test_ticket_
to_task_Connection', 'Project', 'CutItem', 'LocalStorage', 'Release', 'LaunchSceneConnection', 'ReleaseTicketConnection'
, 'LaunchShotConnection', 'CustomEntity01', 'Shot', 'BannerUserConnection', 'AssetAssetConnection', 'EventLogEntry', 'As
setShootDayConnection', 'DeliveryTarget', 'PageSetting', 'Playlist', 'ShootDaySceneConnection', 'Camera', 'TankAction',
'Routine', 'Reply', 'AppWelcomeUserConnection', 'Attachment', 'Tool', 'TicketTicketConnection', 'PhysicalAssetMocapTakeC
onnection', 'Cut', 'Group', 'MocapSetup', 'Note', 'TaskDependency', 'PageHit', 'TemerityNode', 'Status', 'AssetElementCo
nnection', 'Slate', 'MocapTakeRangeShotConnection', 'TimeLog', 'ShootDay', 'AssetBlendshapeConnection', 'MocapTakeRange'
, 'PublishedFile', 'ProjectUserConnection', 'ShotShotConnection', 'PublishedFileType', 'TankType', 'TaskTemplate', 'Play
listShare', 'PerformerShootDayConnection', 'PipelineConfiguration', 'HumanUser', 'FilesystemLocation', 'Performer', 'Ver
sion', 'PhysicalAsset', 'ElementShotConnection', 'AssetSceneConnection', 'AssetMocapTakeConnection', 'PlaylistVersionCon
nection', 'Booking', 'PublishEvent', 'CameraMocapTakeConnection', 'Delivery', 'AssetLibrary', 'Phase', 'Ticket', 'AssetS
hotConnection', 'ClientUser', 'TankContainer', 'RvLicense', 'PerformerRoutineConnection', 'Element', 'PermissionRuleSet'
, 'Blendshape', 'GroupUserConnection', 'AssetSequenceConnection', 'Page', 'TankPublishedFile', 'Sequence', 'TankDependen
cy', 'Scene', 'PerformerMocapTakeConnection', 'RevisionRevisionConnection']

>>> len(sg.schema_entity_read().keys())
99

Quand je l'ai compté, il a renvoyé "99", mais si le nom de l'entité se termine par "Connection", c'est pour lier des entités, vous pouvez donc l'ignorer. Le nombre d'entités de type Connexion et "Entité personnalisée" varie en fonction de la façon dont ils sont utilisés, le nombre de 99 entités ici n'est donc pas fixe.

Si vous téléchargez une image ou une vidéo dans l'entité Versions, vous pouvez la visualiser dans l'application multimédia.

find La méthode la plus basique à utiliser pour les requêtes est la recherche. Si vous voulez vérifier les versions pour le moment sans penser aux filtres, etc., vous pouvez écrire comme ceci

sg.find('Version',[],[])

Cependant, je pense que vous devriez arrêter de faire cette enquête. Si vous ne filtrez rien, toutes les ** versions, y compris le ** exemple de projet, seront la cible, il faudra donc un certain temps pour l'obtenir. En utilisation réelle, il est préférable d'utiliser au moins un filtre qui limite le projet. Dans cet article, nous examinerons comment filtrer, y compris cette zone.

find_one Étant donné qu'un grand nombre de résultats seront renvoyés sans filtre, passez à la méthode ** find_one ** qui ne renvoie qu'un seul résultat. Tout en utilisant cela, réfléchissons à la façon de filtrer.

>>> sg.find_one('Version',[],[])
{'type': 'Version', 'id': 2}

Pour find et find_one, le troisième argument est "** champ ** que vous souhaitez inclure dans la valeur de retour". Si rien n'est spécifié, seuls le type et l'ID seront renvoyés, comme dans l'exemple de phrase ci-dessus.

schema_field_read() Utilisez la méthode schema_field_read () pour voir les champs de l'entité. Ici, nous voulons savoir quels sont les champs de l'entité "Version", donc Se sentir comme ça sg.schema_field_read('Version').keys()

• Cette méthode renvoie également diverses informations, utilisez donc ** clés ** pour obtenir uniquement le nom du champ pour le moment.

>>> sg.schema_field_read('Version').keys()
['sg_version_type', 'open_notes_count', 'code', 'playlists', 'sg_task', 'image', 'updated_at', 'sg_uploaded_movie_frame_
rate', 'sg_path_to_frames', 'tasks', 'sg_department', 'frame_range', 'client_approved', 'id', 'updated_by', 'sg_path_to_
movie', 'sg_uploaded_movie_webm', 'open_notes', 'client_approved_at', 'cached_display_name', 'task_template', 'created_b
y', 'sg_status_list', 'notes', 'sg_frames_aspect_ratio', 'sg_first_frame', 'sg_frames_have_slate', 'sg_uploaded_movie_mp
4', 'description', 'sg_uploaded_movie_image', 'media_center_import_time', 'viewed_by_current_user_at', 'client_code', 's
g_movie_has_slate', 'sg_uploaded_movie', 'user', 'entity', 'published_files', 'step_0', 'sg_last_frame', 'viewed_by_curr
ent_user', 'sg_uploaded_movie_transcoding_status', 'sg_movie_aspect_ratio', 'created_at', 'client_approved_by', 'project
', 'filmstrip_image', 'tag_list', 'frame_count', 'flagged']

À propos, l'entité Version a autant de champs que l'entité Shot. (La version est "50" et le coup est "63". Il semble qu'il augmentera ou diminuera avec la mise à niveau de la version du fusil lui-même)

Essayez de filtrer par "projet"

Disons que vous avez une politique de "filtrons par projet!".

Trouver

Commençons par vérifier comment les informations du projet sont écrites dans le champ du projet. En utilisant find_one de plus tôt, je vais faire une enquête comme celle-ci.

sg.find_one('Version',[],['project'])

Puis

>>> sg.find_one('Version',[],['project'])
{'project': {'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}, 'type': 'Version', 'id': 2}

J'ai trouvé que le champ du projet était rempli de données de projet sous la forme "{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}".

• Big Buck Bunny est un projet produit par blender et publié sous Creative Commons. Divers sont enregistrés comme exemples de projets dans Shotgun.

Si vous passez ceci au deuxième argument de la méthode find, Vous devriez pouvoir demander ** "La version qui appartient au projet XX" **.

Essayez-le 1 (erreur courante)

Il est temps d'obtenir tous les résultats, donc je reviens à la recherche normale au lieu de find_one. En utilisant les informations de projet obtenues précédemment comme filtre, écrivez-le comme ceci.

sg.find('Version',[{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}],[])

>>> sg.find('Version',[{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}],[])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\～～\site-packages\shotgun_api3\shotgun.py", line 606, in find
    filters = _translate_filters(filters, filter_operator)
  File "C:\Users\～～\site-packages\shotgun_api3\shotgun.py", line 2646, in _translate_filters
    return _translate_filters_dict(wrapped_filters)
  File "C:\Users\～～\site-packages\shotgun_api3\shotgun.py", line 2662, in _translate_filters_dict
    new_filters["conditions"] = _translate_filters_list(sg_filter["filters"])
  File "C:\Users\～～\site-packages\shotgun_api3\shotgun.py", line 2673, in _translate_filters_list
    conditions.append(_translate_filters_dict(sg_filter))
  File "C:\Users\～～\site-packages\shotgun_api3\shotgun.py", line 2657, in _translate_filters_dict
    raise ShotgunError("Invalid filter_operator %s" % filter_operator)
shotgun_api3.shotgun.ShotgunError: Invalid filter_operator None

Même si vous le piquez simplement dans le filtre, vous obtiendrez une erreur comme celle-ci. Les filtres ont une manière unique d'écrire.

Comment écrire un filtre

Comment écrire un filtre est officiellement résumé ici

Reference: Filter Syntax https://github.com/shotgunsoftware/python-api/wiki/Reference:-Filter-Syntax

Vous pouvez spécifier plusieurs filtres à la fois. Un filtre sera une liste de configurations comme indiqué ci-dessous

['{Champ}', 'Relation', 'Valeur']

** Field ** est le champ que vous souhaitez utiliser pour le tri, que vous avez obtenu précédemment avec schema_field_read. Ici, c'est "projet". (Vous pouvez cliquer avec le bouton droit de la souris sur la colonne Shotgun (Web) et sélectionner «Configurer le champ ...» au lieu de schema_field_read.)

** Relation ** contrôle le comportement des filtres tels que "renvoie ce qui correspond à ..." et "renvoie ce qui ne correspond pas". Il y a "est", "n'est_pas", "contient", "entre" ... et ainsi de suite. Ici, nous utilisons «est».

** Valeur ** est la valeur utilisée pour la recherche. Ici, il existe différents types pour chaque ** type ** du champ. J'écrirai après avoir obtenu un exemple avec find_one.

Cette liste avec 3 éléments devient un filtre, et la ** double liste ** qui en combine plusieurs devient la notation de filtre.

** Les listes uniques ** ne sont autorisées que s'il n'y a pas de filtre Même si vous pensez "spécifier un seul filtre", vous devez faire une double liste. (Il existe également une manière plus compliquée de spécifier)

Le filtre ressemble cette fois à ceci.

[['project','is',{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}]]

Essayez 2 (limitez le montant retourné)

sg.find('Version',[['project','is',{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}]],[])

… En fait, un nombre considérable de versions sont enregistrées dans l'exemple de projet «Big Buck Bunny». Vous pouvez spécifier la quantité de la valeur de retour avec l'argument limit.

sg.find('Version',[['project','is',{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}]],[],limit=10)

>>> sg.find('Version',[['project','is',{'type': 'Project', 'id': 65, 'name': 'Big Buck Bunny'}]],[],limit=10)
[{'type': 'Version', 'id': 2}, {'type': 'Version', 'id': 3}, {'type': 'Version', 'id': 4}, {'type': 'Version', 'id': 5},
 {'type': 'Version', 'id': 6}, {'type': 'Version', 'id': 7}, {'type': 'Version', 'id': 8}, {'type': 'Version', 'id': 9},
 {'type': 'Version', 'id': 10}, {'type': 'Version', 'id': 11}]

C'est dommage, mais pour le filtre du projet. Ici, j'ai utilisé celui obtenu par find_one tel quel comme valeur, En fait, il peut être utilisé pour ** filtrer sans ** 'nom'.

>> sg.find('Version',[['project','is',{'type': 'Project', 'id': 65}]],[],limit=10)
{'type': 'Version', 'id': 2}, {'type': 'Version', 'id': 3}, {'type': 'Version', 'id': 4}, {'type': 'Version', 'id': 5},
{'type': 'Version', 'id': 6}, {'type': 'Version', 'id': 7}, {'type': 'Version', 'id': 8}, {'type': 'Version', 'id': 9},
{'type': 'Version', 'id': 10}, {'type': 'Version', 'id': 11}]

Essayez-le 3 (Obtenez uniquement la version jointe à Shot)

Ajoutez quelque chose comme ce qui suit au filtre précédent.

['entity','type_is','Shot']

Maintenant, la version dans laquelle la colonne "lien" dans Shotgun (web) est liée au plan, = Vous ne pouvez obtenir que la version pour la photo.

>>> sg.find('Version',[['project','is',{'type': 'Project', 'id': 65}],['entity','type_is','Shot']],['entity'],limit=10)
[{'type': 'Version', 'id': 2, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id'
: 3, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id': 4, 'entity': {'type': '
Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id': 5, 'entity': {'type': 'Shot', 'id': 860, 'name':
 'bunny_010_0010'}}, {'type': 'Version', 'id': 6, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'ty
pe': 'Version', 'id': 7, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id': 8,
'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id': 9, 'entity': {'type': 'Shot'
, 'id': 860, 'name': 'bunny_010_0010'}}, {'type': 'Version', 'id': 10, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bu
nny_010_0010'}}, {'type': 'Version', 'id': 11, 'entity': {'type': 'Shot', 'id': 860, 'name': 'bunny_010_0010'}}]

Ceci est la version pour Asset

>>> sg.find('Version',[['project','is',{'type': 'Project', 'id': 65}],['entity','type_is','Asset']],['entity'],limit=10)

[{'type': 'Version', 'id': 6002, 'entity': {'type': 'Asset', 'id': 726, 'name': 'Buck'}}]

• J'ai essayé de regrouper les versions par type de lien.

Résumé

S'agit-il d'une version d'un actif?