VoltaDynaBim

[Dynamo + Python] Revit 2027 : HVAC Zone → GenericZone (Migration API)

2026-09-30T12:33:33.776+02:00

Comment retrouver les zones systèmes (ex CVC) qui sont attachées aux espaces avec Revit 2027

#DynamoBIM #Revit #Python #RevitAPI #GenericZone #Revit API 2027 #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

Les Zones Système (GenericZones) viennent remplacer les Zones HVAC .

Sur des projets existants, elles sont désormais automatiquement converties lors de l’ouverture des projets Revit 2027.

Parmi les changements notables :

les HVAC Zones deviennent obsolètes
Les espaces MEP peuvent être situés dans plusieurs zones.
Les zones dépendent d'un seul niveau (impossibilité de créer une zone sur plusieurs niveaux).
Les zones peuvent être :

soit attaché aux espaces
soit basées sur une esquisse

Les Zones Système (GenericZones) sont des zones analytiques.

Il en résulte plusieurs modifications dans l'API

Migration / Item	Details
Propriété et BIC dépréciés	`Autodesk.Revit.DB.Mechanical.Space.Zone`, `BuiltInCategory:OST_HVAC_Zones`
a utilisé en remplacement	`GenericZone` + `GetSpaceIds()`

Voici un exemple qui combine deux méthodes pour retrouver les espaces, tout en stockant le tout dans une Datatable pour faire une recherche rapide par ElementId via Select()

1. Zones basées sur des espaces

La méthode la plus rapide consiste à utiliser :

spaceIds = genericZone.GetSpaceIds()

Chaque ElementId correspond à un espace associé à la zone.

2. Zones basées sur une esquisse

Les zones créées à partir d'un contour ne possèdent pas d'association directe avec les espaces.

L'alternative consiste à :

récupérer le polygone de la zone

récupérer le point de calcul de chaque espace et vérifier si ce dernier est dans le polygone (avec l'API Dynamo Polygon.ContainmentTest() )


import clr
import System
from System.Collections.Generic import List
from System.Linq import Enumerable
from System.Collections.Generic import IEnumerable

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
import Autodesk.DesignScript.Geometry as DS

clr.AddReference('RevitAPI')
import Autodesk
import Autodesk.Revit.DB as DB
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Analysis import *

clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)

clr.AddReference('RevitNodes')
import Revit
clr.ImportExtensions(Revit.Elements)
clr.ImportExtensions(Revit.GeometryConversion)
clr.ImportExtensions(Revit.GeometryReferences)

clr.AddReference('System.Data')
from System.Data import *

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)


import traceback
input_space = UnwrapElement(IN[0])

fecSpace = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_MEPSpaces).WhereElementIsNotElementType().ToElements()

def get_ZoneGetSpaceIds(zone):
    try:
        if zone.GeometricDefinition == ZoneGeometricDefinition.Spaces:
            return zone.GetSpaceIds()
        else:
            zone_sketch = doc.GetElement(zone.GetSketchId())
            profile : DB.CurveArrArray = zone_sketch.Profile
            zone_polygon = DS.Polygon.ByPoints([c.GetEndPoint(0).ToPoint() for c in profile[0]])
            level1Filter = ElementLevelFilter(zone.LevelId)
            fecLvlSpaceId = (
                FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_MEPSpaces).WhereElementIsNotElementType().WherePasses(level1Filter)
                .Where(System.Func[System.Object, System.Boolean](lambda space: space.Area > 0 and isinstance(space.Location, DB.LocationPoint)) )
                .Where(System.Func[System.Object, System.Boolean](lambda space: zone_polygon.ContainmentTest(space.Location.Point.ToPoint() ) ))
                .Select[System.Object, DB.ElementId](System.Func[System.Object, DB.ElementId](lambda x: x.Id))
                .ToList()
            )
            return fecLvlSpaceId
    except Exception as ex:
        print(traceback.format_exc())
        return List[ElementId]()

if sdkNumber < 2027:
    OUT = [[s.Name , s.Zone.Name ] for s in fecSpace]
