conan-server 2.22.2__tar.gz → 2.23.0__tar.gz

conan_server-2.23.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.1
+Name: conan_server
+Version: 2.23.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://cppalliance.org/slack/#cpp-slack) 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.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: test

conan_server-2.23.0/README.md

@@ -0,0 +1,162 @@
+<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://cppalliance.org/slack/#cpp-slack) 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)

conan_server-2.23.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.23.0'
+conan_version = Version(__version__)

conan_server-2.23.0/conan/api/conan_api.py

@@ -0,0 +1,152 @@
+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.upload import UploadAPI
+from conan.errors import ConanException
+from conan.internal.cache.home_paths import HomePaths
+from conan.internal.hook_manager import HookManager
+from conan.internal.model.conf import load_global_conf, ConfDefinition, CORE_CONF_PATTERN
+from conan.internal.model.settings import load_settings_yml
+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
+from conan.internal.rest.conan_requester import ConanRequester
+
+
+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 < 7:
+            raise ConanException("Conan needs Python >= 3.7")
+        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)
+        # Deprecated, but still used internally, prefer home_folder
+        self.cache_folder = cache_folder or get_conan_user_home()
+        self._home_folder = self.cache_folder
+        self._api_helpers = self._ApiHelpers(self)
+        self.migrate()
+
+        #: Used to interact with the local Conan configuration
+        self.config: ConfigAPI = ConfigAPI(self, self._api_helpers)
+        #: Used to interact with remotes
+        self.remotes: RemotesAPI = RemotesAPI(self, self._api_helpers)
+        self.command = CommandAPI(self)
+        #: Used to get latest refs and list refs of recipes and packages
+        self.list: ListAPI = ListAPI(self)
+        self.profiles = ProfilesAPI(self, self._api_helpers)
+        self.install = InstallAPI(self, self._api_helpers)
+        self.graph = GraphAPI(self, self._api_helpers)
+        #: Used to export recipes and pre-compiled package binaries to the Conan cache
+        self.export: ExportAPI = ExportAPI(self, self._api_helpers)
+        self.remove = RemoveAPI(self)
+        self.new = NewAPI(self)
+        #: Used to upload recipes and packages to remotes
+        self.upload: UploadAPI = UploadAPI(self, self._api_helpers)
+        #: Used to download recipes and packages from remotes
+        self.download: DownloadAPI = DownloadAPI(self)
+        self.cache = CacheAPI(self, self._api_helpers)
+        self.lockfile = LockfileAPI(self)
+        self.local = LocalAPI(self, self._api_helpers)
+        self.audit = AuditAPI(self)
+        # Now, lazy loading of editables
+        self.workspace = WorkspaceAPI(self)
+        self.report = ReportAPI(self, self._api_helpers)
+
+    @property
+    def home_folder(self) -> str:
+        """ Where the Conan user home is located. Read only.
+        Can be modified by the ``CONAN_HOME`` environment variable or by the
+        ``.conanrc`` file in the current directory or any parent directory
+        when Conan is called.
+        """
+        return self._home_folder
+
+    def reinit(self):
+        """
+        Reinitialize the Conan API. This is useful when the configuration changes.
+        """
+        self._api_helpers.reinit()
+        self.local.reinit()
+
+    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()
+
+    class _ApiHelpers:
+        def __init__(self, conan_api):
+            self._conan_api = conan_api
+            self._cli_core_confs = None
+            self._init_global_conf()
+            self.hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+            # Wraps an http_requester to inject proxies, certs, etc
+            self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
+
+        def set_core_confs(self, core_confs):
+            confs = ConfDefinition()
+            for c in core_confs:
+                if not CORE_CONF_PATTERN.match(c):
+                    raise ConanException(f"Only core. values are allowed in --core-conf. Got {c}")
+            confs.loads("\n".join(core_confs))
+            confs.validate()
+            self._cli_core_confs = confs
+            # Last but not least, apply the new configuration
+            # This will in turn call ApiHelpers.reinit() as the very first thing
+            self._conan_api.reinit()
+
+        def _init_global_conf(self):
+            self.global_conf = load_global_conf(self._conan_api.home_folder)
+            if self._cli_core_confs:
+                self.global_conf.update_conf_definition(self._cli_core_confs)
+            required_range_new = self.global_conf.get("core:required_conan_version")
+            if required_range_new:
+                validate_conan_version(required_range_new)
+
+        def reinit(self):
+            self._init_global_conf()
+            self.hook_manager.reinit()
+            self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
+
+        @property
+        def settings_yml(self):
+            if self._settings_yml is None:
+                self._settings_yml = load_settings_yml(self._conan_api.home_folder)
+            return self._settings_yml
+
+        @property
+        def requester(self):
+            return self._requester

conan_server-2.23.0/conan/api/input.py

