masstack-python-client 0.0.1__py3-none-any.whl

masstack_python_client/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.1"
+__homepage__ = "https://somconnexio.coop/"
+__author__ = "Borja Gimeno <borja.gimeno@somconnexio.coop>"
+__license__ = "GPL-3.0-only"

masstack_python_client/auth/token.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+
+@dataclass(frozen=True)
+class Token:
+    access_token: str
+    expires_at: datetime
+
+    def is_expired(self, skew_seconds: int = 60) -> bool:
+        return datetime.utcnow() >= self.expires_at - timedelta(seconds=skew_seconds)

masstack_python_client/auth/token_manager.py

@@ -0,0 +1,86 @@
+import os
+import base64
+import requests
+from datetime import datetime, timedelta
+from joserfc import jwt
+from joserfc.jwk import RSAKey
+from requests.exceptions import HTTPError
+from ..exceptions import ErrorFetchingToKen
+from .token import Token
+from .token_store import FileTokenStore
+
+
+class TokenManager:
+
+    def __init__(self):
+        self._token_uri = self._token_uri()
+        self._client_email = self._client_email()
+        self._private_key = self._private_key()
+        self._private_key_id = self._private_key_id()
+        self._store = FileTokenStore(self._store_path())
+
+    @staticmethod
+    def _token_uri() -> str:
+        return os.environ.get("MASSTACK_TOKEN_URI", "")
+
+    @staticmethod
+    def _client_email() -> str:
+        return os.environ.get("MASSTACK_CLIENT_EMAIL", "")
+
+    @staticmethod
+    def _private_key() -> str:
+        base64_private_key = os.environ.get("MASSTACK_PRIVATE_KEY_BASE64", "").encode(
+            "ascii"
+        )
+        base64_decode_bytes_private_key = base64.b64decode(base64_private_key)
+        return base64_decode_bytes_private_key.decode("ascii")
+
+    @staticmethod
+    def _private_key_id() -> str:
+        return os.environ.get("MASSTACK_PRIVATE_KEY_ID", "")
+
+    @staticmethod
+    def _store_path() -> str:
+        return os.environ.get("MASSTACK_TOKEN_STORE_PATH")
+
+    def _fetch_token(self) -> Token:
+        now = datetime.utcnow()
+        claims = {
+            "iss": self._client_email,
+            "aud": self._token_uri,
+            "exp": now + timedelta(hours=1),
+            "iat": now,
+        }
+        jwt_header = {"alg": "RS256", "kid": self._private_key_id}
+
+        try:
+            key = RSAKey.import_key(self._private_key)
+            assertion = jwt.encode(jwt_header, claims, key)
+            response = requests.post(
+                self._token_uri,
+                data={
+                    "assertion": assertion,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+                },
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            )
+            response.raise_for_status()
+        except HTTPError:
+            raise ErrorFetchingToKen(response.status_code, response.text)
+        except Exception as e:
+            raise ErrorFetchingToKen(500, str(e))
+        data = response.json()
+
+        return Token(
+            access_token=data["access_token"],
+            expires_at=datetime.utcnow() + timedelta(seconds=data["expires_in"]),
+        )
+
+    def get(self) -> str:
+        token = self._store.load()
+
+        if token is None or token.is_expired():
+            token = self._fetch_token()
+            self._store.save(token)
+
+        return token.access_token

masstack_python_client/auth/token_store.py

@@ -0,0 +1,34 @@
+import json
+from typing import Optional
+from pathlib import Path
+from datetime import datetime
+import tempfile
+from .token import Token
+
+
+class FileTokenStore:
+
+    def __init__(self, path: Optional[str] = None):
+        self.path = Path(
+            path if path is not None else Path(tempfile.gettempdir()) / "masstack.token"
+        )
+
+    def load(self) -> Optional[Token]:
+        if not self.path.exists():
+            return None
+
+        data = json.loads(self.path.read_text())
+        return Token(
+            access_token=data["access_token"],
+            expires_at=datetime.fromisoformat(data["expires_at"]),
+        )
+
+    def save(self, token: Token) -> None:
+        self.path.write_text(
+            json.dumps(
+                {
+                    "access_token": token.access_token,
+                    "expires_at": token.expires_at.isoformat(),
+                }
+            )
+        )

masstack_python_client/client.py

