MambuPy 2.0.0b50__tar.gz → 2.1.1__tar.gz

{MambuPy-2.0.0b50 → mambupy-2.1.1}/MambuPy/__init__.py

@@ -5,17 +5,18 @@
 
     MambuPy.mambuconfig
     MambuPy.mambuutil
-    MambuPy.rest
-    MambuPy.orm
     MambuPy.api
     MambuPy.api.connector
+    MambuPy.orm
+    MambuPy.rest
 
 
 Currently, there are two different ways to access Mambu objects:
 
 1) Objects using `Mambu REST API
    <https://developer.mambu.com/customer/en/portal/articles/1162276-rest-apis-overview/>`_
-   , they live at the :any:`MambuPy.rest` package
+   , they live at the :any:`MambuPy.api` package (the old-and-soon-to-be-deprecated,
+   V1-compatible code lives at :any:`MambuPy.rest`
 
 2) An ORM using a `DB backup retrieved from Mambu
    <https://support.mambu.com/docs/mambu-data-dictionary>`_
@@ -34,5 +35,21 @@ TODOS
           to achive TDD when implementing features or correcting bugs.
 """
 
-__version__ = "2.0.0b50"
+import sys
+from importlib.abc import MetaPathFinder
+from importlib.util import spec_from_file_location
+
+__version__ = "2.1.1"
 """The version of this module."""
+
+
+class CaseInsensitiveFinder(MetaPathFinder):
+    def find_spec(self, fullname, path, target=None):
+        if fullname.lower() == "mambupy":
+            # Get the actual module file location
+            return spec_from_file_location(fullname, __file__)
+        return None
+
+
+# Register the finder
+sys.meta_path.insert(0, CaseInsensitiveFinder())

{MambuPy-2.0.0b50/mambupy → mambupy-2.1.1/MambuPy}/api/connector/rest.py

@@ -36,12 +36,82 @@ from MambuPy.mambuutil import (
     apiurl,
     apiuser,
     setup_logging,
+    activate_request_session_objects,
 )
 
 
 logger = setup_logging(__name__)
 
 
+def _configure_retry_strategy(session, retries=5):
+    """Configure retry strategy for a session.
+
+    Args:
+        session (requests.Session): The session to configure
+        retries (int, optional): Number of retries. Defaults to 5.
+    """
+    retry_strategy = Retry(
+        total=retries,
+        status_forcelist=[429, 500, 502, 503, 504],
+        backoff_factor=1,
+        allowed_methods=[
+            "HEAD",
+            "GET",
+            "OPTIONS",
+            "POST",
+            "PUT",
+            "DELETE",
+            "TRACE",
+            "PATCH",
+        ],
+    )
+    adapter = HTTPAdapter(max_retries=retry_strategy)
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+
+
+class SessionSingleton:
+    """Singleton class to manage HTTP sessions for MambuPy.
+
+    This class ensures that only one requests.Session object is created and reused
+    across all requests to the Mambu API. This helps improve performance by reusing
+    TCP connections.
+
+    Example:
+        >>> session = SessionSingleton()
+        >>> session.get_session()  # Returns a requests.Session object
+        >>> session2 = SessionSingleton()
+        >>> session2.get_session()  # Returns the same requests.Session object
+    """
+
+    __instance = None
+    __session = None
+    _RETRIES = 5
+
+    def __new__(cls):
+        """Create a new instance of SessionSingleton if one doesn't exist.
+
+        Returns:
+            SessionSingleton: The singleton instance.
+        """
+        if cls.__instance is None:
+            cls.__instance = super(SessionSingleton, cls).__new__(cls)
+        return cls.__instance
+
+    def get_session(self):
+        """Get the requests.Session object.
+
+        If no session exists, create a new one. Otherwise, return the existing one.
+
+        Returns:
+            requests.Session: The session object to use for HTTP requests.
+        """
+        if self.__session is None:
+            self.__session = requests.Session()
+            _configure_retry_strategy(self.__session, self._RETRIES)
+        return self.__session
+
+
 class MambuConnectorREST(MambuConnector, MambuConnectorReader, MambuConnectorWriter):
     """A connector for Mambu REST API"""
 
@@ -52,10 +122,19 @@ class MambuConnectorREST(MambuConnector, MambuConnectorReader, MambuConnectorWri
     def __init__(self, user=apiuser, pwd=apipwd, url=apiurl, **kwargs):
         self._headers = {
             "Accept": "application/vnd.mambu.v2+json",
-            "Authorization": "Basic {}".format(
-                base64.b64encode(bytes("{}:{}".format(user, pwd), "utf-8")).decode()
-            ),
         }
+        self.__set_authorization_header(user, pwd)
+        self.__set_url(url)
+        self._session = None
+        if activate_request_session_objects.lower() == "true":
+            self._session = SessionSingleton().get_session()
+
+    def __set_authorization_header(self, user, pwd):
+        self._headers["Authorization"] = "Basic {}".format(
+            base64.b64encode(bytes("{}:{}".format(user, pwd), "utf-8")).decode()
+        )
+
+    def __set_url(self, url):
         self._tenant = url
 
     def __request_headers(self, method, content_type):
@@ -102,26 +181,6 @@ class MambuConnectorREST(MambuConnector, MambuConnectorReader, MambuConnectorWri
         params = self.__request_params(params)
         data = self.__request_data(data)
 
-        retry_strategy = Retry(
-            total=self._RETRIES,
-            status_forcelist=[429, 502, 503, 504],
-            backoff_factor=1,
-            allowed_methods=[
-                "HEAD",
-                "GET",
-                "OPTIONS",
-                "POST",
-                "PUT",
-                "DELETE",
-                "TRACE",
-                "PATCH",
-            ],
-        )
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        http = requests.Session()
-        http.mount("https://", adapter)
-        http.mount("http://", adapter)
-
         resp = ""
         try:
             logger.debug(
@@ -133,10 +192,15 @@ url %s, params %s, data %s, headers %s",
                 data,
                 [(k, v) for k, v in headers.items() if k != "Authorization"],
             )
-            resp = http.request(method, url, params=params, data=data, headers=headers)
+            if self._session:
+                resp = self._session.request(method, url, params=params, data=data, headers=headers)
+            else:
+                http = requests.Session()
+                _configure_retry_strategy(http, self._RETRIES)
+                resp = http.request(method, url, params=params, data=data, headers=headers)
             resp.raise_for_status()
         except requests.exceptions.HTTPError as httperr:
-            logger.error(
+            logger.warning(
                 "%s on %s request: params %s, data %s, headers %s",
                 str(httperr),
                 method,
@@ -145,7 +209,7 @@ url %s, params %s, data %s, headers %s",
                 [(k, v) for k, v in headers.items() if k != "Authorization"],
             )
             if hasattr(resp, "content"):  # pragma: no cover
-                logger.error("HTTPError, resp content: %s", resp.content)
+                logger.warning("HTTPError, resp content: %s", resp.content)
             try:
                 content = json.loads(resp.content.decode())
             except ValueError:
@@ -489,36 +553,48 @@ url %s, params %s, data %s, headers %s",
 
         return self.__list_request("POST", url, params=params, data=data)
 
-    def mambu_update(self, entid, prefix, attrs):
+    def mambu_update(self, entid, prefix, attrs, **kwargs):
         """updates a mambu entity
 
         Args:
           entid (str): the id or encoded key of the entity owning the document
           prefix (str): entity's URL prefix
           attrs (dict): entity to be updated, complying with Mambu's schemas
