conan 2.19.0__tar.gz → 2.20.0__tar.gz

{conan-2.19.0/conan.egg-info → conan-2.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.19.0
+Version: 2.20.0
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD
@@ -179,10 +179,14 @@ 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
-Requires-Python: >=3.6
+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
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Provides-Extra: test

{conan-2.19.0 → conan-2.20.0}/conan/__init__.py

@@ -2,5 +2,5 @@ from conan.internal.model.conan_file import ConanFile
 from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.19.0'
+__version__ = '2.20.0'
 conan_version = Version(__version__)

{conan-2.19.0 → conan-2.20.0}/conan/api/conan_api.py

@@ -19,11 +19,12 @@ 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.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
@@ -38,40 +39,40 @@ class ConanAPI:
     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.
+                             ``"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 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  # Lets call it home, deprecate "cache"
-        # This API is depended upon by the subsequent ones, it should be initialized first
-        self.config = ConfigAPI(self)
-        _check_conan_version(self)
-
+        self._home_folder = self.cache_folder
         self._api_helpers = self._ApiHelpers(self)
         self.migrate()
 
-        self.remotes = RemotesAPI(self)
+        #: 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)
-        # 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)
+        #: 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)
         self.export = ExportAPI(self, self._api_helpers)
         self.remove = RemoveAPI(self)
         self.new = NewAPI(self)
-        self.upload = UploadAPI(self)
-        self.download = DownloadAPI(self)
-        self.cache = CacheAPI(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)
@@ -79,18 +80,23 @@ class ConanAPI:
         self.workspace = WorkspaceAPI(self)
         self.report = ReportAPI(self, self._api_helpers)
 
+    @property
+    def home_folder(self):
+        """ 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.
         """
-        # TODO: Think order of reinitialization for helpers
         self._api_helpers.reinit()
-        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
@@ -101,13 +107,34 @@ class ConanAPI:
     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)
 
+        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()
 
-
-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)
+        @property
+        def settings_yml(self):
+            return load_settings_yml(self._conan_api.home_folder)

{conan-2.19.0 → conan-2.20.0}/conan/api/model/list.py

@@ -13,6 +13,7 @@ from conan.internal.util.files import load
 
 
 class MultiPackagesList:
+    """ A collection of PackagesList by remote name."""
     def __init__(self):
         self.lists = {}
 
@@ -29,6 +30,7 @@ class MultiPackagesList:
         self.lists[remote_name] = {"error": error}
 
     def serialize(self):
+        """ Serialize object to a dictionary."""
         return {k: v.serialize() if isinstance(v, PackagesList) else v
                 for k, v in self.lists.items()}
 
@@ -42,6 +44,7 @@ class MultiPackagesList:
 
     @staticmethod
     def load(file):
+        """ Create an instance of the class from a serialized JSON file path pointed by ``file``."""
         try:
             content = json.loads(load(file))
         except JSONDecodeError as e:
@@ -68,6 +71,25 @@ class MultiPackagesList:
 
     @staticmethod
     def load_graph(graphfile, graph_recipes=None, graph_binaries=None, context=None):
+        """ Create an instance of the class from a graph file path, which is
+        the json format returned by a few commands
+        like ``conan graph info`` or ``conan create/install.``
+
+        :parameter str graphfile: Path to the graph file
+        :parameter list[str] graph_recipes: List for kinds of recipes to return.
+            For example ``"cache"`` will return only recipes in the local cache,
+            ``"download"`` will return only recipes that have been downloaded,
+            and passing ``"*"`` will return all recipes.
+        :parameter list[str] graph_binaries: List for kinds of binaries to return.
+            For example ``"cache"`` will return only binaries in the local cache,
+            ``"download"`` will return only binaries that have been downloaded,
+            ``"build"`` will return only binaries that are built,
+            ``"missing"`` will return only binaries that are missing,
+            ``"invalid"`` will return only binaries that are invalid,
+            and passing ``"*"`` will return all binaries.
+        :parameter str context: Context to filter the graph,
+            can be ``"host"``, ``"build"``, ``"host-only"`` or ``"build-only"``
+        """
         if not os.path.isfile(graphfile):
             raise ConanException(f"Graph file not found: {graphfile}")
         try:
@@ -81,7 +103,7 @@ class MultiPackagesList:
                     "More Info at 'https://docs.conan.io/2/reference/commands/formatters/graph_info_json_formatter.html"
                 )
 
-            mpkglist =  MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+            mpkglist = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
                                                         context=base_context)
             if context == "build-only":
                 host = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
