mirror
/
conan-config
mirror of https://github.com/Ultimaker/conan-config.git
1
0
Fork 1
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #12 from Ultimaker/CURA-11622_conan_v2 

Conan V2
pull/24/head
Erwan MATHIEU 1 year ago committed by GitHub
parent
f6f7779fa7 712ed439bb
commit
7a2667addd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 284 additions and 315 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      README.md
  2. 25
      conan.conf
  3. 39
      extensions/generators/PyCharmRunEnv.py
  4. 160
      extensions/generators/VirtualPythonEnv.py
  5. 30
      generators/GitHubActionsBuildEnv.py
  6. 30
      generators/GitHubActionsRunEnv.py
  7. 174
      generators/VirtualPythonEnv.py
  8. 8
      global.conf
  9. 45
      profiles/cura.jinja
  10. 11
      profiles/cura_build.jinja
  11. 13
      profiles/cura_clang.jinja
  12. 19
      profiles/cura_wasm.jinja
  13. 22
      profiles/installer.jinja
  14. 20
      remotes.json
  15. 1
      remotes.txt

2
README.md
Unescape View File

@ -6,3 +6,5 @@ use as:
```
conan config install https://github.com/Ultimaker/conan-config.git
```

25
conan.conf
Unescape View File

@ -1,25 +0,0 @@
[log]
run_to_output = True # environment CONAN_LOG_RUN_TO_OUTPUT
run_to_file = False # environment CONAN_LOG_RUN_TO_FILE
level = warn # environment CONAN_LOGGING_LEVEL
print_run_commands = True # environment CONAN_PRINT_RUN_COMMANDS
[general]
default_profile = default
compression_level = 9 # environment CONAN_COMPRESSION_LEVEL
sysrequires_sudo = True # environment CONAN_SYSREQUIRES_SUDO
request_timeout = 60 # environment CONAN_REQUEST_TIMEOUT (seconds)
default_package_id_mode = full_package_mode # environment CONAN_DEFAULT_PACKAGE_ID_MODE
revisions_enabled = True
scm_to_conandata = True
use_always_short_paths = True
config_install_interval = 12h
skip_broken_symlinks_check = True
[storage]
path = ./data
[proxies]
[hooks]
attribute_checker

39
generators/PyCharmRunEnv.py → extensions/generators/PyCharmRunEnv.py
Unescape View File

@ -1,12 +1,18 @@
from pathlib import Path
from typing import Dict
from conans import tools
from conans.model import Generator
from jinja2 import Template
from conan import ConanFile
from conan.tools.scm import Version
from conan.tools.files import save
from conan.tools.env.virtualrunenv import VirtualRunEnv
class PyCharmRunEnv(Generator):
class PyCharmRunEnv:
def __init__(self, conanfile: ConanFile):
self.conanfile: ConanFile = conanfile
self.settings = self.conanfile.settings
@property
def _base_dir(self):
return Path("$PROJECT_DIR$", "venv")
@ -14,7 +20,8 @@ class PyCharmRunEnv(Generator):
@property
def _py_interp(self):
if self.settings.os == "Windows":
py_interp = Path(*[f'"{p}"' if " " in p else p for p in self._base_dir.joinpath("Scripts", "python.exe").parts])
py_interp = Path(
*[f'"{p}"' if " " in p else p for p in self._base_dir.joinpath("Scripts", "python.exe").parts])
return py_interp
return self._base_dir.joinpath("bin", "python")
@ -22,21 +29,13 @@ class PyCharmRunEnv(Generator):
def _site_packages(self):
if self.settings.os == "Windows":
return self._base_dir.joinpath("Lib", "site-packages")
py_version = tools.Version(self.conanfile.deps_cpp_info["cpython"].version)
py_version = Version(self.conanfile.dependencies["cpython"].ref.version)
return self._base_dir.joinpath("lib", f"python{py_version.major}.{py_version.minor}", "site-packages")
@property
def filename(self):
pass
@property
def content(self) -> Dict[str, str]:
# Mapping of file names -> files
run_configurations: Dict[str, str] = {}
if not hasattr(self.conanfile, "_pycharm_targets"):
def generate(self) -> None:
if self.conanfile.conan_data is None or "pycharm_targets" not in self.conanfile.conan_data:
# There are no _pycharm_targets in the conanfile for the package using this generator.
return run_configurations
return
# Collect environment variables for use in the template
env = VirtualRunEnv(self.conanfile).environment()
@ -48,15 +47,13 @@ class PyCharmRunEnv(Generator):
env.compose_env(project_run_env) # TODO: Add logic for dependencies
# Create Pycharm run configuration from template for each target
for target in self.conanfile._pycharm_targets:
for target in self.conanfile.conan_data["pycharm_targets"]:
target["env_vars"] = env.vars(self.conanfile, scope="run")
target["sdk_path"] = str(self._py_interp)
if "parameters" not in target:
target["parameters"] = ""
with open(target["jinja_path"], "r") as f:
with open(Path(self.conanfile.source_folder, target["jinja_path"]), "r") as f:
template = Template(f.read())
run_configuration = template.render(target)
run_configurations[str(Path(self.conanfile.source_folder).joinpath(".run", f"{target['name']}.run.xml"))] = run_configuration
return run_configurations
save(self.conanfile, Path(".run", f"{target['name']}.run.xml"), run_configuration)