@@ -0,0 +1,95 @@
+import getpass
+import sys
+
+from conan.errors import ConanException
+
+
+class UserInput:
+    """Class to interact with the user, used to show messages and ask for information"""
+
+    def __init__(self, non_interactive):
+        """
+        Params:
+            ins: input stream
+            out: ConanOutput, should have "write" method
+        """
+        self._ins = sys.stdin
+        # FIXME: circular include, move "color_enabled" function to better location
+        from conan.api.output import ConanOutput
+        self._out = ConanOutput()
+        self._interactive = not non_interactive
+
+    def _raise_if_non_interactive(self):
+        if not self._interactive:
+            raise ConanException("Conan interactive mode disabled")
+
+    def raw_input(self):
+        self._raise_if_non_interactive()
+        return input()
+
+    def request_login(self, remote_name, username=None):
+        """Request user to input their name and password
+        :param remote_name:
+        :param username If username is specified it only request password"""
+        self._raise_if_non_interactive()
+        if not username:
+            self._out.login_msg(f"Remote '{remote_name}' username: ")
+            username = self.get_username()
+
+        self._out.login_msg("Please enter a password for "
+                            f"user '{username}' on remote '{remote_name}': ")
+        try:
+            pwd = self.get_password()
+        except ConanException:
+            raise
+        except Exception as e:
+            raise ConanException('Cancelled pass %s' % e)
+        return username, pwd
+
+    def get_username(self):
+        """Overridable for testing purpose"""
+        return self.raw_input()
+
+    @staticmethod
+    def get_password():
+        """Overridable for testing purpose"""
+        try:
+            return getpass.getpass("")
+        except BaseException:  # For KeyboardInterrupt too
+            raise ConanException("Interrupted interactive password input")
+
+    def request_string(self, msg, default_value=None):
+        """Request user to input a msg
+        :param default_value:
+        :param msg Name of the msg
+        """
+        self._raise_if_non_interactive()
+
+        if default_value:
+            self._out.write('%s (%s): ' % (msg, default_value))
+        else:
+            self._out.write('%s: ' % msg)
+        s = self._ins.readline().replace("\n", "")
+        if default_value is not None and s == '':
+            return default_value
+        return s
+
+    def request_boolean(self, msg, default_option=None):
+        """Request user to input a boolean"""
+        ret = None
+        while ret is None:
+            if default_option:
+                s = self.request_string("%s (YES/no)" % msg)
+            elif default_option is False:
+                s = self.request_string("%s (NO/yes)" % msg)
+            else:
+                s = self.request_string("%s (yes/no)" % msg)
+            if default_option is not None and s == '':
+                return default_option
+            if s.lower() in ['yes', 'y']:
+                ret = True
+            elif s.lower() in ['no', 'n']:
+                ret = False
+            else:
+                self._out.error(f"{s} is not a valid answer")
+        return ret

conan_server-2.23.0/conan/api/model/remote.py

@@ -0,0 +1,59 @@
+LOCAL_RECIPES_INDEX = "local-recipes-index"
+
+
+class Remote:
+    """
+    The ``Remote`` class represents a remote registry of packages.
+    """
+    def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
+                 remote_type=None, recipes_only=False):
+        """ A Remote object can be constructed to be passed as an argument to
+        RemotesAPI methods. When possible, it is better to use Remote objects returned by the API,
+        but for the ``RemotesAPI.add()`` method, for which a new constructed object is necessary.
+        It is recommended to use named arguments like ``Remote(..., verify_ssl=False)`` in
+        the constructor.
+        :param name: The name of the remote.
+        :param url: The URL of the remote repository (or local folder for "local-recipes-index").
+        :param verify_ssl: Enable SSL Certificate validation.
+        :param disabled: Disable the remote repository.
+        :param allowed_packages: List of patterns of allowed packages from this remote
+        :param remote_type: Type of the remote repository, use "local-recipes-index" or ``None``
+        :param recipes_only: If True, binaries form this remote will be ignored and never used
+        """
+        self.name = name  # Read only, is the key
+        self.url = url
+        self.verify_ssl = verify_ssl
+        self.disabled = disabled
+        self.allowed_packages = allowed_packages
+        self.recipes_only = recipes_only
+        self.remote_type = remote_type
+        self._caching = {}
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        return (self.name == other.name and self.url == other.url and
+                self.verify_ssl == other.verify_ssl and self.disabled == other.disabled)
+
+    def __str__(self):
+        allowed_msg = ""
+        if self.allowed_packages:
+            allowed_msg = ", Allowed packages: {}".format(", ".join(self.allowed_packages))
+        if self.recipes_only:
+            allowed_msg += ", Recipes only"
+        if self.remote_type == LOCAL_RECIPES_INDEX:
+            return "{}: {} [{}, Enabled: {}{}]".format(self.name, self.url, LOCAL_RECIPES_INDEX,
+                                                       not self.disabled, allowed_msg)
+        return "{}: {} [Verify SSL: {}, Enabled: {}{}]".format(self.name, self.url, self.verify_ssl,
+                                                               not self.disabled, allowed_msg)
+
+    def __repr__(self):
+        return str(self)
+
+    def invalidate_cache(self):
+        """ If external operations might have modified the remote since it was instantiated,
+        this method can be called to invalidate the cache.
+        Note that this is done automatically when the remote is used in any operation by Conan,
+        such as uploading packages, so this method is not usually needed when only interacting
+        with the Conan API"""
+        self._caching = {}