conanfile.py 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525
  1. import os
  2. from pathlib import Path
  3. from jinja2 import Template
  4. from conan import ConanFile
  5. from conan.tools.files import copy, rmdir, save, mkdir, rm, update_conandata
  6. from conan.tools.microsoft import unix_path
  7. from conan.tools.env import VirtualRunEnv, Environment, VirtualBuildEnv
  8. from conan.tools.scm import Version
  9. from conan.errors import ConanInvalidConfiguration, ConanException
  10. required_conan_version = ">=1.58.0 <2.0.0"
  11. class CuraConan(ConanFile):
  12. name = "cura"
  13. license = "LGPL-3.0"
  14. author = "UltiMaker"
  15. url = "https://github.com/Ultimaker/cura"
  16. description = "3D printer / slicing GUI built on top of the Uranium framework"
  17. topics = ("conan", "python", "pyqt6", "qt", "qml", "3d-printing", "slicer")
  18. build_policy = "missing"
  19. exports = "LICENSE*", "*.jinja"
  20. settings = "os", "compiler", "build_type", "arch"
  21. # FIXME: Remove specific branch once merged to main
  22. python_requires = "translationextractor/[>=2.2.0]@ultimaker/stable"
  23. options = {
  24. "enterprise": ["True", "False", "true", "false"], # Workaround for GH Action passing boolean as lowercase string
  25. "staging": ["True", "False", "true", "false"], # Workaround for GH Action passing boolean as lowercase string
  26. "devtools": [True, False], # FIXME: Split this up in testing and (development / build (pyinstaller) / system installer) tools
  27. "cloud_api_version": "ANY",
  28. "display_name": "ANY", # TODO: should this be an option??
  29. "cura_debug_mode": [True, False], # FIXME: Use profiles
  30. "internal": ["True", "False", "true", "false"], # Workaround for GH Action passing boolean as lowercase string
  31. "enable_i18n": [True, False],
  32. }
  33. default_options = {
  34. "enterprise": "False",
  35. "staging": "False",
  36. "devtools": False,
  37. "cloud_api_version": "1",
  38. "display_name": "UltiMaker Cura",
  39. "cura_debug_mode": False, # Not yet implemented
  40. "internal": "False",
  41. "enable_i18n": False,
  42. }
  43. def set_version(self):
  44. if not self.version:
  45. self.version = self.conan_data["version"]
  46. @property
  47. def _i18n_options(self):
  48. return self.conf.get("user.i18n:options", default = {"extract": True, "build": True}, check_type = dict)
  49. @property
  50. def _pycharm_targets(self):
  51. return self.conan_data["pycharm_targets"]
  52. # FIXME: These env vars should be defined in the runenv.
  53. _cura_env = None
  54. @property
  55. def _cura_run_env(self):
  56. if self._cura_env:
  57. return self._cura_env
  58. self._cura_env = Environment()
  59. self._cura_env.define("QML2_IMPORT_PATH", str(self._site_packages.joinpath("PyQt6", "Qt6", "qml")))
  60. self._cura_env.define("QT_PLUGIN_PATH", str(self._site_packages.joinpath("PyQt6", "Qt6", "plugins")))
  61. if not self.in_local_cache:
  62. self._cura_env.define("CURA_DATA_ROOT", str(self._share_dir.joinpath("cura")))
  63. if self.settings.os == "Linux":
  64. self._cura_env.define("QT_QPA_FONTDIR", "/usr/share/fonts")
  65. self._cura_env.define("QT_QPA_PLATFORMTHEME", "xdgdesktopportal")
  66. self._cura_env.define("QT_XKB_CONFIG_ROOT", "/usr/share/X11/xkb")
  67. return self._cura_env
  68. @property
  69. def _enterprise(self):
  70. return self.options.enterprise in ["True", 'true']
  71. @property
  72. def _internal(self):
  73. return self.options.internal in ["True", 'true']
  74. @property
  75. def _app_name(self):
  76. if self._enterprise:
  77. return str(self.options.display_name) + " Enterprise"
  78. return str(self.options.display_name)
  79. @property
  80. def _urls(self):
  81. if self.options.staging in ["True", 'true']:
  82. return "staging"
  83. return "default"
  84. @property
  85. def requirements_txts(self):
  86. if self.options.devtools:
  87. return ["requirements.txt", "requirements-ultimaker.txt", "requirements-dev.txt"]
  88. return ["requirements.txt", "requirements-ultimaker.txt"]
  89. @property
  90. def _base_dir(self):
  91. if self.install_folder is None:
  92. if self.build_folder is not None:
  93. return Path(self.build_folder)
  94. return Path(os.getcwd(), "venv")
  95. if self.in_local_cache:
  96. return Path(self.install_folder)
  97. else:
  98. return Path(self.source_folder, "venv")
  99. @property
  100. def _share_dir(self):
  101. return self._base_dir.joinpath("share")
  102. @property
  103. def _script_dir(self):
  104. if self.settings.os == "Windows":
  105. return self._base_dir.joinpath("Scripts")
  106. return self._base_dir.joinpath("bin")
  107. @property
  108. def _site_packages(self):
  109. if self.settings.os == "Windows":
  110. return self._base_dir.joinpath("Lib", "site-packages")
  111. py_version = Version(self.deps_cpp_info["cpython"].version)
  112. return self._base_dir.joinpath("lib", f"python{py_version.major}.{py_version.minor}", "site-packages")
  113. @property
  114. def _py_interp(self):
  115. py_interp = self._script_dir.joinpath(Path(self.deps_user_info["cpython"].python).name)
  116. if self.settings.os == "Windows":
  117. py_interp = Path(*[f'"{p}"' if " " in p else p for p in py_interp.parts])
  118. return py_interp
  119. @property
  120. def _pyinstaller_spec_arch(self):
  121. if self.settings.os == "Macos":
  122. if self.settings.arch == "armv8":
  123. return "'arm64'"
  124. return "'x86_64'"
  125. return "None"
  126. def _conan_installs(self):
  127. conan_installs = {}
  128. # list of conan installs
  129. for dependency in self.dependencies.host.values():
  130. conan_installs[dependency.ref.name] = {
  131. "version": dependency.ref.version,
  132. "revision": dependency.ref.revision
  133. }
  134. return conan_installs
  135. def _python_installs(self):
  136. python_installs = {}
  137. # list of python installs
  138. python_ins_cmd = f"python -c \"import pkg_resources; print(';'.join([(s.key+','+ s.version) for s in pkg_resources.working_set]))\""
  139. from six import StringIO
  140. buffer = StringIO()
  141. self.run(python_ins_cmd, run_environment= True, env = "conanrun", output=buffer)
  142. packages = str(buffer.getvalue()).split("-----------------\n")
  143. packages = packages[1].strip('\r\n').split(";")
  144. for package in packages:
  145. name, version = package.split(",")
  146. python_installs[name] = {"version": version}
  147. return python_installs
  148. def _generate_cura_version(self, location):
  149. with open(os.path.join(self.recipe_folder, "CuraVersion.py.jinja"), "r") as f:
  150. cura_version_py = Template(f.read())
  151. # If you want a specific Cura version to show up on the splash screen add the user configuration `user.cura:version=VERSION`
  152. # the global.conf, profile, package_info (of dependency) or via the cmd line `-c user.cura:version=VERSION`
  153. cura_version = Version(self.conf.get("user.cura:version", default = self.version, check_type = str))
  154. pre_tag = f"-{cura_version.pre}" if cura_version.pre else ""
  155. build_tag = f"+{cura_version.build}" if cura_version.build else ""
  156. internal_tag = f"+internal" if self._internal else ""
  157. cura_version = f"{cura_version.major}.{cura_version.minor}.{cura_version.patch}{pre_tag}{build_tag}{internal_tag}"
  158. with open(os.path.join(location, "CuraVersion.py"), "w") as f:
  159. f.write(cura_version_py.render(
  160. cura_app_name = self.name,
  161. cura_app_display_name = self._app_name,
  162. cura_version = cura_version,
  163. cura_build_type = "Enterprise" if self._enterprise else "",
  164. cura_debug_mode = self.options.cura_debug_mode,
  165. cura_cloud_api_root = self.conan_data["urls"][self._urls]["cloud_api_root"],
  166. cura_cloud_api_version = self.options.cloud_api_version,
  167. cura_cloud_account_api_root = self.conan_data["urls"][self._urls]["cloud_account_api_root"],
  168. cura_marketplace_root = self.conan_data["urls"][self._urls]["marketplace_root"],
  169. cura_digital_factory_url = self.conan_data["urls"][self._urls]["digital_factory_url"],
  170. cura_latest_url=self.conan_data["urls"][self._urls]["cura_latest_url"],
  171. conan_installs=self._conan_installs(),
  172. python_installs=self._python_installs(),
  173. ))
  174. def _generate_pyinstaller_spec(self, location, entrypoint_location, icon_path, entitlements_file):
  175. pyinstaller_metadata = self.conan_data["pyinstaller"]
  176. datas = []
  177. for data in pyinstaller_metadata["datas"].values():
  178. if not self._internal and data.get("internal", False):
  179. continue
  180. if "package" in data: # get the paths from conan package
  181. if data["package"] == self.name:
  182. if self.in_local_cache:
  183. src_path = os.path.join(self.package_folder, data["src"])
  184. else:
  185. src_path = os.path.join(self.source_folder, data["src"])
  186. else:
  187. src_path = os.path.join(self.deps_cpp_info[data["package"]].rootpath, data["src"])
  188. elif "root" in data: # get the paths relative from the install folder
  189. src_path = os.path.join(self.install_folder, data["root"], data["src"])
  190. else:
  191. continue
  192. if Path(src_path).exists():
  193. datas.append((str(src_path), data["dst"]))
  194. binaries = []
  195. for binary in pyinstaller_metadata["binaries"].values():
  196. if "package" in binary: # get the paths from conan package
  197. src_path = os.path.join(self.deps_cpp_info[binary["package"]].rootpath, binary["src"])
  198. elif "root" in binary: # get the paths relative from the sourcefolder
  199. src_path = str(self.source_path.joinpath(binary["root"], binary["src"]))
  200. if self.settings.os == "Windows":
  201. src_path = src_path.replace("\\", "\\\\")
  202. else:
  203. continue
  204. if not Path(src_path).exists():
  205. self.output.warning(f"Source path for binary {binary['binary']} does not exist")
  206. continue
  207. for bin in Path(src_path).glob(binary["binary"] + "*[.exe|.dll|.so|.dylib|.so.|.pdb]*"):
  208. binaries.append((str(bin), binary["dst"]))
  209. for bin in Path(src_path).glob(binary["binary"]):
  210. binaries.append((str(bin), binary["dst"]))
  211. # Make sure all Conan dependencies which are shared are added to the binary list for pyinstaller
  212. for _, dependency in self.dependencies.host.items():
  213. for bin_paths in dependency.cpp_info.bindirs:
  214. binaries.extend([(f"{p}", ".") for p in Path(bin_paths).glob("**/*.dll")])
  215. for lib_paths in dependency.cpp_info.libdirs:
  216. binaries.extend([(f"{p}", ".") for p in Path(lib_paths).glob("**/*.so*")])
  217. binaries.extend([(f"{p}", ".") for p in Path(lib_paths).glob("**/*.dylib*")])
  218. # Copy dynamic libs from lib path
  219. binaries.extend([(f"{p}", ".") for p in Path(self._base_dir.joinpath("lib")).glob("**/*.dylib*")])
  220. binaries.extend([(f"{p}", ".") for p in Path(self._base_dir.joinpath("lib")).glob("**/*.so*")])
  221. # Collect all dll's from PyQt6 and place them in the root
  222. binaries.extend([(f"{p}", ".") for p in Path(self._site_packages, "PyQt6", "Qt6").glob("**/*.dll")])
  223. with open(os.path.join(self.recipe_folder, "UltiMaker-Cura.spec.jinja"), "r") as f:
  224. pyinstaller = Template(f.read())
  225. version = self.conf.get("user.cura:version", default = self.version, check_type = str)
  226. cura_version = Version(version)
  227. with open(os.path.join(location, "UltiMaker-Cura.spec"), "w") as f:
  228. f.write(pyinstaller.render(
  229. name = str(self.options.display_name).replace(" ", "-"),
  230. display_name = self._app_name,
  231. entrypoint = entrypoint_location,
  232. datas = datas,
  233. binaries = binaries,
  234. venv_script_path = str(self._script_dir),
  235. hiddenimports = pyinstaller_metadata["hiddenimports"],
  236. collect_all = pyinstaller_metadata["collect_all"],
  237. icon = icon_path,
  238. entitlements_file = entitlements_file,
  239. osx_bundle_identifier = "'nl.ultimaker.cura'" if self.settings.os == "Macos" else "None",
  240. upx = str(self.settings.os == "Windows"),
  241. 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
  242. target_arch = self._pyinstaller_spec_arch,
  243. macos = self.settings.os == "Macos",
  244. version = f"'{version}'",
  245. short_version = f"'{cura_version.major}.{cura_version.minor}.{cura_version.patch}'",
  246. ))
  247. def export(self):
  248. update_conandata(self, {"version": self.version})
  249. def export_sources(self):
  250. copy(self, "*", os.path.join(self.recipe_folder, "plugins"), os.path.join(self.export_sources_folder, "plugins"))
  251. copy(self, "*", os.path.join(self.recipe_folder, "resources"), os.path.join(self.export_sources_folder, "resources"), excludes = "*.mo")
  252. copy(self, "*", os.path.join(self.recipe_folder, "tests"), os.path.join(self.export_sources_folder, "tests"))
  253. copy(self, "*", os.path.join(self.recipe_folder, "cura"), os.path.join(self.export_sources_folder, "cura"), excludes="CuraVersion.py")
  254. copy(self, "*", os.path.join(self.recipe_folder, "packaging"), os.path.join(self.export_sources_folder, "packaging"))
  255. copy(self, "*", os.path.join(self.recipe_folder, ".run_templates"), os.path.join(self.export_sources_folder, ".run_templates"))
  256. copy(self, "requirements.txt", self.recipe_folder, self.export_sources_folder)
  257. copy(self, "requirements-dev.txt", self.recipe_folder, self.export_sources_folder)
  258. copy(self, "requirements-ultimaker.txt", self.recipe_folder, self.export_sources_folder)
  259. copy(self, "cura_app.py", self.recipe_folder, self.export_sources_folder)
  260. def config_options(self):
  261. if self.settings.os == "Windows" and not self.conf.get("tools.microsoft.bash:path", check_type=str):
  262. del self.options.enable_i18n
  263. def configure(self):
  264. self.options["pyarcus"].shared = True
  265. self.options["pysavitar"].shared = True
  266. self.options["pynest2d"].shared = True
  267. self.options["dulcificum"].shared = self.settings.os != "Windows"
  268. self.options["cpython"].shared = True
  269. self.options["boost"].header_only = True
  270. if self.settings.os == "Linux":
  271. self.options["curaengine_grpc_definitions"].shared = True
  272. self.options["openssl"].shared = True
  273. if self.conf.get("user.curaengine:sentry_url", "", check_type=str) != "":
  274. self.options["curaengine"].enable_sentry = True
  275. def validate(self):
  276. version = self.conf.get("user.cura:version", default = self.version, check_type = str)
  277. if version and Version(version) <= Version("4"):
  278. raise ConanInvalidConfiguration("Only versions 5+ are support")
  279. def requirements(self):
  280. for req in self.conan_data["requirements"]:
  281. if self._internal and "fdm_materials" in req:
  282. continue
  283. self.requires(req)
  284. if self._internal:
  285. for req in self.conan_data["requirements_internal"]:
  286. self.requires(req)
  287. self.requires("cpython/3.10.4@ultimaker/stable")
  288. self.requires("openssl/3.2.0")
  289. self.requires("boost/1.82.0")
  290. self.requires("spdlog/1.12.0")
  291. self.requires("fmt/10.1.1")
  292. self.requires("zlib/1.2.13")
  293. def build_requirements(self):
  294. if self.options.get_safe("enable_i18n", False):
  295. self.tool_requires("gettext/0.21", force_host_context = True)
  296. def layout(self):
  297. self.folders.source = "."
  298. self.folders.build = "venv"
  299. self.folders.generators = os.path.join(self.folders.build, "conan")
  300. self.cpp.package.libdirs = [os.path.join("site-packages", "cura")]
  301. self.cpp.package.bindirs = ["bin"]
  302. self.cpp.package.resdirs = ["resources", "plugins", "packaging", "pip_requirements"] # pip_requirements should be the last item in the list
  303. def generate(self):
  304. copy(self, "cura_app.py", self.source_folder, str(self._script_dir))
  305. cura_run_envvars = self._cura_run_env.vars(self, scope = "run")
  306. ext = ".ps1" if self.settings.os == "Windows" else ".sh"
  307. cura_run_envvars.save_script(os.path.join(self.folders.generators, f"cura_run_environment{ext}"))
  308. vr = VirtualRunEnv(self)
  309. vr.generate()
  310. self._generate_cura_version(os.path.join(self.source_folder, "cura"))
  311. if not self.in_local_cache:
  312. # Copy CuraEngine.exe to bindirs of Virtual Python Environment
  313. curaengine = self.dependencies["curaengine"].cpp_info
  314. copy(self, "CuraEngine.exe", curaengine.bindirs[0], self.source_folder, keep_path = False)
  315. copy(self, "CuraEngine", curaengine.bindirs[0], self.source_folder, keep_path = False)
  316. # Copy the external plugins that we want to bundle with Cura
  317. rmdir(self,str(self.source_path.joinpath("plugins", "CuraEngineGradualFlow")))
  318. curaengine_plugin_gradual_flow = self.dependencies["curaengine_plugin_gradual_flow"].cpp_info
  319. copy(self, "*", curaengine_plugin_gradual_flow.resdirs[0], str(self.source_path.joinpath("plugins", "CuraEngineGradualFlow")), keep_path = True)
  320. copy(self, "*", curaengine_plugin_gradual_flow.bindirs[0], self.source_folder, keep_path = False)
  321. copy(self, "bundled_*.json", curaengine_plugin_gradual_flow.resdirs[1], str(self.source_path.joinpath("resources", "bundled_packages")), keep_path = False)
  322. # Copy resources of cura_binary_data
  323. cura_binary_data = self.dependencies["cura_binary_data"].cpp_info
  324. copy(self, "*", cura_binary_data.resdirs[0], str(self._share_dir.joinpath("cura")), keep_path = True)
  325. copy(self, "*", cura_binary_data.resdirs[1], str(self._share_dir.joinpath("uranium")), keep_path = True)
  326. if self.settings.os == "Windows":
  327. copy(self, "*", cura_binary_data.resdirs[2], str(self._share_dir.joinpath("windows")), keep_path = True)
  328. for dependency in self.dependencies.host.values():
  329. for bindir in dependency.cpp_info.bindirs:
  330. copy(self, "*.dll", bindir, str(self._site_packages), keep_path = False)
  331. for libdir in dependency.cpp_info.libdirs:
  332. copy(self, "*.pyd", libdir, str(self._site_packages), keep_path = False)
  333. copy(self, "*.pyi", libdir, str(self._site_packages), keep_path = False)
  334. copy(self, "*.dylib", libdir, str(self._base_dir.joinpath("lib")), keep_path = False)
  335. # Copy materials (flat)
  336. rmdir(self, os.path.join(self.source_folder, "resources", "materials"))
  337. fdm_materials = self.dependencies["fdm_materials"].cpp_info
  338. copy(self, "*", fdm_materials.resdirs[0], self.source_folder)
  339. # Copy internal resources
  340. if self._internal:
  341. cura_private_data = self.dependencies["cura_private_data"].cpp_info
  342. copy(self, "*", cura_private_data.resdirs[0], str(self._share_dir.joinpath("cura")))
  343. if self.options.devtools:
  344. entitlements_file = "'{}'".format(os.path.join(self.source_folder, "packaging", "MacOS", "cura.entitlements"))
  345. self._generate_pyinstaller_spec(
  346. location=self.generators_folder,
  347. entrypoint_location="'{}'".format(
  348. os.path.join(self.source_folder, self.conan_data["pyinstaller"]["runinfo"]["entrypoint"])).replace(
  349. "\\", "\\\\"),
  350. icon_path="'{}'".format(os.path.join(self.source_folder, "packaging",
  351. self.conan_data["pyinstaller"]["icon"][
  352. str(self.settings.os)])).replace("\\", "\\\\"),
  353. entitlements_file=entitlements_file if self.settings.os == "Macos" else "None"
  354. )
  355. if self.options.get_safe("enable_i18n", False) and self._i18n_options["extract"]:
  356. # Update the po and pot files
  357. vb = VirtualBuildEnv(self)
  358. vb.generate()
  359. # # FIXME: once m4, autoconf, automake are Conan V2 ready use self.win_bash and add gettext as base tool_requirement
  360. cpp_info = self.dependencies["gettext"].cpp_info
  361. pot = self.python_requires["translationextractor"].module.ExtractTranslations(self, cpp_info.bindirs[0])
  362. pot.generate()
  363. def build(self):
  364. if self.options.get_safe("enable_i18n", False) and self._i18n_options["build"]:
  365. for po_file in self.source_path.joinpath("resources", "i18n").glob("**/*.po"):
  366. mo_file = Path(self.build_folder, po_file.with_suffix('.mo').relative_to(self.source_path))
  367. mo_file = mo_file.parent.joinpath("LC_MESSAGES", mo_file.name)
  368. mkdir(self, str(unix_path(self, Path(mo_file).parent)))
  369. cpp_info = self.dependencies["gettext"].cpp_info
  370. self.run(f"{cpp_info.bindirs[0]}/msgfmt {po_file} -o {mo_file} -f", env="conanbuild", ignore_errors=True)
  371. def deploy(self):
  372. copy(self, "*", os.path.join(self.package_folder, self.cpp.package.resdirs[2]), os.path.join(self.install_folder, "packaging"), keep_path = True)
  373. # Copy resources of Cura (keep folder structure) needed by pyinstaller to determine the module structure
  374. copy(self, "*", os.path.join(self.package_folder, self.cpp_info.bindirs[0]), str(self._base_dir), keep_path = False)
  375. copy(self, "*", os.path.join(self.package_folder, self.cpp_info.libdirs[0]), str(self._site_packages.joinpath("cura")), keep_path = True)
  376. copy(self, "*", os.path.join(self.package_folder, self.cpp_info.resdirs[0]), str(self._share_dir.joinpath("cura", "resources")), keep_path = True)
  377. copy(self, "*", os.path.join(self.package_folder, self.cpp_info.resdirs[1]), str(self._share_dir.joinpath("cura", "plugins")), keep_path = True)
  378. # Copy resources of Uranium (keep folder structure)
  379. uranium = self.dependencies["uranium"].cpp_info
  380. copy(self, "*", uranium.resdirs[0], str(self._share_dir.joinpath("uranium", "resources")), keep_path = True)
  381. copy(self, "*", uranium.resdirs[1], str(self._share_dir.joinpath("uranium", "plugins")), keep_path = True)
  382. copy(self, "*", uranium.libdirs[0], str(self._site_packages.joinpath("UM")), keep_path = True)
  383. # Generate the GitHub Action version info Environment
  384. version = self.conf.get("user.cura:version", default = self.version, check_type = str)
  385. cura_version = Version(version)
  386. env_prefix = "Env:" if self.settings.os == "Windows" else ""
  387. activate_github_actions_version_env = Template(r"""echo "CURA_VERSION_MAJOR={{ cura_version_major }}" >> ${{ env_prefix }}GITHUB_ENV
  388. echo "CURA_VERSION_MINOR={{ cura_version_minor }}" >> ${{ env_prefix }}GITHUB_ENV
  389. echo "CURA_VERSION_PATCH={{ cura_version_patch }}" >> ${{ env_prefix }}GITHUB_ENV
  390. echo "CURA_VERSION_BUILD={{ cura_version_build }}" >> ${{ env_prefix }}GITHUB_ENV
  391. echo "CURA_VERSION_FULL={{ cura_version_full }}" >> ${{ env_prefix }}GITHUB_ENV
  392. echo "CURA_APP_NAME={{ cura_app_name }}" >> ${{ env_prefix }}GITHUB_ENV
  393. """).render(cura_version_major = cura_version.major,
  394. cura_version_minor = cura_version.minor,
  395. cura_version_patch = cura_version.patch,
  396. cura_version_build = cura_version.build if cura_version.build != "" else "0",
  397. cura_version_full = self.version,
  398. cura_app_name = self._app_name,
  399. env_prefix = env_prefix)
  400. ext = ".sh" if self.settings.os != "Windows" else ".ps1"
  401. save(self, os.path.join(self._script_dir, f"activate_github_actions_version_env{ext}"), activate_github_actions_version_env)
  402. self._generate_cura_version(os.path.join(self._site_packages, "cura"))
  403. entitlements_file = "'{}'".format(Path(self.cpp_info.res_paths[2], "MacOS", "cura.entitlements"))
  404. self._generate_pyinstaller_spec(location = self._base_dir,
  405. entrypoint_location = "'{}'".format(os.path.join(self.package_folder, self.cpp_info.bindirs[0], self.conan_data["pyinstaller"]["runinfo"]["entrypoint"])).replace("\\", "\\\\"),
  406. icon_path = "'{}'".format(os.path.join(self.package_folder, self.cpp_info.resdirs[2], self.conan_data["pyinstaller"]["icon"][str(self.settings.os)])).replace("\\", "\\\\"),
  407. entitlements_file = entitlements_file if self.settings.os == "Macos" else "None")
  408. def package(self):
  409. copy(self, "cura_app.py", src = self.source_folder, dst = os.path.join(self.package_folder, self.cpp.package.bindirs[0]))
  410. copy(self, "*", src = os.path.join(self.source_folder, "cura"), dst = os.path.join(self.package_folder, self.cpp.package.libdirs[0]))
  411. copy(self, "*", src = os.path.join(self.source_folder, "resources"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[0]))
  412. copy(self, "*.mo", os.path.join(self.build_folder, "resources"), os.path.join(self.package_folder, "resources"))
  413. copy(self, "*", src = os.path.join(self.source_folder, "plugins"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[1]))
  414. copy(self, "requirement*.txt", src = self.source_folder, dst = os.path.join(self.package_folder, self.cpp.package.resdirs[-1]))
  415. copy(self, "*", src = os.path.join(self.source_folder, "packaging"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[2]))
  416. # Remove the CuraEngineGradualFlow plugin from the package
  417. rmdir(self, os.path.join(self.package_folder, self.cpp.package.resdirs[1], "CuraEngineGradualFlow"))
  418. rm(self, "bundled_*.json", os.path.join(self.package_folder, self.cpp.package.resdirs[0], "bundled_packages"), recursive = False)
  419. # Remove the fdm_materials from the package
  420. rmdir(self, os.path.join(self.package_folder, self.cpp.package.resdirs[0], "materials"))
  421. def package_info(self):
  422. self.user_info.pip_requirements = "requirements.txt"
  423. self.user_info.pip_requirements_git = "requirements-ultimaker.txt"
  424. self.user_info.pip_requirements_build = "requirements-dev.txt"
  425. if self.in_local_cache:
  426. self.runenv_info.append_path("PYTHONPATH", os.path.join(self.package_folder, "site-packages"))
  427. self.runenv_info.append_path("PYTHONPATH", os.path.join(self.package_folder, "plugins"))
  428. else:
  429. self.runenv_info.append_path("PYTHONPATH", self.source_folder)
  430. self.runenv_info.append_path("PYTHONPATH", os.path.join(self.source_folder, "plugins"))
  431. def package_id(self):
  432. self.info.clear()
  433. # The following options shouldn't be used to determine the hash, since these are only used to set the CuraVersion.py
  434. # which will als be generated by the deploy method during the `conan install cura/5.1.0@_/_`
  435. del self.info.options.enterprise
  436. del self.info.options.staging
  437. del self.info.options.devtools
  438. del self.info.options.cloud_api_version
  439. del self.info.options.display_name
  440. del self.info.options.cura_debug_mode
  441. self.options.rm_safe("enable_i18n")
  442. # TODO: Use the hash of requirements.txt and requirements-ultimaker.txt, Because changing these will actually result in a different
  443. # Cura. This is needed because the requirements.txt aren't managed by Conan and therefor not resolved in the package_id. This isn't
  444. # ideal but an acceptable solution for now.