The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
convert nodes_rodin.py to V3 schema (#10195)
Alexander Piskun2ed74f7ac78d
diff --git a/comfy_api_nodes/nodes_rodin.py b/comfy_api_nodes/nodes_rodin.pyindex 633ac46d3..bd758f762 100644--- a/comfy_api_nodes/nodes_rodin.py+++ b/comfy_api_nodes/nodes_rodin.py@@ -7,14 +7,15 @@ Rodin API docs: https://developer.hyper3d.ai/from __future__ import annotationsfrom inspect import cleandoc-from comfy.comfy_types.node_typing import IOimport folder_paths as comfy_pathsimport aiohttpimport osimport asyncio-import ioimport loggingimport math+from typing import Optional+from io import BytesIO+from typing_extensions import overridefrom PIL import Imagefrom comfy_api_nodes.apis.rodin_api import (Rodin3DGenerateRequest,@@ -31,428 +32,436 @@ from comfy_api_nodes.apis.client import (SynchronousOperation,PollingOperation,)+from comfy_api.latest import ComfyExtension, io as comfy_io-COMMON_PARAMETERS = {- "Seed": (- IO.INT,- {- "default":0,- "min":0,- "max":65535,- "display":"number"- }+COMMON_PARAMETERS = [+ comfy_io.Int.Input(+ "Seed",+ default=0,+ min=0,+ max=65535,+ display_mode=comfy_io.NumberDisplay.number,+ optional=True,),- "Material_Type": (- IO.COMBO,- {- "options": ["PBR", "Shaded"],- "default": "PBR"- }+ comfy_io.Combo.Input("Material_Type", options=["PBR", "Shaded"], default="PBR", optional=True),+ comfy_io.Combo.Input(+ "Polygon_count",+ options=["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "200K-Triangle"],+ default="18K-Quad",+ optional=True,),- "Polygon_count": (- IO.COMBO,- {- "options": ["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "200K-Triangle"],- "default": "18K-Quad"- }- )-}+]-def create_task_error(response: Rodin3DGenerateResponse):- """Check if the response has error"""- return hasattr(response, "error")+def get_quality_mode(poly_count):+ polycount = poly_count.split("-")+ poly = polycount[1]+ count = polycount[0]+ if poly == "Triangle":+ mesh_mode = "Raw"+ elif poly == "Quad":+ mesh_mode = "Quad"+ else:+ mesh_mode = "Quad"++ if count == "4K":+ quality_override = 4000+ elif count == "8K":+ quality_override = 8000+ elif count == "18K":+ quality_override = 18000+ elif count == "50K":+ quality_override = 50000+ elif count == "2K":+ quality_override = 2000+ elif count == "20K":+ quality_override = 20000+ elif count == "150K":+ quality_override = 150000+ elif count == "500K":+ quality_override = 500000+ else:+ quality_override = 18000-class Rodin3DAPI:+ return mesh_mode, quality_override+++def tensor_to_filelike(tensor, max_pixels: int = 2048*2048):"""- Generate 3D Assets using Rodin API+ Converts a PyTorch tensor to a file-like object.++ Args:+ - tensor (torch.Tensor): A tensor representing an image of shape (H, W, C)+ where C is the number of channels (3 for RGB), H is height, and W is width.++ Returns:+ - io.BytesIO: A file-like object containing the image data."""- RETURN_TYPES = (IO.STRING,)- RETURN_NAMES = ("3D Model Path",)- CATEGORY = "api node/3d/Rodin"- DESCRIPTION = cleandoc(__doc__ or "")- FUNCTION = "api_call"- API_NODE = True-- def tensor_to_filelike(self, tensor, max_pixels: int = 2048*2048):- """- Converts a PyTorch tensor to a file-like object.-- Args:- - tensor (torch.Tensor): A tensor representing an image of shape (H, W, C)- where C is the number of channels (3 for RGB), H is height, and W is width.-- Returns:- - io.BytesIO: A file-like object containing the image data.- """- array = tensor.cpu().numpy()- array = (array * 255).astype('uint8')- image = Image.fromarray(array, 'RGB')-- original_width, original_height = image.size- original_pixels = original_width * original_height- if original_pixels > max_pixels:- scale = math.sqrt(max_pixels / original_pixels)- new_width = int(original_width * scale)- new_height = int(original_height * scale)- else:- new_width, new_height = original_width, original_height-- if new_width != original_width or new_height != original_height:- image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)-- img_byte_arr = io.BytesIO()- image.save(img_byte_arr, format='PNG') # PNG is used for lossless compression- img_byte_arr.seek(0)- return img_byte_arr-- def check_rodin_status(self, response: Rodin3DCheckStatusResponse) -> str:- has_failed = any(job.status == JobStatus.Failed for job in response.jobs)- all_done = all(job.status == JobStatus.Done for job in response.jobs)- status_list = [str(job.status) for job in response.jobs]- logging.info(f"[ Rodin3D API - CheckStatus ] Generate Status: {status_list}")- if has_failed:- logging.error(f"[ Rodin3D API - CheckStatus ] Generate Failed: {status_list}, Please try again.")- raise Exception("[ Rodin3D API ] Generate Failed, Please Try again.")- elif all_done:- return "DONE"- else:- return "Generating"-- async def create_generate_task(self, images=None, seed=1, material="PBR", quality_override=18000, tier="Regular", mesh_mode="Quad", TAPose = False, **kwargs):- if images is None:- raise Exception("Rodin 3D generate requires at least 1 image.")- if len(images) > 5:- raise Exception("Rodin 3D generate requires up to 5 image.")-- path = "/proxy/rodin/api/v2/rodin"- operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=path,- method=HttpMethod.POST,- request_model=Rodin3DGenerateRequest,- response_model=Rodin3DGenerateResponse,- ),- request=Rodin3DGenerateRequest(- seed=seed,- tier=tier,- material=material,- quality_override=quality_override,- mesh_mode=mesh_mode,- TAPose=TAPose,- ),- files=[- (- "images",- open(image, "rb") if isinstance(image, str) else self.tensor_to_filelike(image)- )- for image in images if image is not None- ],- content_type = "multipart/form-data",- auth_kwargs=kwargs,- )+ array = tensor.cpu().numpy()+ array = (array * 255).astype('uint8')+ image = Image.fromarray(array, 'RGB')++ original_width, original_height = image.size+ original_pixels = original_width * original_height+ if original_pixels > max_pixels:+ scale = math.sqrt(max_pixels / original_pixels)+ new_width = int(original_width * scale)+ new_height = int(original_height * scale)+ else:+ new_width, new_height = original_width, original_height++ if new_width != original_width or new_height != original_height:+ image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)++ img_byte_arr = BytesIO()+ image.save(img_byte_arr, format='PNG') # PNG is used for lossless compression+ img_byte_arr.seek(0)+ return img_byte_arr+++async def create_generate_task(+ images=None,+ seed=1,+ material="PBR",+ quality_override=18000,+ tier="Regular",+ mesh_mode="Quad",+ TAPose = False,+ auth_kwargs: Optional[dict[str, str]] = None,+):+ if images is None:+ raise Exception("Rodin 3D generate requires at least 1 image.")+ if len(images) > 5:+ raise Exception("Rodin 3D generate requires up to 5 image.")++ path = "/proxy/rodin/api/v2/rodin"+ operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path=path,+ method=HttpMethod.POST,+ request_model=Rodin3DGenerateRequest,+ response_model=Rodin3DGenerateResponse,+ ),+ request=Rodin3DGenerateRequest(+ seed=seed,+ tier=tier,+ material=material,+ quality_override=quality_override,+ mesh_mode=mesh_mode,+ TAPose=TAPose,+ ),+ files=[+ (+ "images",+ open(image, "rb") if isinstance(image, str) else tensor_to_filelike(image)+ )+ for image in images if image is not None+ ],+ content_type="multipart/form-data",+ auth_kwargs=auth_kwargs,+ )- response = await operation.execute()-- if create_task_error(response):- error_message = f"Rodin3D Create 3D generate Task Failed. Message: {response.message}, error: {response.error}"- logging.error(error_message)- raise Exception(error_message)-- logging.info("[ Rodin3D API - Submit Jobs ] Submit Generate Task Success!")- subscription_key = response.jobs.subscription_key- task_uuid = response.uuid- logging.info(f"[ Rodin3D API - Submit Jobs ] UUID: {task_uuid}")- return task_uuid, subscription_key-- async def poll_for_task_status(self, subscription_key, **kwargs) -> Rodin3DCheckStatusResponse:-- path = "/proxy/rodin/api/v2/status"-- poll_operation = PollingOperation(- poll_endpoint=ApiEndpoint(- path = path,- method=HttpMethod.POST,- request_model=Rodin3DCheckStatusRequest,- response_model=Rodin3DCheckStatusResponse,- ),- request=Rodin3DCheckStatusRequest(- subscription_key = subscription_key- ),- completed_statuses=["DONE"],- failed_statuses=["FAILED"],- status_extractor=self.check_rodin_status,- poll_interval=3.0,- auth_kwargs=kwargs,- )+ response = await operation.execute()++ if hasattr(response, "error"):+ error_message = f"Rodin3D Create 3D generate Task Failed. Message: {response.message}, error: {response.error}"+ logging.error(error_message)+ raise Exception(error_message)++ logging.info("[ Rodin3D API - Submit Jobs ] Submit Generate Task Success!")+ subscription_key = response.jobs.subscription_key+ task_uuid = response.uuid+ logging.info(f"[ Rodin3D API - Submit Jobs ] UUID: {task_uuid}")+ return task_uuid, subscription_key+++def check_rodin_status(response: Rodin3DCheckStatusResponse) -> str:+ all_done = all(job.status == JobStatus.Done for job in response.jobs)+ status_list = [str(job.status) for job in response.jobs]+ logging.info(f"[ Rodin3D API - CheckStatus ] Generate Status: {status_list}")+ if any(job.status == JobStatus.Failed for job in response.jobs):+ logging.error(f"[ Rodin3D API - CheckStatus ] Generate Failed: {status_list}, Please try again.")+ raise Exception("[ Rodin3D API ] Generate Failed, Please Try again.")+ if all_done:+ return "DONE"+ return "Generating"+++async def poll_for_task_status(+ subscription_key, auth_kwargs: Optional[dict[str, str]] = None,+) -> Rodin3DCheckStatusResponse:+ poll_operation = PollingOperation(+ poll_endpoint=ApiEndpoint(+ path="/proxy/rodin/api/v2/status",+ method=HttpMethod.POST,+ request_model=Rodin3DCheckStatusRequest,+ response_model=Rodin3DCheckStatusResponse,+ ),+ request=Rodin3DCheckStatusRequest(subscription_key=subscription_key),+ completed_statuses=["DONE"],+ failed_statuses=["FAILED"],+ status_extractor=check_rodin_status,+ poll_interval=3.0,+ auth_kwargs=auth_kwargs,+ )+ logging.info("[ Rodin3D API - CheckStatus ] Generate Start!")+ return await poll_operation.execute()+++async def get_rodin_download_list(uuid, auth_kwargs: Optional[dict[str, str]] = None) -> Rodin3DDownloadResponse:+ logging.info("[ Rodin3D API - Downloading ] Generate Successfully!")+ operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path="/proxy/rodin/api/v2/download",+ method=HttpMethod.POST,+ request_model=Rodin3DDownloadRequest,+ response_model=Rodin3DDownloadResponse,+ ),+ request=Rodin3DDownloadRequest(task_uuid=uuid),+ auth_kwargs=auth_kwargs,+ )+ return await operation.execute()+++async def download_files(url_list, task_uuid):+ save_path = os.path.join(comfy_paths.get_output_directory(), f"Rodin3D_{task_uuid}")+ os.makedirs(save_path, exist_ok=True)+ model_file_path = None+ async with aiohttp.ClientSession() as session:+ for i in url_list.list:+ url = i.url+ file_name = i.name+ file_path = os.path.join(save_path, file_name)+ if file_path.endswith(".glb"):+ model_file_path = file_path+ logging.info(f"[ Rodin3D API - download_files ] Downloading file: {file_path}")+ max_retries = 5+ for attempt in range(max_retries):+ try:+ async with session.get(url) as resp:+ resp.raise_for_status()+ with open(file_path, "wb") as f:+ async for chunk in resp.content.iter_chunked(32 * 1024):+ f.write(chunk)+ break+ except Exception as e:+ logging.info(f"[ Rodin3D API - download_files ] Error downloading {file_path}:{e}")+ if attempt < max_retries - 1:+ logging.info("Retrying...")+ await asyncio.sleep(2)+ else:+ logging.info(+ "[ Rodin3D API - download_files ] Failed to download %s after %s attempts.",+ file_path,+ max_retries,+ )+ return model_file_path+++class Rodin3D_Regular(comfy_io.ComfyNode):+ """Generate 3D Assets using Rodin API"""- logging.info("[ Rodin3D API - CheckStatus ] Generate Start!")-- return await poll_operation.execute()-- async def get_rodin_download_list(self, uuid, **kwargs) -> Rodin3DDownloadResponse:- logging.info("[ Rodin3D API - Downloading ] Generate Successfully!")-- path = "/proxy/rodin/api/v2/download"- operation = SynchronousOperation(- endpoint=ApiEndpoint(- path=path,- method=HttpMethod.POST,- request_model=Rodin3DDownloadRequest,- response_model=Rodin3DDownloadResponse,- ),- request=Rodin3DDownloadRequest(- task_uuid=uuid- ),- auth_kwargs=kwargs+ @classmethod+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="Rodin3D_Regular",+ display_name="Rodin 3D Generate - Regular Generate",+ category="api node/3d/Rodin",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input("Images"),+ *COMMON_PARAMETERS,+ ],+ outputs=[comfy_io.String.Output(display_name="3D Model Path")],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ ],+ is_api_node=True,)- return await operation.execute()-- def get_quality_mode(self, poly_count):- polycount = poly_count.split("-")- poly = polycount[1]- count = polycount[0]- if poly == "Triangle":- mesh_mode = "Raw"- elif poly == "Quad":- mesh_mode = "Quad"- else:- mesh_mode = "Quad"-- if count == "4K":- quality_override = 4000- elif count == "8K":- quality_override = 8000- elif count == "18K":- quality_override = 18000- elif count == "50K":- quality_override = 50000- elif count == "2K":- quality_override = 2000- elif count == "20K":- quality_override = 20000- elif count == "150K":- quality_override = 150000- elif count == "500K":- quality_override = 500000- else:- quality_override = 18000-- return mesh_mode, quality_override-- async def download_files(self, url_list, task_uuid):- save_path = os.path.join(comfy_paths.get_output_directory(), f"Rodin3D_{task_uuid}")- os.makedirs(save_path, exist_ok=True)- model_file_path = None- async with aiohttp.ClientSession() as session:- for i in url_list.list:- url = i.url- file_name = i.name- file_path = os.path.join(save_path, file_name)- if file_path.endswith(".glb"):- model_file_path = file_path- logging.info(f"[ Rodin3D API - download_files ] Downloading file: {file_path}")- max_retries = 5- for attempt in range(max_retries):- try:- async with session.get(url) as resp:- resp.raise_for_status()- with open(file_path, "wb") as f:- async for chunk in resp.content.iter_chunked(32 * 1024):- f.write(chunk)- break- except Exception as e:- logging.info(f"[ Rodin3D API - download_files ] Error downloading {file_path}:{e}")- if attempt < max_retries - 1:- logging.info("Retrying...")- await asyncio.sleep(2)- else:- logging.info(- "[ Rodin3D API - download_files ] Failed to download %s after %s attempts.",- file_path,- max_retries,- )-- return model_file_path---class Rodin3D_Regular(Rodin3DAPI):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "Images":- (- IO.IMAGE,- {- "forceInput":True,- }- )- },- "optional": {- **COMMON_PARAMETERS- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- },- }-- async def api_call(- self,+ async def execute(+ cls,Images,Seed,Material_Type,Polygon_count,- **kwargs- ):+ ) -> comfy_io.NodeOutput:tier = "Regular"num_images = Images.shape[0]m_images = []for i in range(num_images):m_images.append(Images[i])- mesh_mode, quality_override = self.get_quality_mode(Polygon_count)- task_uuid, subscription_key = await self.create_generate_task(images=m_images, seed=Seed, material=Material_Type,- quality_override=quality_override, tier=tier, mesh_mode=mesh_mode,- **kwargs)- await self.poll_for_task_status(subscription_key, **kwargs)- download_list = await self.get_rodin_download_list(task_uuid, **kwargs)- model = await self.download_files(download_list, task_uuid)+ mesh_mode, quality_override = get_quality_mode(Polygon_count)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }+ task_uuid, subscription_key = await create_generate_task(+ images=m_images,+ seed=Seed,+ material=Material_Type,+ quality_override=quality_override,+ tier=tier,+ mesh_mode=mesh_mode,+ auth_kwargs=auth,+ )+ await poll_for_task_status(subscription_key, auth_kwargs=auth)+ download_list = await get_rodin_download_list(task_uuid, auth_kwargs=auth)+ model = await download_files(download_list, task_uuid)++ return comfy_io.NodeOutput(model)- return (model,)+class Rodin3D_Detail(comfy_io.ComfyNode):+ """Generate 3D Assets using Rodin API"""-class Rodin3D_Detail(Rodin3DAPI):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "Images":- (- IO.IMAGE,- {- "forceInput":True,- }- )- },- "optional": {- **COMMON_PARAMETERS- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- },- }+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="Rodin3D_Detail",+ display_name="Rodin 3D Generate - Detail Generate",+ category="api node/3d/Rodin",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input("Images"),+ *COMMON_PARAMETERS,+ ],+ outputs=[comfy_io.String.Output(display_name="3D Model Path")],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,Images,Seed,Material_Type,Polygon_count,- **kwargs- ):+ ) -> comfy_io.NodeOutput:tier = "Detail"num_images = Images.shape[0]m_images = []for i in range(num_images):m_images.append(Images[i])- mesh_mode, quality_override = self.get_quality_mode(Polygon_count)- task_uuid, subscription_key = await self.create_generate_task(images=m_images, seed=Seed, material=Material_Type,- quality_override=quality_override, tier=tier, mesh_mode=mesh_mode,- **kwargs)- await self.poll_for_task_status(subscription_key, **kwargs)- download_list = await self.get_rodin_download_list(task_uuid, **kwargs)- model = await self.download_files(download_list, task_uuid)+ mesh_mode, quality_override = get_quality_mode(Polygon_count)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }+ task_uuid, subscription_key = await create_generate_task(+ images=m_images,+ seed=Seed,+ material=Material_Type,+ quality_override=quality_override,+ tier=tier,+ mesh_mode=mesh_mode,+ auth_kwargs=auth,+ )+ await poll_for_task_status(subscription_key, auth_kwargs=auth)+ download_list = await get_rodin_download_list(task_uuid, auth_kwargs=auth)+ model = await download_files(download_list, task_uuid)++ return comfy_io.NodeOutput(model)- return (model,)+class Rodin3D_Smooth(comfy_io.ComfyNode):+ """Generate 3D Assets using Rodin API"""-class Rodin3D_Smooth(Rodin3DAPI):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "Images":- (- IO.IMAGE,- {- "forceInput":True,- }- )- },- "optional": {- **COMMON_PARAMETERS- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- },- }+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="Rodin3D_Smooth",+ display_name="Rodin 3D Generate - Smooth Generate",+ category="api node/3d/Rodin",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input("Images"),+ *COMMON_PARAMETERS,+ ],+ outputs=[comfy_io.String.Output(display_name="3D Model Path")],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,Images,Seed,Material_Type,Polygon_count,- **kwargs- ):+ ) -> comfy_io.NodeOutput:tier = "Smooth"num_images = Images.shape[0]m_images = []for i in range(num_images):m_images.append(Images[i])- mesh_mode, quality_override = self.get_quality_mode(Polygon_count)- task_uuid, subscription_key = await self.create_generate_task(images=m_images, seed=Seed, material=Material_Type,- quality_override=quality_override, tier=tier, mesh_mode=mesh_mode,- **kwargs)- await self.poll_for_task_status(subscription_key, **kwargs)- download_list = await self.get_rodin_download_list(task_uuid, **kwargs)- model = await self.download_files(download_list, task_uuid)+ mesh_mode, quality_override = get_quality_mode(Polygon_count)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }+ task_uuid, subscription_key = await create_generate_task(+ images=m_images,+ seed=Seed,+ material=Material_Type,+ quality_override=quality_override,+ tier=tier,+ mesh_mode=mesh_mode,+ auth_kwargs=auth,+ )+ await poll_for_task_status(subscription_key, auth_kwargs=auth)+ download_list = await get_rodin_download_list(task_uuid, auth_kwargs=auth)+ model = await download_files(download_list, task_uuid)++ return comfy_io.NodeOutput(model)- return (model,)+class Rodin3D_Sketch(comfy_io.ComfyNode):+ """Generate 3D Assets using Rodin API"""-class Rodin3D_Sketch(Rodin3DAPI):@classmethod- def INPUT_TYPES(s):- return {- "required": {- "Images":- (- IO.IMAGE,- {- "forceInput":True,- }- )- },- "optional": {- "Seed":- (- IO.INT,- {- "default":0,- "min":0,- "max":65535,- "display":"number"- }- )- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- },- }+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="Rodin3D_Sketch",+ display_name="Rodin 3D Generate - Sketch Generate",+ category="api node/3d/Rodin",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input("Images"),+ comfy_io.Int.Input(+ "Seed",+ default=0,+ min=0,+ max=65535,+ display_mode=comfy_io.NumberDisplay.number,+ optional=True,+ ),+ ],+ outputs=[comfy_io.String.Output(display_name="3D Model Path")],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,Images,Seed,- **kwargs- ):+ ) -> comfy_io.NodeOutput:tier = "Sketch"num_images = Images.shape[0]m_images = []@@ -461,104 +470,110 @@ class Rodin3D_Sketch(Rodin3DAPI):material_type = "PBR"quality_override = 18000mesh_mode = "Quad"- task_uuid, subscription_key = await self.create_generate_task(- images=m_images, seed=Seed, material=material_type, quality_override=quality_override, tier=tier, mesh_mode=mesh_mode, **kwargs+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }+ task_uuid, subscription_key = await create_generate_task(+ images=m_images,+ seed=Seed,+ material=material_type,+ quality_override=quality_override,+ tier=tier,+ mesh_mode=mesh_mode,+ auth_kwargs=auth,)- await self.poll_for_task_status(subscription_key, **kwargs)- download_list = await self.get_rodin_download_list(task_uuid, **kwargs)- model = await self.download_files(download_list, task_uuid)+ await poll_for_task_status(subscription_key, auth_kwargs=auth)+ download_list = await get_rodin_download_list(task_uuid, auth_kwargs=auth)+ model = await download_files(download_list, task_uuid)++ return comfy_io.NodeOutput(model)- return (model,)-class Rodin3D_Gen2(Rodin3DAPI):+class Rodin3D_Gen2(comfy_io.ComfyNode):+ """Generate 3D Assets using Rodin API"""+@classmethod- def INPUT_TYPES(s):- return {- "required": {- "Images":- (- IO.IMAGE,- {- "forceInput":True,- }- )- },- "optional": {- "Seed": (- IO.INT,- {- "default":0,- "min":0,- "max":65535,- "display":"number"- }- ),- "Material_Type": (- IO.COMBO,- {- "options": ["PBR", "Shaded"],- "default": "PBR"- }+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="Rodin3D_Gen2",+ display_name="Rodin 3D Generate - Gen-2 Generate",+ category="api node/3d/Rodin",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input("Images"),+ comfy_io.Int.Input(+ "Seed",+ default=0,+ min=0,+ max=65535,+ display_mode=comfy_io.NumberDisplay.number,+ optional=True,),- "Polygon_count": (- IO.COMBO,- {- "options": ["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "2K-Triangle", "20K-Triangle", "150K-Triangle", "500K-Triangle"],- "default": "500K-Triangle"- }+ comfy_io.Combo.Input("Material_Type", options=["PBR", "Shaded"], default="PBR", optional=True),+ comfy_io.Combo.Input(+ "Polygon_count",+ options=["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "2K-Triangle", "20K-Triangle", "150K-Triangle", "500K-Triangle"],+ default="500K-Triangle",+ optional=True,),- "TAPose": (- IO.BOOLEAN,- {- "default": False,- }- )- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- },- }+ comfy_io.Boolean.Input("TAPose", default=False),+ ],+ outputs=[comfy_io.String.Output(display_name="3D Model Path")],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ ],+ is_api_node=True,+ )- async def api_call(- self,+ @classmethod+ async def execute(+ cls,Images,Seed,Material_Type,Polygon_count,TAPose,- **kwargs- ):+ ) -> comfy_io.NodeOutput:tier = "Gen-2"num_images = Images.shape[0]m_images = []for i in range(num_images):m_images.append(Images[i])- mesh_mode, quality_override = self.get_quality_mode(Polygon_count)- task_uuid, subscription_key = await self.create_generate_task(images=m_images, seed=Seed, material=Material_Type,- quality_override=quality_override, tier=tier, mesh_mode=mesh_mode, TAPose=TAPose,- **kwargs)- await self.poll_for_task_status(subscription_key, **kwargs)- download_list = await self.get_rodin_download_list(task_uuid, **kwargs)- model = await self.download_files(download_list, task_uuid)-- return (model,)--# A dictionary that contains all nodes you want to export with their names-# NOTE: names should be globally unique-NODE_CLASS_MAPPINGS = {- "Rodin3D_Regular": Rodin3D_Regular,- "Rodin3D_Detail": Rodin3D_Detail,- "Rodin3D_Smooth": Rodin3D_Smooth,- "Rodin3D_Sketch": Rodin3D_Sketch,- "Rodin3D_Gen2": Rodin3D_Gen2,-}--# A dictionary that contains the friendly/humanly readable titles for the nodes-NODE_DISPLAY_NAME_MAPPINGS = {- "Rodin3D_Regular": "Rodin 3D Generate - Regular Generate",- "Rodin3D_Detail": "Rodin 3D Generate - Detail Generate",- "Rodin3D_Smooth": "Rodin 3D Generate - Smooth Generate",- "Rodin3D_Sketch": "Rodin 3D Generate - Sketch Generate",- "Rodin3D_Gen2": "Rodin 3D Generate - Gen-2 Generate",-}+ mesh_mode, quality_override = get_quality_mode(Polygon_count)+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }+ task_uuid, subscription_key = await create_generate_task(+ images=m_images,+ seed=Seed,+ material=Material_Type,+ quality_override=quality_override,+ tier=tier,+ mesh_mode=mesh_mode,+ TAPose=TAPose,+ auth_kwargs=auth,+ )+ await poll_for_task_status(subscription_key, auth_kwargs=auth)+ download_list = await get_rodin_download_list(task_uuid, auth_kwargs=auth)+ model = await download_files(download_list, task_uuid)++ return comfy_io.NodeOutput(model)+++class Rodin3DExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[comfy_io.ComfyNode]]:+ return [+ Rodin3D_Regular,+ Rodin3D_Detail,+ Rodin3D_Smooth,+ Rodin3D_Sketch,+ Rodin3D_Gen2,+ ]+++async def comfy_entrypoint() -> Rodin3DExtension:+ return Rodin3DExtension()