+          kwargs (dict): keyword arguments for this method.
+                         May include a user, pwd and url to connect to Mambu.
 
         Returns:
           response content (str json {})
         """
+        if "url" in kwargs:
+            self.__set_url(kwargs["url"])
+        if "user" in kwargs and "pwd" in kwargs:
+            self.__set_authorization_header(kwargs["user"], kwargs["pwd"])
         url = "https://{}/api/{}/{}".format(self._tenant, prefix, entid)
 
         return self.__request("PUT", url, data=attrs)
 
-    def mambu_create(self, prefix, attrs):
+    def mambu_create(self, prefix, attrs, **kwargs):
         """creates a mambu entity
 
         Args:
           prefix (str): entity's URL prefix
           attrs (dict): entity to be created, complying with Mambu's schemas
+          kwargs (dict): keyword arguments for this method.
+                         May include a user, pwd and url to connect to Mambu.
 
         Returns:
           response content (str json {})
         """
+        if "url" in kwargs:
+            self.__set_url(kwargs["url"])
+        if "user" in kwargs and "pwd" in kwargs:
+            self.__set_authorization_header(kwargs["user"], kwargs["pwd"])
         url = "https://{}/api/{}".format(self._tenant, prefix)
 
         return self.__request("POST", url, data=attrs)
 
-    def mambu_patch(self, entid, prefix, fields_ops=None):
+    def mambu_patch(self, entid, prefix, fields_ops=None, **kwargs):
         """patches certain parts of a mambu entity
 
         https://api.mambu.com/?python#tocspatchoperation
