conan-server 2.17.0__tar.gz → 2.18.0__tar.gz

conan_server-2.18.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.1
+Name: conan_server
+Version: 2.18.0
+Summary: Conan Server of Conan C/C++ package manager
+Home-page: https://conan.io
+Author: JFrog LTD
+Author-email: luism@jfrog.com
+License: MIT
+Description: <picture>
+          <!-- These are also used for https://github.com/conan-io/.github/blob/main/profile/README.md -->
+          <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/conan-io/conan/develop2/.github/conan2-logo-for-dark.svg">
+          <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/conan-io/conan/develop2/.github/conan2-logo-for-light.svg">
+          <img alt="JFrog | Conan 2.0 Logo" src="https://raw.githubusercontent.com/conan-io/conan/develop2/.github/conan2-logo-with-bg.svg">
+        </picture>
+        
+        # Conan
+        
+        Decentralized, open-source (MIT), C/C++ package manager.
+        
+        - Homepage: https://conan.io/
+        - Github: https://github.com/conan-io/conan
+        - Docs: https://docs.conan.io
+        - Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://join.slack.com/t/cpplang/shared_invite/zt-1snzdn6rp-rOUxF3166oz1_11Tr5H~xg) to get an invitation)
+        - Twitter: https://twitter.com/conan_io
+        - Blog: https://blog.conan.io
+        - Security reports: https://jfrog.com/trust/report-vulnerability
+        
+        
+        Conan is a package manager for C and C++ developers:
+        
+        - It is fully decentralized. Users can host their packages on their servers, privately. Integrates with Artifactory and Bintray.
+        - Portable. Works across all platforms, including Linux, OSX, Windows (with native and first-class support, WSL, MinGW),
+          Solaris, FreeBSD, embedded and cross-compiling, docker, WSL
+        - Manage binaries. It can create, upload and download binaries for any configuration and platform,
+          even cross-compiling, saving lots of time in development and continuous integration. The binary compatibility can be configured
+          and customized. Manage all your artifacts in the same way on all platforms.
+        - Integrates with any build system, including any proprietary and custom one. Provides tested support for major build systems
+          (CMake, MSBuild, Makefiles, Meson, etc).
+        - Extensible: Its Python-based recipes, together with extension points allow for great power and flexibility.
+        - Large and active community, especially in GitHub (https://github.com/conan-io/conan) and Slack (https://cppalliance.org/slack/ #conan channel).
+          This community also creates and maintains packages in ConanCenter and Bincrafters repositories in Bintray.
+        - Stable. Used in production by many companies, since 1.0 there is a commitment not to break package recipes and documented behavior.
+        
+        
+        This is the **developer/maintainer** documentation. For user documentation, go to https://docs.conan.io
+        
+        
+        ## Setup
+        
+        You can run Conan from source in Windows, MacOS, and Linux:
+        
+        - **Install pip following** [pip docs](https://pip.pypa.io/en/stable/installation/).
+        
+        - **Clone Conan repository:**
+        
+          ```bash
+          $ git clone https://github.com/conan-io/conan.git conan-io
+          ```
+        
+          > **Note**: repository directory name matters, some directories are known to be problematic to run tests (e.g. `conan`). `conan-io` directory name was tested and guaranteed to be working.
+        
+        - **Install in editable mode**
+        
+          ```bash
+          $ cd conan-io && sudo pip install -e .
+          ```
+        
+          If you are in Windows, using ``sudo`` is not required. Some Linux distros won't allow you to put Python packages in editable mode in the root Python installation, and creating a virtual environment ``venv`` first, is mandatory.
+        
+        - **You are ready, try to run Conan:**
+        
+          ```bash
+          $ conan --help
+        
+          Consumer commands
+            install    Installs the requirements specified in a recipe (conanfile.py or conanfile.txt).
+            ...
+        
+            Conan commands. Type "conan <command> -h" for help
+          ```
+        
+        ## Contributing to the project
+        
+        
+        Feedback and contribution are always welcome in this project.
+        Please read our [contributing guide](https://github.com/conan-io/conan/blob/develop2/.github/CONTRIBUTING.md).
+        Also, if you plan to contribute, please add some testing for your changes. You can read the [Conan
+        tests guidelines section](https://github.com/conan-io/conan/blob/develop2/test/README.md) for
+        some advice on how to write tests for Conan.
+        
+        ### Running the tests
+        
+        
+        **Install Python requirements**
+        
+        ```bash
+        $ python -m pip install -r conans/requirements.txt
+        $ python -m pip install -r conans/requirements_server.txt
+        $ python -m pip install -r conans/requirements_dev.txt
+        ```
+        
+        If you are not on Windows and you are not using a Python virtual environment, you will need to run these
+        commands using `sudo`.
+        
+        Before you can run the tests, you need to set a few environment variables first.
+        
+        ```bash
+        $ export PYTHONPATH=$PYTHONPATH:$(pwd)
+        ```
+        
+        On Windows it would be (while being in the Conan root directory):
+        
+        ```bash
+        $ set PYTHONPATH=.
+        ```
+        
+        Conan test suite defines and configures some required tools (CMake, Ninja, etc) in the
+        ``conftest.py`` and allows to define a custom ``conftest_user.py``.
+        Some specific versions, like cmake>=3.15 are necessary.
+        
+        
+        You can run the tests like this:
+        
+        ```bash
+        $ python -m pytest .
+        ```
+        
+        A few minutes later it should print ``OK``:
+        
+        ```bash
+        ............................................................................................
+        ----------------------------------------------------------------------
+        Ran 146 tests in 50.993s
+        
+        OK
+        ```
+        
+        To run specific tests, you can specify the test name too, something like:
+        
+        ```bash
+        $ python -m pytest test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
+        ```
+        
+        The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.
+        
+        Also, you can run tests against an instance of Artifactory. Those tests should add the attribute
+        `artifactory_ready`.
+        
+        ```bash
+        $ python -m pytest . -m artifactory_ready
+        ```
+        
+        Some environment variables have to be defined to run them. For example, for an
+        Artifactory instance that is running on the localhost with default user and password configured, the
+        variables could take the values:
+        
+        ```bash
+        $ export CONAN_TEST_WITH_ARTIFACTORY=1
+        $ export ARTIFACTORY_DEFAULT_URL=http://localhost:8081/artifactory
+        $ export ARTIFACTORY_DEFAULT_USER=admin
+        $ export ARTIFACTORY_DEFAULT_PASSWORD=password
+        ```
+        
+        `ARTIFACTORY_DEFAULT_URL` is the base URL for the Artifactory repo, not one for a specific
+        repository. Running the tests with a real Artifactory instance will create repos on the fly so please
+        use a separate server for testing purposes.
+        
+        ## License
+        
+        [MIT LICENSE](LICENSE.md)
+        
+Keywords: C/C++,package,libraries,developer,manager,dependency,tool,c,c++,cpp
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: test

conan_server-2.18.0/conan/__init__.py

@@ -0,0 +1,6 @@
+from conan.internal.model.conan_file import ConanFile
+from conan.internal.model.workspace import Workspace
+from conan.internal.model.version import Version
+
+__version__ = '2.18.0'
+conan_version = Version(__version__)

conan_server-2.18.0/conan/api/conan_api.py

@@ -0,0 +1,101 @@
+import os
+import sys
+
+from conan.api.output import init_colorama
+from conan.api.subapi.audit import AuditAPI
+from conan.api.subapi.cache import CacheAPI
+from conan.api.subapi.command import CommandAPI
+from conan.api.subapi.local import LocalAPI
+from conan.api.subapi.lockfile import LockfileAPI
+from conan.api.subapi.report import ReportAPI
+from conan.api.subapi.workspace import WorkspaceAPI
+from conan.api.subapi.config import ConfigAPI
+from conan.api.subapi.download import DownloadAPI
+from conan.api.subapi.export import ExportAPI
+from conan.api.subapi.install import InstallAPI
+from conan.api.subapi.graph import GraphAPI
+from conan.api.subapi.new import NewAPI
+from conan.api.subapi.profiles import ProfilesAPI
+from conan.api.subapi.list import ListAPI
+from conan.api.subapi.remotes import RemotesAPI
+from conan.api.subapi.remove import RemoveAPI
+from conan.api.subapi.search import SearchAPI
+from conan.api.subapi.upload import UploadAPI
+from conan.errors import ConanException
+from conan.internal.paths import get_conan_user_home
+from conan.internal.api.migrations import ClientMigrator
+from conan.internal.model.version_range import validate_conan_version
+
+
+class ConanAPI:
+    """
+    This is the main object to interact with the Conan API. It provides all the subapis to work with
+    recipes, packages, remotes, etc., which are exposed as attributes of this class, and should
+    not be created directly.
+    """
+    def __init__(self, cache_folder=None):
+        """
+        :param cache_folder: Conan cache/home folder. It will have less priority than the
+                             "home_folder" defined in a Workspace.
+        """
+
+        version = sys.version_info
+        if version.major == 2 or version.minor < 6:
+            raise ConanException("Conan needs Python >= 3.6")
+        if cache_folder is not None and not os.path.isabs(cache_folder):
+            raise ConanException("cache_folder has to be an absolute path")
+
+        init_colorama(sys.stderr)
+        self.cache_folder = cache_folder or get_conan_user_home()
+        self.home_folder = self.cache_folder  # Lets call it home, deprecate "cache"
+        self.migrate()
+
+        # This API is depended upon by the subsequent ones, it should be initialized first
+        self.config = ConfigAPI(self)
+
+        self.remotes = RemotesAPI(self)
+        self.command = CommandAPI(self)
+        # Search recipes by wildcard and packages filtering by configuration
+        self.search = SearchAPI(self)
+        # Get latest refs and list refs of recipes and packages
+        self.list = ListAPI(self)
+        self.profiles = ProfilesAPI(self)
+        self.install = InstallAPI(self)
+        self.graph = GraphAPI(self)
+        self.export = ExportAPI(self)
+        self.remove = RemoveAPI(self)
+        self.new = NewAPI(self)
+        self.upload = UploadAPI(self)
+        self.download = DownloadAPI(self)
+        self.cache = CacheAPI(self)
+        self.lockfile = LockfileAPI(self)
+        self.local = LocalAPI(self)
+        self.audit = AuditAPI(self)
+        # Now, lazy loading of editables
+        self.workspace = WorkspaceAPI(self)
+        self.report = ReportAPI(self)
+
+        _check_conan_version(self)
+
+    def reinit(self):
+        """
+        Reinitialize the Conan API. This is useful when the configuration changes.
+        """
+        self.config.reinit()
+        self.remotes.reinit()
+        self.local.reinit()
+
+        _check_conan_version(self)
+
+    def migrate(self):
+        # Migration system
+        # TODO: A prettier refactoring of migrators would be nice
+        from conan import conan_version
+        migrator = ClientMigrator(self.cache_folder, conan_version)
+        migrator.migrate()
+
+
+def _check_conan_version(conan_api):
+    required_range_new = conan_api.config.global_conf.get("core:required_conan_version")
+    if required_range_new:
+        validate_conan_version(required_range_new)

conan_server-2.18.0/conan/api/output.py

@@ -0,0 +1,318 @@
+import fnmatch
+import os
+import sys
+import time
+from threading import Lock
+
+import colorama
+from colorama import Fore, Style
+
+from conan.errors import ConanException
+
+LEVEL_QUIET = 80  # -q
+LEVEL_ERROR = 70  # Errors
+LEVEL_WARNING = 60  # Warnings
+LEVEL_NOTICE = 50  # Important messages to attract user attention.
+LEVEL_STATUS = 40  # Default - The main interesting messages that users might be interested in.
+LEVEL_VERBOSE = 30  # -v  Detailed informational messages.
+LEVEL_DEBUG = 20  # -vv Closely related to internal implementation details
+LEVEL_TRACE = 10  # -vvv Fine-grained messages with very low-level implementation details
+
+
+class Color(object):
+    """ Wrapper around colorama colors that are undefined in importing
+    """
+    RED = Fore.RED  # @UndefinedVariable
+    WHITE = Fore.WHITE  # @UndefinedVariable
+    CYAN = Fore.CYAN  # @UndefinedVariable
+    GREEN = Fore.GREEN  # @UndefinedVariable
+    MAGENTA = Fore.MAGENTA  # @UndefinedVariable
+    BLUE = Fore.BLUE  # @UndefinedVariable
+    YELLOW = Fore.YELLOW  # @UndefinedVariable
+    BLACK = Fore.BLACK  # @UndefinedVariable
+
+    BRIGHT_RED = Style.BRIGHT + Fore.RED  # @UndefinedVariable
+    BRIGHT_BLUE = Style.BRIGHT + Fore.BLUE  # @UndefinedVariable
+    BRIGHT_YELLOW = Style.BRIGHT + Fore.YELLOW  # @UndefinedVariable
+    BRIGHT_GREEN = Style.BRIGHT + Fore.GREEN  # @UndefinedVariable
+    BRIGHT_CYAN = Style.BRIGHT + Fore.CYAN  # @UndefinedVariable
+    BRIGHT_WHITE = Style.BRIGHT + Fore.WHITE  # @UndefinedVariable
+    BRIGHT_MAGENTA = Style.BRIGHT + Fore.MAGENTA  # @UndefinedVariable
+
+
+if os.environ.get("CONAN_COLOR_DARK"):
+    Color.WHITE = Fore.BLACK
+    Color.CYAN = Fore.BLUE
+    Color.YELLOW = Fore.MAGENTA
+    Color.BRIGHT_WHITE = Fore.BLACK
+    Color.BRIGHT_CYAN = Fore.BLUE
+    Color.BRIGHT_YELLOW = Fore.MAGENTA
+    Color.BRIGHT_GREEN = Fore.GREEN
+
+
+def init_colorama(stream):
+    import colorama
+    if _color_enabled(stream):
+        if os.getenv("CLICOLOR_FORCE", "0") != "0":
+            # Otherwise it is not really forced if colorama doesn't feel it
+            colorama.init(strip=False, convert=False)
+        else:
+            colorama.init()
+
+
+def _color_enabled(stream):
+    """
+    NO_COLOR: No colors
+
+    https://no-color.org/
+
+    Command-line software which adds ANSI color to its output by default should check for the
+    presence of a NO_COLOR environment variable that, when present (**regardless of its value**),
+    prevents the addition of ANSI color.
+
+    CLICOLOR_FORCE: Force color
+
+    https://bixense.com/clicolors/
+    """
+
+    if os.getenv("CLICOLOR_FORCE", "0") != "0":
+        # CLICOLOR_FORCE != 0, ANSI colors should be enabled no matter what.
+        return True
+
+    if os.getenv("NO_COLOR") is not None:
+        return False
+    return hasattr(stream, "isatty") and stream.isatty()
+
+
+class ConanOutput:
+    # Singleton
+    _conan_output_level = LEVEL_STATUS
+    _silent_warn_tags = []
+    _warnings_as_errors = []
+    lock = Lock()
+
+    def __init__(self, scope=""):
+        self.stream = sys.stderr
+        self._scope = scope
+        # FIXME:  This is needed because in testing we are redirecting the sys.stderr to a buffer
+        #         stream to capture it, so colorama is not there to strip the color bytes
+        self._color = _color_enabled(self.stream)
+
+    @classmethod
+    def define_silence_warnings(cls, warnings):
+        cls._silent_warn_tags = warnings
+
+    @classmethod
+    def set_warnings_as_errors(cls, value):
+        cls._warnings_as_errors = value
+
+    @classmethod
+    def define_log_level(cls, v):
+        """
+        Translates the verbosity level entered by a Conan command. If it's `None` (-v),
+        it will be defaulted to `verbose` level.
+
+        :param v: `str` or `None`, where `None` is the same as `verbose`.
+        """
+        env_level = os.getenv("CONAN_LOG_LEVEL")
+        v = env_level or v
+        levels = {"quiet": LEVEL_QUIET,  # -vquiet 80
+                  "error": LEVEL_ERROR,  # -verror 70
+                  "warning": LEVEL_WARNING,  # -vwaring 60
+                  "notice": LEVEL_NOTICE,  # -vnotice 50
+                  "status": LEVEL_STATUS,  # -vstatus 40
+                  None: LEVEL_VERBOSE,  # -v 30
+                  "verbose": LEVEL_VERBOSE,  # -vverbose 30
+                  "debug": LEVEL_DEBUG,  # -vdebug 20
+                  "v": LEVEL_DEBUG,  # -vv 20
+                  "trace": LEVEL_TRACE,  # -vtrace 10
+                  "vv": LEVEL_TRACE  # -vvv 10
+                  }
+        try:
+            level = levels[v]
+        except KeyError:
+            msg = " defined in CONAN_LOG_LEVEL environment variable" if env_level else ""
+            vals = "quiet, error, warning, notice, status, verbose, debug(v), trace(vv)"
+            raise ConanException(f"Invalid argument '-v{v}'{msg}.\nAllowed values: {vals}")
+        else:
+            cls._conan_output_level = level
+
+    @classmethod
+    def level_allowed(cls, level):
+        return cls._conan_output_level <= level
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def scope(self):
+        return self._scope
+
+    @scope.setter
+    def scope(self, out_scope):
+        self._scope = out_scope
+
+    @property
+    def is_terminal(self):
+        return hasattr(self.stream, "isatty") and self.stream.isatty()
+
+    def writeln(self, data, fg=None, bg=None):
+        return self.write(data, fg, bg, newline=True)
+
+    def write(self, data, fg=None, bg=None, newline=False):
+        if self._conan_output_level > LEVEL_NOTICE:
+            return self
+        if self._color and (fg or bg):
+            data = "%s%s%s%s" % (fg or '', bg or '', data, Style.RESET_ALL)
+
+        if newline:
+            data = "%s\n" % data
+
+        with self.lock:
+            self.stream.write(data)
+            self.stream.flush()
+
+        return self
+
+    def box(self, msg):
+        color = Color.BRIGHT_GREEN
+        self.writeln("\n**************************************************", fg=color)
+        self.writeln(f'*{msg: ^48}*', fg=color)
+        self.writeln(f"**************************************************\n", fg=color)
+
+    def _write_message(self, msg, fg=None, bg=None, newline=True):
+        if isinstance(msg, dict):
+            # For traces we can receive a dict already, we try to transform then into more natural
+            # text
+            msg = ", ".join([f"{k}: {v}" for k, v in msg.items()])
+            msg = "=> {}".format(msg)
+            # msg = json.dumps(msg, sort_keys=True, default=json_encoder)
+
+        ret = ""
+        if self._scope:
+            if self._color:
+                ret = "{}{}{}:{} ".format(fg or '', bg or '', self.scope, Style.RESET_ALL)
+            else:
+                ret = "{}: ".format(self._scope)
+
+        if self._color:
+            ret += "{}{}{}{}".format(fg or '', bg or '', msg, Style.RESET_ALL)
+        else:
+            ret += "{}".format(msg)
+
+        if newline:
+            ret = "%s\n" % ret
+
+        with self.lock:
+            self.stream.write(ret)
+            self.stream.flush()
+
+    def trace(self, msg):
+        if self._conan_output_level <= LEVEL_TRACE:
+            self._write_message(msg, fg=Color.BLUE)
+        return self
+
+    def debug(self, msg, fg=Color.MAGENTA, bg=None):
+        if self._conan_output_level <= LEVEL_DEBUG:
+            self._write_message(msg, fg=fg, bg=bg)
+        return self
+
+    def verbose(self, msg, fg=None, bg=None):
+        if self._conan_output_level <= LEVEL_VERBOSE:
+            self._write_message(msg, fg=fg, bg=bg)
+        return self
+
+    def status(self, msg, fg=None, bg=None):
+        if self._conan_output_level <= LEVEL_STATUS:
+            self._write_message(msg, fg=fg, bg=bg)
+        return self
+
+    # Remove in a later refactor of all the output.info calls
+    info = status
+
+    def title(self, msg):
+        if self._conan_output_level <= LEVEL_NOTICE:
+            self._write_message("\n======== {} ========".format(msg),
+                                fg=Color.BRIGHT_MAGENTA)
+        return self
+
+    def subtitle(self, msg):
+        if self._conan_output_level <= LEVEL_NOTICE:
+            self._write_message("\n-------- {} --------".format(msg),
+                                fg=Color.BRIGHT_MAGENTA)
+        return self
+
+    def highlight(self, msg):
+        if self._conan_output_level <= LEVEL_NOTICE:
+            self._write_message(msg, fg=Color.BRIGHT_MAGENTA)
+        return self
+
+    def success(self, msg):
+        if self._conan_output_level <= LEVEL_NOTICE:
+            self._write_message(msg, fg=Color.BRIGHT_GREEN)
+        return self
+
+    @staticmethod
+    def _warn_tag_matches(warn_tag, patterns):
+        lookup_tag = warn_tag or "unknown"
+        return any(fnmatch.fnmatch(lookup_tag, pattern) for pattern in patterns)
+
+    def warning(self, msg, warn_tag=None):
+        _treat_as_error = self._warn_tag_matches(warn_tag, self._warnings_as_errors)
+        if self._conan_output_level <= LEVEL_WARNING or (_treat_as_error and self._conan_output_level <= LEVEL_ERROR):
+            if self._warn_tag_matches(warn_tag, self._silent_warn_tags):
+                return self
+            warn_tag_msg = "" if warn_tag is None else f"{warn_tag}: "
+            output = f"{warn_tag_msg}{msg}"
+
+            if _treat_as_error:
+                self.error(output)
+            else:
+                self._write_message(f"WARN: {output}", Color.YELLOW)
+        return self
+
+    def error(self, msg, error_type=None):
+        if self._warnings_as_errors and error_type != "exception":
+            raise ConanException(msg)
+        if self._conan_output_level <= LEVEL_ERROR:
+            self._write_message("ERROR: {}".format(msg), Color.RED)
+        return self
+
+    def flush(self):
+        self.stream.flush()
+
+
+def cli_out_write(data, fg=None, bg=None, endline="\n", indentation=0):
+    """
+    Output to be used by formatters to dump information to stdout
+    """
+    if (fg or bg) and _color_enabled(sys.stdout):  # need color
+        data = f"{' ' * indentation}{fg or ''}{bg or ''}{data}{Style.RESET_ALL}{endline}"
+        sys.stdout.write(data)
+    else:
+        data = f"{' ' * indentation}{data}{endline}"
+        if sys.stdout.isatty():
+            # https://github.com/conan-io/conan/issues/17245 avoid colorama crash and overhead
+            # skip deinit/reinit if stdout is not a TTY to preserve redirected output to file
+            colorama.deinit()
+            sys.stdout.write(data)
+            colorama.reinit()
+        else:
+            sys.stdout.write(data)
+
+
+class TimedOutput:
+    def __init__(self, interval, out=None, msg_format=None):
+        self._interval = interval
+        self._msg_format = msg_format
+        self._t = time.time()
+        self._out = out or ConanOutput()
+
+    def info(self, msg, *args, **kwargs):
+        t = time.time()
+        if t - self._t > self._interval:
+            self._t = t
+            if self._msg_format:
+                msg = self._msg_format(msg, *args, **kwargs)
+            self._out.info(msg)