conanfile.py 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. import os
  2. import sys
  3. from pathlib import Path
  4. from io import StringIO
  5. from platform import python_version
  6. from jinja2 import Template
  7. from conans import tools
  8. from conan import ConanFile
  9. from conan.tools import files
  10. from conan.tools.env import VirtualRunEnv
  11. from conan.errors import ConanInvalidConfiguration
  12. required_conan_version = ">=1.47.0"
  13. class CuraConan(ConanFile):
  14. name = "cura"
  15. license = "LGPL-3.0"
  16. author = "Ultimaker B.V."
  17. url = "https://github.com/Ultimaker/cura"
  18. description = "3D printer / slicing GUI built on top of the Uranium framework"
  19. topics = ("conan", "python", "pyqt5", "qt", "qml", "3d-printing", "slicer")
  20. build_policy = "missing"
  21. exports = "LICENSE*", "Ultimaker-Cura.spec.jinja", "CuraVersion.py.jinja"
  22. settings = "os", "compiler", "build_type", "arch"
  23. no_copy_source = True # We won't build so no need to copy sources to the build folder
  24. # FIXME: Remove specific branch once merged to main
  25. # Extending the conanfile with the UMBaseConanfile https://github.com/Ultimaker/conan-ultimaker-index/tree/CURA-9177_Fix_CI_CD/recipes/umbase
  26. python_requires = "umbase/0.1.5@ultimaker/testing"
  27. python_requires_extend = "umbase.UMBaseConanfile"
  28. options = {
  29. "enterprise": ["True", "False", "true", "false"], # Workaround for GH Action passing boolean as lowercase string
  30. "staging": ["True", "False", "true", "false"], # Workaround for GH Action passing boolean as lowercase string
  31. "devtools": [True, False], # FIXME: Split this up in testing and (development / build (pyinstaller) / system installer) tools
  32. "cloud_api_version": "ANY",
  33. "display_name": "ANY", # TODO: should this be an option??
  34. "cura_debug_mode": [True, False] # FIXME: Use profiles
  35. }
  36. default_options = {
  37. "enterprise": "False",
  38. "staging": "False",
  39. "devtools": False,
  40. "cloud_api_version": "1",
  41. "display_name": "Ultimaker Cura",
  42. "cura_debug_mode": False # Not yet implemented
  43. }
  44. scm = {
  45. "type": "git",
  46. "subfolder": ".",
  47. "url": "auto",
  48. "revision": "auto"
  49. }
  50. @property
  51. def _staging(self):
  52. return self.options.staging in ["True", 'true']
  53. @property
  54. def _enterprise(self):
  55. return self.options.enterprise in ["True", 'true']
  56. @property
  57. def _cloud_api_root(self):
  58. return "https://api-staging.ultimaker.com" if self._staging else "https://api.ultimaker.com"
  59. @property
  60. def _cloud_account_api_root(self):
  61. return "https://account-staging.ultimaker.com" if self._staging else "https://account.ultimaker.com"
  62. @property
  63. def _marketplace_root(self):
  64. return "https://marketplace-staging.ultimaker.com" if self._staging else "https://marketplace.ultimaker.com"
  65. @property
  66. def _digital_factory_url(self):
  67. return "https://digitalfactory-staging.ultimaker.com" if self._staging else "https://digitalfactory.ultimaker.com"
  68. @property
  69. def requirements_txts(self):
  70. if self.options.devtools:
  71. return ["requirements.txt", "requirements-ultimaker.txt", "requirements-dev.txt"]
  72. return ["requirements.txt", "requirements-ultimaker.txt"]
  73. @property
  74. def _base_dir(self):
  75. if self.install_folder is None:
  76. if self.build_folder is not None:
  77. return Path(self.build_folder)
  78. return Path(os.getcwd(), "venv")
  79. return Path(self.install_folder) # TODO: add base dir for running from source
  80. @property
  81. def _share_dir(self):
  82. return self._base_dir.joinpath("share")
  83. @property
  84. def _script_dir(self):
  85. if self.settings.os == "Windows":
  86. return self._base_dir.joinpath("Scripts")
  87. return self._base_dir.joinpath("bin")
  88. @property
  89. def _site_packages(self):
  90. if self.settings.os == "Windows":
  91. return self._base_dir.joinpath("Lib", "site-packages")
  92. py_version = tools.Version(self.deps_cpp_info["cpython"].version)
  93. return self._base_dir.joinpath("lib", f"python{py_version.major}.{py_version.minor}", "site-packages")
  94. @property
  95. def _py_interp(self):
  96. py_interp = self._script_dir.joinpath(Path(self.deps_user_info["cpython"].python).name)
  97. if self.settings.os == "Windows":
  98. py_interp = Path(*[f'"{p}"' if " " in p else p for p in py_interp.parts])
  99. return py_interp
  100. def _generate_cura_version(self, location):
  101. with open(Path(__file__).parent.joinpath("CuraVersion.py.jinja"), "r") as f:
  102. cura_version_py = Template(f.read())
  103. with open(Path(location, "CuraVersion.py"), "w") as f:
  104. f.write(cura_version_py.render(
  105. cura_app_name = self.name,
  106. cura_app_display_name = self.options.display_name,
  107. cura_version = self.version,
  108. cura_build_type = "Enterprise" if self._enterprise else "",
  109. cura_debug_mode = self.options.cura_debug_mode,
  110. cura_cloud_api_root = self._cloud_api_root,
  111. cura_cloud_api_version = self.options.cloud_api_version,
  112. cura_cloud_account_api_root = self._cloud_account_api_root,
  113. cura_marketplace_root = self._marketplace_root,
  114. cura_digital_factory_url = self._digital_factory_url))
  115. def _generate_pyinstaller_spec(self, location, entrypoint_location, icon_path, entitlements_file):
  116. pyinstaller_metadata = self._um_data()["pyinstaller"]
  117. datas = [(str(self._base_dir.joinpath("conan_install_info.json")), ".")]
  118. for data in pyinstaller_metadata["datas"].values():
  119. if "package" in data: # get the paths from conan package
  120. if data["package"] == self.name:
  121. if self.in_local_cache:
  122. src_path = Path(self.package_folder, data["src"])
  123. else:
  124. src_path = Path(self.source_folder, data["src"])
  125. else:
  126. src_path = Path(self.deps_cpp_info[data["package"]].rootpath, data["src"])
  127. elif "root" in data: # get the paths relative from the sourcefolder
  128. src_path = Path(self.source_folder, data["root"], data["src"])
  129. else:
  130. continue
  131. if src_path.exists():
  132. datas.append((str(src_path), data["dst"]))
  133. binaries = []
  134. for binary in pyinstaller_metadata["binaries"].values():
  135. if "package" in binary: # get the paths from conan package
  136. src_path = Path(self.deps_cpp_info[binary["package"]].rootpath, binary["src"])
  137. elif "root" in binary: # get the paths relative from the sourcefolder
  138. src_path = Path(self.source_folder, binary["root"], binary["src"])
  139. else:
  140. continue
  141. if not src_path.exists():
  142. continue
  143. for bin in src_path.glob(binary["binary"] + ".*[exe|dll|so|dylib]"):
  144. binaries.append((str(bin), binary["dst"]))
  145. for bin in src_path.glob(binary["binary"]):
  146. binaries.append((str(bin), binary["dst"]))
  147. for _, dependency in self.dependencies.items():
  148. for bin_paths in dependency.cpp_info.bindirs:
  149. binaries.extend([(f"{p}", ".") for p in Path(bin_paths).glob("**/*.dll")])
  150. binaries.extend([(f"{p}", ".") for p in Path(bin_paths).glob("**/*.dylib")])
  151. binaries.extend([(f"{p}", ".") for p in Path(bin_paths).glob("**/*.so")])
  152. # Copy dynamic libs from lib path
  153. binaries.extend([(f"{p}", ".") for p in Path(self._base_dir.joinpath("lib")).glob("**/*.dylib")])
  154. # Collect all dll's from PyQt6 and place them in the root
  155. binaries.extend([(f"{p}", ".") for p in Path(self._site_packages, "PyQt6", "Qt6").glob("**/*.dll")])
  156. # Collect platform-support libs for Linux KDE and GTK.
  157. if self.settings.os == "Linux":
  158. binaries.append((str(Path("/usr/lib/x86_64-linux-gnu/libexec/xdg-desktop-portal-kde")), "."))
  159. binaries.append((str(Path("/usr/lib/x86_64-linux-gnu/libexec/xdg-desktop-portal-gtk")), "."))
  160. with open(Path(__file__).parent.joinpath("Ultimaker-Cura.spec.jinja"), "r") as f:
  161. pyinstaller = Template(f.read())
  162. cura_version = tools.Version(self.version) if self.version else tools.Version("0.0.0")
  163. with open(Path(location, "Ultimaker-Cura.spec"), "w") as f:
  164. f.write(pyinstaller.render(
  165. name = str(self.options.display_name).replace(" ", "-"),
  166. display_name = self.options.display_name,
  167. entrypoint = entrypoint_location,
  168. datas = datas,
  169. binaries = binaries,
  170. venv_script_path = str(self._script_dir),
  171. hiddenimports = pyinstaller_metadata["hiddenimports"],
  172. collect_all = pyinstaller_metadata["collect_all"],
  173. icon = icon_path,
  174. entitlements_file = entitlements_file,
  175. osx_bundle_identifier = "'nl.ultimaker.cura'" if self.settings.os == "Macos" else "None",
  176. upx = str(self.settings.os == "Windows"),
  177. strip = False, # This should be possible on Linux and MacOS but, it can also cause issues on some distributions. Safest is to disable it for now
  178. target_arch = "'x86_64'" if self.settings.os == "Macos" else "None", # FIXME: Make this dependent on the settings.arch_target
  179. macos = self.settings.os == "Macos",
  180. version = f"'{self.version}'",
  181. short_version = f"'{cura_version.major}.{cura_version.minor}.{cura_version.patch}'",
  182. ))
  183. def source(self):
  184. self._generate_cura_version(Path(self.source_folder, "cura"))
  185. def configure(self):
  186. self.options["arcus"].shared = True
  187. self.options["savitar"].shared = True
  188. self.options["pynest2d"].shared = True
  189. self.options["cpython"].shared = True
  190. def validate(self):
  191. if self.version and tools.Version(self.version) <= tools.Version("4"):
  192. raise ConanInvalidConfiguration("Only versions 5+ are support")
  193. def requirements(self):
  194. for req in self._um_data()["requirements"]:
  195. self.requires(req)
  196. def layout(self):
  197. self.folders.source = "."
  198. self.folders.build = "venv"
  199. self.folders.generators = Path(self.folders.build, "conan")
  200. self.cpp.package.libdirs = [os.path.join("site-packages", "cura")]
  201. self.cpp.package.bindirs = ["bin"]
  202. self.cpp.package.resdirs = ["resources", "plugins", "packaging", "pip_requirements"] # pip_requirements should be the last item in the list
  203. def generate(self):
  204. vr = VirtualRunEnv(self)
  205. vr.generate()
  206. if self.options.devtools:
  207. entitlements_file = "'{}'".format(Path(self.source_folder, "packaging", "dmg", "cura.entitlements"))
  208. self._generate_pyinstaller_spec(location = self.generators_folder,
  209. entrypoint_location = "'{}'".format(Path(self.source_folder, self._um_data()["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
  210. icon_path = "'{}'".format(Path(self.source_folder, "packaging", self._um_data()["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
  211. entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
  212. def imports(self):
  213. self.copy("CuraEngine.exe", root_package = "curaengine", src = "@bindirs", dst = "", keep_path = False)
  214. self.copy("CuraEngine", root_package = "curaengine", src = "@bindirs", dst = "", keep_path = False)
  215. files.rmdir(self, "resources/materials")
  216. self.copy("*.fdm_material", root_package = "fdm_materials", src = "@resdirs", dst = "resources/materials", keep_path = False)
  217. self.copy("*.sig", root_package = "fdm_materials", src = "@resdirs", dst = "resources/materials", keep_path = False)
  218. # Copy resources of cura_binary_data
  219. self.copy("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[0],
  220. dst = "venv/share/cura", keep_path = True)
  221. self.copy("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[1],
  222. dst = "venv/share/uranium", keep_path = True)
  223. self.copy("*.dll", src = "@bindirs", dst = self._site_packages)
  224. self.copy("*.pyd", src = "@libdirs", dst = self._site_packages)
  225. self.copy("*.pyi", src = "@libdirs", dst = self._site_packages)
  226. self.copy("*.dylib", src = "@libdirs", dst = self._script_dir)
  227. def deploy(self):
  228. # Copy CuraEngine.exe to bindirs of Virtual Python Environment
  229. # TODO: Fix source such that it will get the curaengine relative from the executable (Python bindir in this case)
  230. self.copy_deps("CuraEngine.exe", root_package = "curaengine", src = self.deps_cpp_info["curaengine"].bindirs[0],
  231. dst = self._base_dir,
  232. keep_path = False)
  233. self.copy_deps("CuraEngine", root_package = "curaengine", src = self.deps_cpp_info["curaengine"].bindirs[0], dst = self._base_dir,
  234. keep_path = False)
  235. # Copy resources of Cura (keep folder structure)
  236. self.copy("*", src = self.cpp_info.bindirs[0], dst = self._base_dir, keep_path = False)
  237. self.copy("*", src = self.cpp_info.libdirs[0], dst = self._site_packages.joinpath("cura"), keep_path = True)
  238. self.copy("*", src = self.cpp_info.resdirs[0], dst = self._share_dir.joinpath("cura", "resources"), keep_path = True)
  239. self.copy("*", src = self.cpp_info.resdirs[1], dst = self._share_dir.joinpath("cura", "plugins"), keep_path = True)
  240. # Copy materials (flat)
  241. self.copy_deps("*.fdm_material", root_package = "fdm_materials", src = self.deps_cpp_info["fdm_materials"].resdirs[0],
  242. dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
  243. self.copy_deps("*.sig", root_package = "fdm_materials", src = self.deps_cpp_info["fdm_materials"].resdirs[0],
  244. dst = self._share_dir.joinpath("cura", "resources", "materials"), keep_path = False)
  245. # Copy resources of Uranium (keep folder structure)
  246. self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].resdirs[0],
  247. dst = self._share_dir.joinpath("uranium", "resources"), keep_path = True)
  248. self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].resdirs[1],
  249. dst = self._share_dir.joinpath("uranium", "plugins"), keep_path = True)
  250. self.copy_deps("*", root_package = "uranium", src = self.deps_cpp_info["uranium"].libdirs[0],
  251. dst = self._site_packages.joinpath("UM"),
  252. keep_path = True)
  253. self.copy_deps("*", root_package = "uranium", src = str(Path(self.deps_cpp_info["uranium"].libdirs[0], "Qt", "qml", "UM")),
  254. dst = self._site_packages.joinpath("PyQt6", "Qt6", "qml", "UM"),
  255. keep_path = True)
  256. # Copy resources of cura_binary_data
  257. self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[0],
  258. dst = self._share_dir.joinpath("cura"), keep_path = True)
  259. self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[1],
  260. dst = self._share_dir.joinpath("uranium"), keep_path = True)
  261. if self.settings.os == "Windows":
  262. self.copy_deps("*", root_package = "cura_binary_data", src = self.deps_cpp_info["cura_binary_data"].resdirs[2],
  263. dst = self._share_dir.joinpath("windows"), keep_path = True)
  264. self.copy_deps("*.dll", src = "@bindirs", dst = self._site_packages)
  265. self.copy_deps("*.pyd", src = "@libdirs", dst = self._site_packages)
  266. self.copy_deps("*.pyi", src = "@libdirs", dst = self._site_packages)
  267. self.copy_deps("*.dylib", src = "@libdirs", dst = self._base_dir.joinpath("lib"))
  268. # Copy packaging scripts
  269. self.copy("*", src = self.cpp_info.resdirs[2], dst = self._base_dir.joinpath("packaging"))
  270. # Copy requirements.txt's
  271. self.copy("*.txt", src = self.cpp_info.resdirs[-1], dst = self._base_dir.joinpath("pip_requirements"))
  272. # Generate the GitHub Action version info Environment
  273. cura_version = tools.Version(self.version)
  274. env_prefix = "Env:" if self.settings.os == "Windows" else ""
  275. activate_github_actions_version_env = Template(r"""echo "CURA_VERSION_MAJOR={{ cura_version_major }}" >> ${{ env_prefix }}GITHUB_ENV
  276. echo "CURA_VERSION_MINOR={{ cura_version_minor }}" >> ${{ env_prefix }}GITHUB_ENV
  277. echo "CURA_VERSION_PATCH={{ cura_version_patch }}" >> ${{ env_prefix }}GITHUB_ENV
  278. echo "CURA_VERSION_BUILD={{ cura_version_build }}" >> ${{ env_prefix }}GITHUB_ENV
  279. echo "CURA_VERSION_FULL={{ cura_version_full }}" >> ${{ env_prefix }}GITHUB_ENV
  280. """).render(cura_version_major = cura_version.major,
  281. cura_version_minor = cura_version.minor,
  282. cura_version_patch = cura_version.patch,
  283. cura_version_build = cura_version.build if cura_version.build != "" else "0",
  284. cura_version_full = self.version,
  285. env_prefix = env_prefix)
  286. ext = ".sh" if self.settings.os != "Windows" else ".ps1"
  287. files.save(self, self._script_dir.joinpath(f"activate_github_actions_version_env{ext}"), activate_github_actions_version_env)
  288. self._generate_cura_version(Path(self._site_packages, "cura"))
  289. entitlements_file = "'{}'".format(Path(self.cpp_info.res_paths[2], "dmg", "cura.entitlements"))
  290. self._generate_pyinstaller_spec(location = self._base_dir,
  291. entrypoint_location = "'{}'".format(Path(self.cpp_info.bin_paths[0], self._um_data()["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
  292. icon_path = "'{}'".format(Path(self.cpp_info.res_paths[2], self._um_data()["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
  293. entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
  294. def package(self):
  295. self.copy("cura_app.py", src = ".", dst = self.cpp.package.bindirs[0])
  296. self.copy("*", src = "cura", dst = self.cpp.package.libdirs[0])
  297. self.copy("*", src = "resources", dst = self.cpp.package.resdirs[0])
  298. self.copy("*", src = "plugins", dst = self.cpp.package.resdirs[1])
  299. self.copy("requirement*.txt", src = ".", dst = self.cpp.package.resdirs[-1])
  300. self.copy("*", src = "packaging", dst = self.cpp.package.resdirs[2])
  301. def package_info(self):
  302. self.user_info.pip_requirements = "requirements.txt"
  303. self.user_info.pip_requirements_git = "requirements-ultimaker.txt"
  304. self.user_info.pip_requirements_build = "requirements-dev.txt"
  305. if self.in_local_cache:
  306. self.runenv_info.append_path("PYTHONPATH", str(Path(self.cpp_info.lib_paths[0]).parent))
  307. self.runenv_info.append_path("PYTHONPATH", self.cpp_info.res_paths[1]) # Add plugins to PYTHONPATH
  308. else:
  309. self.runenv_info.append_path("PYTHONPATH", self.source_folder)
  310. self.runenv_info.append_path("PYTHONPATH", os.path.join(self.source_folder, "plugins"))
  311. def package_id(self):
  312. del self.info.settings.os
  313. del self.info.settings.compiler
  314. del self.info.settings.build_type
  315. del self.info.settings.arch
  316. # The following options shouldn't be used to determine the hash, since these are only used to set the CuraVersion.py
  317. # which will als be generated by the deploy method during the `conan install cura/5.1.0@_/_`
  318. del self.info.options.enterprise
  319. del self.info.options.staging
  320. del self.info.options.devtools
  321. del self.info.options.cloud_api_version
  322. del self.info.options.display_name
  323. del self.info.options.cura_debug_mode
  324. # TODO: Use the hash of requirements.txt and requirements-ultimaker.txt, Because changing these will actually result in a different
  325. # Cura. This is needed because the requirements.txt aren't managed by Conan and therefor not resolved in the package_id. This isn't
  326. # ideal but an acceptable solution for now.