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

masstack_python_client/resources/feasibility.py

@@ -0,0 +1,267 @@
+import os
+from typing import Optional, List
+from masstack_python_client.client import MasstackClient
+from masstack_python_client.resources.models.address import (
+    BuildingData,
+    ClarifierData,
+    CoverageData,
+    StreetData,
+    UnitData,
+)
+
+
+class FeasibilityResource:
+    """Resource for feasibility operations
+    https://developers.masstack.com/en/docs/apis_feasibility_doc_swagger/1/apioverview
+    """
+
+    _api_domain = "feasibility"
+
+
+class Coverage(FeasibilityResource):
+
+    _api_path = "coverage"
+    _version = "v1"
+
+    @staticmethod
+    def _sf_segment() -> str:
+        return os.environ.get("MASSTACK_COVERAGE_SEGMENT", "")
+
+    @staticmethod
+    def _sf_channel() -> str:
+        return os.environ.get("MASSTACK_COVERAGE_CHANNEL", "")
+
+    @classmethod
+    def _get_endpoint(cls, subpath: str) -> str:
+        return f"{cls._api_path}/{subpath}"
+
+    @classmethod
+    def _get_header(cls, uuid: str) -> dict:
+        return {
+            "sf-channel": cls._sf_channel(),
+            "sf-segment": cls._sf_segment(),
+            "sf-check-id": uuid,
+        }
+
+    @classmethod
+    def _request(
+        cls,
+        method: str,
+        subpath: str,
+        uuid: str,
+        data: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        client = MasstackClient()
+        func = getattr(client, method)
+
+        return func(
+            api=cls._api_domain,
+            version=cls._version,
+            endpoint=cls._get_endpoint(subpath),
+            params=params,
+            data=data,
+            header=cls._get_header(uuid),
+        )
+
+
+class Streets(Coverage):
+
+    _api_subpath = "streets"
+
+    @classmethod
+    def search(cls, text: str, lang: str, uuid: str) -> List[StreetData]:
+        """Search streets by text
+
+        Args:
+            text (str): Text to search
+            lang (str): Language code
+            uuid (str): Unique identifier for the request
+
+        Returns:
+            StreetData
+
+        """
+        streets = cls._request(
+            "get",
+            cls._api_subpath,
+            uuid,
+            params={"search": text},
+        )
+        return [StreetData.from_dict(uuid, lang, **street) for street in streets]
+
+    @classmethod
+    def get_building_info_by_street(
+        cls, street_id: str, uuid: str
+    ) -> List[ClarifierData]:
+        """Provides information to identify a building from a street.
+
+        Args:
+            street_id (str): Street identifier (Gescal 12)
+            uuid (str): Unique identifier for the request
+
+        Returns:
+            ClarifierData
+        """
+        clarifiers = cls._request(
+            "get",
+            f"{cls._api_subpath}/clarifiers/{street_id}",
+            uuid,
+        )
+
+        return [ClarifierData(uuid, **clarifier) for clarifier in clarifiers]
+
+
+class Buildings(Coverage):
+
+    _api_subpath = "buildings"
+
+    @classmethod
+    def search(cls, text: str, lang: str, uuid: str) -> List[BuildingData]:
+        """Search buildings by text
+
+        Args:
+            text (str): Text to search
+            lang (str): Language code
+            uuid (str): Unique identifier for the request
+
+        Returns:
+            BuildingData
+        """
+        buildings = cls._request(
+            "get",
+            cls._api_subpath,
+            uuid,
+            params={"search": text},
+        )
+        return [
+            BuildingData.from_dict(uuid, lang, **building) for building in buildings
+        ]
+
+    @classmethod
+    def get(
+        cls, id: str, lang: str, uuid: str, unit_to_data: Optional[bool] = False
+    ) -> BuildingData:
+        """Returns a single building object
+
+        Args:
+            id (str): Building identifier (Gescal 17)
+            lang (str): Language code
+            uuid (str): Unique identifier for the request
+            unit_to_data (bool): Territory_owner (TO) for each unit
+
+        Returns:
+            BuildingData
+        """
+        building = cls._request(
+            "get",
+            f"{cls._api_subpath}/{id}",
+            uuid,
+            params={"unit_to_data": unit_to_data},
+        )
+        return BuildingData.from_dict(
+            uuid,
+            lang,
+            **building,
+        )
+
+    @classmethod
+    def multi_search(
+        cls,
+        way_name: str,
+        number: str,
+        lang: str,
+        uuid: str,
+        postal_code: Optional[str] = "",
+        way_type: Optional[str] = "",
+        town: Optional[str] = "",
+    ) -> List[BuildingData]:
+        """Search buildings by required way_name and number
+           optionaly with postal_code, way_type, town, postal_code
+
+        Args:
+            way_name (str): Street name
+            number (str): Building number
+            lang (str): Language code
+            uuid (str): Unique identifier for the request
+            postal_code (str, optional): Postal code. Defaults to "".
+            way_type (str, optional): Street type. Defaults to "".
+            town (str, optional): Town name. Defaults to "".
+
+        Returns:
+            BuildingData
+        """
+
+        buildings = cls._request(
+            "post",
+            f"{cls._api_subpath}/search",
+            uuid,
+            data={
+                "way_name": way_name,
+                "number": number,
+                "way_type": way_type,
+                "town": town,
+                "postal_code": postal_code,
+            },
+        )
+        return [
+            BuildingData.from_dict(uuid, lang, **building) for building in buildings
+        ]
+
+
+class Units(Coverage):
+
+    _api_subpath = "units"
+
+    @classmethod
+    def get(
+        cls, unit_id: str, lang: str, uuid: str, parent_coverage: Optional[bool] = False
+    ) -> UnitData:
+        """Returns a single unit object
+
+        Args:
+            unit_id (str): Unit identifier (Gescal 37)
+            lang (str): Language code
+            uuid (str): Unique identifier for the request
+            parent_coverage (bool): return the parent coverage
+
+        Returns:
+            UnitData
+        """
+        unit = cls._request(
+            "get",
+            f"{cls._api_subpath}/{unit_id}",
+            uuid,
+            params={"parent_coverage": parent_coverage},
+        )
+        return UnitData.from_dict(
+            lang,
+            uuid=uuid,
+            include_coverage=True,
+            include_parent=parent_coverage,
+            **unit,
+        )
+
+    @classmethod
+    def get_coverage(
+        cls, unit_id: str, territory_owner: str, uuid: str
+    ) -> CoverageData:
+        """Returns an coverage info for a unit 'id' and 'territory_owner'.
+
+        Args:
+            unit_id (str): Unit identifier (Gescal 37)
+            territory_owner (str): territory_owner parameter to match with a unit
+            uuid (str): Unique identifier for the request
+
+        Returns:
+            CoverageData
+        """
+        unit = cls._request(
+            "get",
+            f"{cls._api_subpath}/extra",
+            uuid,
+            params={"id": unit_id, "territory_owner": territory_owner},
+        )
+        return CoverageData.from_dict(
+            **unit,
+        )

masstack_python_client/resources/models/address.py

@@ -0,0 +1,197 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from masstack_python_client.data.data_utils import (
+    get_province_by_id,
+    get_street_type,
+    get_unit_translation,
+)
+
+
+@dataclass(frozen=True)
+class CoverageData:
+    territory_owner: str
+    operator: str
+    territory_owner_type: str
+    address_id: str
+    technology: str
+    availability: bool
+    priority: str
+
+    @classmethod
+    def from_dict(
+        cls,
+        territory_owner: str,
+        operator: str,
+        territory_owner_type: str,
+        address_id: str,
+        priority: str = "1",
+        availability: bool = True,
+        technology: str = "FTTH",
+        **kwargs,
+    ):
+        return cls(
+            **{
+                "territory_owner": territory_owner,
+                "operator": operator,
+                "territory_owner_type": territory_owner_type,
+                "address_id": address_id,
+                "technology": technology,
+                "availability": availability,
+                "priority": priority,
+            }
+        )
+
+
+@dataclass(frozen=True)
+class UnitData:
+    uuid: str
+    id: str
+    technical_id: str
+    floor: str = ""
+    hand1: str = ""
+    summary: str = ""
+    hand2: str = ""
+    block: str = ""
+    door: str = ""
+    letter: str = ""
+    stair: str = ""
+    translated_floor: str = ""
+    translated_hand1: str = ""
+    translated_hand2: str = ""
+    coverages: List[CoverageData] = field(default_factory=list)
+    parent_id: str = ""
+
+    @classmethod
+    def from_dict(
+        cls,
+        lang: str,
+        id: str,
+        technical_id: str,
+        address_description: dict,
+        uuid: str = "",
+        coverage: list = [],
+        parent: dict = {},
+        include_coverage: bool = False,
+        include_parent: bool = False,
+        **kwargs,
+    ):
+        fields_dict = {
+            "id": id,
+            "uuid": uuid,
+            "technical_id": technical_id,
+            "floor": address_description.get("floor"),
+            "hand1": address_description.get("hand1"),
+            "hand2": address_description.get("hand2"),
+            "summary": address_description.get("summary"),
+            "block": address_description.get("block"),
+            "door": address_description.get("door"),
+            "letter": address_description.get("letter"),
+            "stair": address_description.get("stair"),
+            "translated_floor": get_unit_translation(
+                address_description.get("floor"), lang
+            ),
+            "translated_hand1": get_unit_translation(
+                address_description.get("hand1"), lang
+            ),
+            "translated_hand2": get_unit_translation(
+                address_description.get("hand2"), lang
+            ),
+        }
+        if include_coverage:
+            fields_dict = {
+                "coverages": [CoverageData.from_dict(**cov) for cov in coverage],
+                **fields_dict,
+            }
+        if include_parent:
+            fields_dict = {
+                "parent_id": parent["id"],
+                **fields_dict,
+            }
+        return cls(**fields_dict)
+
+
+@dataclass(frozen=True)
+class AddressData:
+    uuid: str
+    id: str
+    technical_id: str
+    summary: str
+    street_type: str
+    street_name: str
+    town: str
+    province: str
+    province_id: str
+    translated_street_type: str
+    translated_province: str
+
+    @classmethod
+    def base_fields_dict(
+        cls, uuid: str, lang: str, id: str, technical_id: str, address: dict
+    ) -> dict:
+        return {
+            "uuid": uuid,
+            "id": id,
+            "technical_id": technical_id,
+            "summary": address["summary"],
+            "street_type": address["street_type"],
+            "street_name": address["street_name"],
+            "town": address["town"],
+            "province": address["province"],
+            "province_id": address["province_id"],
+            "translated_street_type": get_street_type(address["street_type"], lang),
+            "translated_province": get_province_by_id(
+                address["province_id"], address["province"], lang
+            ),
+        }
+
+
+@dataclass(frozen=True)
+class StreetData(AddressData):
+    postal_codes: list
+
+    @classmethod
+    def from_dict(
+        cls, uuid: str, lang: str, id: str, technical_id: str, address: dict, **kwargs
+    ) -> "StreetData":
+        base_fields = super().base_fields_dict(uuid, lang, id, technical_id, address)
+        return cls(**{**base_fields, "postal_codes": address["postal_code"]})
+
+
+@dataclass(frozen=True)
+class BuildingData(AddressData):
+    number: str
+    postal_code: str
+    units: List[UnitData] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls,
+        uuid: str,
+        lang: str,
+        id: str,
+        technical_id: str,
+        address: dict,
+        units: list = [],
+        **kwargs,
+    ) -> "BuildingData":
+        base_fields = super().base_fields_dict(uuid, lang, id, technical_id, address)
+        return cls(
+            **{
+                **base_fields,
+                "number": address["number"],
+                "postal_code": address["postal_code"],
+                "units": [
+                    UnitData.from_dict(lang, uuid=uuid, **unit) for unit in units
+                ],
+            }
+        )
+
+
+@dataclass(frozen=True)
+class ClarifierData:
+    uuid: str
+    number: str
+    description: str
+    building_id: str
+    street_id: str