160
extensions/generators/VirtualPythonEnv.py
Unescape View File

@ -0,0 +1,160 @@
import os
import sys
from io import StringIO
from shutil import which
from pathlib import Path
from conan import ConanFile
from conan.errors import ConanException
from conan.tools.files import copy, save, load
from conan.tools.scm import Version
from conan.tools.env import VirtualRunEnv
import subprocess
class VirtualPythonEnv:
def __init__(self, conanfile: ConanFile):
self.conanfile: ConanFile = conanfile
def generate(self) -> None:
'''
Creates a Python venv using the CPython installed by conan, then create a script so that this venv can be easily used
in Conan commands, and finally install the pip dependencies declared in the conanfile data
'''
venv_name = f"{self.conanfile.name}_venv"
bin_venv_path = "Scripts" if self.conanfile.settings.os == "Windows" else "bin"
# Check if CPython is added as a dependency use the Conan recipe if available; if not use system interpreter
try:
cpython = self.conanfile.dependencies["cpython"]
py_interp = cpython.conf_info.get("user.cpython:python").replace("\\", "/")
except KeyError:
py_interp = sys.executable
run_env = VirtualRunEnv(self.conanfile)
env = run_env.environment()
env_vars = env.vars(self.conanfile, scope="run")
venv_folder = os.path.abspath(venv_name)
self.conanfile.output.info(f"Using Python interpreter '{py_interp}' to create Virtual Environment in '{venv_folder}'")
with env_vars.apply():
subprocess.run([py_interp, "-m", "venv", "--copies", venv_folder], check=True)
# Make sure there executable is named the same on all three OSes this allows it to be called with `python`
# simplifying GH Actions steps
if self.conanfile.settings.os != "Windows":
py_interp_venv = Path(venv_folder, bin_venv_path, "python")
if not py_interp_venv.exists():
py_interp_venv.hardlink_to(
Path(venv_folder, bin_venv_path, Path(sys.executable).stem + Path(sys.executable).suffix))
else:
py_interp_venv = Path(venv_folder, bin_venv_path,
Path(sys.executable).stem + Path(sys.executable).suffix)
# Generate a script that mimics the venv activate script but is callable easily in Conan commands
with env_vars.apply():
buffer = subprocess.run([py_interp_venv, "-c", "import sysconfig; print(sysconfig.get_path('purelib'))"], capture_output=True, encoding="utf-8", check=True).stdout
pythonpath = buffer.splitlines()[-1]
env.define_path("VIRTUAL_ENV", venv_folder)
env.prepend_path("PATH", os.path.join(venv_folder, bin_venv_path))
env.prepend_path("LD_LIBRARY_PATH", os.path.join(venv_folder, bin_venv_path))
env.prepend_path("DYLD_LIBRARY_PATH", os.path.join(venv_folder, bin_venv_path))
env.prepend_path("PYTHONPATH", pythonpath)
env.unset("PYTHONHOME")
env_vars.save_script("virtual_python_env")
# Install some base packages
with env_vars.apply():
subprocess.run([py_interp_venv, "-m", "pip", "install", "--upgrade", "pip"], check=True)
subprocess.run([py_interp_venv, "-m", "pip", "install", "wheel", "setuptools"], check=True)
requirements_core = self._make_pip_requirements_files("core")
requirements_dev = self._make_pip_requirements_files("dev")
requirements_installer = self._make_pip_requirements_files("installer")
self._install_pip_requirements(requirements_core, env_vars, py_interp_venv)
if self.conanfile.conf.get("user.generator.virtual_python_env:dev_tools", default=False, check_type=bool):
self._install_pip_requirements(requirements_dev, env_vars, py_interp_venv)
if self.conanfile.conf.get("user.generator.virtual_python_env:installer_tools", default=False,
check_type=bool):
self._install_pip_requirements(requirements_installer, env_vars, py_interp_venv)
def _install_pip_requirements(self, files_paths, env_vars, py_interp_venv):
with env_vars.apply():
for file_path in files_paths:
self.conanfile.output.info(f"Installing pip requirements from {file_path}")
subprocess.run([py_interp_venv, "-m", "pip", "install", "-r", file_path], check=True)
def _make_pip_requirements_files(self, suffix):
actual_os = str(self.conanfile.settings.os)
pip_requirements = VirtualPythonEnv._populate_pip_requirements(self.conanfile, suffix, actual_os)
for _, dependency in reversed(self.conanfile.dependencies.host.items()):
pip_requirements |= VirtualPythonEnv._populate_pip_requirements(dependency, suffix, actual_os)
# We need to make separate files because pip accepts either files containing hashes for all or none of the packages
requirements_basic_txt = []
requirements_hashes_txt = []
for package_name, package_desc in pip_requirements.items():
package_requirement = ""
packages_hashes = []
if "url" in package_desc:
package_requirement = f"{package_name}@{package_desc['url']}"
elif "version" in package_desc:
package_requirement = f"{package_name}=={package_desc['version']}"
else:
package_requirement = package_name
if "hashes" in package_desc:
for hash_str in package_desc["hashes"]:
packages_hashes.append(f"--hash={hash_str}")
destination_file = requirements_hashes_txt if len(packages_hashes) > 0 else requirements_basic_txt
destination_file.append(' '.join([package_requirement] + packages_hashes))
generated_files = []
self._make_pip_requirements_file(requirements_basic_txt, "basic", suffix, generated_files)
self._make_pip_requirements_file(requirements_hashes_txt, "hashes", suffix, generated_files)
return generated_files
def _make_pip_requirements_file(self, requirements_txt, requirements_type, suffix, generated_files):
if len(requirements_txt) > 0:
file_suffixes = [file_suffix for file_suffix in [suffix, requirements_type] if file_suffix is not None]
file_path = os.path.abspath(f"pip_requirements_{suffix}_{requirements_type}.txt")
self.conanfile.output.info(f"Generating pip requirements file at '{file_path}'")
save(self.conanfile, file_path, "\n".join(requirements_txt))
generated_files.append(file_path)
@staticmethod
def _populate_pip_requirements(conanfile, suffix, actual_os):
pip_requirements = {}
data_key = f"pip_requirements_{suffix}"
if hasattr(conanfile, "conan_data") and data_key in conanfile.conan_data:
pip_requirements_data = conanfile.conan_data[data_key]
for system in (system for system in pip_requirements_data if system in ("any_os", actual_os)):
for package_name, package_desc in pip_requirements_data[system].items():
try:
actual_package_version = Version(pip_requirements[package_name]["version"])
except KeyError:
actual_package_version = None
new_package_version = Version(package_desc["version"]) if "version" in package_desc else None
if (actual_package_version is None or
(actual_package_version is not None and new_package_version is not None and new_package_version > actual_package_version)):
pip_requirements[package_name] = package_desc
return pip_requirements