@@ -532,10 +608,16 @@ url %s, params %s, data %s, headers %s",
             OP (str): operation ("ADD", "REPLACE", "REMOVE")
             PATH (str): json pointer referencing the location in the target entity
             VALUE (obj, opc): the value of the field (not for REMOVE op)
+          kwargs (dict): keyword arguments for this method.
+                         May include a user, pwd and url to connect to Mambu.
         """
         if not fields_ops:
             fields_ops = []
 
+        if "url" in kwargs:
+            self.__set_url(kwargs["url"])
+        if "user" in kwargs and "pwd" in kwargs:
+            self.__set_authorization_header(kwargs["user"], kwargs["pwd"])
         url = "https://{}/api/{}/{}".format(self._tenant, prefix, entid)
 
         # build data from fields_ops param
@@ -549,8 +631,16 @@ url %s, params %s, data %s, headers %s",
         if patch_data:
             return self.__request("PATCH", url, data=patch_data)
 
-    def mambu_delete(self, entid, prefix):
-        """deletes a mambu entity"""
+    def mambu_delete(self, entid, prefix, **kwargs):
+        """deletes a mambu entity
+
+           kwargs (dict): keyword arguments for this method.
+                  May include a user, pwd and url to connect to Mambu.
+        """
+        if "url" in kwargs:
+            self.__set_url(kwargs["url"])
+        if "user" in kwargs and "pwd" in kwargs:
+            self.__set_authorization_header(kwargs["user"], kwargs["pwd"])
         url = "https://{}/api/{}/{}".format(self._tenant, prefix, entid)
 
         return self.__request("DELETE", url)

{MambuPy-2.0.0b50 → mambupy-2.1.1}/MambuPy/api/entities.py

@@ -428,19 +428,22 @@ class MambuEntity(MambuStruct):
 class MambuEntityWritable(MambuStruct, MambuWritable):
     """A Mambu object with writing capabilities."""
 
-    def update(self):
+    def update(self, **kwargs):
         """updates a mambu entity
 
         Uses the current values of the _attrs to send to Mambu.
         Pre-requires that CustomFields are updated previously.
         Post-requires that CustomFields are extracted again.
+
+        kwargs (dict): keyword arguments for this method.
+                       May include a user, pwd and url to connect to Mambu.
         """
         self._updateVOs()
         self._updateCustomFields()
         self._serializeFields()
         try:
             self._connector.mambu_update(
-                self.id, self._prefix, copy.deepcopy(self._attrs)
+                self.id, self._prefix, copy.deepcopy(self._attrs), **kwargs
             )
             # should I refresh _attrs? (either get request from Mambu or using the response)
         except MambuError:
@@ -450,19 +453,22 @@ class MambuEntityWritable(MambuStruct, MambuWritable):
             self._extractCustomFields()
             self._extractVOs()
 
-    def create(self):
+    def create(self, **kwargs):
         """creates a mambu entity
 
         Uses the current values of the _attrs to send to Mambu.
         Pre-requires that CustomFields are updated previously.
         Post-requires that CustomFields are extracted again.
+
+        kwargs (dict): keyword arguments for this method.
+                       May include a user, pwd and url to connect to Mambu.
         """
         self._updateVOs()
         self._updateCustomFields()
         self._serializeFields()
         try:
             self._resp = self._connector.mambu_create(
-                self._prefix, copy.deepcopy(self._attrs)
+                self._prefix, copy.deepcopy(self._attrs), **kwargs
             )
             self._attrs.update(dict(json.loads(self._resp.decode())))
             self._tzattrs = dict(json.loads(self._resp.decode()))
@@ -516,7 +522,7 @@ class MambuEntityWritable(MambuStruct, MambuWritable):
         else:
             raise MambuPyError("Unrecognizable field {} for patching".format(field))
 
-    def patch(self, fields=None, autodetect_remove=False):
+    def patch(self, fields=None, autodetect_remove=False, **kwargs):
         """patches a mambu entity
 
         Allows patching of parts of the entity up to Mambu.
@@ -583,7 +589,7 @@ class MambuEntityWritable(MambuStruct, MambuWritable):
             self._updateCustomFields()
             self._serializeFields()
             if fields_ops:
-                self._connector.mambu_patch(self.id, self._prefix, fields_ops)
+                self._connector.mambu_patch(self.id, self._prefix, fields_ops, **kwargs)
             # should I refresh _attrs? (needs get request from Mambu)
         except MambuError:
             raise