@@ -169,6 +191,7 @@ class MultiPackagesList:
 
 
 class PackagesList:
+    """ A collection of recipes, revisions and packages."""
     def __init__(self):
         self.recipes = {}
 
@@ -202,12 +225,13 @@ class PackagesList:
             result.append(subpkglist)
         return result
 
-    def only_recipes(self):
-        result = {}
+    def only_recipes(self) -> None:
+        """ Filter out all the packages and package revisions, keep only the recipes and
+            recipe revisions in self.recipes.
+        """
         for ref, ref_dict in self.recipes.items():
             for rrev_dict in ref_dict.get("revisions", {}).values():
                 rrev_dict.pop("packages", None)
-        return result
 
     def add_refs(self, refs):
         # RREVS alreday come in ASCENDING order, so upload does older revisions first
@@ -264,18 +288,36 @@ class PackagesList:
         return result
 
     def serialize(self):
-        return self.recipes
+        """ Serialize the instance to a dictionary."""
+        return self.recipes.copy()
 
     @staticmethod
     def deserialize(data):
+        """ Loads the data from a serialized dictionary."""
         result = PackagesList()
         result.recipes = data
         return result
 
 
 class ListPattern:
+    """ Object holding a pattern that matches recipes, revisions and packages."""
 
     def __init__(self, expression, rrev="latest", package_id=None, prev="latest", only_recipe=False):
+        """
+        :param expression: The pattern to match, e.g. ``"name/*:*"``
+        :param rrev: The recipe revision to match, defaults to ``"latest"``,
+                     can also be ``"!latest"`` or ``"~latest"`` to match all but the latest revision,
+                     a pattern like ``"1234*"`` to match a specific revision,
+                     or a specific revision like ``"1234"``.
+        :param package_id: The package ID to match, defaults to ``None``, which matches all package IDs.
+        :param prev: The package revision to match, defaults to ``"latest"``,
+                     can also be ``"!latest"`` or ``"~latest"`` to match all but the latest revision,
+                     a pattern like ``"1234*"`` to match a specific revision,
+                     or a specific revision like ``"1234"``.
+        :param only_recipe: If ``True``, only the recipe part of the expression is parsed,
+                            ignoring ``package_id`` and ``prev``. This is useful for commands that
+                            only operate on recipes, like ``conan search``.
+        """
         def split(s, c, default=None):
             if not s:
                 return None, default

{conan-2.19.0 → conan-2.20.0}/conan/api/model/refs.py

@@ -10,20 +10,28 @@ from conan.internal.util.dates import timestamp_to_str
 
 @total_ordering
 class RecipeReference:
