L’un des sujets les plus fréquents qui revient lorsqu’on visite des studios ou qu’on discute de la conception d’un pipeline avec des artistes CG, c’est la hiérarchie des fichiers. Bien que les structures de dossiers puissent sembler simples, créer une hiérarchie scalable et maintenable nécessite une planification minutieuse.
Nous avons déjà abordé la conception de la hiérarchie des fichiers dans un article précédent ; ainsi, plutôt que de parler de théorie, ce tutoriel se concentre sur la mise en œuvre. Vous allez apprendre comment utiliser l’API Kitsu et son client Python, Gazu, pour générer automatiquement une structure de production, créer des tâches et construire un arbre complet des fichiers.
Commençons par notre premier tutoriel d’automatisation de pipeline.
Étape 1 : Configurer l’API Kitsu
Avant d’exécuter les exemples de ce tutoriel, assurez-vous que vous avez une instance Kitsu fonctionnelle qui tourne sur un serveur accessible depuis votre réseau local.
Si vous souhaitez démarrer rapidement, vous pouvez lancer le serveur avec Docker :
docker build -t cgwire .
docker run
-ti --rm
-p 80:80
--name cgwire
-v zou-storage:/var/lib/postgresql
-v zou-storage:/opt/zou/zou/thumbnails
cgwire
Pour le reste de ce tutoriel, nous supposerons que l’API est disponible à l’adresse :
http://localhost/apiInstaller le client Python
Installez le client Python Gazu :
pip install gazu
Se connecter à l’API
Créez un nouveau fichier appelé build_file_tree.py et ajoutez le code suivant :
import gazu
gazu.set_host("http://localhost/api") gazu.log_in("admin@example.com", "default")
À ce stade, votre script est connecté à l’API Kitsu et prêt à créer des données de production.
Étape 2 : Créer des assets et des plans
Ensuite, créez une production d’exemple contenant quelques assets et plans.
new_prod = gazu.project.new_project("Super Production")characters = gazu.asset.new_asset_type("Characters") props = gazu.asset.new_asset_type("Props")
rabbit = gazu.asset.new_asset(new_prod, characters, "Rabbit") monkey = gazu.asset.new_asset(new_prod, characters, "Monkey") chair = gazu.asset.new_asset(new_prod, props, "Chair")
episode = gazu.shot.new_episode(new_prod, "E01") sequence = gazu.shot.new_sequence(new_prod, episode, "SE01")
gazu.shot.new_shot(new_prod, sequence, "SH01") gazu.shot.new_shot(new_prod, sequence, "SH02") gazu.shot.new_shot(new_prod, sequence, "SH03")
Ce script crée :
- Un projet : Super Production
- Trois assets : Rabbit, Monkey et Chair
- Un épisode et une séquence
- Trois plans : SH01, SH02 et SH03
Étape 3 : Créer des tâches
Une fois la structure de production en place, créez les tâches sur lesquelles les artistes vont travailler.
modeling = gazu.task.get_task_type_by_name("Modeling") setup = gazu.task.get_task_type_by_name("Setup") animation = gazu.task.get_task_type_by_name("Animation") render = gazu.task.get_task_type_by_name("Render")for asset in gazu.asset.all_assets_for_project(new_prod): gazu.task.new_task(asset, modeling) gazu.task.new_task(asset, setup)
for shot in gazu.shot.all_shots_for_project(new_prod): gazu.task.new_task(shot, animation) gazu.task.new_task(shot, render)
Ce qui crée :
Tâches pour les assets
- Modeling
- Setup
Tâches pour les plans
- Animation
- Render
Chaque asset et chaque plan disposent désormais de la structure de tâches nécessaire au travail de production.
Étape 4 : Générer la hiérarchie des fichiers
Une fois les projets, les assets, les plans et les tâches créés, vous pouvez générer la structure de dossiers correspondante.
import osgazu.files.set_project_file_tree(new_prod, "simple")
for asset in gazu.asset.all_assets_for_project(new_prod): for task in gazu.task.all_tasks_for_asset(asset): path = os.path.dirname( gazu.files.build_working_file_path(task) )1: os.makedirs(path, exist_ok=True)
for shot in gazu.shot.all_shots_for_project(new_prod): for task in gazu.task.all_tasks_for_shot(shot): path = os.path.dirname( gazu.files.build_working_file_path(task) )1: os.makedirs(path, exist_ok=True)
Ce que fait ce script
- Applique le modèle d’arborescence de fichiers
simple - Génère des chemins de fichiers pour chaque tâche
- Crée automatiquement les répertoires nécessaires
- Garantit une structure cohérente sur toute la production
Structure de dossiers obtenue
En lançant le script, vous obtenez l’arborescence de dossiers suivante :
my_root_folder/
└── productions
└── super_production
├── assets
│ ├── characters
│ │ ├── monkey
│ │ │ ├── modeling
│ │ │ └── setup
│ │ └── rabbit
│ │ ├── modeling
│ │ └── setup
│ └── props
│ └── chair
│ ├── modeling
│ └── setup
└── shots
└── se01
├── sh01
│ ├── animation
│ └── render
├── sh02
│ ├── animation
│ └── render
└── sh03
├── animation
└── render
Personnaliser la structure de dossiers
La hiérarchie générée est contrôlée par un modèle. Vous pouvez la personnaliser afin de correspondre aux exigences du pipeline de votre studio.
Exemple de modèle :
{
"working": {
"mountpoint": "/my_root_folder",
"root": "productions",
"folder_path": {
"shot": "<Project>/shots/<Sequence>/<Shot>/<TaskType>",
"asset": "<Project>/assets/<AssetType>/<Asset>/<TaskType>"
}
}
}
En modifiant ces chemins, vous pouvez adapter la hiérarchie à n’importe quel workflow de production sans changer vos scripts d’automatisation.
Pourquoi automatiser la création de la hiérarchie des fichiers ?
Créer manuellement les dossiers est gérable pour un petit projet de test, mais cela devient rapidement source d’erreurs à mesure que les productions grandissent.
Utiliser l’API Kitsu vous permet de :
- Créer des projets par programmation
- Standardiser les structures de dossiers entre les équipes
- Supprimer les erreurs de configuration manuelle
- Passer à l’échelle avec des milliers d’assets et de plans
- Centraliser et maintenir la configuration du pipeline
Avec quelques lignes de Python seulement, vous pouvez générer à la fois les données de production et la structure de fichiers correspondante, offrant aux artistes un environnement cohérent dès le premier jour.
Si vous êtes intéressé par les pipelines CG, la gestion de production et l’automatisation des workflows, assurez-vous d’explorer nos autres articles !