30
generators/GitHubActionsBuildEnv.py
Unescape View File

@ -1,30 +0,0 @@
from pathlib import Path
from jinja2 import Template
from conan.tools.env import VirtualBuildEnv
from conans.model import Generator
class GitHubActionsBuildEnv(Generator):
@property
def filename(self):
filepath = str(Path(self.conanfile.generators_folder).joinpath("activate_github_actions_buildenv"))
if self.conanfile.settings.get_safe("os") == "Windows":
if self.conanfile.conf.get("tools.env.virtualenv:powershell", check_type = bool):
filepath += ".ps1"
else:
filepath += ".bat"
else:
filepath += ".sh"
return filepath
@property
def content(self):
template = Template("""{% for k, v in envvars.items() %}echo "{{ k }}={{ v }}" >> ${{ env_prefix }}GITHUB_ENV\n{% endfor %}""")
build_env = VirtualBuildEnv(self.conanfile)
env = build_env.environment()
envvars = env.vars(self.conanfile, scope = "build")
env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
return template.render(envvars = envvars, env_prefix = env_prefix)

30
generators/GitHubActionsRunEnv.py
Unescape View File

@ -1,30 +0,0 @@
from pathlib import Path
from jinja2 import Template
from conan.tools.env import VirtualRunEnv
from conans.model import Generator
class GitHubActionsRunEnv(Generator):
@property
def filename(self):
filepath = str(Path(self.conanfile.generators_folder).joinpath("activate_github_actions_runenv"))
if self.conanfile.settings.get_safe("os") == "Windows":
if self.conanfile.conf.get("tools.env.virtualenv:powershell", check_type = bool):
filepath += ".ps1"
else:
filepath += ".bat"
else:
filepath += ".sh"
return filepath
@property
def content(self):
template = Template("""{% for k, v in envvars.items() %}echo "{{ k }}={{ v }}" >> ${{ env_prefix }}GITHUB_ENV\n{% endfor %}""")
build_env = VirtualRunEnv(self.conanfile)
env = build_env.environment()
envvars = env.vars(self.conanfile, scope = "run")
env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
return template.render(envvars = envvars, env_prefix = env_prefix)