else:
    # Global variable DataTable                                
    dt_zone = DataTable("GZone")
    dt_zone.Columns.Add('SpaceId', DB.ElementId)
    dt_zone.Columns.Add('SpaceIdValue', System.Int64)
    dt_zone.Columns.Add('Zone', DB.Analysis.GenericZone)     
    dt_zone.Columns.Add('ZoneName', System.String)  
    #
    dt_zone.BeginLoadData()
    lst_zones = (
                FilteredElementCollector(doc).OfClass(GenericZone)
                .SelectMany[DB.Element, DB.ElementId, DataRow](
                                                System.Func[DB.Element, IEnumerable[DB.ElementId]](lambda z : get_ZoneGetSpaceIds(z) ),
                                                System.Func[DB.Element, DB.ElementId, DataRow](lambda z, space_id : dt_zone.Rows.Add(space_id, space_id.Value, z, z.Name)
                                                ))
                .ToList()
    )
    
    dt_zone.EndLoadData()
    #
    #OUT = [[s.Name , dt_zone.Select(f"[SpaceIdValue] = '{s.Id.Value}'").Cast[DataRow]().FirstOrDefault() ] for s in fecSpace]
    # 
    out = []
    for s in fecSpace:
        dataRow_spaces = dt_zone.Select(f"[SpaceIdValue] = '{s.Id.Value}'").Cast[DataRow]()#.FirstOrDefault() 
        if dataRow_spaces is not None:
            out.append([s.Name, [r['ZoneName'] for r in dataRow_spaces] ])
            
    if input_space is not None:
        dataRow_spaces = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}'").Cast[DataRow]()
        print(len(list(dataRow_spaces)))
        dataRow_ZDM = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}' AND [ZoneName] Like '%ZDM%'").Cast[DataRow]().FirstOrDefault() 
        dataRow_ZDA = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}' AND [ZoneName] Like '%ZDA%'").Cast[DataRow]().FirstOrDefault() 
        if dataRow_spaces is not None:
            out.insert(0, [
                            input_space.Name, 
                            [r['ZoneName'] for r in dataRow_spaces], 
                            dataRow_ZDM['ZoneName'] if dataRow_ZDM is not None else None,
                            dataRow_ZDA['ZoneName'] if dataRow_ZDA is not None else None
                        ])
    OUT = out

. .

« Ce n’est pas que nous ayons peu de temps, c’est que nous en perdons beaucoup. »
Sénèque

...

[Dynamo += Python] Export IFC : configurations Utilisateur (MAJ 05/09/2026)

2026-09-04T23:50:00.000+02:00

Une astuce pour obtenir les données des configurations d'Export IFC

#DynamoBIM #Revit #Python #RevitAPI #IFC #ConfigurationIFC #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

MAJ 05/09/2026 : Mise à jour pour Revit 2027

Dans le présent article, depuis Revit, nous cherchons à récupérer les données des configurations utilisateur d'export IFC.

Le but étant de permettre un export IFC depuis Dynamo suivant une configuration précise sans avoir à faire un export-import de celle-ci (au format json)

Le code Python



import clr
import sys
import System

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import *
from Autodesk.Revit.DB.IFC import *


clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)


IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    print("pass1")
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication

import json

ifc_dict_config = {}
if IFCExportConfigurationsMap is not None:
    idfdocA = IFCCommandOverrideApplication.TheDocument
    if idfdocA is None:
        propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
        propinfo.SetValue(None, doc)
    configurationsMap = IFCExportConfigurationsMap(doc)
    configurationsMap.AddBuiltInConfigurations()
    configurationsMap.AddSavedConfigurations({})
    
    for config in configurationsMap.Values:
        dict_ifc_version_str = {"IFC_Version_str": config.IFCVersion.ToString() }
        dict_config = json.loads(config.SerializeConfigToJson())
        # merge dictionaries
        merge_dict_3 = dict(dict_ifc_version_str,**dict_config)
        ifc_dict_config[config.Name] = merge_dict_3
  
