#!/usr/bin/env python
# -*- coding: utf-8 -*-
from conans import python_requires
base = python_requires("boost_base/2.0.0@bincrafters/testing")
class BoostHOFConan(base.BoostBaseConan):
name = "boost_hof"
version = "1.70.0"
from conans import python_requires
import os
common = python_requires('llvm-common/0.0.0@orbitdeps/stable')
class LLVMBitReader(common.LLVMModulePackage):
version = common.LLVMModulePackage.version
name = 'llvm_bit_reader'
llvm_component = 'llvm'
llvm_module = 'BitReader'
llvm_requires = [
'llvm_headers', 'llvm_bitstream_reader', 'llvm_core', 'llvm_support'
]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from conans import python_requires
base = python_requires("boost_base/1.67.0@bincrafters/stable")
class BoostAlgorithmConan(base.BoostBaseConan):
name = "boost_algorithm"
url = "https://github.com/bincrafters/conan-boost_algorithm"
lib_short_names = ["algorithm"]
header_only_libs = ["algorithm"]
b2_requires = [
"boost_array", "boost_assert", "boost_bind", "boost_concept_check",
"boost_config", "boost_core", "boost_exception", "boost_function",
"boost_iterator", "boost_mpl", "boost_range", "boost_regex",
"boost_static_assert", "boost_throw_exception", "boost_tuple",
"boost_type_traits", "boost_unordered"
]
# SPDX-License-Identifier: GPL-2.0
# Copyright (c) 2019-2020 VMware, Inc. All rights reserved.
# Copyright (c) 2016-2019 Carbon Black, Inc. All rights reserved.
from conans import python_requires, CMake, tools, AutoToolsBuildEnvironment
import os
from datetime import datetime
base = python_requires("CONAN_UTIL_VERSION")
class KernelEventCollectorModule(base.CbConanFile):
name = "KernelEventCollectorModule"
version = "PROJECT_VERSION"
settings = "os", "arch"
generators = "cmake"
build_requires = "CPPUTEST_VERSION"
options = {'module_name': ['event_collector', 'cbsensor']}
default_options = "module_name=event_collector"
kernelDeps = [
"KERNEL_RHEL_6_6_VERSION", "KERNEL_RHEL_6_7_VERSION",
"KERNEL_RHEL_6_8_VERSION", "KERNEL_RHEL_6_9_VERSION",
"KERNEL_RHEL_6_10_VERSION", "KERNEL_RHEL_7_0_VERSION",
"KERNEL_RHEL_7_1_VERSION", "KERNEL_RHEL_7_2_VERSION",
"KERNEL_RHEL_7_3_VERSION", "KERNEL_RHEL_7_4_VERSION",
"KERNEL_RHEL_7_5_VERSION", "KERNEL_RHEL_7_6_VERSION",
"KERNEL_RHEL_7_7_VERSION", "KERNEL_RHEL_7_8_VERSION",
"KERNEL_RHEL_7_9_VERSION"
]
override_list = "KERNEL_OVERRIDE_LIST"
from conans import (
ConanFile,
python_requires,
)
b2 = python_requires("b2-helper/0.7.1@grisumbras/stable")
@b2.build_with_b2
class LibSassTestConan(ConanFile):
settings = "arch", "os", "compiler", "build_type"
exports_sources = "build.jam", "*.cpp"
from conans import ConanFile, python_requires
base = python_requires("waf-build-helper/0.1@czoido/testing")
class ConsumerConan(base.get_conanfile()):
settings = "os", "compiler", "build_type", "arch", "arch_build"
name = "waf-build-helper-consumer"
version = "0.2"
generators = "Waf"
exports = "wscript", "example.cpp"
requires = "opencv/4.1.0@conan/stable", "WafGen/0.1@czoido/testing"
build_requires = "waf/2.0.17@czoido/testing"
def source(self):
pass
def build(self):
waf = base.WafBuildEnvironment(self)
waf.configure()
waf.build()
def imports(self):
self.copy("*.dll", dst="build", src="lib")
self.copy("*.dylib*", dst="build", src="lib")
self.copy("*.so*", dst="build", src="lib")
from conans import python_requires
CMakeConanFile = python_requires('autorecipes/[*]@jfreeman/testing').cmake()
class Recipe(CMakeConanFile):
name = CMakeConanFile.__dict__['name']
version = CMakeConanFile.__dict__['version']
topics = ('testing')
settings = None
build_requires = (
'future/[*]@jfreeman/testing',
'Catch2/2.5.0@catchorg/stable',
'gtest/1.8.1@bincrafters/stable',
)
generators = 'cmake_find_package', 'cmake_paths'
def package_id(self):
return self.info.header_only()
from conans import python_requires
import os
pmi_helper = python_requires('pmi_common_recipe/1.0.7@pmi/develop')
class QtCommonConan(pmi_helper.CommonRecipeConan):
scm = {
'type': 'git',
'url': 'https://bitbucket.org/ykil/qt_common.git',
'revision': 'auto'
}
name = 'qt_common'
version = pmi_helper.pmi_version_from_cmake()
description = 'qt_common'
requires = (
'qt/5.9.2@pmi/develop',
'boost/1.66.0@pmi/develop',
'pmi_common_stable/2019.5.14@pmi/develop',
'qwt/6.1.3@pel/develop',
'eigen/3.3.5@pel/develop',
'sqlite3/3.20.0@pel/develop',
'vendor_api_qtc/0.0.1@pel/develop',
'pwiz_pmi/1.0.0@pel/develop'
)
options = {
'shared': [True, False],
'autotest': [True, False],
}
default_options= '''
shared=True
from conans import ConanFile, python_requires, tools
import os
common = python_requires(
'CastleConanRecipes/[>=0.0.22-0, include_prerelease=True]@BoseCorp/master')
class ProfessorDocker(common.MakefilePackage):
name = "Product-Docker"
version = common.get_version_git_tag(prefix="")
url = "https://github.com/BoseCorp/%s" % name
scm = {
"type": "git",
"url": "[email protected]:BoseCorp/%s.git" % name,
"revision": "auto"
}
x86_64_excludes = ["opensource-OpenAvnuApple", "RivieraSwUpRecovery"]
def build(self):
self.run(
'make cfg=%s sdk=%s jobs=%d DONT_UPDATE_CASTLETOOLS=1' %
(self.settings.build_type, self.settings.arch, tools.cpu_count()))
def requirements(self):
for package in common.parse_requires(
os.path.join(os.path.dirname(__file__), "depends.json")):
assert package[0]
packageName = package[0].split('/')[0]
assert packageName
from conans import ConanFile, CMake, tools
from conans import python_requires
base = python_requires("conan-base-project/0.1.0@test/test")
class ConanchildprojectConan(base.ConanbaseprojectConan):
name = "conan-child-project"
version = "0.1.0"
exports_sources = "CMakeLists.txt", "src/*"
generators = "cmake"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
self.copy("bin/*");
from conans import ConanFile, python_requires, VisualStudioBuildEnvironment, tools
import os, json, shutil
build_tools = "sqpBuildTools/[~2.2]@tools/release"
sqp = python_requires(build_tools)
def read_git_information():
# Wir ermitteln ein Map von wichtigen Informationen aus dem
# gitinfo.json, welches ganz zu Begin die Daten von Git enthält.
if os.path.exists("gitinfo.json"):
with open("gitinfo.json", "r") as read_file:
data = json.load(read_file)
author = data["gitinfo"]["author"]
branch = data["gitinfo"]["branch"]
commit_hash = data["gitinfo"]["commit_hash"]
return {
"author": author,
"branch": branch,
"commit_hash": commit_hash
}
class SQPQtIFWConan(ConanFile):
name = "sqpQtIFW"
version = sqp.get_version()
sqp.git_information()
license = "proprietary"
author = "swissQprint AG"
url = "www.swissqprint.com"
description = "Basic binary for building Qt installers."
from conans import ConanFile, python_requires
common = python_requires('conan_build_helper/0.0.1@conan/stable')
class ConanCommonRecipesTest(common.HeaderOnlyPackage):
def test(self):
pass
from conans import ConanFile, python_requires, tools
import os
base = python_requires("llvm-project/0.1@mmha/testing")
class IntelLLVMConan(base.llvm_base_project()):
name = "llvm"
version = "10.0.0-20190903"
description = "LLVM Compiler Infrastructure"
url = "https://llvm.org"
license = "Apache-2.0"
author = "LLVM"
topics = ("llvm", "clang", "compiler")
scm = {
"type": "git",
"url": "https://github.com/llvm/llvm-project.git",
"revision": "ea366122d28f7756008543e495f1899b64f4060a",
}
@property
def source_subfolder(self):
return "llvm"
llvm_cmake_options = {
# Build targets
"build_benchmarks": [True, False],
"build_examples": [True, False],
"build_instrumented_coverage": [True, False],
"build_llvm_dylib": [True, False],
from conans import (
ConanFile,
python_requires,
)
b2 = python_requires("b2-helper/[>=0.5.0]@grisumbras/stable")
@b2.build_with_b2
class MSassConan(ConanFile):
name = "m.sass"
version = "0.1.0"
description = "SASS version of m.css"
url = "https://github.com/grisumbras/m.sass"
homepage = url
license = "MIT"
exports_sources = ("LICENSE*", "jamroot.jam", "sass/*")
def package_info(self):
self.info.header_only()
self.cpp_info.includedirs = ["share"]
from conans import (
ConanFile,
python_requires,
tools,
)
import re
b2 = python_requires('b2-helper/0.5.0@grisumbras/stable')
def get_version():
try:
content = tools.load("build.jam")
match = re.search(r"constant\s*VERSION\s*:\s*(\S+)\s*;", content)
return match.group(1)
except:
pass
@b2.build_with_b2
class {{cookiecutter.project_name.title().replace('-', '').replace(' ', '')}}Conan(ConanFile):
name = '{{cookiecutter.project_slug}}'
version = get_version()
license = 'BSL-1.0'
description = '{{cookiecutter.project_description}}'
{% if cookiecutter.git -%}
{%- set url = 'https://'
+ cookiecutter.remote_server + '/'
+ cookiecutter.remote_username + '/'
+ cookiecutter.project_slug
from conans import ConanFile, python_requires
mytools = python_requires("mytools/0.1@user/testing")
class ConsumerConan(ConanFile):
name = "consumer"
version = "0.1"
settings = "os", "compiler", "build_type", "arch"
def build(self):
mytools.mymsg(self)
# -*- coding: utf-8 -*-
#
# Copyright 2012-2019 CNRS-UM LIRMM, CNRS-AIST JRL
#
from conans import python_requires
import conans.tools as tools
from conans.tools import SystemPackageTool, Version
import os
base = python_requires("RBDyn/1.1.0@gergondet/stable")
class EigenQLDConan(base.RBDynConan):
name = "eigen-qld"
version = "1.0.0"
description = "QLD QP solver through Eigen3 library"
topics = ("robotics", "optimization", "qp", "python")
url = "https://github.com/jrl-umi3218/eigen-qld"
homepage = "https://github.com/jrl-umi3218/eigen-qld"
author = "Pierre Gergondet <*****@*****.**>"
license = "BSD-2-Clause"
exports = ["LICENSE"]
exports_sources = [
"CMakeLists.txt", "conan/CMakeLists.txt", "binding/*", "cmake/*",
"doc/*", "src/*"
]
generators = "cmake"
settings = "os", "arch", "compiler", "build_type"
options = {"python_version": ["2.7", "3.3", "3.4", "3.5", "3.6", "3.7"]}
default_options = {"python_version": base.get_python_version()}
import os
from conans import ConanFile, python_requires
data = python_requires("fasttext_data/0.2.0@jgsogo/stable")
crawl_vector_languages = data.CrawlVectors.list_languages()
supervised_models = data.SupervisedModels.list_models()
def option_crawl(lang):
return "crawl_{}".format(lang)
def option_supervised(lang):
return "supervised_{}".format(lang)
class Example(ConanFile):
name = "example"
version = "0.2.0"
options = dict(
{option_crawl(lang): [True, False]
for lang in crawl_vector_languages}, **{
option_supervised(model): [True, False]
for model in supervised_models
})
default_options = dict(
{option_crawl(lang): False
for lang in crawl_vector_languages},
from conans import (
CMake,
ConanFile,
python_requires,
)
import os
b2 = python_requires("b2-helper/0.2.0@grisumbras/testing")
class EnumFlagsTestConan(ConanFile):
settings = "os", "compiler", "build_type", "arch", "cppstd",
build_requires = (
"boost_build/[>=1.68]@bincrafters/stable",
"boost_core/[>1.60]@bincrafters/stable",
"cmake_installer/[>3.0]@conan/stable",
)
generators = "b2"
def test(self):
builder = b2.B2(self)
builder.build_folder = os.path.join(self.build_folder, "base")
builder.configure()
builder.build()
builder = b2.B2(self)
builder.source_folder = os.path.join(self.source_folder, "pkgconfig")
builder.build_folder = os.path.join(self.build_folder, "pkgconfig")
builder.configure()
builder.build()
from conans import ConanFile, python_requires, CMake
from conans.errors import ConanInvalidConfiguration
conan_tools = python_requires("conan-tools/[>=1.0.0]@includeos/stable")
class IncludeOSConan(ConanFile):
settings= "os","arch","build_type","compiler"
name = "includeos"
version = conan_tools.git_get_semver()
license = 'Apache-2.0'
description = 'Run your application with zero overhead'
generators = [ 'cmake','virtualenv' ]
url = "http://www.includeos.org/"
scm = {
"type": "git",
"url": "auto",
"subfolder": ".",
"revision": "auto"
}
options = {
'platform': [
'default',
'nano',
'solo5-hvt',
'solo5-spt',
'userspace'
],
'smp': [ True, False ]
}
from conans import python_requires
base = python_requires("theo_conanfile/dev@theo/testing")
class BugConan(base.get_conanfile()):
name = "bug"
def build_requirements(self):
if self.should_build_tests:
# commenting the following line avoids the assert
self.build_requires("functional-helpers/%s@theo/testing" %
self.version)
# The following adds 3 build requirements, but functional-helpers is not one of them
super().build_requirements()
def requirements(self):
pass
#self.requires("log/%s@theo/testing" % self.version)
#self.requires("errors/%s@theo/testing" % self.version)
#self.requires("fmt/5.3.0@bincrafters/stable")
#self.requires("jsonformoderncpp/3.4.0@theo/testing")
#self.requires("optional-lite/3.1.1@theo/testing")
from conans import (
ConanFile,
python_requires,
tools,
)
import os
import re
b2 = python_requires("b2-helper/0.2.0@grisumbras/testing")
def get_version():
try:
content = tools.load("jamroot.jam")
match = re.search(r"constant\s*VERSION\s*:\s*(\S+)\s*;", content)
return match.group(1)
except:
pass
class EnumFlagsConan(b2.B2.Mixin, ConanFile):
name = "b2-tools"
version = get_version()
description = "Helper tools for Boost.Build"
topics = "building",
author = "Dmitry Arkhipov <*****@*****.**>"
license = "BSL-1.0"
url = "https://gitlab.com/grisumbras/b2-tools"
homepage = url
exports_sources = (
# -*- coding: utf-8 -*-
#
from conans import python_requires
import conans.tools as tools
from conans.tools import SystemPackageTool, Version
import os
base = python_requires("Eigen3ToPython/latest@multi-contact/dev")
class EigenQuadProgConan(base.Eigen3ToPythonConan):
name = "eigen-quadprog"
version = "1.1.0"
description = "QuadProg QP solver through Eigen3 library"
topics = ("robotics", "optimization", "qp", "python")
url = "https://github.com/jrl-umi3218/eigen-quadprog"
homepage = "https://github.com/jrl-umi3218/eigen-quadprog"
author = "Pierre Gergondet <*****@*****.**>"
license = "BSD-2-Clause"
exports = ["LICENSE"]
exports_sources = ["CMakeLists.txt", "conan/CMakeLists.txt", "binding/*", "cmake/*", "doc/*", "src/*"]
generators = "cmake"
settings = "os", "arch", "compiler", "build_type"
requires = (
"eigen/3.3.4@conan/stable"
)
def config_options(self):
del self.options.python2_version
del self.options.python3_version
from conans import python_requires
base = python_requires('MicroblinkConanFile/4.0.3@microblink/stable')
class MicroblinkRecognizerConanFile(base.MicroblinkConanFile):
options = dict(base.MicroblinkConanFile.options, **{
'result_jsonization': ['Off', 'Serialization', 'SerializationAndTesting'],
'binary_serialization': [True, False]
})
default_options = dict(base.MicroblinkConanFile.default_options, **{
'result_jsonization': 'Off'
})
def config_options(self):
if self.options.binary_serialization == None: # noqa: E711
if self.settings.os == 'Android':
self.options.binary_serialization = True
else:
self.options.binary_serialization = False
def configure(self):
self.options['*'].result_jsonization = self.options.result_jsonization
self.options['*'].binary_serialization = self.options.binary_serialization
self.options['*'].enable_testing = self.options.enable_testing
def common_recognizer_build_args(self):
cmake_args = [
f'-DRecognizer_RESULT_JSONIZATION={self.options.result_jsonization}',
f'-DRecognizer_BINARY_SERIALIZATION={self.options.binary_serialization}',
f'-DMB_ENABLE_TESTING={self.options.enable_testing}'
import glob
import os
from conans import ConanFile, CMake, tools
from conans.model.version import Version
from conans.errors import ConanInvalidConfiguration
from conans import ConanFile, CMake, tools, AutoToolsBuildEnvironment, RunEnvironment, python_requires
from conans.errors import ConanInvalidConfiguration, ConanException
from conans.tools import os_info
import os, re, stat, fnmatch, platform, glob, traceback, shutil
from functools import total_ordering
# if you using python less than 3 use from distutils import strtobool
from distutils.util import strtobool
conan_build_helper = python_requires("conan_build_helper/[~=0.0]@conan/stable")
# Users locally they get the 1.0.0 version,
# without defining any env-var at all,
# and CI servers will append the build number.
# USAGE
# version = get_version("1.0.0")
# BUILD_NUMBER=-pre1+build2 conan export-pkg . my_channel/release
def get_version(version):
bn = os.getenv("BUILD_NUMBER")
return (version + bn) if bn else version
class FmtConan(conan_build_helper.CMakePackage):
name = "fmt"
from conans import ConanFile, CMake, tools, python_requires
import traceback
import os
import shutil
from conans.tools import OSInfo
# if you using python less than 3 use from distutils import strtobool
from distutils.util import strtobool
basis_plugin_helper = python_requires("basis_plugin_helper/[~=0.0]@conan/stable")
class <%= projectName %>_conan_project(basis_plugin_helper.CMakePackage):
name = "<%= projectName %>"
version = "master"
url = "https://CHANGE_ME"
license = "MIT" # CHANGE_ME
author = "CHANGE_ME <>"
description = "<%= projectName %>: CHANGE_ME"
topics = tuple(['c++', 'CHANGE_ME'])
options = dict(basis_plugin_helper.CMakePackage.plugin_options, **{
'example_option': [True, False]
})
default_options = dict(basis_plugin_helper.CMakePackage.plugin_default_options, **{
"example_option": "True",
"flex_reflect_plugin:shared": "True",
"boost:no_rtti": "False",
"boost:no_exceptions": "False",
from conans import python_requires
common = python_requires('llvm-common/0.0.0@Manu343726/testing')
class Libclang(common.LLVMModulePackage):
version = common.LLVMModulePackage.version
name = 'libclang'
llvm_component = 'clang'
llvm_module = 'clang'
library_name = 'libclang'
llvm_requires = [
'clang_headers', 'clang_ast', 'clang_basic', 'clang_frontend',
'clang_index', 'clang_lex', 'clang_sema', 'clang_tooling',
'clang_arc_migrate', 'llvm_x86_codegen', 'llvm_x86_asm_printer',
'llvm_x86_asm_parser', 'llvm_x86_desc', 'llvm_x86_info', 'llvm_support'
]
options = {'with_clang': [True, False], **common.LLVMModulePackage.options}
default_options = (
'with_clang=False', ) + common.LLVMModulePackage.default_options
def package(self):
super().package()
if self.options.with_clang:
self.copy_from_component('clang*',
src='bin',
dst='bin',
keep_path=False)
from conans import ConanFile, CMake, python_requires
base = python_requires("pyreq/version@user/channel")
class ConsumerConan(base.get_conanfile()):
name = "consumer"
version = base.get_version()
# All the recipe attributes and methods are defined in
# the python_requires imported source, it is a very
# easy way to share all the business logic across
# all the recipes in the same company
# -*- coding: utf-8 -*-
#
# Copyright 2012-2019 CNRS-UM LIRMM, CNRS-AIST JRL
#
from conans import python_requires, tools
import os
base = python_requires("Eigen3ToPython/1.0.0@gergondet/stable")
get_python_version = base.get_python_version
class RBDynConan(base.Eigen3ToPythonConan):
name = "RBDyn"
version = "1.1.0"
description = "Model the dynamics of rigid body systems"
topics = ("robotics", "dynamics", "eigen", "python")
url = "https://github.com/jrl-umi3218/RBDyn"
homepage = "https://github.com/jrl-umi3218/RBDyn"
author = "Pierre Gergondet <*****@*****.**>"
license = "BSD-2-Clause"
exports = ["LICENSE"]
exports_sources = [
"CMakeLists.txt", "conan/CMakeLists.txt", "binding/*", "cmake/*",
"doc/*", "src/*"
]
generators = "cmake"
settings = "os", "arch", "compiler", "build_type"
options = {"python_version": ["2.7", "3.3", "3.4", "3.5", "3.6", "3.7"]}
default_options = {"python_version": get_python_version()}
from conans import python_requires
common = python_requires('conan_common_recipes/0.0.8@Manu343726/testing')
class ReactiveTelegram(common.CMakePackage):
name = 'reactive-telegram'
version = '0.0.0'
url = 'https://github.com/joaquintides/usingstdcpp2019'
license = 'MIT'
requires = ('tgbot_cpp/1.1@Manu343726/testing',
'boost_signals2/1.69.0@bincrafters/testing',
'fmt/5.2.1@bincrafters/stable',
'range-v3/0.4.0@ericniebler/stable')
default_options = {'tgbot_cpp:shared': False}
generators = 'cmake'
from conans import ConanFile, python_requires, CMake
conan_tools = python_requires("conan-tools/[>=1.0.0]@includeos/stable")
class UplinkConan(ConanFile):
settings = "os", "arch", "build_type", "compiler"
name = "uplink"
license = 'Apache-2.0'
version = conan_tools.git_get_semver()
description = 'Run your application with zero overhead'
generators = 'cmake'
url = "http://www.includeos.org/"
scm = {"type": "git", "url": "auto", "subfolder": ".", "revision": "auto"}
default_user = "******"
default_channel = "test"
options = {
"liveupdate": [True, False],
"tls": [True, False],
"uplink_log": [True, False]
}
default_options = {"liveupdate": True, "tls": True, "uplink_log": True}
no_copy_source = True
def package_id(self):
self.info.requires.major_mode()
def requirements(self):
self.requires(
from conans import python_requires, ConanFile
import os
cpython_version = "3.7.1"
cpython_base = python_requires(
"cpython_base/{}@maarten/testing".format(cpython_version))
assert cpython_version == cpython_base.CPythonBaseConan.version
class CPythonInstallerConan(cpython_base.CPythonBaseConan):
name = "cpython_installer"
version = cpython_version
description = "The Python programming language"
topics = ("conan", "python", "programming", "language", "scripting")
url = "https://github.com/bincrafters/conan-cpython_installer"
homepage = "https://www.python.org"
author = "Bincrafters <*****@*****.**>"
license = "PSF"
settings = "os_build", "arch_build"
options = cpython_base.CPythonBaseConan.base_options
default_options = cpython_base.CPythonBaseConan.base_default_options
cpython_base_fail_on_error = True
def config_options(self):
for option in self.options.fields:
setattr(self.options, option, False)
self.options.optimizations = False # True # FIXME: Enable when finished?
self.options.ctypes = True
self.options.decimal = True
