MambuPy 2.0.0b49__tar.gz → 2.1.0__tar.gz

{MambuPy-2.0.0b49 → mambupy-2.1.0}/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.0b49"
+import sys
+from importlib.abc import MetaPathFinder
+from importlib.util import spec_from_file_location
+
+__version__ = "2.1.0"
 """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.0b49/mambupy → mambupy-2.1.0/MambuPy}/api/connector/rest.py

@@ -52,10 +52,16 @@ 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)
+
+    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):
@@ -104,7 +110,7 @@ class MambuConnectorREST(MambuConnector, MambuConnectorReader, MambuConnectorWri
 
         retry_strategy = Retry(
             total=self._RETRIES,
-            status_forcelist=[429, 502, 503, 504],
+            status_forcelist=[429, 500, 502, 503, 504],
             backoff_factor=1,
             allowed_methods=[
                 "HEAD",
@@ -489,36 +495,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 +550,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 +573,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.0b49 → mambupy-2.1.0}/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.0b49 → mambupy-2.1.0}/MambuPy/mambuutil.py

@@ -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.0/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.0/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

mambupy-2.1.0/MambuPy/rest/mambubranch.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+"""Mambu Branches objects.
+
+.. autosummary::
+   :nosignatures:
+   :toctree: _autosummary
+
+MambuBranch holds a branch.
+
+MambuBranches holds a list of branches.
+
+Uses mambugeturl.getbranchesurl as default urlfunc
+"""
+
+
+from ..mambugeturl import getbranchesurl
+from .mambustruct import MambuStruct
+from .mamburestutils import MambuStructIterator
+
+mod_urlfunc = getbranchesurl
+
+
+class MambuBranch(MambuStruct):
+    """A Branch from Mambu.
+
+    With the default urlfunc, entid argument must be the ID of the
+    branch you wish to retrieve.
+    """
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        """Tasks done here:
+
+        Just initializes the MambuStruct.
+        """
+        MambuStruct.__init__(
+            self, urlfunc, entid, custom_field_name="customFieldValues", *args, **kwargs
+        )
+
+    def setUsers(self, *args, **kwargs):
+        """Adds the active users for this branch to a 'users' field.
+
+                Returns the number of requests done to Mambu.
+
+        .. todo:: since pagination logic was added, is not always true that
+                  just 1 request was done. It may be more! But since request
+                  counter singleton holds true information about how many requests
+                  were done to Mambu, in fact this return value may be obsolete
+        """
+        try:
+            self.mambuuserclass
+        except AttributeError:
+            from .mambuuser import MambuUsers
+
+            self.mambuusersclass = MambuUsers
+
+        usrs = [
+            us
+            for us in self.mambuusersclass(branchId=self["id"], *args, **kwargs)
+            if us["userState"] == "ACTIVE"
+        ]
+        self["users"] = usrs
+
+        return 1
+
+    def update(self, *args, **kwargs):
+        """Updates a branch from Mambu
+        """
+        if "data" in kwargs:
+            data = kwargs.pop("data")
+            if data:
+                raise NotImplementedError
+        return super(MambuBranch, self).update(data={}, *args, **kwargs)
+
+
+class MambuBranches(MambuStruct):
+    """A list of Branches from Mambu.
+
+    With the default urlfunc, entid argument must be empty at
+    instantiation time to retrieve all the branches according to any
+    other filter you send to the urlfunc.
+    """
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        """By default, entid argument is empty. That makes perfect
+        sense: you want several branches, not just one
+        """
+        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 Branch 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 MambuBranch just
+                created.
+
+        .. todo:: pass a valid (perhaps default) urlfunc, and its
+                  corresponding id to entid to each MambuBranch, telling
+                  MambuStruct not to connect() by default. It's desirable to
+                  connect at any other further moment to refresh some element in
+                  the list.
+        """
+        for n, b 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.mambubranchclass
+            except AttributeError:
+                self.mambubranchclass = MambuBranch
+
+            branch = self.mambubranchclass(urlfunc=None, entid=None, *args, **kwargs)
+            branch.init(b, *args, **kwargs)
+            branch._MambuStruct__urlfunc = getbranchesurl
+            self.attrs[n] = branch

mambupy-2.1.0/MambuPy/rest/mambucentre.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+"""Mambu Centres objects.
+
+.. autosummary::
+   :nosignatures:
+   :toctree: _autosummary
+
+MambuCentre holds a centre.
+
+MambuCentres holds a list of centres.
+
+Uses mambugeturl.getcentresurl as default urlfunc
+"""
+
+
+from ..mambugeturl import getcentresurl
+from .mambustruct import MambuStruct
+from .mamburestutils import MambuStructIterator
+
+mod_urlfunc = getcentresurl
+
+
+class MambuCentre(MambuStruct):
+    """A Centre from Mambu.
+
+    With the default urlfunc, entid argument must be the ID of the
+    centre you wish to retrieve.
+    """
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        """Tasks done here:
+
+        Just initializes the MambuStruct.
+        """
+        MambuStruct.__init__(
+            self, urlfunc, entid, custom_field_name="customFieldValues", *args, **kwargs
+        )
+
+    def setBranch(self, *args, **kwargs):
+        """Adds the branch for this centre to a 'branch' field.
+
+                Returns the number of requests done to Mambu.
+        """
+        try:
+            self.mambubranchclass
+        except AttributeError:
+            from .mambubranch import MambuBranch
+
+            self.mambubranchclass = MambuBranch
+
+        brnch = self.mambubranchclass(entid=self["assignedBranchKey"], *args, **kwargs)
+        self["branch"] = brnch
+
+        return 1
+
+
+class MambuCentres(MambuStruct):
+    """A list of Centres from Mambu.
+
+    With the default urlfunc, entid argument must be empty at
+    instantiation time to retrieve all the centres according to any
+    other filter you send to the urlfunc.
+    """
+
+    def __init__(self, urlfunc=mod_urlfunc, entid="", *args, **kwargs):
+        """By default, entid argument is empty. That makes perfect
+        sense: you want several centres, not just one
+        """
+        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 Centre 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 MambuCentre just
+                created.
+
+        .. todo:: pass a valid (perhaps default) urlfunc, and its
+                  corresponding id to entid to each MambuCentre, telling
+                  MambuStruct not to connect() by default. It's desirable to
+                  connect at any other further moment to refresh some element in
+                  the list.
+        """
+        for n, b 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.mambucentreclass
+            except AttributeError:
+                self.mambucentreclass = MambuCentre
+
+            centre = self.mambucentreclass(urlfunc=None, entid=None, *args, **kwargs)
+            centre.init(b, *args, **kwargs)
+            centre._MambuStruct__urlfunc = getcentresurl
+            self.attrs[n] = centre