drb 2.3.4__tar.gz → 2.3.8__tar.gz

{drb-2.3.4/drb.egg-info → drb-2.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.3.4
+Version: 2.3.8
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr
@@ -54,22 +54,6 @@ Once successfully run, the command line prompt is updated with the virtual envir
 Once the virtual environment installed, the dependencies shall be downloaded:
 ```commandline
 (venv) $~> pip install -r requirements.txt --no-cache-dir
-Collecting pip==21.1.2
-  Downloading pip-21.1.2-py3-none-any.whl (1.5 MB)
-     |████████████████████████████████| 1.5 MB 54 kB/s 
-Collecting setuptools==57.0.0
-  Downloading setuptools-57.0.0-py3-none-any.whl (821 kB)
-     |████████████████████████████████| 821 kB 73 kB/s 
-Installing collected packages: pip, setuptools
-  Attempting uninstall: pip
-    Found existing installation: pip 20.0.2
-    Uninstalling pip-20.0.2:
-      Successfully uninstalled pip-20.0.2
-  Attempting uninstall: setuptools
-    Found existing installation: setuptools 44.0.0
-    Uninstalling setuptools-44.0.0:
-      Successfully uninstalled setuptools-44.0.0
-Successfully installed pip-21.1.2 setuptools-57.0.0
 ```
 At this stage the environment is installed.
 

{drb-2.3.4 → drb-2.3.8}/README.md

@@ -25,22 +25,6 @@ Once successfully run, the command line prompt is updated with the virtual envir
 Once the virtual environment installed, the dependencies shall be downloaded:
 ```commandline
 (venv) $~> pip install -r requirements.txt --no-cache-dir
-Collecting pip==21.1.2
-  Downloading pip-21.1.2-py3-none-any.whl (1.5 MB)
-     |████████████████████████████████| 1.5 MB 54 kB/s 
-Collecting setuptools==57.0.0
-  Downloading setuptools-57.0.0-py3-none-any.whl (821 kB)
-     |████████████████████████████████| 821 kB 73 kB/s 
-Installing collected packages: pip, setuptools
-  Attempting uninstall: pip
-    Found existing installation: pip 20.0.2
-    Uninstalling pip-20.0.2:
-      Successfully uninstalled pip-20.0.2
-  Attempting uninstall: setuptools
-    Found existing installation: setuptools 44.0.0
-    Uninstalling setuptools-44.0.0:
-      Successfully uninstalled setuptools-44.0.0
-Successfully installed pip-21.1.2 setuptools-57.0.0
 ```
 At this stage the environment is installed.
 

{drb-2.3.4 → drb-2.3.8}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-19T11:01:35+0000",
+ "date": "2026-06-25T20:48:59+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "ad5712117cb18c0a99fbddcf98e59256eafd435e",
- "version": "2.3.4"
+ "full-revisionid": "15fc9c3ff4c5c9f27c0ec6e7bba7d7c3e3885305",
+ "version": "2.3.8"
 }
 '''  # END VERSION_JSON
 

drb-2.3.8/drb/core/context.py

@@ -0,0 +1,24 @@
+from typing import Dict
+
+
+class Context:
+    """Per-node store of named context buckets.
+
+    A bucket is a plain ``dict`` keyed by a name (e.g. ``'resolver'`` for
+    resolution state, ``'metadata'`` for an add-on's extracted values).
+    Buckets are created lazily on first access, so any consumer
+    (resolver, add-on) can stash per-node state without the node knowing
+    about it:
+
+        node.context['resolver']['topic'] = topic
+        node.context['metadata']['platform'] = 'S2A'
+    """
+
+    def __init__(self):
+        self._buckets: Dict[str, dict] = {}
+
+    def __getitem__(self, name: str) -> dict:
+        return self._buckets.setdefault(name, {})
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._buckets

{drb-2.3.4 → drb-2.3.8}/drb/core/node.py

@@ -9,6 +9,7 @@ from deprecated import deprecated
 
 from .item import DrbItem
 from .path import ParsedPath, parse_path
+from .context import Context
 from .impls import ImplementationManager
 from ..exceptions.core import DrbException, DrbNotImplementationException
 from ..utils.utils import get_name_namespace_index, get_name_namespace_value
@@ -42,6 +43,7 @@ class DrbNode(DrbItem, abc.ABC):
         self.__namespace_aware = None
         self._attrs = {}
         self._parent = None
+        self._context = Context()
         self._impl_mng = ImplementationManager()
         for event_name in self.__event_type_node:
             self._event_manager.append_event_type(event_name)
@@ -464,5 +466,10 @@ class DrbNode(DrbItem, abc.ABC):
             return self.has_child(*item)
         return False
 
+    @property
+    def context(self) -> Context:
+        """Per-node store of named context buckets (resolver, add-ons...)."""
+        return self._context
+
     def __eq__(self, other):
         return self.path == other.path

drb-2.3.8/drb/core/protocol.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+from typing import Optional
+
+import drb.utils.plugins
+from drb.core.factory import DrbFactory
+
+
+class ProtocolLoader:
+    """Loads ``drb.protocol`` entry points into a scheme -> factory map.
+
+    Each entry point's name is a URL scheme (e.g. ``s3``, ``https``) and its
+    value is ``module:FactoryClass`` (a ``DrbFactory`` subclass). Mirrors
+    :class:`drb.core.factory.FactoryLoader`.
+    """
+    __instance = None
+    __factories = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__instance is None:
+            cls.__instance = super(ProtocolLoader, cls).__new__(cls)
+            cls.__factories = cls.__load()
+        return cls.__instance
+
+    @classmethod
+    def __is_class(cls, class_name: str):
+        return lambda obj: inspect.isclass(obj) and class_name == obj.__name__
+
+    @classmethod
+    def __load(cls) -> dict:
+        factories = {}
+        for ep in drb.utils.plugins.get_entry_points('drb.protocol'):
+            if ep.name in factories:
+                continue
+            m, c = ep.value.split(':')
+            try:
+                module = importlib.import_module(m)
+                for _, obj in inspect.getmembers(module, cls.__is_class(c)):
+                    if obj != DrbFactory and issubclass(obj, DrbFactory):
+                        factories[ep.name] = obj()
+                    else:
+                        logging.getLogger().warning(
+                            f'Failed to load protocol "{ep.name}": '
+                            f'invalid factory: {ep.value}')
+            except ModuleNotFoundError:
+                logging.getLogger().warning(
+                    f'Failed to load protocol "{ep.name}": module {m} '
+                    f'not found')
+        return factories
+
+    def get_schemes(self) -> set:
+        return set(self.__factories.keys())
+
+    def get_factory(self, scheme: str) -> Optional[DrbFactory]:
+        return self.__factories.get(scheme, None)

{drb-2.3.4 → drb-2.3.8}/drb/signatures/core.py

@@ -49,6 +49,40 @@ class NamespaceSignature(Signature):
         return 'namespace'
 
 
+class NameTestSignature(Signature):
+    """Allowing to check if a DRB Node name equals a specific string."""
+
+    def __init__(self, value: str):
+        self.__value = value
+
+    def matches(self, node: DrbNode) -> bool:
+        return node.name == self.__value
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__value}
+
+    @staticmethod
+    def get_name():
+        return 'nameTest'
+
+
+class NamespaceTestSignature(Signature):
+    """Allowing to check if a DRB Node namespace equals a specific string."""
+
+    def __init__(self, value: str):
+        self.__value = value
+
+    def matches(self, node: DrbNode) -> bool:
+        return node.namespace_uri == self.__value
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__value}
+
+    @staticmethod
+    def get_name():
+        return 'namespaceTest'
+
+
 class PathSignature(Signature):
     """
     Allowing to check if a DRB Node path match a specific regex.

drb-2.3.8/drb/signatures/hierarchy.py

@@ -0,0 +1,124 @@
+import re
+
+from drb.core.node import DrbNode
+from drb.core.signature import Signature
+
+
+def _parent_topic(node: DrbNode):
+    """Resolve the parent node to its finest topic, or None."""
+    import drb.topics.resolver as resolver
+    parent = node.parent
+    if parent is None:
+        return None
+    try:
+        topic, _ = resolver.resolve(parent)
+    except Exception:
+        return None
+    return topic
+
+
+def _topic_by_uri(uri: str, dao=None):
+    if dao is None:
+        from drb.topics.dao import ManagerDao
+        dao = ManagerDao()
+    for t in dao.get_all_drb_topics():
+        if t.uri == uri:
+            return t
+    return None
+
+
+class ParentClassTestSignature(Signature):
+    """Matches when the node's parent resolves exactly to ``class_uri``."""
+
+    def __init__(self, class_uri: str):
+        self.__uri = class_uri
+
+    def matches(self, node: DrbNode) -> bool:
+        topic = _parent_topic(node)
+        return topic is not None and topic.uri == self.__uri
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__uri}
+
+    @staticmethod
+    def get_name():
+        return 'parentClassTest'
+
+
+class ParentIsSubClassTestSignature(Signature):
+    """Matches when the parent's topic is a sub-class of ``class_uri``."""
+
+    def __init__(self, class_uri: str):
+        self.__uri = class_uri
+
+    def matches(self, node: DrbNode) -> bool:
+        from drb.topics.dao import ManagerDao
+        topic = _parent_topic(node)
+        if topic is None:
+            return False
+        dao = ManagerDao()
+        expected = _topic_by_uri(self.__uri, dao)
+        if expected is None:
+            return False
+        return dao.is_subclass(topic, expected)
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__uri}
+
+    @staticmethod
+    def get_name():
+        return 'parentIsSubClassTest'
+
+
+class ParentClassMatchSignature(Signature):
+    """Matches when the parent's topic class URI matches ``regex``.
+
+    Parity with Java ``DrbCortexItemSignature``: the regex is tested against
+    the parent topic's **class URI**, not its label.
+    """
+
+    def __init__(self, regex: str):
+        self.__regex = regex
+
+    def matches(self, node: DrbNode) -> bool:
+        topic = _parent_topic(node)
+        return topic is not None and re.match(self.__regex, topic.uri) \
+            is not None
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__regex}
+
+    @staticmethod
+    def get_name():
+        return 'parentClassMatch'
+
+
+class ParentIsSubClassMatchSignature(Signature):
+    """Matches when a topic whose **class URI** matches ``regex`` is a
+    super-class of the parent's topic.
+
+    Parity with Java ``DrbCortexItemSignature``: the regex is tested against
+    the candidate topic's **class URI**, not its label.
+    """
+
+    def __init__(self, regex: str):
+        self.__regex = regex
+
+    def matches(self, node: DrbNode) -> bool:
+        topic = _parent_topic(node)
+        if topic is None:
+            return False
+        from drb.topics.dao import ManagerDao
+        dao = ManagerDao()
+        for candidate in dao.get_all_drb_topics():
+            if re.match(self.__regex, candidate.uri) is not None \
+                    and dao.is_subclass(topic, candidate):
+                return True
+        return False
+
+    def to_dict(self) -> dict:
+        return {self.get_name(): self.__regex}
+
+    @staticmethod
+    def get_name():
+        return 'parentIsSubClassMatch'

{drb-2.3.4 → drb-2.3.8}/drb/topics/dao/manager_dao.py

@@ -24,6 +24,38 @@ logger = logging.getLogger('DrbTopic')
 _HTTP_TIMEOUT = (10, 60)
 
 
+# Topic descriptor file names looked up in a topic package, in priority
+# order: ontology descriptors (TTL/OWL) first, legacy YAML cortex last. This
+# lets a package ship its topic as TTL (the knowledge-base format) while YAML
+# keeps working during the migration.
+_DESCRIPTOR_NAMES = ('cortex.ttl', 'cortex.owl', 'cortex.yml', 'cortex.yaml')
+
+
+def _find_topic_descriptor(directory: str):
+    """Return the topic descriptor path in ``directory`` (TTL/OWL preferred
+    over YAML), or None if none is present."""
+    for name in _DESCRIPTOR_NAMES:
+        path = os.path.join(directory, name)
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def _implementation_available(topic: DrbTopic) -> bool:
+    """Whether the topic's driver implementation is installed.
+
+    A topic with no ``factory`` needs no driver (abstract/container topic).
+    Otherwise its ``implementationIdentifier`` (``topic.factory``) must match
+    an installed ``drb.driver`` entry point: a descriptor (TTL/OWL/YAML) is not
+    enough — the implementation is required.
+    """
+    if topic.factory is None:
+        return True
+    # Lazy import to avoid any import cycle with drb.core.factory.
+    from drb.core.factory import FactoryLoader
+    return topic.factory in FactoryLoader().get_factories()
+
+
 def _load_all_drb_topic_dao() -> Dict[uuid.UUID, DrbTopicDao]:
     """
     Loads topics defined in the Python context
@@ -39,11 +71,23 @@ def _load_all_drb_topic_dao() -> Dict[uuid.UUID, DrbTopicDao]:
             logger.warning(f'Invalid entry point {ep.name}: {ex.msg}')
             continue
 
+        path = _find_topic_descriptor(module.__path__[0])
+        if path is None:
+            logger.warning(
+                f'No topic descriptor (cortex.ttl/.owl/.yml) for {ep.name}')
+            continue
+
         try:
-            path = os.path.join(module.__path__[0], 'cortex.yml')
             dao = DaoFactory().create(path)
             topics = dao.read_all()
             for topic in topics:
+                if not _implementation_available(topic):
+                    logger.warning(
+                        "Topic %s (%s) skipped: no installed driver "
+                        "implementation '%s' (drb.driver). Descriptor present "
+                        "but implementation required.",
+                        topic.label, topic.uri, topic.factory)
+                    continue
                 if topic.id in result:
                     logger.warning(
                         f'Topic definition conflict: id ({topic.id}) defined '
@@ -165,6 +209,24 @@ class ManagerDao:
 
         raise DrbException('No DrbTopic found')
 
+    def get_dao(self, identifier: uuid.UUID) -> DrbTopicDao:
+        """
+        Retrieves the DAO that loaded a topic.
+
+        Lets callers (e.g. add-ons) reach the source of a topic without the
+        manager knowing about their concern: for an RDF topic the returned
+        ``RDFDao`` exposes ``graph``, the ontology graph it was read from.
+
+        Parameters:
+            identifier (UUID): topic UUID
+        Returns:
+            DrbTopicDao: the DAO that loaded the topic identified by the
+                         given UUID.
+        """
+        if identifier in self.__topic_dao.keys():
+            return self.__topic_dao[identifier]
+        raise DrbException('No DrbTopic found')
+
     def is_subclass(self, actual: DrbTopic, expected: DrbTopic) -> bool:
         """
         Check if a topic is subclass of another.
@@ -264,6 +326,13 @@ class ManagerDao:
         self.__added_dao.append(dao)
         topics = dao.read_all()
         for topic in topics:
+            if not _implementation_available(topic):
+                logger.warning(
+                    "Topic %s (%s) skipped: no installed driver "
+                    "implementation '%s' (drb.driver). Descriptor present "
+                    "but implementation required.",
+                    topic.label, topic.uri, topic.factory)
+                continue
             self.__topic_dao[topic.id] = dao
         self.__update_topics()
 
@@ -280,6 +349,13 @@ class ManagerDao:
         """
         self.__added_dao.append(dao)
         for topic in dao.read_all():
+            if not _implementation_available(topic):
+                logger.warning(
+                    "Topic %s (%s) skipped: no installed driver "
+                    "implementation '%s' (drb.driver). Descriptor present "
+                    "but implementation required.",
+                    topic.label, topic.uri, topic.factory)
+                continue
             self.__topic_dao[topic.id] = dao
         self.__update_topics()
         return dao

{drb-2.3.4 → drb-2.3.8}/drb/topics/dao/rdf_dao.py

@@ -115,13 +115,31 @@ class RDFDao(DrbTopicDao):
 
         result = self.graph.query(f'''
                 PREFIX drb: <http://www.gael.fr/drb#>