174
generators/VirtualPythonEnv.py
Unescape View File

@ -1,174 +0,0 @@
import sys
import os
from io import StringIO
from pathlib import Path
from jinja2 import Template
from conan.tools.env import VirtualRunEnv
from conans.model import Generator
from conans.errors import ConanException
class VirtualPythonEnv(Generator):
@property
def _script_ext(self):
if self.conanfile.settings.get_safe("os") == "Windows":
return ".ps1"
return ".sh"
@property
def _venv_path(self):
if self.settings.os == "Windows":
return "Scripts"
return "bin"
@property
def filename(self):
pass
@property
def content(self):
python_interpreter = Path(self.conanfile.deps_user_info["cpython"].python)
# When on Windows execute as Windows Path
if self.conanfile.settings.os == "Windows":
python_interpreter = Path(*[f'"{p}"' if " " in p else p for p in python_interpreter.parts])
# Create the virtual environment
if self.conanfile.in_local_cache:
venv_folder = self.conanfile.install_folder
else:
venv_folder = self.conanfile.build_folder if self.conanfile.build_folder else Path(os.getcwd(), "venv")
self.conanfile.output.info(f"Creating virtual environment in {venv_folder}")
run_env = VirtualRunEnv(self.conanfile)
env = run_env.environment()
sys_vars = env.vars(self.conanfile, scope = "run")
with sys_vars.apply():
self.conanfile.run(f"""{python_interpreter} -m venv {venv_folder}""", scope = "run")
# Make sure there executable is named the same on all three OSes this allows it to be called with `python`
# simplifying GH Actions steps
if self.conanfile.settings.os != "Windows":
python_venv_interpreter = Path(venv_folder, self._venv_path, "python")
if not python_venv_interpreter.exists():
python_venv_interpreter.hardlink_to(
Path(venv_folder, self._venv_path, Path(sys.executable).stem + Path(sys.executable).suffix))
else:
python_venv_interpreter = Path(venv_folder, self._venv_path, Path(sys.executable).stem + Path(sys.executable).suffix)
if not python_venv_interpreter.exists():
raise ConanException(f"Virtual environment Python interpreter not found at: {python_venv_interpreter}")
if self.conanfile.settings.os == "Windows":
python_venv_interpreter = Path(*[f'"{p}"' if " " in p else p for p in python_venv_interpreter.parts])
buffer = StringIO()
outer = '"' if self.conanfile.settings.os == "Windows" else "'"
inner = "'" if self.conanfile.settings.os == "Windows" else '"'
with sys_vars.apply():
self.conanfile.run(f"""{python_venv_interpreter} -c {outer}import sysconfig; print(sysconfig.get_path({inner}purelib{inner})){outer}""",
env = "conanrun",
output = buffer)
pythonpath = buffer.getvalue().splitlines()[-1]
if hasattr(self.conanfile, f"_{self.conanfile.name}_run_env"):
project_run_env = getattr(self.conanfile, f"_{self.conanfile.name}_run_env")
if project_run_env:
env.compose_env(project_run_env) # TODO: Add logic for dependencies
env.define_path("VIRTUAL_ENV", venv_folder)
env.prepend_path("PATH", os.path.join(venv_folder, self._venv_path))
env.prepend_path("LD_LIBRARY_PATH", os.path.join(venv_folder, self._venv_path))
env.prepend_path("DYLD_LIBRARY_PATH", os.path.join(venv_folder, self._venv_path))
env.prepend_path("PYTHONPATH", pythonpath)
env.unset("PYTHONHOME")
venv_vars = env.vars(self.conanfile, scope = "run")
# Install some base_packages
with venv_vars.apply():
self.conanfile.run(f"""{python_venv_interpreter} -m pip install wheel setuptools""", env = "conanrun")
# Install pip_requirements from dependencies
for dep_name in reversed(self.conanfile.deps_user_info):
dep_user_info = self.conanfile.deps_user_info[dep_name]
if len(dep_user_info.vars) == 0:
continue
pip_req_paths = [self.conanfile.deps_cpp_info[dep_name].res_paths[i] for i, req_path in
enumerate(self.conanfile.deps_cpp_info[dep_name].resdirs) if req_path.endswith("pip_requirements")]
if len(pip_req_paths) != 1:
continue
pip_req_base_path = Path(pip_req_paths[0])
if hasattr(dep_user_info, "pip_requirements"):
req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements)
if req_txt.exists():
with venv_vars.apply():
self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements in user_info installed!")
else:
self.conanfile.output.warn(f"Dependency {dep_name} specifies pip_requirements in user_info but {req_txt} can't be found!")
if hasattr(dep_user_info, "pip_requirements_git"):
req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements_git)
if req_txt.exists():
with venv_vars.apply():
self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements_git in user_info installed!")
else:
self.conanfile.output.warn(
f"Dependency {dep_name} specifies pip_requirements_git in user_info but {req_txt} can't be found!")
if hasattr(dep_user_info, "pip_requirements_build"):
req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements_build)
if req_txt.exists():
with venv_vars.apply():
self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements_build in user_info installed!")
else:
self.conanfile.output.warn(
f"Dependency {dep_name} specifies pip_requirements_build in user_info but {req_txt} can't be found!")
if not self.conanfile.in_local_cache and hasattr(self.conanfile, "requirements_txts"):
# Install the Python requirements of the current conanfile requirements*.txt
pip_req_base_path = Path(self.conanfile.source_folder)
for req_path in sorted(self.conanfile.requirements_txts, reverse = True):
req_txt = pip_req_base_path.joinpath(req_path)
if req_txt.exists():
with venv_vars.apply():
self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
self.conanfile.output.success(f"Requirements file {req_txt} installed!")
else:
self.conanfile.output.warn(f"Requirements file {req_txt} can't be found!")
# Add all dlls/dylibs/so found in site-packages to the PATH, DYLD_LIBRARY_PATH and LD_LIBRARY_PATH
dll_paths = list({ dll.parent for dll in Path(pythonpath).glob("**/*.dll") })
for dll_path in dll_paths:
env.append_path("PATH", str(dll_path))
dylib_paths = list({ dylib.parent for dylib in Path(pythonpath).glob("**/*.dylib") })
for dylib_path in dylib_paths:
env.append_path("DYLD_LIBRARY_PATH", str(dylib_path))
so_paths = list({ so.parent for so in Path(pythonpath).glob("**/*.dylib") })
for so_path in so_paths:
env.append_path("LD_LIBRARY_PATH", str(so_path))
full_envvars = env.vars(self.conanfile, scope = "conanrun")
# Generate the Python Virtual Environment Script
full_envvars.save_sh(Path(venv_folder, self._venv_path, "activate"))
full_envvars.save_bat(Path(venv_folder, self._venv_path, "activate.bat"))
full_envvars.save_ps1(Path(venv_folder, self._venv_path, "Activate.ps1"))
# Generate the GitHub Action activation script
env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
activate_github_actions_buildenv = Template(r"""{% for var, value in envvars.items() %}echo "{{ var }}={{ value }}" >> ${{ env_prefix }}GITHUB_ENV
{% endfor %}""").render(envvars = full_envvars, env_prefix = env_prefix)
return {
str(Path(venv_folder, self._venv_path, f"activate_github_actions_env{self._script_ext}")): activate_github_actions_buildenv
}

