[PYTHON] Überlegen Sie, wie Sie einen Filter mit den Shotgun API-Contact-Versionen schreiben

Was ist das?

Ich möchte die Shotgun-API verwenden, um Informationen über die Entität "Versionen" zu erhalten.

Annahme

Basierend auf dem bisherigen Durchfluss http://qiita.com/it_ks/items/e026f61fb8c3683ac035

--Shotgun API wurde in der Python-Umgebung installiert

• Erstellt Skriptbenutzer auf Shotgun

Ich möchte von diesem Punkt aus beginnen.

Versionsentität

In Bezug auf Shotgun werden die Ergebnisse (Videos / Bilder, einschließlich der Mitte), die beim Empfang von Bewertungen oder bei der Meldung von Fortschritten an Kunden eingereicht werden, als "Versionen" bezeichnet. (Übrigens bleibt das Trennzeichen, das der Arbeiter in die entsprechende Arbeitsphase setzt, unter dem Namen "Schnappschuss" erhalten.) Ersteres wird durch Hochladen in die Cloud verwaltet / freigegeben, letzteres gehört jedoch zur Kategorie der Mitarbeiter oder liegt im Ermessen der Mitarbeiter.

--Überprüfen Sie target version = "version" = to cloud --In-Worker-Version = "Schnappschuss" = auf Hand beschränkt

Eine Entität ist eine Datentabelle für Shotgun. Es stehen verschiedene Typen wie Shot, Asset und Task zur Verfügung, und Version ist einer davon.

Verwenden Sie die Methode schema_entity_read (), wenn Sie eine Entität untersuchen.

>>> 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

Wenn ich es gezählt habe, gab es "99" zurück, aber wenn der Entitätsname mit "Verbindung" endet, dient er zum Verknüpfen der Entitäten, sodass Sie ihn ignorieren können. Da die Anzahl der Entitäten vom Verbindungstyp und "Benutzerdefinierte Entität" abhängig von ihrer Verwendung variiert, ist die Anzahl von 99 Entitäten hier nicht festgelegt.

Wenn Sie ein Bild oder Video in die Version-Entität hochladen, können Sie es in der Medien-App anzeigen.

find Die grundlegendste Methode für Abfragen ist find. Wenn Sie vorerst Versionen überprüfen möchten, ohne an Filter usw. zu denken, können Sie so schreiben

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

Ich denke jedoch, Sie sollten aufhören, diese Anfrage zu stellen. Wenn Sie nichts filtern, werden alle ** Versionen einschließlich des ** Beispielprojekts als Ziel ausgewählt. Es wird also einige Zeit dauern, bis Sie es erhalten. Bei der tatsächlichen Verwendung ist es am besten, mindestens einen Filter zu verwenden, der das Projekt einschränkt. In diesem Artikel werden wir uns mit dem Filtern einschließlich dieses Bereichs befassen.

find_one Da eine große Anzahl von Ergebnissen ohne Filter zurückgegeben wird, wechseln Sie zur Methode ** find_one **, die nur ein Ergebnis zurückgibt. Lassen Sie uns dabei überlegen, wie Sie filtern.

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

Sowohl für find als auch für find_one lautet das dritte Argument "** Feld **, das Sie in den Rückgabewert aufnehmen möchten". Wenn nichts angegeben ist, werden nur Typ und ID zurückgegeben, wie im obigen Beispielsatz.

schema_field_read() Verwenden Sie die Methode schema_field_read (), um zu sehen, über welche Felder die Entität verfügt. Hier wollen wir herausfinden, welche Felder die Entität "Version" hat Ich fühle mich so sg.schema_field_read('Version').keys()

• Diese Methode gibt auch verschiedene Informationen zurück. Verwenden Sie daher ** Schlüssel **, um vorerst nur den Feldnamen abzurufen.

>>> 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']

Übrigens hat die Version-Entität so viele Felder wie die Shot-Entität. (Die Version ist "50" und der Schuss ist "63". Es scheint, dass die Anzahl zunimmt oder abnimmt, wenn die Schrotflinte selbst aktualisiert wird.)