@@ -599,7 +605,7 @@ class MambuEntityWritable(MambuStruct, MambuWritable):
         Implement on entities which require further cleaning.
         """
 
-    def delete(self):
+    def delete(self, **kwargs):
         """deletes a mambu entity.
 
         Leaves the object in a supposedly state where you can create
@@ -610,7 +616,7 @@ class MambuEntityWritable(MambuStruct, MambuWritable):
         make sure we can run creation after deletion.
         """
         try:
-            self._connector.mambu_delete(self.id, self._prefix)
+            self._connector.mambu_delete(self.id, self._prefix, **kwargs)
         except MambuError:
             raise
 

{MambuPy-2.0.0b50/mambupy → mambupy-2.1.1/MambuPy}/mambuconfig.py

@@ -24,6 +24,7 @@ RC files must have the following format:
     apiuser=API_user
     apipwd=API_password
     apipagination=API_pagination_limit
+    activate_request_session_objects=API_persistent_session
     [DB]
     dbname=Database_name
     dbuser=Database_user
@@ -75,6 +76,10 @@ user on your Mambu instance
 
 The db* configs refer to Database configurations which hold a backup of
 your Mambu Database on some server.
+
+The activate_request_session_objects config enables or disables HTTP persistent sessions
+for API requests. When enabled, it will reuse the same TCP connection for
+multiple requests, improving performance. Default is False.
 """
 
 default_configs = {
@@ -83,6 +88,7 @@ default_configs = {
     "apiuser": "mambu_api_user",
     "apipwd": "mambu_api_password",
     "apipagination": "50",
+    "activate_request_session_objects": "False",
     # Mambu DB configurations
     "dbname": "mambu_db",
     "dbuser": "mambu_db_user",
@@ -123,6 +129,7 @@ argparser.add_argument("--mambupy_apiurl")
 argparser.add_argument("--mambupy_apiuser")
 argparser.add_argument("--mambupy_apipwd")
 argparser.add_argument("--mambupy_apipagination")
+argparser.add_argument("--mambupy_activate_request_session_objects")
 argparser.add_argument("--mambupy_dbname")
 argparser.add_argument("--mambupy_dbuser")
 argparser.add_argument("--mambupy_dbpwd")
@@ -184,6 +191,8 @@ apipwd = get_conf(config, "API", "apipwd")
 """Password to access Mambu API"""
 apipagination = get_conf(config, "API", "apipagination")
 """Pagination default limit for requests to Mambu API"""
+activate_request_session_objects = get_conf(config, "API", "activate_request_session_objects")
+"""Whether to use persistent HTTP sessions for API requests"""
 dbname = get_conf(config, "DB", "dbname")
 """Name of the DB with a backup of Mambu's DB"""
 dbuser = get_conf(config, "DB", "dbuser")

{MambuPy-2.0.0b50 → mambupy-2.1.1}/MambuPy/mambuutil.py

@@ -28,7 +28,7 @@ from codecs import open as copen
 
 import yaml
 
-from .mambuconfig import apipagination, apipwd, apiurl, apiuser, loggingconf
+from .mambuconfig import apipagination, apipwd, apiurl, apiuser, loggingconf, activate_request_session_objects
 from .mambugeturl import getmambuurl
 
 try:
@@ -258,7 +258,7 @@ def strip_consecutive_repeated_char(s, ch):
 
 if sys.version_info >= (3, 0):
     # python3
-    from future.moves.urllib import parse as urlparse
+    from urllib import parse as urlparse
 else:  # pragma: no cover
     # python2
     import urlparse
@@ -405,7 +405,7 @@ def _backup_db_timeout_mechanism(
 ):
     value_to_latest = True
     while not justbackup and retries and not bool_func():
-        logger.info("waiting...")
+        logger.debug("waiting...")
         sleep(10)
         retries -= 1
         if retries < 0:

mambupy-2.1.1/MambuPy/rest/__init__.py

@@ -0,0 +1,49 @@
+"""MambuPy's REST package (SOON TO BE DEPRECATED).
+
+Objects using `Mambu REST API
+<https://developer.mambu.com/customer/en/portal/articles/1162276-rest-apis-overview/>`_
+
+.. autosummary::
+   :toctree: _autosummary
+
+    MambuPy.rest.mambustruct
+    MambuPy.rest.mambuclient
+    MambuPy.rest.mambugroup
+    MambuPy.rest.mambuloan
+    MambuPy.rest.mamburepayment
+    MambuPy.rest.mambutransaction
+    MambuPy.rest.mambuproduct
+    MambuPy.rest.mambubranch
+    MambuPy.rest.mambucentre
+    MambuPy.rest.mambuactivity
+    MambuPy.rest.mambutask
+    MambuPy.rest.mambusaving
+    MambuPy.rest.mambusavingtransaction
+    MambuPy.rest.mambutransactionchannel
+    MambuPy.rest.mambuuser
+    MambuPy.rest.mamburoles
+
+.. warning:: This package is soon to be deprecated. Use the :any:`MambuPy.api` package instead.
+
+The REST API way is the currently most developed code on *MambuPy*.
+
+Lives under the :any:`MambuPy.rest` package
+
+It has a lot of objects which model some Mambu entity.
+
+Every object inherits from the parent :any:`mambustruct.MambuStruct`
+class. Start at the documentation there for more info on how it works.
+
+.. todo:: Implement objects to make POST requests. The suggestion may be to use
+          MambuStruct, to default the __init__ to make a POST request (via the data
+          argument) and the attrs attribute to store the elements of the response that
+          Mambu gives when a successful POST is achieved.
+.. todo:: Implement a lot of other Mambu entities available through GET requests on
+          Mambu.
+.. todo:: Implement a lot of lacking GET filters on the currently available Mambu
+          objects, inside the urlfuncs on the mambuutil module.
+.. todo:: A lot of TODO comments are inserted inside the pydocs of the code
+          itself. Please read them for suggestions on work need to be done.
+"""
+
+from .. import mambuconfig, mambuutil

mambupy-2.1.1/MambuPy/rest/mambuactivity.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+"""Mambu Activity objects.
+
+.. autosummary::
+   :nosignatures:
+   :toctree: _autosummary
+
+MambuActivity holds a mambu activity. Don't instantiate this class
+directly. Look at MambuActivity pydoc for further info.
+
+MambuActivities holds a list of activities.
+
+Uses mambugeturl.getactivitiesurl as default urlfunc
+"""
+
+
+from ..mambugeturl import getactivitiesurl
+from .mambustruct import MambuStruct
+from .mamburestutils import MambuStructIterator
+
+mod_urlfunc = getactivitiesurl
+
+
+class MambuActivity(MambuStruct):
+    """A loan Activity from Mambu.
+
+    Don't instantiate this class directly. It's mostly used by
+    MambuActivities to configure each of its elements as
+    MambuActivity objects. There's no suitable urlfunc to use to
+    retrieve just a specific transaction from a loan account. In fact,
+    you can look at the code of MambuActivities.convert_dict_to_attrs(),
+    it uses urlfunc and entid = None , so no connection to Mambu will be
+    made, never, for any particular MambuActivity object.
+    """
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        """Tasks done here:
+
+        Just initializes the MambuStruct.
+        """
+        MambuStruct.__init__(self, urlfunc, entid, *args, **kwargs)
+
+    def __repr__(self):
+        """Instead of the default id given by the parent class, shows
+        the transactionid of the transaction.
+        """
+        try:
+            return self.__class__.__name__ + " - activityid: %s" % self["activity"]
+        except KeyError:
+            return self.__class__.__name__ + " - activityid: %s" % self["activity"]
+
+
+class MambuActivities(MambuStruct):
+    """A list of loan Activities from Mambu."""
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        MambuStruct.__init__(self, urlfunc, entid, *args, **kwargs)
+
+    def __iter__(self):
+        return MambuStructIterator(self.attrs)
+
+    def convert_dict_to_attrs(self, *args, **kwargs):
+        """The trick for iterable Mambu Objects comes here:
+
+        You iterate over each element of the responded List from Mambu,
+        and create a Mambu Activity object for each one, initializing
+        them one at a time, and changing the attrs attribute (which just
+        holds a list of plain dictionaries) with a MambuActivity just
+        created.
+
+        """
+        for n, a in enumerate(self.attrs):
+            # ok ok, I'm modifying elements of a list while iterating it. BAD PRACTICE!
+            try:
+                params = self.params
+            except AttributeError:
+                params = {}
+            kwargs.update(params)
+            try:
+                self.mambuactivityclass
+            except AttributeError:
+                self.mambuactivityclass = MambuActivity
+
+            activity = self.mambuactivityclass(urlfunc=None, entid=None, *args, **kwargs)
+            activity.init(a, *args, **kwargs)
+            activity._MambuStruct__urlfunc = getactivitiesurl
+            self.attrs[n] = activity