@@ -0,0 +1,85 @@
+import os
+import requests as req
+from typing import Optional
+from masstack_python_client.auth.token_manager import TokenManager
+from masstack_python_client.exceptions import ErrorPostingData, ErrorRetrievingData
+
+
+class MasstackClient:
+    """Base Masstack API client"""
+
+    def __init__(self):
+        self._token_manager = TokenManager()
+        self.domain = self._domain()
+        self.org_id = self._org_id()
+
+    @staticmethod
+    def _org_id() -> str:
+        return os.environ.get("MASSTACK_ORG_ID", "")
+
+    @staticmethod
+    def _domain() -> str:
+        return os.environ.get("MASSTACK_DOMAIN", "")
+
+    def _common_header(self) -> dict:
+        token = self._token_manager.get()
+        return {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+
+    def get(
+        self,
+        api: str,
+        version: str,
+        endpoint: str,
+        params: Optional[dict] = None,
+        header: Optional[dict] = None,
+        data: Optional[dict] = None,
+    ) -> dict:
+        url = self._build_url(api, version, endpoint)
+        res = self._send_request("GET", url, extra_headers=header, params=params)
+
+        if res.status_code >= 400:
+            raise ErrorRetrievingData(res.status_code, res.text, params)
+
+        return res.json()
+
+    def post(
+        self,
+        api: str,
+        version: str,
+        endpoint: str,
+        data: Optional[dict],
+        header: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        url = self._build_url(api, version, endpoint)
+        res = self._send_request(
+            "POST", url, extra_headers=header, payload=data, params=params
+        )
+        if res.status_code >= 400:
+            raise ErrorPostingData(res.status_code, res.text, data)
+
+        return res.json()
+
+    def _send_request(
+        self,
+        verb: str,
+        url: str,
+        payload: Optional[dict] = None,
+        params: Optional[dict] = None,
+        extra_headers: Optional[dict] = None,
+    ) -> req.Response:
+        headers = self._common_header()
+        if extra_headers:
+            headers.update(extra_headers)
+
+        return req.request(
+            verb.upper(), url, headers=headers, json=payload, params=params
+        )
+
+    def _build_url(self, api: str, version: str, endpoint: str) -> str:
+        return (
+            f"https://{api}.{self.domain}/"
+            f"{version.strip('/')}/"
+            f"orgs/{self.org_id.strip('/')}/"
+            f"{endpoint.lstrip('/')}"
+        )

masstack_python_client/data/data_utils.py

@@ -0,0 +1,51 @@
+import csv
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+PROVINCE_FILE_PATH = BASE_DIR / "province_translation.csv"
+STREET_TYPE_FILE_PATH = BASE_DIR / "street_type_translation.csv"
+UNIT_TRANSLATION_FILE_PATH = BASE_DIR / "unit_translation.csv"
+
+
+def get_province_by_id(
+    province_id: str, province: str = "", lang: str = "ca_ES"
+) -> str:
+    with open(
+        PROVINCE_FILE_PATH,
+        newline="",
+        encoding="utf-8",
+    ) as f:
+        return _get_by_code(csv.DictReader(f), province_id, lang, province)
+
+
+def get_street_type(original_text: str, lang: str = "ca_ES") -> str:
+    with open(
+        STREET_TYPE_FILE_PATH,
+        newline="",
+        encoding="utf-8",
+    ) as f:
+        return _get_translation(csv.DictReader(f), original_text, lang)
+
+
+def get_unit_translation(original_text: str, lang: str = "ca_ES") -> str:
+    with open(
+        UNIT_TRANSLATION_FILE_PATH,
+        newline="",
+        encoding="utf-8",
+    ) as f:
+        return _get_translation(csv.DictReader(f), original_text, lang)
+
+
+def _get_by_code(reader, code, lang, default):
+    return next((row[lang] for row in reader if row["code"] == code), default)
+
+
+def _get_translation(reader, text, lang):
+    match = {"es": None, "ca": None}
+    for row in reader:
+        if row["es_ES"] == text:
+            match["es"] = row
+        if row["ca_ES"] == text:
+            match["ca"] = row
+
+    return ((m := match["es"] or match["ca"]) and m.get(lang)) or text

masstack_python_client/data/province_translation.csv

@@ -0,0 +1,53 @@
+code,es_ES,ca_ES
+1,ALAVA,ALAVA
+2,ALBACETE,ALBACETE
+3,ALICANTE,ALACANT
+4,ALMERIA,ALMERIA
+33,ASTURIAS,ASTURIES
+5,AVILA,AVILA
+6,BADAJOZ,BADAJOZ
+8,BARCELONA,BARCELONA
+9,BURGOS,BURGOS
+10,CACERES,CACERES
+11,CADIZ,CADIZ
+39,CANTABRIA,CANTABRIA
+12,CASTELLON,CASTELLO
+51,CEUTA,CEUTA
+13,CIUDAD REAL,CIUTAT REAL
+14,CORDOBA,CORDOBA
+15,CORU+ANE-A (A),CORUNYA (A)
+16,CUENCA,CUENCA
+17,GERONA,GIRONA
+18,GRANADA,GRANADA
+19,GUADALAJARA,GUADALAJARA
+20,GUIPUZCOA,GIPUSKOA
+21,HUELVA,HUELVA
+22,HUESCA,HUESCA
+7,ILLES BALEARS,ILLES BALEARS
+23,JAEN,JAEN
+24,LEON,LEON
+25,LERIDA,LLEIDA
+27,LUGO,LUGO
+28,MADRID,MADRID
+29,MALAGA,MALAGA
+52,MELILLA,MELILLA
+30,MURCIA,MURCIA
+31,NAVARRA,NAVARRA
+32,OURENSE,ORENSE
+34,PALENCIA,PALENCIA
+35,PALMAS (LAS),PALMES (LES)
+36,PONTEVEDRA,PONTEVEDRA
+26,RIOJA (LA),RIOJA (LA)
+37,SALAMANCA,SALAMANCA
+38,SANTA CRUZ DE TENERIFE,SANTA CRUZ DE TENERIFE
+40,SEGOVIA,SEGOVIA
+41,SEVILLA,SEVILLA
+42,SORIA,SORIA
+43,TARRAGONA,TARRAGONA
+44,TERUEL,TEROL
+45,TOLEDO,TOLEDO
+46,VALENCIA,VALENCIA
+47,VALLADOLID,VALLADOLID
+48,VIZCAYA,BIZKAIA
+49,ZAMORA,ZAMORA
+50,ZARAGOZA,SARAGOSSA

masstack_python_client/data/street_type_translation.csv

@@ -0,0 +1,91 @@
+code,es_ES,ca_ES
+AL,ALAMEDA,ALAMEDA
+AD,ALDEA,ALDEA
+AP,APARTAMENTOS,APARTAMENTS
+AY,ARROYO,RIEROL
+AV,AVENIDA,AVINGUDA
+BJ,BAJADA,BAIXADA
+BR,BARRANCO,BARRANC
+BO,BARRIO,BARRI
+BL,BLOQUE,BLOC
+CL,CALLE,CARRER
+CJ,CALLEJA,CARRERÓ
+CM,CAMINO,CAMÍ
+CR,CARRETERA,CARRETERA
+CS,CASERIO,CASERIU
+CH,CHALET,XALÉ
+CG,COLEGIO,COL·LEGI
+CO,COLONIA,COLÒNIA
+CN,CONJUNTO,CONJUNT
+CT,CUESTA,COSTA
+ED,EDIFICIO,EDIFICI
+EN,ENTRADA,ENTRADA
+ES,ESCALINATA,ESCALINATA
+EX,EXPLANADA,ESPLANADA
+EM,EXTRAMUROS,EXTRAMURS
+ER,EXTRARRADIO,EXTRARADI
+FC,FERROCARRIL,FERROCARRIL
+GL,GLORIETA,GLORIETA
+GV,GRAN VÍA,GRAN VIA
+GR,GRUPO,GRUP
+HT,HUERTA,HORTA
+JR,JARDINES,JARDINS
+LD,LADO,COSTAT
+LG,LUGAR,LLOC
+MZ,MANZANA,ILLA
+MS,MASÍA,MASIA
+MC,MERCADO,MERCAT
+MT,MONTE,MUNTANYA
+ML,MUELLE,MOLL
+MN,MUNICIPIO,MUNICIPI
+PA,PARCELA,PARCEL·LA
+PQ,PARQUE,PARC
+PI,PARROQUIA,PARRÒQUIA
+PD,PARTIDA,PARTIDA
+PJ,PASAJE,PASSATGE
+PS,PASEO,PASSEIG
+PZ,PLAZA,PLAÇA
+PB,POBLADO,POBLAT
+PG,POLIGONO,POLÍGON
+PR,PROLONGACION,PROLONGACIÓ
+PT,PUENTE,PONT
+PU,PUERTA,PORTA
+QT,QUINTA,QUINTA
+RM,RAMAL,RAMAL
+RB,RAMBLA,RAMBLA
+RP,RAMPA,RAMPA
+RR,RIERA,RIERA
+RC,RINCÓN,RACÓ
+RD,RONDA,RONDA
+RU,RÚA,RUA
+SA,SALIDA,SORTIDA
+SC,SECTOR,SECTOR
+SC,SECCIÓN,SECCIÓ
+SD,SENDA,SENDERA
+SL,SOLAR,SOLAR
+SL,SALÓN,SALÓ
+SB,SUBIDA,PUJADA
+TN,TERRENOS,TERRENYS
+TO,TORRENTE,TORRENT
+TR,TRAVESÍA,TRAVESSERA
+UR,URBANIZACION,URBANITZACIÓ
+VI,VÍA,VIA
+VP,VÍA PÚBLICA,VIA PÚBLICA
+AR,ÁREA,ÀREA
+AR,ARRABAL,RAVAL
+AC,ACCESO,ACCÉS
+VR,ACERA,VORERA
+AQ,ACEQUIA,SÈQUIA
+AF,AFUERA(S),AFORES
+AG,AGRUPACION,AGRUPACIÓ
+AS,ARRABAL(ES),RAVALS
+AV,AUTOPISTA/AUTOVIA,AUTOPISTA/AUTOVIA
+BB,BARRIADA/BAJADA,BARRIADA/BAIXADA
+CC,CASA(S)/CASETA,CASA(ES)/CASETA
+MJ,COMPLEJO,COMPLEXE
+RJ,CORTIJO,MAS
+DM,DISEMINADO(S)/EXTR.,DISSEMINAT(S)/EXTR.
+NO,NUCLEO,NUCLI
+PO,PATIO,PATI
+LA,POBLACIÓN,POBLACIÓ
+RS,RESIDENCIA,RESIDÈNCIA

masstack_python_client/data/unit_translation.csv

@@ -0,0 +1,13 @@
+es_ES,ca_ES
+BAJO,BAIX
+LOCAL,LOCAL
+OTROS,ALTRES
+ATICO,ATIC
+PLANTA BAJA,PLANTA BAIXA
+NAVE,NAU
+PARCELA,PARCEL·LA
+ENTRESUELO,ENTRESOL
+BLOQUE,BLOC
+TIENDA,TENDA
+SOTANO,SOTERRANI
+SOBREATICO,SOBREATIC

masstack_python_client/exceptions.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+
+class MasstackClientException(Exception):
+    """Base exception for Masstack Python Client."""
+
+    _status_code: Optional[int] = None
+    _message: Optional[str] = None
+
+    def __init__(self, status_code: int, message: str):
+        super(Exception, self).__init__(message)
+        self._message = message
+        self._status_code = status_code
+
+    @property
+    def status_code(self) -> int:
+        """The status_code property."""
+        return self._status_code or 0
+
+    @property
+    def message(self) -> str:
+        """The error message property."""
+        return self._message or ""
+
+    def _params_to_string(self, params):
+        if not params or len(params) == 0:
+            return ""
+        params_msg = ""
+        for key, value in params.items():
+            params_msg = params_msg + "{}: {}\n".format(key, value)
+        return params_msg
+
+
+class ErrorFetchingToKen(MasstackClientException):
+    def __init__(self, status_code: int, error_msg: str):
+        message = "Error fetching token with the next error message: {}".format(
+            error_msg
+        )
+        super(ErrorFetchingToKen, self).__init__(status_code, message)
+
+
+class ErrorRetrievingData(MasstackClientException):
+    def __init__(self, status_code: int, error_msg: str, params: Optional[dict] = None):
+        message = "Error retrieving data with the next error message: {}\nParameters:\n{}".format(
+            error_msg, self._params_to_string(params)
+        )
+        super(ErrorRetrievingData, self).__init__(status_code, message)
+
+
+class ErrorPostingData(MasstackClientException):
+    def __init__(self, status_code: int, error_msg: str, body: dict):
+        message = (
+            "Error posting data with the next error message: {}\nBody:\n{}".format(
+                error_msg, self._params_to_string(body)
+            )
+        )
+        super(ErrorPostingData, self).__init__(status_code, message)