Versuchen Sie, nach "Projekt" zu filtern.

Angenommen, Sie haben die Richtlinie "Filtern nach Projekt!".

Rausfinden

Lassen Sie uns zunächst überprüfen, wie die Projektinformationen in das Projektfeld geschrieben werden. Mit find_one von früher werde ich eine solche Anfrage stellen.

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

Dann

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

Ich fand heraus, dass das Projektfeld mit Projektdaten in der Form "{'Typ': 'Projekt', 'ID': 65, 'Name': 'Big Buck Bunny'}" gefüllt war.

• Big Buck Bunny ist ein Projekt, das von Blender produziert und als Creative Commons veröffentlicht wurde. Verschiedene sind als Beispielprojekte in Shotgun registriert.

Wenn Sie dies an das zweite Argument der find-Methode übergeben, Sie sollten in der Lage sein, ** "Die Version, die zum XX-Projekt gehört" ** abzufragen.

Versuchen Sie es 1 (häufiger Fehler)

Es ist Zeit, alle Ergebnisse zu erhalten, also gehe ich zurück zum normalen Suchen anstelle von find_one. Schreiben Sie die zuvor erhaltenen Projektinformationen als Filter.

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

Selbst wenn Sie es nur in den Filter stecken, wird eine solche Fehlermeldung angezeigt. Filter haben eine einzigartige Schreibweise.

Wie schreibe ich einen Filter?

Wie man einen Filter schreibt, wird hier offiziell zusammengefasst

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

Sie können mehrere Filter gleichzeitig angeben. Ein Filter ist eine Liste von Konfigurationen, wie unten gezeigt

['{Field}', 'Relation', 'Value']

** Feld ** ist das Feld, das Sie zum Sortieren verwenden möchten, das Sie zuvor mit schema_field_read erhalten haben. Hier ist es "Projekt". (Sie können mit der rechten Maustaste auf die Spalte in Shotgun (Web) klicken und "Feld konfigurieren ..." anstelle von "schema_field_read" auswählen.)

** Beziehung ** steuert das Verhalten von Filtern wie "gibt zurück, was entspricht ..." und "gibt zurück, was nicht entspricht". Es gibt 'is', 'is_not', 'enthält', 'zwischen' ... und so weiter. Hier benutzen wir 'is'.

** Wert ** ist der Wert, der für die Suche verwendet wird. Hier gibt es verschiedene Typen für jeden ** Typ ** des Feldes. Ich werde schreiben, nachdem ich ein Beispiel mit find_one bekommen habe.

Diese Liste mit 3 Elementen wird zu einem Filter, und die ** Doppelliste **, die mehrere davon kombiniert, wird zur Filternotation.

** Einzelne ** Listen sind nur zulässig, wenn kein Filter vorhanden ist Selbst wenn Sie denken, "nur einen Filter angeben", müssen Sie eine Doppelliste erstellen. (Es gibt auch eine kompliziertere Art der Angabe)

Der Filter sieht diesmal so aus.

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

Probieren Sie es aus 2 (Begrenzen Sie den zurückgegebenen Betrag)

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

… Tatsächlich ist im Beispielprojekt „Big Buck Bunny“ eine beträchtliche Anzahl von Versionen registriert. Sie können die Menge des Rückgabewerts mit dem Argument limit angeben.

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}]

Es ist eine Schande, aber über den Projektfilter. Hier wurde vorerst die von find_one erhaltene als Wert verwendet, Tatsächlich kann es zum ** Filtern ohne ** 'Name' verwendet werden.

>> 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}]

Probieren Sie es aus 3 (Holen Sie sich nur die an Shot angehängte Version)

Fügen Sie dem vorherigen Filter Folgendes hinzu.

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

Nun ist die Version, in der die Spalte "Link" in Shotgun (Web) mit dem Schuss verknüpft ist, = Sie können nur die Version für den Schuss erhalten.

>>> 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'}}]

Dies ist die Version für 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'}}]

• Ich habe versucht, die Versionen nach Link-Typ zu gruppieren.

Zusammenfassung

Ist es eine Version eines Assets?