masstack_python_client-0.0.1.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: masstack-python-client
+Version: 0.0.1
+Summary: This Python API client provides access to masmovil core API domains
+Author-email: Borja Gimeno <borja.gimeno@somconnexio.coop>
+License: GPL-3.0-only
+Project-URL: Homepage, https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: joserfc
+Dynamic: license-file
+
+[![Latest Release](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/-/badges/release.svg)](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/-/releases)
+[![pipeline status](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/badges/main/pipeline.svg)](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/-/commits/main)
+[![coverage report](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/badges/main/coverage.svg)](https://git.coopdevs.org/coopdevs/som-connexio/masmovil/masstack-python-client/-/commits/main)
+
+:warning: WORK IN PROGRESS :warning:
+
+This Python API client provides access to masmovil core API domains.
+
+## Resources
+
+* Feasibility
+    - Coverage - find an address
+        - Streets:
+            - search: returns a list of street by text
+            - get_building_info_by_street: returns a list of building info by street id
+        - Buildings:
+            - search: returns a list of buildings by text
+            - multi_search: returns a list of buildings by request body
+            - get: returns a building by id with a list of units
+        - Units:
+            - get: returns a unit by id with a list of coverages
+            - get_coverage: returns coverage info for a unit id and territory_owner
+
+## Installation
+
+```commandline
+$ pip install masstack-python-client
+```
+
+## Configuration Environment
+
+You need define the Masstack CLIENT_EMAIL, PRIVATE_KEY_ID TOKEN_URI, MASSTACK_DOMAIN and PRIVATE_KEY in BASE64 as environment variables to request access toekn. You need define:
+
+```
+MASSTACK_CLIENT_EMAIL=<YOUR CLIENT EMAIL>
+MASSTACK_PRIVATE_KEY_ID=<YOUR PRIVATE KEY ID>
+MASSTACK_TOKEN_URI=<MASSTACK TOKEN URI>
+MASSTACK_PRIVATE_KEY_BASE64=<YOUR PRIVATE KEY in BASE64>
+MASSTACK_DOMAIN=<MASSTACK DOMAIN>
+
+```
+
+If this envvars are not defined, a exception will be raised with the name of the envvar not defined.
+
+Optional TOKEN_STORE_PATH environment variable to store token, if is not defined by defect is /tmp/masstack.token
+
+```
+MASSTACK_TOKEN_STORE_PATH=<YOUR PATH>
+
+```
+
+To all resources need define ORG_ID
+
+```
+MASSTACK_ORG_ID=<MASSTACK ORG ID>
+
+```
+
+For coverage resources need define COVERAGE_SEGMENT and COVERAGE_CHANNEL
+
+```
+MASSTACK_COVERAGE_SEGMENT=<SF SEGMENT>
+MASSTACK_COVERAGE_CHANNEL=<SF CHANNEL>
+
+```
+
+## Development
+
+### Setup environment
+
+1. Install `pyenv`
+```sh
+curl https://pyenv.run | bash
+```
+2. Build the Python version
+```sh
+pyenv install 3.11.9
+```
+3. Create a virtualenv
+```sh
+pyenv virtualenv 3.11.9 masstack-python-client
+```
+4. Activate virtualenv
+```sh
+pyenv activate masstack-python-client
+```
+5. Install dependencies
+```sh
+pyenv exec pip install -r requirements-dev.txt
+```
+6. Install pre-commit hooks
+```sh
+pyenv exec pre-commit install

masstack_python_client-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+masstack_python_client/__init__.py,sha256=_LdSbviglyB3x3fpuIQ9EUcSCj35jDkPRsaneNm-d6Y,154
+masstack_python_client/client.py,sha256=5b52Q2ekABi7DlZPsNobcmaJXOKzZfhKE_kHvNEqE9Q,2496
+masstack_python_client/exceptions.py,sha256=TszLAHlTurfnzlyf_OWvP9qACx1Y565TyIl4j75w-EM,1941
+masstack_python_client/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+masstack_python_client/auth/token.py,sha256=cNpV8lwfme1E9XBpGAtMj2ZFh2C_NgGVlIuXswE-eBE,306
+masstack_python_client/auth/token_manager.py,sha256=zEtLBUgmJh6kfN9w2csBzsCRwZevZwgWsjZkjE7AkBE,2738
+masstack_python_client/auth/token_store.py,sha256=SYj8oxkyELVV_AxtHSE1dpURRIqP6Gbj87MPQdhmXj8,910
+masstack_python_client/data/data_utils.py,sha256=TKybTybMXPqJdN6s-VTFur2jWHwfpzicQ-HQQZhm1_o,1476
+masstack_python_client/data/province_translation.csv,sha256=Jpd6jbjYaqeNOk9lUA3W_ftd1dPP3jFrlfxoTuuE3W0,1063
+masstack_python_client/data/street_type_translation.csv,sha256=2MGeTs0v6wVz2yRMyZUuoNOYA4NSqKGJCGYIRi9X8Ic,1791
+masstack_python_client/data/unit_translation.csv,sha256=34FPfaCC1eSmBfV0BbHSHJ-tktQk7YLlfT8tMxnfnys,194
+masstack_python_client/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+masstack_python_client/resources/feasibility.py,sha256=DbiPwWa9orSmITgcID7RVPKf7b50Pk8h1XQh0xxGYhw,7119
+masstack_python_client/resources/models/address.py,sha256=hKnEUVVz8AfGjhaDngzQ0HuR4_Z6zhK6Xe8Aj6xJR7I,5451
+masstack_python_client-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+masstack_python_client-0.0.1.dist-info/METADATA,sha256=71BLaspeDsRB3_jss4r86h8LMokS2kMOXPV_3uk7Nn0,3462
+masstack_python_client-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+masstack_python_client-0.0.1.dist-info/top_level.txt,sha256=q_iYlqJq22lhg_2O2iktARr7Mzz3QfjaW4l6J4vwyE8,23
+masstack_python_client-0.0.1.dist-info/RECORD,,

masstack_python_client-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+