-    """ an exact (no version-range, no alias) reference of a recipe.
-    Should be enough to locate a recipe in the cache or in a server
-    Validation will be external to this class, at specific points (export, api, etc)
+    """ An exact (no version-range, no alias) reference of a recipe,
+    it represents a reference of the form ``name/version[@user/channel][#revision][%timestamp]``.
+    Should be enough to locate a recipe in the cache or in a server, and
+    validation will be external to this class, at specific points (export, api, etc).
     """
 
     def __init__(self, name=None, version=None, user=None, channel=None, revision=None,
                  timestamp=None):
-        self.name = name
+        """ The attributes should be regarded as immutable, and should not be modified by the user."""
+        #: Name of the reference
+        self.name: str = name
         if version is not None and not isinstance(version, Version):
             version = Version(version)
-        self.version = version  # This MUST be a version if we want to be able to order
+        #: Version of the reference
+        self.version: Version = version  # This MUST be a version if we want to be able to order
+        #: User of the reference, if any
         self.user = user
+        #: Channel of the reference, if any
         self.channel = channel
+        #: Revision of the reference, if any
         self.revision = revision
+        #: Timestamp of the reference, if any
         self.timestamp = timestamp
 
     def copy(self):
@@ -90,6 +98,8 @@ class RecipeReference:
 
     @staticmethod
     def loads(rref):
+        """ Instantiates an object from a string, in the form:
+        ``name/version[@user/channel][#revision][%timestamp]``"""
         try:
             # timestamp
             tokens = rref.rsplit("%", 1)
@@ -120,8 +130,7 @@ class RecipeReference:
                 f" in the form name/version[@user/channel]")
 
     def validate_ref(self, allow_uppercase=False):
-        """ at the moment only applied to exported (exact) references, but not for requires
-        that could contain version ranges
+        """ Check that the reference is valid, and raise a ``ConanException`` if not.
         """
         from conan.api.output import ConanOutput
         self_str = str(self)
@@ -159,6 +168,13 @@ class RecipeReference:
                                   f"'{self.channel}'")
 
     def matches(self, pattern, is_consumer):
+        """ fnmatches the reference against the provided pattern.
+
+        :parameter str pattern: the pattern to match against, it can contain wildcards,
+            and can start with ``!`` or ``~`` to negate the match.
+            A special value of ``&`` will return a match only of ``is_consumer`` is ``True``
+        :parameter bool is_consumer: if ``True``, the pattern ``&`` will match this reference.
+        """
         negate = False
         if pattern.startswith("!") or pattern.startswith("~"):
             pattern = pattern[1:]
@@ -182,9 +198,7 @@ class RecipeReference:
         return condition
 
     def partial_match(self, pattern):
-        """
-        Finds if pattern matches any of partial sums of tokens of conan reference
-        """
+        # Finds if pattern matches any of partial sums of tokens of conan reference
         tokens = [self.name, "/", str(self.version)]
         if self.user:
             tokens += ["@", self.user]

{conan-2.19.0 → conan-2.20.0}/conan/api/model/remote.py

@@ -36,4 +36,9 @@ class Remote:
         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 = {}

{conan-2.19.0 → conan-2.20.0}/conan/api/output.py

@@ -85,13 +85,31 @@ def _color_enabled(stream):
 
 
 class ConanOutput:
+    """ A singleton class to handle output messages in Conan.
+
+    Recipes should only access this class through the ``self.output`` attribute of the recipe,
+    but custom commands or tools can instantiate it directly, where doing so for each message is
+    a valid practice.
+
+    It provides methods to write messages at different levels of verbosity, such as debug, info,
+    warning, and error. The output level can be controlled by the user through command-line options
+    or environment variables.
+
+    The output methods return the instance itself, so different methods can be chained together.
+    """
     # Singleton
     _conan_output_level = LEVEL_STATUS
     _silent_warn_tags = []
     _warnings_as_errors = []
     lock = Lock()
 
-    def __init__(self, scope=""):
+    def __init__(self, scope: str = ""):
+        """ Initialize the ConanOutput instance.
+
+        :parameter scope: A string that represents the scope of the output. This is usually the
+            reference of the recipe being executed, like ``pkg/1.0@user/channel`` and is prefixed
+            to the output messages. If not provided, it defaults to an empty string.
+        """
         self.stream = sys.stderr
         self._scope = scope
         # FIXME:  This is needed because in testing we are redirecting the sys.stderr to a buffer
@@ -108,12 +126,6 @@ class ConanOutput:
 
     @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
@@ -175,11 +187,13 @@ class ConanOutput:
 
         return self
 
-    def box(self, msg):
+    def box(self, msg: str):
+        """ Draw a box around the message, useful for important messages"""
         color = Color.BRIGHT_GREEN
         self.writeln("\n**************************************************", fg=color)
         self.writeln(f'*{msg: ^48}*', fg=color)
         self.writeln(f"**************************************************\n", fg=color)
+        return self
 
     def login_msg(self, msg, newline=False):
         # unconditional to the error level, this has to show always
@@ -206,53 +220,91 @@ class ConanOutput:
                 ret = msg
 
         if newline:
-            ret += "\n"
+            ret = f"{ret}\n"
 
         with self.lock:
             self.stream.write(ret)
             self.stream.flush()
 
-    def trace(self, msg):
+    def trace(self, msg: str):
+        """ This is the most extreme level of detail.
+
+        Trace messages log every little step the system takes, including function entries and exits,
+        variable changes, and other very specific events.
+
+        This message won't be printed unless the user has set the log level to trace
+        (e.g., using the ``-vvv`` option in the command line).
+
+        It’s used when full visibility of everything happening in the system is required,
+        but should be used carefully due to the large amount of information it can generate."""
         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):
+    def debug(self, msg: str, fg: str = Color.MAGENTA, bg: str = None):
+        """ With a high level of detail, it is mainly used for debugging code.
+
+        This message won't be printed unless the user has set the log level to debug
+        (e.g., using the ``-vv`` option in the command line).
+
+        These messages provide useful information for developers, such as variable values
+        or execution flow details, to trace errors or analyze the program's behavior."""
         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):
+    def verbose(self, msg: str, fg: str = None, bg: str = None):
+        """ Displays additional and detailed information that, while not critical,
+        can be useful for better understanding how the system is working.
+
+        This message won't be printed unless the user has set the log level to verbose
+        (e.g., using the ``-v`` option in the command line).
+
+        It’s appropriate for gaining more context without overloading the logs with
+        excessive detail. Useful when more clarity is needed than a simple info."""
         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):