8
global.conf
Unescape View File

@ -1,11 +1,5 @@
core:default_profile = cura.jinja
core:default_build_profile = cura_build.jinja
tools.cmake.cmaketoolchain:generator = Ninja
tools.env.virtualenv:auto_use = True
tools.gnu:define_libcxx11_abi = True
tools.build:skip_test = False
# FIXME: Needs to be commented out for OpenSSL to work but if we wan't to create ps1 scripts it needs to be set to True
# Otherwise .bat files are created. Maybe we should define this on a recipe basis:
#
#{% if platform.system() == 'Windows' %}tools.env.virtualenv:powershell=True{% endif %}
core.version_ranges:resolve_prereleases=True

45
profiles/cura.jinja
Unescape View File

@ -1,24 +1,37 @@
include(default)
[build_requires]
[settings]
compiler.cppstd=17
curaengine:compiler.cppstd=20
curaengine*:compiler.cppstd=20
curaengine_plugin_infill_generate:compiler.cppstd=20
curaengine_plugin_gradual_flow:compiler.cppstd=20
curaengine_grpc_definitions:compiler.cppstd=20
scripta:compiler.cppstd=20
curaengine_plugin_infill_generate*:compiler.cppstd=20
curaengine_plugin_gradual_flow*:compiler.cppstd=20
curaengine_grpc_definitions*:compiler.cppstd=20
scripta*:compiler.cppstd=20
umspatial*:compiler.cppstd=20
dulcificum:compiler.cppstd=20
cura_settings:compiler.cppstd=20
dulcificum*:compiler.cppstd=20
curator*:compiler.cppstd=20
{% if compiler == 'gcc' %}compiler.libcxx=libstdc++11
{% elif compiler == 'apple-clang' %}compiler.libcxx=libc++
{% elif compiler == 'Visual Studio' %}compiler.toolset=v143
{% endif %}
[options]
[env]
[conf]
asio-grpc/*:local_allocator=recycling_allocator
grpc/*:csharp_plugin=False
grpc/*:node_plugin=False
grpc/*:objective_c_plugin=False
grpc/*:php_plugin=False
grpc/*:ruby_plugin=False
grpc/*:python_plugin=False
boost/*:header_only=True
{% if platform.system() == 'Linux' %}
openssl/*:shared=True
{% endif %}
pyarcus/*:shared=True
pysavitar/*:shared=True
pynest2d/*:shared=True
cpython/*:shared=True
cpython/*:with_tkinter=False
cpython/*:with_curses=False
{% if platform.system() == 'Windows' %}
dulcificum/*:shared=False
{% else %}
dulcificum/*:shared=True
{% endif %}
clipper/*:shared=True

11
profiles/cura_build.jinja
Unescape View File

@ -1,15 +1,4 @@
include(default)
[build_requires]
[settings]
compiler.cppstd=17
{% if compiler == 'gcc' %}compiler.libcxx=libstdc++11
{% elif compiler == 'apple-clang' %}compiler.libcxx=libc++
{% elif compiler == 'Visual Studio' %}compiler.toolset=v143
{% endif %}
[options]
[env]
[conf]

13
profiles/cura_clang.jinja
Unescape View File

@ -0,0 +1,13 @@
include(cura.jinja)
[tool_requires]
[settings]
compiler=clang
compiler.version=18
compiler.libcxx=libstdc++11
[options]
[conf]
tools.build:compiler_executables={"c":"clang", "cpp":"clang++"}

19
profiles/cura_wasm.jinja
Unescape View File

@ -0,0 +1,19 @@
include(cura.jinja)
[tool_requires]
emsdk/3.1.65@ultimaker/stable
nodejs/20.16.0@ultimaker/stable
[settings]
os=Emscripten
arch=wasm
[conf]
tools.build:skip_test=True
[options]
curaengine/*:enable_plugins=False
curaengine/*:enable_arcus=False
curator/*:with_cura_resources=True
curator/*:disable_logging=True
libzip/*:crypto=False

22
profiles/installer.jinja
Unescape View File

@ -0,0 +1,22 @@
include(cura.jinja)
[conf]
tools.build:skip_test=True
user.sentry:url=https://734f9ec9024f73e53701d59c3ffddfe3@o323038.ingest.sentry.io/4506257745510401
user.sentry:organization=ultimaker-o7
[options]
curaengine/*:enable_sentry=True
curaengine/*:sentry_send_binaries=True
curaengine/*:sentry_create_release=True
arcus/*:enable_sentry=True
arcus/*:sentry_send_binaries=True
arcus/*:sentry_project=curaengine
clipper/*:enable_sentry=True
clipper/*:sentry_send_binaries=True
clipper/*:sentry_project=curaengine
[settings]
curaengine/*:build_type=RelWithDebInfo
arcus/*:build_type=RelWithDebInfo
clipper/*:build_type=RelWithDebInfo

20
remotes.json
Unescape View File

@ -0,0 +1,20 @@
{
"remotes": [
{
"name": "conancenter",
"url": "https://center2.conan.io",
"verify_ssl": true
},
{
"name": "cura-conan2",
"url": "https://cura.jfrog.io/artifactory/api/conan/cura-conan2-dev",
"verify_ssl": true
},
{
"name": "cura-private-conan2",
"url": "https://cura.jfrog.io/artifactory/api/conan/cura-private-conan2-dev",
"verify_ssl": true,
"disabled": true
}
]
}

1
remotes.txt
Unescape View File

@ -1 +0,0 @@
cura https://cura.jfrog.io/artifactory/api/conan/cura-conan-dev True
Write Preview
Loading…
Cancel
Save