-                SELECT ?xquery ?name
+                SELECT ?name ?nameTest ?namespace ?namespaceTest
+                       ?xquery ?python ?pythonScript
+                       ?parentClassMatch ?parentClassTest
+                       ?parentIsSubClassMatch ?parentIsSubClassTest
                 WHERE {{
                 ?Class a owl:Class .
                 FILTER(?Class = <{topic.uri}>)
                 ?Class drb:signature ?signature .
-                OPTIONAL {{ ?signature drb:xqueryTest ?xquery . }}
                 OPTIONAL {{ ?signature drb:nameMatch ?name . }}
+                OPTIONAL {{ ?signature drb:nameTest ?nameTest . }}
+                OPTIONAL {{ ?signature drb:namespaceMatch ?namespace . }}
+                OPTIONAL {{ ?signature drb:namespaceTest ?namespaceTest . }}
+                OPTIONAL {{ ?signature drb:xqueryTest ?xquery . }}
+                OPTIONAL {{ ?signature drb:pythonTest ?python . }}
+                OPTIONAL {{ ?signature drb:pythonScript ?pythonScript . }}
+                OPTIONAL {{
+                    ?signature drb:parentClassMatch ?parentClassMatch . }}
+                OPTIONAL {{
+                    ?signature drb:parentClassTest ?parentClassTest . }}
+                OPTIONAL {{
+                    ?signature drb:parentIsSubClassMatch
+                    ?parentIsSubClassMatch . }}
+                OPTIONAL {{
+                    ?signature drb:parentIsSubClassTest
+                    ?parentIsSubClassTest . }}
                 }}
                 GROUP BY ?signature
                 ''')
@@ -131,7 +149,16 @@ class RDFDao(DrbTopicDao):
             for k in row.asdict().keys():
                 v = row[k]
                 if v is not None:
-                    signature[k] = v.toPython()
+                    if k == 'pythonScript':
+                        # drb:pythonScript is the deprecated spelling of
+                        # drb:pythonTest (kept for backward-compat with KB
+                        # descriptors); both map to the python PythonSignature.
+                        logging.getLogger('drb.topics.dao.rdf_dao').warning(
+                            'drb:pythonScript is deprecated; '
+                            'use drb:pythonTest')
+                        signature['python'] = v.toPython()
+                    else:
+                        signature[k] = v.toPython()
             if signature:
                 signatures.append(parse_signature(signature))
 

{drb-2.3.4 → drb-2.3.8}/drb/topics/resolver.py

@@ -10,6 +10,7 @@ from typing import List, Optional, Tuple, Union
 
 from drb.core.node import DrbNode
 from drb.core.factory import DrbFactory, FactoryLoader
+from drb.core.protocol import ProtocolLoader
 from drb.topics.topic import DrbTopic, TopicCategory
 from drb.exceptions.core import DrbFactoryException, DrbException
 from drb.nodes.url_node import UrlNode
@@ -30,14 +31,38 @@ def _is_remote_url(parsed_path):
 def forced_factory(topic: DrbTopic, node: DrbNode) -> Optional[DrbNode]:
     if topic.forced and topic.factory is not None:
         try:
-            new_node = FactoryLoader().get_factory(
-                topic.factory).create(node)
+            new_node = _create_via_factory(topic, node)
         except Exception as e:
             return node
         return new_node
     return node
 
 
+def _create_via_factory(topic: DrbTopic, node: DrbNode) -> DrbNode:
+    """Create the child node via the topic's driver factory.
+
+    Raises a clear :class:`DrbException` when no ``drb.driver`` implementation
+    is installed for ``topic.factory`` — replacing the opaque ``None.create``
+    ``AttributeError``.
+    """
+    factory = FactoryLoader().get_factory(topic.factory)
+    if factory is None:
+        raise DrbException(
+            f"No driver implementation '{topic.factory}' installed for "
+            f"topic '{topic.label}' ({topic.uri})")
+    return factory.create(node)
+
+
+def _topic_by_factory(name: str):
+    """The PROTOCOL topic whose implementationIdentifier == name, or None."""
+    from drb.topics.dao import ManagerDao
+    for topic in ManagerDao().get_drb_topics_by_category(
+            TopicCategory.PROTOCOL):
+        if topic.factory == name:
+            return topic
+    return None
+
+
 class _DrbFactoryResolver(DrbFactory):
     """ The factory resolver
 
@@ -74,6 +99,29 @@ class _DrbFactoryResolver(DrbFactory):
                 return protocol
         return None
 
+    def __dispatch_scheme(self, node):
+        """Dispatch a root URL by its scheme via drb.protocol, then apply a
+        ``+<name>`` forced driver if present. Returns (topic, node) or None
+        when the base scheme is not registered (caller falls back to
+        signature matching)."""
+        scheme = node.path.scheme
+        if not scheme:
+            return None
+        parts = scheme.split('+', 1)
+        base = parts[0]
+        forced = parts[1] if len(parts) > 1 else None
+        base_factory = ProtocolLoader().get_factory(base)
+        if base_factory is None:
+            return None
+        created = base_factory.create(node)
+        if forced is None:
+            return _topic_by_factory(base), created
+        forced_factory = FactoryLoader().get_factory(forced)
+        if forced_factory is None:
+            raise DrbFactoryException(
+                f'No driver registered for forced scheme "+{forced}"')
+        return _topic_by_factory(forced), forced_factory.create(created)
+
     def __retrieve_container(
             self, node: DrbNode) -> Tuple[Optional[DrbTopic], DrbNode]:
         """
@@ -122,8 +170,7 @@ class _DrbFactoryResolver(DrbFactory):
             if topic.matches(node):
                 n = node
                 if topic.factory is not None:
-                    n = FactoryLoader().get_factory(
-                        topic.factory).create(node)
+                    n = _create_via_factory(topic, node)
                 return self.__finest_drb_topic(n, topic)
         return finest, node
 
@@ -230,23 +277,23 @@ class _DrbFactoryResolver(DrbFactory):
             node = source
         protocol = None
         if node.parent is None:
-
-            protocol = self.__retrieve_protocol(node)
-            if protocol is None:
-                raise DrbFactoryException(f'Cannot resolve: {source}')
-            node = FactoryLoader().get_factory(
-                protocol.factory).create(node)
+            dispatched = self.__dispatch_scheme(node)
+            if dispatched is not None:
+                protocol, node = dispatched
+            else:
+                protocol = self.__retrieve_protocol(node)
+                if protocol is None:
+                    raise DrbFactoryException(f'Cannot resolve: {source}')
+                node = _create_via_factory(protocol, node)
 
         container, node = self.__retrieve_container(node)
         if container is not None and container.factory is not None:
-            node = FactoryLoader().get_factory(
-                container.factory).create(node)
+            node = _create_via_factory(container, node)
 
         formatting = self.__retrieve_formatting(node)
         if formatting is not None:
             if formatting.factory is not None:
-                node = FactoryLoader().get_factory(formatting.factory).create(
-                    node)
+                node = _create_via_factory(formatting, node)
             t, n = self.__finest_drb_topic(node, formatting)
         elif container is not None:
             t, n = container, node
@@ -284,7 +331,7 @@ class _DrbFactoryResolver(DrbFactory):
         if result is not None:
             topic, node = result
             if topic.factory is not None:
-                node = FactoryLoader().get_factory(topic.factory).create(node)
+                node = _create_via_factory(topic, node)
             return topic, node
         return self._basic_resolve(node)
 

{drb-2.3.4 → drb-2.3.8/drb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.3.4
+Version: 2.3.8
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr
@@ -54,22 +54,6 @@ Once successfully run, the command line prompt is updated with the virtual envir
 Once the virtual environment installed, the dependencies shall be downloaded:
 ```commandline
 (venv) $~> pip install -r requirements.txt --no-cache-dir
-Collecting pip==21.1.2
-  Downloading pip-21.1.2-py3-none-any.whl (1.5 MB)
-     |████████████████████████████████| 1.5 MB 54 kB/s 
-Collecting setuptools==57.0.0
-  Downloading setuptools-57.0.0-py3-none-any.whl (821 kB)
-     |████████████████████████████████| 821 kB 73 kB/s 
-Installing collected packages: pip, setuptools
-  Attempting uninstall: pip
-    Found existing installation: pip 20.0.2
-    Uninstalling pip-20.0.2:
-      Successfully uninstalled pip-20.0.2
-  Attempting uninstall: setuptools
-    Found existing installation: setuptools 44.0.0
-    Uninstalling setuptools-44.0.0:
-      Successfully uninstalled setuptools-44.0.0
-Successfully installed pip-21.1.2 setuptools-57.0.0
 ```
 At this stage the environment is installed.