+    def status(self, msg: str, fg: str = None, bg: str = None):
+        """ Provides general information about the system or ongoing operations.
+
+        Info messages are basic and used to inform about common events,
+        like the start or completion of processes, without implying specific problems or achievements."""
         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):
+    def title(self, msg: str):
+        """ Draws a title around the message, useful for important messages"""
         if self._conan_output_level <= LEVEL_NOTICE:
             self._write_message("\n======== {} ========".format(msg),
                                 fg=Color.BRIGHT_MAGENTA)
         return self
 
-    def subtitle(self, msg):
+    def subtitle(self, msg: str):
+        """ Draws a subtitle around the message, useful for important messages"""
         if self._conan_output_level <= LEVEL_NOTICE:
             self._write_message("\n-------- {} --------".format(msg),
                                 fg=Color.BRIGHT_MAGENTA)
         return self
 
-    def highlight(self, msg):
+    def highlight(self, msg: str):
+        """ Marks or emphasizes important events or processes that need to stand out but don’t necessarily
+        indicate success or error.
+
+        These messages draw attention to key points that may be relevant for the user or administrator."""
         if self._conan_output_level <= LEVEL_NOTICE:
             self._write_message(msg, fg=Color.BRIGHT_MAGENTA)
         return self
 
-    def success(self, msg):
+    def success(self, msg: str):
+        """ Shows that an operation has been completed successfully.
+
+        This type of message is useful to confirm that key processes or tasks have finished correctly,
+        which is essential for good application monitoring."""
         if self._conan_output_level <= LEVEL_NOTICE:
             self._write_message(msg, fg=Color.BRIGHT_GREEN)
         return self
@@ -262,7 +314,15 @@ class ConanOutput:
         lookup_tag = warn_tag or "unknown"
         return any(fnmatch.fnmatch(lookup_tag, pattern) for pattern in patterns)
 
-    def warning(self, msg, warn_tag=None):
+    def warning(self, msg: str, warn_tag: str = None):
+        """ Highlights a potential issue that, while not stopping the system,
+        could cause problems in the future or under certain conditions.
+
+        Warnings signal abnormal situations that should be
+        reviewed but don’t necessarily cause an immediate halt in operations.
+        Notice that if the tag matches the pattern in the ``core:warnings_as_errors`` configuration,
+        and is not skipped, this will be upgraded to an error, and raise an exception
+        when the output is printed, so that the error does not pass unnoticed."""
         _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)):
@@ -277,7 +337,15 @@ class ConanOutput:
                 self._write_message(f"WARN: {output}", Color.YELLOW)
         return self
 
-    def error(self, msg, error_type=None):
+    def error(self, msg: str, error_type: str = None):
+        """ Indicates that a serious issue has occurred that prevents the system
+        or application from continuing to function correctly.
+
+        Typically, this represents a failure in the normal flow of execution,
+        such as a service crash or a critical exception.
+        Notice that if the user has set the ``core:warnings_as_errors`` configuration,
+        this will raise an exception when the output is printed,
+        so that the error does not pass unnoticed."""
         if self._warnings_as_errors and error_type != "exception":
             raise ConanException(msg)
         if self._conan_output_level <= LEVEL_ERROR:

{conan-2.19.0 → conan-2.20.0}/conan/api/subapi/audit.py

@@ -19,7 +19,7 @@ class AuditAPI:
     """
 
     def __init__(self, conan_api):
-        self.conan_api = conan_api
+        self._conan_api = conan_api
         self._home_folder = conan_api.home_folder
         self._providers_path = os.path.join(self._home_folder, "audit_providers.json")
         self._provider_cls = {
@@ -86,7 +86,7 @@ class AuditAPI:
 
         provider_cls = self._provider_cls.get(provider_data["type"])
 
-        return provider_cls(self.conan_api, provider_name, provider_data)
+        return provider_cls(self._conan_api, provider_name, provider_data)
 
     def list_providers(self):
         """
@@ -96,7 +96,7 @@ class AuditAPI:
         result = []
         for name, provider_data in providers.items():
             provider_cls = self._provider_cls.get(provider_data["type"])
-            result.append(provider_cls(self.conan_api, name, provider_data))
+            result.append(provider_cls(self._conan_api, name, provider_data))
         return result
 
     def add_provider(self, name, url, provider_type):