OUT = ifc_dict_config

Note 1

il existe 2 addin export IFC, celui de base (qui est livré d'origine avec Revit) et celui que l'on met à jour manuellement par la suite via le Repo Github d'Autodesk, ce dernier vient remplacer le 1er, mais ne partage pas le même dossier.

Il faut donc veiller à charger la bonne assembly (voir code ci dessus)

Note 2

Une petite explication concernant ces lignes


idfdocA = IFCCommandOverrideApplication.TheDocument
if idfdocA is None:
	propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
	propinfo.SetValue(None, doc)

Ces lignes de code effectuent une opération de réflexion (.NET Reflection) pour modifier dynamiquement la propriété TheDocument d'une instance de la classe IFCCommandOverrideApplication.

Le but de ces lignes est de s'assurer que l'application d'exportation IFC IFCCommandOverrideApplication est configurée pour utiliser le document Revit actuel (doc) comme contexte pour l'exportation. Cela peut être nécessaire si l'application d'exportation IFC n'est pas automatiquement configurée pour utiliser le bon document Revit ou si vous devez réaffecter explicitement le document cible pour l'exportation dans des scénarios spécifiques.

Résultat

Export IFC à partir des valeurs d'une configuration

Vous pouvez ensuite compléter le script dynamo en rajoutant par exemple le nœud Export IFC du package GeniusLoci

Export IFC direct à partir d'un IFCExportConfiguration

Une autre solution consiste de transférer les valeurs une instance d'un IFCExportConfiguration vers une instance IFCExportOptions avec la méthode

Void UpdateOptions(Autodesk.Revit.DB.IFCExportOptions, Autodesk.Revit.DB.ElementId)

CODE 1 (extraction des configurations)


import clr
import sys
import System

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import *
from Autodesk.Revit.DB.IFC import *


clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)


IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    print("pass1")
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication

import json

ifc_dict_config = {}
if IFCExportConfigurationsMap is not None:
    idfdocA = IFCCommandOverrideApplication.TheDocument
    if idfdocA is None:
        propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
        propinfo.SetValue(None, doc)
    configurationsMap = IFCExportConfigurationsMap(doc)
    configurationsMap.AddBuiltInConfigurations()
    configurationsMap.AddSavedConfigurations({})
    
    for config in configurationsMap.Values:
        dict_ifc_version_str = {"IFC_Version_str": config.IFCVersion.ToString() }
        dict_config = json.loads(config.SerializeConfigToJson())
        # merge dictionaries
        merge_dict_3 = dict(dict_ifc_version_str,**dict_config)
        ifc_dict_config[config.Name] = merge_dict_3
  
OUT = ifc_dict_config

CODE 2 (Export IFC)

Actuellement (sous Pythonnet3 + Revit 2027.1 ) une erreur se produit avec Document.Export(String, String, IFCExportOptions) , une solution de contournement consiste à utiliser la Reflection.


import clr
import sys
import System
from System.Collections.Generic import *

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *


clr.AddReference("System.Reflection")
from System.Reflection import BindingFlags

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import*
from Autodesk.Revit.DB.IFC import*

# Import DocumentManager and TransactionManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application
uidoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument
sdkNumber = int(app.VersionNumber)

IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("Revit.IFC.Common")
        from Revit.IFC.Common.Extensions import IFCClassificationMgr
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
        
        
def exportIfc(current_doc, pathfolder, name, ifcExportConfig, view3DId=ElementId.InvalidElementId):
    global error
    #
    if name.endswith(".rvt"):
        name = name.replace(".rvt", ".ifc")
    #
    #When using transactions with documents other than the primary document,better luck creating transactions from scratch.
    TransactionManager.Instance.ForceCloseTransaction()
    # define options
    options = IFCExportOptions()
    if ifcExportConfig is not None :
        #Define the of a 3d view to export
        
        # copy settings of the myIFCExportConfiguration to the IFCExportOptions
        if sdkNumber < 2027:
            exportViewId = ElementId.InvalidElementId # or None -> add view in options
            ifcExportConfig.UpdateOptions(options, exportViewId)
        else:
            # Revit 2027 and above
            if view3DId == ElementId.InvalidElementId:
                ifcExportConfig.UseActiveViewGeometry = False
                ifcExportConfig.VisibleElementsOfCurrentView = False
            else:
                ifcExportConfig.VisibleElementsOfCurrentView = True
                ifcExportConfig.ActiveViewId = view3DId
            #
            if ifcExportConfig.ExportUserDefinedPsets:
                userDefinedPsetsFileName = System.IO.Path.GetFileName(ifcExportConfig.ExportUserDefinedPsetsFileName)
                ifcExportConfig.ExportUserDefinedPsetsFileName = System.IO.Path.Combine(pathfolder, userDefinedPsetsFileName)
            #
            if ifcExportConfig.ExportUserDefinedPsets:
                userDefinedParameterMappingFileName = System.IO.Path.GetFileName(ifcExportConfig.ExportUserDefinedParameterMappingFileName)
                ifcExportConfig.ExportUserDefinedParameterMappingFileName = System.IO.Path.Combine(pathfolder, userDefinedParameterMappingFileName)
                
            ifcExportConfig.UpdateOptions(current_doc, options, view3DId, False)
            # call this before the Export IFC transaction starts, as it has its own transaction.
            IFCClassificationMgr.DeleteObsoleteSchemas(current_doc)
    
    #
    t = Transaction(current_doc, 'Export IFC')
    t.Start()
    failureOptions = t.GetFailureHandlingOptions()
    failureOptions.SetClearAfterRollback(False)
    t.SetFailureHandlingOptions(failureOptions)
    #
    try:
        #
        current_doc.Regenerate()
        result = current_doc.GetType().InvokeMember("Export", BindingFlags.InvokeMethod , None, current_doc, (pathfolder, name, options) )
    except Exception as ex:
        print(ex)
        t.RollBack()
        t.Dispose()
        return 0
    else:
        t.RollBack() # instead of t.Dispose()
        t.Dispose()
        return pathfolder + '\\' + name
        
        
ifc_config_map = IN[0]
pathfolder = IN[1]
name = IN[2]
ifc_config_name = IN[3]

ifcExportConfig = ifc_config_map[ifc_config_name]

exportIfc(doc, pathfolder, name, ifcExportConfig)

Le monde se divise en deux catégories......
NWC VS IFC
Close VS Open
sans hôte VS hôte par face
Modèle Générique VS Site
Etc...

La meilleure, c'est celle qui fait avancer le projet…

[Dynamo += Python] Compilation de librairies personalisé Python

2026-07-26T23:53:00.848+02:00

Compilation de code Python et l'utiliser dans Dynamo, c'est possible ?

#DynamoBIM #Python #pyc #pyd #compile #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

Si vous développez en Python, vous savez probablement que vous pouvez importer vos propres classes/modules Python sous forme de fichier py, mais savez-vous qu'il existe des fichiers pyc et pyd ?

Voyons cela.

1. Le classique : le module sous forme de fichier `.py`

Avantages :

Lisibilité absolue : C'est du texte brut, compréhensible par n'importe quel développeur (et éditable avec un simple bloc-notes)

Simplicité : aucun processus de compilation complexe n'est requis pour tester son code.
Débogage facile : en cas de plantage, pas besoin de recompiler.

Inconvénients :

Lenteur relative : le code doit être analysé et compilé en "bytecode" par l'interpréteur à chaque lancement (si aucun fichier .pyc n'est disponible).

Propriété intellectuelle : Si vous distribuez votre application sous forme de fichiers .py, n'importe qui peut lire votre code source (surtout si celui-ci contient des informations sensibles).

2. Le compilé bytecode : le module sous forme de fichier `.pyc`

Présentation

