MambuPy 2.1.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

MambuPy/__init__.py

@@ -8,15 +8,13 @@
     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.api` package (the old-and-soon-to-be-deprecated,
-   V1-compatible code lives at :any:`MambuPy.rest`
+   , they live at the :any:`MambuPy.api` package
 
 2) An ORM using a `DB backup retrieved from Mambu
    <https://support.mambu.com/docs/mambu-data-dictionary>`_
@@ -39,7 +37,7 @@ import sys
 from importlib.abc import MetaPathFinder
 from importlib.util import spec_from_file_location
 
-__version__ = "2.1.0"
+__version__ = "2.2.1"
 """The version of this module."""
 
 

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"""
 
@@ -55,6 +125,9 @@ class MambuConnectorREST(MambuConnector, MambuConnectorReader, MambuConnectorWri
         }
         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(
@@ -108,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, 500, 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(
@@ -139,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,
@@ -151,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:

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",
@@ -99,20 +105,10 @@ You may edit this to your own liking. But beware of pricking eyes!
 """
 
 import os
+import configparser
+from configparser import NoSectionError
 
-# import ConfigParser depending on Python version
-import sys
-
-if sys.version_info.major < 3:
-    import ConfigParser
-    from ConfigParser import NoSectionError
-
-    config = ConfigParser.ConfigParser(defaults=default_configs)
-else:
-    import configparser
-    from configparser import NoSectionError
-
-    config = configparser.ConfigParser(defaults=default_configs)
+config = configparser.ConfigParser(defaults=default_configs)
 
 # argparse for command line arguments overriding
 import argparse
@@ -123,6 +119,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 +181,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/mambuutil.py

@@ -28,16 +28,9 @@ 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:
-    # python2
-    unicode
-except NameError:
-    # python3
-    unicode = str
-
 import json
 import sys
 from datetime import datetime, timezone
@@ -186,21 +179,23 @@ def date_format(field, formato=None, as_utc=False):
 
     if not formato:
         formato = "%Y-%m-%dT%H:%M:%S"
-    if sys.version_info < (3, 0):
-        return datetime.strptime(
-            datetime.strptime(field, "%Y-%m-%dT%H:%M:%S+0000").strftime(formato),
+
+    field_with_tz = datetime.fromisoformat(field)
+
+    if as_utc and field_with_tz.tzinfo is not None:
+        # Convertir a UTC mientras aún tiene tzinfo
+        field_as_dt = field_with_tz.astimezone(timezone.utc)
+        field_as_dt = datetime.strptime(
+            field_as_dt.strftime(formato),
             formato,
         )
     else:
         field_as_dt = datetime.strptime(
-            datetime.fromisoformat(field).strftime(formato),
+            field_with_tz.strftime(formato),
             formato,
         )
-        if as_utc:
-            field_as_dt = field_as_dt.astimezone(
-                timezone.utc
-            ).replace(tzinfo=None)
-        return field_as_dt
+
+    return field_as_dt
 
 
 def strip_tags(html):
@@ -221,10 +216,7 @@ def strip_tags(html):
         """
 
         def __init__(self):
-            try:
-                super().__init__()  # required for python3
-            except TypeError:  # pragma: no cover
-                pass  # with python2 raises TypeError
+            super().__init__()
             self.reset()
             self.fed = []
 
@@ -256,12 +248,7 @@ def strip_consecutive_repeated_char(s, ch):
     return sdest
 
 
-if sys.version_info >= (3, 0):
-    # python3
-    from future.moves.urllib import parse as urlparse
-else:  # pragma: no cover
-    # python2
-    import urlparse
+from urllib import parse as urlparse
 
 
 def iri_to_uri(iri):
@@ -277,35 +264,9 @@ def iri_to_uri(iri):
     unicode chars there. Using this I solved the problem.
     """
 
-    def url_encode_non_ascii(b):
-        """Encode Non ASCII chars to URL-friendly chars.
-
-        Sometimes unicode gets in the way. A shame, I know. And perhaps the
-        biggest shame is not me correctly handling it.
-        """
-        import re
-
-        return re.sub("[\x80-\xFF]", lambda c: "%%%02x" % ord(c.group(0)), b)
-
     parts = urlparse.urlparse(iri)
-    if sys.version_info < (3, 0):  # pragma: no cover
-        # python2
-        partes = []
-        for parti, part in enumerate(parts):
-            try:
-                if parti != 1:
-                    partes.append(url_encode_non_ascii(part.encode("utf-8")))
-                else:
-                    partes.append(part.encode("idna"))
-            except UnicodeDecodeError:
-                partes.append(url_encode_non_ascii(part.decode("latin")))
-            except Exception:
-                raise Exception
-        return urlparse.urlunparse(partes)
-    else:
-        # python3
-        uri = [part.decode("utf8") for parti, part in enumerate(parts.encode("utf8"))]
-        return urlparse.urlunparse(uri)
+    uri = [part.decode("utf8") for parti, part in enumerate(parts.encode("utf8"))]
+    return urlparse.urlunparse(uri)
 
 
 def encoded_dict(in_dict):
@@ -315,13 +276,6 @@ def encoded_dict(in_dict):
     """
     out_dict = {}
     for k, v in in_dict.items():
-        if isinstance(v, unicode):
-            if sys.version_info < (3, 0):  # pragma: no cover
-                v = v.encode("utf8")
-        elif isinstance(v, str):
-            # Must be encoded in UTF-8
-            if sys.version_info < (3, 0):  # pragma: no cover
-                v.decode("utf8")
         out_dict[k] = v
     return out_dict
 

MambuPy/orm/schema_groups.py

@@ -15,10 +15,9 @@ from .schema_users import User
 
 # technical debt, cannot import name schema_clients
 try:
-    from . import \
-        schema_clients  # this should work for python2 and python3, but doesnt
-except Exception as e:
-    import schema_clients  # python 2
+    from . import schema_clients
+except Exception:
+    import schema_clients
 
 from sqlalchemy import (Column, DateTime, ForeignKey, Integer, Numeric, String,
                         Text)

MambuPy/orm/schema_orm.py

@@ -23,8 +23,6 @@ every schema_*.py you need.
 This last requirement also applies for the Base, or for the engine and
 the sessionmaker for that matter.
 """
-from __future__ import absolute_import
-
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, scoped_session
 

MambuPy/rest/__init__.py

@@ -1,49 +1,31 @@
-"""MambuPy's REST package (SOON TO BE DEPRECATED).
+# coding: utf-8
+"""MambuPy REST module - DEPRECATED.
 
-Objects using `Mambu REST API
-<https://developer.mambu.com/customer/en/portal/articles/1162276-rest-apis-overview/>`_
+.. warning::
 
-.. autosummary::
-   :toctree: _autosummary
+   DEPRECATED: This module uses Mambu API v1 which is no longer supported.
+   This code is maintained only for backwards compatibility with legacy systems.
+   It will be removed in a future version of MambuPy.
 
-    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.
+   Only mambuactivity is available in this legacy module.
 """
-
-from .. import mambuconfig, mambuutil
+import warnings
+
+warnings.warn(
+    "MambuPy.rest module is deprecated and will be removed in a future version. "
+    "Mambu API v1 is no longer supported by Mambu.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from .mambuactivity import (
+    MambuActivity,
+    MambuActivities,
+    getactivitiesurl,
+)
+
+__all__ = [
+    "MambuActivity",
+    "MambuActivities",
+    "getactivitiesurl",
+]