Le "c" signifie compiled (compilé). Lorsqu'un module .py est importé pour la première fois, Python le traduit dans un format intermédiaire appelé bytecode et le sauvegarde dans un fichier .pyc (généralement caché dans un dossier __pycache__). Le bytecode est une série d'instructions optimisées que la machine virtuelle Python (CPython) peut exécuter beaucoup plus rapidement que du texte brut.

Avantages :

Temps de chargement réduit : si vous utilisez des fichiers .py pour charger des modules personnalisés, vous pouvez les remplacer par des .pyc, ce qui accélère le démarrage du script.

Légère obfuscation : le code n'est plus en texte clair, ce qui offre une (très) mince couche de protection contre la lecture directe par un novice.

Inconvénients :

Dépendance à la version de Python : un fichier .pyc généré par Python 3.9 pourrait ne pas fonctionner sur Python 3.11.

Ce n'est pas de la vraie sécurité : Des outils de "décompilation" (comme uncompyle6 ou PyLingual) peuvent facilement recréer un fichier .py presque identique à partir d'un .pyc.

Comment le générer ?

Vous pouvez forcer la génération de fichiers .pyc pour tout un projet en utilisant le module intégré compileall.

Exemple de génération de fichier .pyc à partir d'un nœud Python Dynamo.

Ici on récupère le contenu du code Python d'un nœud et on le compile en .pyc directement depuis Dynamo.


import clr
import System
from System.Collections.Generic import List

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

# Add Revit API References
clr.AddReference('RevitAPI')
clr.AddReference("RevitServices")
clr.AddReference("RevitNodes")

import RevitServices
import Revit
clr.ImportExtensions(Revit.GeometryConversion)

import Autodesk
import Autodesk.Revit.DB as DB
from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

# Document reference
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument

clr.AddReference('DynamoRevitDS')
import Dynamo 
#reference dynamo core to update node values
clr.AddReference('DynamoCore')
from Dynamo.Graph import UpdateValueParams

#access to the current Dynamo instance and workspace
dynamoRevit = Dynamo.Applications.DynamoRevit()
engine = dynamoRevit.RevitDynamoModel.EngineController
currentWorkspace = dynamoRevit.RevitDynamoModel.CurrentWorkspace
model = dynamoRevit.RevitDynamoModel

import os

folder = IN[0]
name_pyc = IN[1]
py_path = f"{folder}\\{name_pyc}.py"
pyc_path = f"{folder}\\{name_pyc}.pyc"

nodeK = next((i for i in currentWorkspace.Nodes\
                if i.Name == "Python Script | Module1"), None)
code_py = nodeK.Script
code_py = code_py.replace("\r","")
with open(py_path, "w", encoding='utf-8') as f:
    f.write(code_py)

import py_compile
py_compile.compile(py_path, cfile=pyc_path)

os.remove(py_path)

OUT = folder

3. La DLL : Le fichier `.pyd`

Présentation

Le fichier .pyd est une bibliothèque de liens dynamiques (DLL) spécifique à Windows (son équivalent sous Linux/macOS est le fichier .so).

Ce n'est plus du Python : c'est du code compilé (généralement à partir de C, C++ ou Rust) qui a été empaqueté pour être importable directement dans un script Python comme n'importe quel autre module (ex: import mon_module_pyd).

Avantages :

Performances élevées : le code s'exécute à la vitesse du C. C'est idéal pour les calculs lourds, le traitement d'images ou l'intelligence artificielle.

Protection du code source : le code est compilé en langage machine. Il est extrêmement difficile (voire impossible sans ingénierie inverse lourde) de retrouver le code source d'origine.

Accès bas niveau : permet d'interagir directement avec le matériel ou des API système de manière très pointue.

Inconvénients :

Complexité de développement : il faut maîtriser d'autres langages (C/C++) et comprendre l'API C de Python.
Pour compiler en .pyd, il faut obligatoirement installer Python sur votre PC (même version que celle de Python dans Dynamo) ainsi que les Microsoft Visual C++ Build Tools

L'environnement Python intégré dans le nœud Dynamo est une version "allégée" et encapsulée, optimisée pour l'exécution. Elle ne contient pas de bibliothèques de développement.

Perte de portabilité : un .pyd compilé pour Windows 64 bits ne fonctionnera ni sur Windows 32 bits, ni sur Linux, ni sur macOS. Il faut recompiler le module pour chaque architecture et système d'exploitation cible.
Dépendance stricte à la version mineure de Python : un pyd compilé en 3.11 ne pourra pas être importé avec Python 3.12

Comment le générer ?

La création d'un .pyd est un processus de compilation. Voici les méthodes les plus courantes :

En utilisant Cython (à ne pas confondre avec CPython) : on écrit un code hybride Python/C (fichier .pyx), puis vous utilisez un script setup.py (via setuptools) pour le compiler en .pyd.

Note : dans le fichier pyx , vous pouvez utiliser le typage statique ( en utilisant le mot-clé cdef), cela accélérera la vitesse d'exécution.

En écrivant cdef int i ou cdef double x, vous donnez une instruction stricte au compilateur : "N'utilise pas un objet Python dynamique pour cette variable. Crée une vraie variable C directement dans la mémoire vive."

Si, pour des raisons de tests, votre code à compiler est déjà dans votre espace Dynamo (nœud Python), vous pouvez utiliser le module subprocess pour générer le pyd directement depuis Dynamo comme suit :

code pour générer le pyd


import clr
import System
from System.Collections.Generic import List

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

# Add Revit API References
clr.AddReference('RevitAPI')
clr.AddReference("RevitServices")
clr.AddReference("RevitNodes")

import RevitServices
import Revit
clr.ImportExtensions(Revit.GeometryConversion)

import Autodesk
import Autodesk.Revit.DB as DB
from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

# Document reference
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument

clr.AddReference('DynamoRevitDS')
import Dynamo 
#reference dynamo core to update node values
clr.AddReference('DynamoCore')
from Dynamo.Graph import UpdateValueParams

#access to the current Dynamo instance and workspace
dynamoRevit = Dynamo.Applications.DynamoRevit()
engine = dynamoRevit.RevitDynamoModel.EngineController
currentWorkspace = dynamoRevit.RevitDynamoModel.CurrentWorkspace
model = dynamoRevit.RevitDynamoModel

import os
import subprocess 
import sysconfig
# standard library path
sys.path.append(sysconfig.get_path("platstdlib"))
# site-package library path
sys.path.append(sysconfig.get_path("platlib"))

folder = IN[0]
name_pyd = IN[1]
py_path = f"{folder}\\{name_pyd}.pyx"
pyc_path = f"{folder}\\{name_pyd}.pyd"
setup_path = f"{folder}\\setup.py"

python_exe = r"C:\Users\sneep\AppData\Local\Programs\Python\Python311\python.exe" 

# write the py file from a python node
nodeK = next((i for i in currentWorkspace.Nodes if i.Name == "Python Script | Module1"), None)
code_py = nodeK.Script
code_py = code_py.replace("\r","")
with open(py_path, "w", encoding='utf-8') as f:
    f.write(code_py)

contenu_setup = f"""# Généré automatiquement via Dynamo
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("{name_pyd}.pyx")
)
"""
with open(setup_path, "w", encoding='utf-8') as f:
    f.write(contenu_setup)
    
# compilation via Subprocess
commande = [python_exe, setup_path, "build_ext", "--inplace"]

try:
    resultat = subprocess.run(
        commande,
        cwd=folder,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        shell=True
    )
    
    # return
    if resultat.returncode == 0:
        OUT = resultat.stdout, 
    else:
        OUT = resultat.stderr, 
        
except Exception as e:
    OUT = str(e),

Exemple de code à générer en pyd (non optimisé )

Ici on reste sur une syntaxe CPython.


import sys
import clr
import System
import math

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

class Utils:
    guid = "a8c3aa76-f731-4086-ae08-8cb41464e425"

       
    def __name__(self):
        return "Utils"
    
    @staticmethod   
    def filter_points(flat_points, pt_center, radius):
        inside_points = []
        center_x, center_y, center_z = pt_center.X, pt_center.Y, pt_center.Z
        r_square = radius ** 2
        
        for p in flat_points:
            x, y, z = p.X, p.Y, p.Z
            
            dist_square = (x - center_x)**2 + (y - center_y)**2 + (z - center_z)**2
            
            if dist_square <= r_square:
                inside_points.append(p)
                
        return inside_points

OUT = Utils

Exemple de code à compiler en pyd (optimisé)

Dans ce 2ᵉ exemple, on est sur un langage Cython, il s'agit d'un langage hybride (techniquement un "sur-ensemble" de Python) créé spécifiquement pour servir de pont entre les deux mondes (le C et le Python).

On a ajouté des déclarations de types statiques du C (cdef).


import sys
import clr
import System
import math

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

class Utils:
    guid = "a8c3aa76-f731-4086-ae08-8cb41464e425"
    def __name__(self):
        return "Utils"
    
    @staticmethod   
    def filter_points_fast(points, pt_center, double radius):
        # variables declarations
        cdef double center_x, center_y, center_z
        cdef double r_square
        cdef double x, y, z, dist_square
        
        inside_points = []
        
        center_x = pt_center.X
        center_y = pt_center.Y
        center_z = pt_center.Z
        r_square = radius * radius
        
        for p in points:
            x = p.X
            y = p.Y
            z = p.Z
            
            dist_square = (x - center_x)*(x - center_x) + (y - center_y)*(y - center_y) + (z - center_z)*(z - center_z)
            
            if dist_square <= r_square:
                inside_points.append(p)
                
        return inside_points

OUT = Utils

Note : on pourrait également dans cet exemple passer directement les valeurs numériques des points au lieu des objets ".Net" , ce qui accélérerait encore plus l'exécution, notamment au niveau de la boucle for

4. L'importation et l'utilisation

L'importation se fait de la même manière pour les 3 types de fichiers (py, pyc, pyd) via le module `sys`


import clr
import System

import sys
import os
import importlib
import inspect

pyd_folder_path = IN[0] # the folder path of py/pyc/pyd file (NOT THE FILEPATH)
flat_points = IN[1]
pt_center = IN[2]

sys.path.append(pyd_folder_path) 

import Utils2
# optionnal : reload the module if it has already been loaded
importlib.reload(Utils2)

from Utils2 import Utils
# optionnal : check the filepath of module (py, pyc, pyd)
pyd_file_path = inspect.getfile(Utils2)

OUT =  Utils.filter_points(flat_points, pt_center, radius=4), pyd_file_path

4. Résultats

Format du module	Fonction testée	Temps d'exécution moyen	Nombre de tests
pyc (Bytecode standard)	`test_from_pyc`	75.186 ms	4
pyd (CPython/Cython non optimisé)	`test_from_pyd_not_optimised`	56.692 ms	4
pyd (Cython optimisé)	`test_from_pyd_optimised`	43.488 ms	4

Soyez gentil, car tous ceux que vous rencontrez mènent un dur combat.
Ian Maclaren (John Watson)

...

VoltaDynaBim

[Dynamo + Python] Revit 2027 : HVAC Zone → GenericZone (Migration API)

[Dynamo += Python] Export IFC : configurations Utilisateur (MAJ 05/09/2026)

[Dynamo += Python] Compilation de librairies personalisé Python

1. Le classique : le module sous forme de fichier .py

2. Le compilé bytecode : le module sous forme de fichier .pyc

3. La DLL : Le fichier .pyd

4. L'importation et l'utilisationL'importation se fait de la même manière pour les 3 types de fichiers (py, pyc, pyd) via le module sys

4. Résultats

1. Le classique : le module sous forme de fichier `.py`

2. Le compilé bytecode : le module sous forme de fichier `.pyc`

3. La DLL : Le fichier `.pyd`

4. L'importation et l'utilisation

L'importation se fait de la même manière pour les 3 types de fichiers (py, pyc, pyd) via le module `sys`