hidroconta 1.0.0__tar.gz

hidroconta-1.0.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: hidroconta
+Version: 1.0.0
+Summary: API to easily access Demeter REST API provided by Hidroconta S.A.U.
+Home-page: UNKNOWN
+Author: JavierL
+Author-email: javier.lopez@hidroconta.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+
+# Integrations-PythonAPI
+API Python para facilitar el acceso a los endpoints de la interfaz REST de Demeter
+
+La API permite la gestión de grandes cantidades de datos mediante la librería Pandas, siempre y cuando se utilice la siguiente directiva en las llamadas a los métodos:
+```
+# Pandas = True returns a pandas dataframe instead a json
+```
+
+La forma de usar la API es la siguiente:
+
+- Importar los modulos deseados:
+```
+import demeterpy as demeter
+import demeterapitypes as tp
+import pandas as pd
+import datetime
+import endpoints
+```
+- Seleccionar el servidor con el cual se quiere comunicar (se puede modificar en todo momento):
+```
+# Set server
+demeter.set_server(endpoints.Server.MAIN)
+```
+
+- Realizar el login en dicho servidor
+```
+# Login
+demeter.login('USERNAME', 'PASSWORD')
+```
+
+Una vez seguidos los anteriores pasos, se puede realizar cualquier consulta sobre el sistema.
+Algunas de ellas son:
+
+- Búsqueda
+```
+# Search
+df = demeter.search(text='SAT', element_types=[tp.Element.COUNTER, tp.Element.ANALOG_INPUT, tp.Element.RTU], status=tp.Status.ENABLED, pandas=True)
+print(df)
+```
+
+- Obtención de historicos
+```
+# Get historics
+df = demeter.get_historics(start_date=datetime.datetime.now(), end_date=datetime.datetime.now(), element_ids=[1000], subtype=tp.AnalogInputHist.subtype, subcode=[tp.AnalogInputHist.subcode], pandas=True)
+print(df)
+```
+
+- Obtención de elementos
+```
+# Get
+df = demeter.get_rtus(element_id=17512, pandas=True)
+print(df)
+```
+La API define también una excepción especial cuando la llamada al endpoint de Demeter no devuelve el resultado esperado.
+La excepción de denomina "DemeterStatusCodeException" y contiene el código de error HTTP.
+```
+# Exception treatment
+try:
+    df = demeter.get_rtus(element_id=17512, pandas=True)
+except demeter.DemeterStatusCodeException as status_code:
+    print('Error {}'.format(status_code))
+```
+- Por último, se debería hacer un logout en el servidor
+```
+demeter.logout()
+```
+
+

hidroconta-1.0.0/README.md

@@ -0,0 +1,66 @@
+# Integrations-PythonAPI
+API Python para facilitar el acceso a los endpoints de la interfaz REST de Demeter
+
+La API permite la gestión de grandes cantidades de datos mediante la librería Pandas, siempre y cuando se utilice la siguiente directiva en las llamadas a los métodos:
+```
+# Pandas = True returns a pandas dataframe instead a json
+```
+
+La forma de usar la API es la siguiente:
+
+- Importar los modulos deseados:
+```
+import demeterpy as demeter
+import demeterapitypes as tp
+import pandas as pd
+import datetime
+import endpoints
+```
+- Seleccionar el servidor con el cual se quiere comunicar (se puede modificar en todo momento):
+```
+# Set server
+demeter.set_server(endpoints.Server.MAIN)
+```
+
+- Realizar el login en dicho servidor
+```
+# Login
+demeter.login('USERNAME', 'PASSWORD')
+```
+
+Una vez seguidos los anteriores pasos, se puede realizar cualquier consulta sobre el sistema.
+Algunas de ellas son:
+
+- Búsqueda
+```
+# Search
+df = demeter.search(text='SAT', element_types=[tp.Element.COUNTER, tp.Element.ANALOG_INPUT, tp.Element.RTU], status=tp.Status.ENABLED, pandas=True)
+print(df)
+```
+
+- Obtención de historicos
+```
+# Get historics
+df = demeter.get_historics(start_date=datetime.datetime.now(), end_date=datetime.datetime.now(), element_ids=[1000], subtype=tp.AnalogInputHist.subtype, subcode=[tp.AnalogInputHist.subcode], pandas=True)
+print(df)
+```
+
+- Obtención de elementos
+```
+# Get
+df = demeter.get_rtus(element_id=17512, pandas=True)
+print(df)
+```
+La API define también una excepción especial cuando la llamada al endpoint de Demeter no devuelve el resultado esperado.
+La excepción de denomina "DemeterStatusCodeException" y contiene el código de error HTTP.
+```
+# Exception treatment
+try:
+    df = demeter.get_rtus(element_id=17512, pandas=True)
+except demeter.DemeterStatusCodeException as status_code:
+    print('Error {}'.format(status_code))
+```
+- Por último, se debería hacer un logout en el servidor
+```
+demeter.logout()
+```

hidroconta-1.0.0/hidroconta/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "1.0.0"
+
+import hidroconta.types
+import hidroconta.time
+import hidroconta.endpoints
+import hidroconta.hist
+import hidroconta.api

hidroconta-1.0.0/hidroconta/api.py

@@ -0,0 +1,232 @@
+import requests as re
+import pandas as pd
+import json
+import hidroconta.types as tp
+import hidroconta.hist as hist
+import hidroconta.endpoints as endpoints
+import hidroconta.time as time
+import datetime
+# For python <3.9, replace list[] with List[] from 'from typing import List'
+
+'''
+Allows an easy access to Demeter API from Python and
+implements pandas dataframes compatibility
+'''
+
+'''Session cookies stored'''
+__stored_cookies = None
+
+POST_HDR = {"Content-Type": "application/json"}
+
+# Exception to be thrown when Demeter API returns an error status code
+class DemeterStatusCodeException(Exception):
+    pass
+
+def set_server(server: endpoints.Server):
+    endpoints.set_server(server)
+
+def get_server():
+    return endpoints.get_server()
+
+def login(username: str, password: str):
+    global __stored_cookies
+
+    payload = '{{"username":"{}", "password":"{}"}}'.format(username, password)
+
+    response = re.post(get_server() + endpoints.DEMETER_LOGIN ,data=payload, headers=POST_HDR)
+
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+
+    cookies = response.cookies.get_dict()
+    __stored_cookies = cookies
+    return cookies
+
+def logout():
+    response = re.post(get_server() + endpoints.DEMETER_LOGOUT, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    
+def __get_elements(element: str, element_id: int = None, pandas = False):
+    print(get_server() + endpoints.DEMETER_GET + element + ('' if element_id == None else ('/' + str(element_id))))
+    response = re.get(get_server() + endpoints.DEMETER_GET + element + ('' if element_id == None else ('/' + str(element_id))), cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    else:
+        if pandas:
+            data = json.loads(response.text)
+            return pd.json_normalize(data)
+        else:
+            return response.text
+
+def search(text:str = None, element_types:list[tp.Element] = None, status:tp.Status = tp.Status.ALL, pandas = False):
+
+    payload = '{"status":"' + status + '"'
+    if(text is not None):
+        payload = payload + ',"searchText":"' + text + '"'
+    if(element_types is None):
+        element_types = [e for e in tp.Element.__dict__.values() if type(e) == str and e != 'demeterapitypes']
+    payload = payload + ',"type":' + str(element_types).replace("'", '"')
+    payload = payload + '}'
+    print(payload)
+
+    response = re.post(get_server() + endpoints.DEMETER_SEARCH, headers=POST_HDR, data=payload, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    else:
+        if pandas:
+            data = json.loads(response.text)
+            return pd.json_normalize(data)
+        else:
+            return response.text
+
+    
+def get_rtus(element_id:int = None, pandas = False):
+    return __get_elements('rtus', element_id, pandas)
+        
+def get_counters(element_id:int = None, pandas = False):
+    return __get_elements('counters', element_id, pandas)
+        
+def get_analog_inputs(element_id:int = None, pandas = False):
+    return __get_elements('analogInputs', element_id, pandas)
+
+def get_digital_inputs(element_id:int = None, pandas = False):
+    return __get_elements('digitalInputs', element_id, pandas)
+        
+def get_iris_nb(element_id:int = None, pandas = False):
+    return __get_elements('iris/nbiot', element_id, pandas)
+        
+def get_iris_lw(element_id:int = None, pandas = False):
+    return __get_elements('iris/lorawan', element_id, pandas)
+        
+def get_iris_sigfox(element_id:int = None, pandas = False):
+    return __get_elements('iris/sigfox', element_id, pandas)
+
+def get_iris_gprs(element_id:int = None, pandas = False):
+    return __get_elements('iris/gprs', element_id, pandas)
+
+def get_installations(element_id:int = None, pandas = False):
+    return __get_elements('installations', element_id, pandas)
+
+def get_rtus_installation_dict(pandas = False):
+    installations = __get_elements('installations', pandas=pandas)
+    rtus = __get_elements('rtus', pandas=pandas)
+    match_installations = pd.merge(installations, rtus, on='installationId')
+    timezones = {}
+    for index, match in match_installations.iterrows():
+        timezones[match['rtuId']] = match['timeZone']
+    return timezones
+
+def get_centinel(element_id:int = None, pandas = False):
+    return __get_elements('centinel', element_id, pandas)
+
+def get_centaurus(element_id:int = None, pandas = False):
+    return __get_elements('centaurus', element_id, pandas)
+    
+def global_update(rtu_id: int, timestamp: datetime.datetime, liters:int):
+    
+    payload = '{"rtuId":' + str(rtu_id) + ',"timestamp":"' + time.strftime_demeter(timestamp) + '","value":' + str(int(liters)) + '}'
+    print(payload)
+    response = re.put(get_server() + endpoints.DEMETER_UPDATE_COUNTER_GLOBAL ,data=payload, headers=POST_HDR, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    
+def add_historics(rtu_id: int, historics: list[hist.Hist]):
+
+    hist = '['
+    for historic in historics[:-1]:
+        hist = hist + '{'
+        hist = hist + '"timestamp":"' + str(historic.timestamp) + '",'
+        hist = hist + '"subtype":' + str(historic.type.subtype) + ','
+        hist = hist + '"subcode":' + str(historic.type.subcode) + ','
+        hist = hist + '"value":' + str(historic.value) + ','
+        hist = hist + '"position":' + str(historic.position) + ','
+        hist = hist + '"expansion":' + str(historic.expansion) + '},'
+    historic = historics[-1]
+    hist = hist + '{'
+    hist = hist + '"timestamp":"' + str(historic.timestamp) + '",'
+    hist = hist + '"subtype":' + str(historic.type.subtype) + ','
+    hist = hist + '"subcode":' + str(historic.type.subcode) + ','
+    hist = hist + '"value":' + str(historic.value) + ','
+    hist = hist + '"position":' + str(historic.position) + ','
+    hist = hist + '"expansion":' + str(historic.expansion) + '}'
+    hist = hist + ']'
+    
+    payload = '{{"rtuId":{}, "historicDataEntities":{}}}'.format(rtu_id, hist)
+    print(payload)
+    response = re.post(get_server() + endpoints.DEMETER_HISTORICS ,data=payload, headers=POST_HDR, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+
+def get_historics(start_date: datetime.datetime, end_date: datetime.datetime, element_ids: list[int], subtype: int, subcode:list[int] = [], pandas=False):
+    start_date = time.strftime_demeter(start_date)
+    end_date = time.strftime_demeter(end_date)
+    payload = '{{"from":"{}", "until":"{}", "subcode":{}, "subtype":{}, "elementIds":{}}}'.format(start_date, end_date, subcode, subtype, element_ids)
+    
+    response = re.post(get_server() + endpoints.DEMETER_HISTORY_DATA, headers=POST_HDR, data=payload, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    else:
+        if pandas:
+            data = json.loads(response.text)
+            return pd.json_normalize(data)
+        else:
+            return response.text
+
+def get_minute_consumption(start_date: datetime.datetime, end_date: datetime.datetime, element_ids: list[int], period_value: int, min_interval: bool = True, pandas=False):
+    start_date = time.strftime_demeter(start_date)
+    end_date = time.strftime_demeter(end_date)
+    payload = '{{"from":"{}", "until":"{}", "minInterval":{}, "elementIds":{}, "periodValue":{}}}'.format(start_date, end_date, min_interval, element_ids, period_value)
+
+    response = re.post(get_server() + endpoints.DEMETER_CONSUMPTION, headers=POST_HDR, data=payload, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    else:
+        if pandas:
+            data = json.loads(response.text)
+            unfolded = pd.DataFrame(columns=['code', 'timestamp'])
+            df = pd.json_normalize(data)
+            for ix, row in df.iterrows():
+                unfolded_row = row['values']
+                unfolded_list = []
+                for x in unfolded_row:
+                    x['code'] = row['series'][0]
+                    x['values'] = x['values'][0]
+                    unfolded_list.append(x)
+                    x['timestamp'] = time.strptime_demeter(x['timestamp'])
+                unfolded = pd.concat([unfolded, pd.json_normalize(unfolded_list)])
+            return unfolded
+        else:
+            return response.text
+
+def update_analog_input_value(rtu_id:int, position:int, expansion:int, value:int, timestamp:datetime.datetime):
+    timestamp = time.strftime_demeter(timestamp)
+    payload = '{{"rtuId":{}, "position":{}, "expansion":{}, "value":{}, "timestamp":"{}"}}'.format(rtu_id, position, expansion, value, timestamp)
+    print(payload)
+    response = re.put(get_server() + endpoints.DEMETER_ANALOG_UPDATE ,data=payload, headers=POST_HDR, cookies=__stored_cookies)
+    if response.status_code != 200:
+        raise DemeterStatusCodeException(response.status_code)
+    
+def create_iris_nb(payload:str):
+    response = re.post(get_server() + endpoints.DEMETER_IRIS_NB, data=payload, headers=POST_HDR, cookies=__stored_cookies)
+    if response.status_code != 201:
+        print(response.text)
+        raise DemeterStatusCodeException(response.status_code)
+    
+def delete_iris_nb(elementid:int, confirmation = True):
+    if confirmation:
+        iris = get_iris_nb(element_id=elementid, pandas=True)
+        print('{} será eliminado de {}.'.format(iris['code'].values.tolist()[0], get_server()))
+        res = input('Desea continuar (y|n)? ')
+        if res.capitalize() == 'Y': 
+            print('Borrando')
+            response = re.delete(get_server() + endpoints.DEMETER_IRIS_NB + '/' + str(elementid), cookies=__stored_cookies)
+            if response.status_code != 200:
+                raise DemeterStatusCodeException(response.status_code)
+        else:
+            print('Cancelado')
+            return
+    else:
+        response = re.delete(get_server() + endpoints.DEMETER_IRIS_NB + '/' + str(elementid), cookies=__stored_cookies)
+        if response.status_code != 200:
+            raise DemeterStatusCodeException(response.status_code)

hidroconta-1.0.0/hidroconta/endpoints.py

@@ -0,0 +1,24 @@
+DEMETER_LOGIN = 'login'
+DEMETER_LOGOUT = 'logout'
+DEMETER_GET = ''
+DEMETER_UPDATE_COUNTER_GLOBAL = 'counters/global/update'
+DEMETER_HISTORICS = 'historics'
+DEMETER_HISTORY_DATA = 'history/data'
+DEMETER_ANALOG_UPDATE = 'analogInputs/value/update'
+DEMETER_SEARCH = 'search'
+DEMETER_CONSUMPTION = 'history/consumption/minute/volume'
+DEMETER_IRIS_LORAWAN = 'iris/lorawan'
+DEMETER_IRIS_NB = 'iris/nbiot'
+
+class Server(enumerate):
+    MAIN = 'https://demeter2.hidroconta.com/Demeter2/v2/'
+    TEST = 'https://demeter2-test.hidroconta.com/Demeter2/v2/'
+
+__server = Server.MAIN
+
+def set_server(server: Server):
+    global __server
+    __server = server
+
+def get_server():
+    return __server

hidroconta-1.0.0/hidroconta/hist.py

@@ -0,0 +1,8 @@
+class Hist:
+    
+    def __init__(self, timestamp = 0, value = 0, position = 0, expansion = 0, type = None):
+        self.timestamp=timestamp
+        self.value=value
+        self.position = position
+        self.expansion = expansion
+        self.type = type

hidroconta-1.0.0/hidroconta/time.py

@@ -0,0 +1,6 @@
+import datetime
+def strftime_demeter(timestamp: datetime.datetime):
+    return timestamp.strftime('%d/%m/%Y %H:%M:%S')
+
+def strptime_demeter(timestamp: str):
+    return datetime.datetime.strptime(timestamp, '%d/%m/%Y %H:%M:%S')

hidroconta-1.0.0/hidroconta/types.py

@@ -0,0 +1,25 @@
+class AnalogInputHist:
+    subtype = 4
+    subcode = 0
+
+class CounterGlobalHist:
+    subtype = 2
+    subcode = 2
+
+class Element(enumerate):
+    ANALOG_INPUT = 'analogInputs'
+    COUNTER = 'counters'
+    RTU = 'rtus'
+    IRIS = 'iris'
+    HYDRANT = 'hydrants'
+    VALVE = 'valves'
+    DIGITAL_INPUT = 'digitalInputs'
+    DIGITAL_OUTPUT = 'digitalOutputs'
+    CENTINEL = 'centinels'
+    WMBUS_COUNTER = 'wmbusCounters'
+    CENTAURUS = 'centaurus'
+
+class Status(enumerate):
+    ENABLED = 'enabled'
+    DISABLED = 'disabled'
+    ALL = 'all'

hidroconta-1.0.0/hidroconta.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: hidroconta
+Version: 1.0.0
+Summary: API to easily access Demeter REST API provided by Hidroconta S.A.U.
+Home-page: UNKNOWN
+Author: JavierL
+Author-email: javier.lopez@hidroconta.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+
+# Integrations-PythonAPI
+API Python para facilitar el acceso a los endpoints de la interfaz REST de Demeter
+
+La API permite la gestión de grandes cantidades de datos mediante la librería Pandas, siempre y cuando se utilice la siguiente directiva en las llamadas a los métodos:
+```
+# Pandas = True returns a pandas dataframe instead a json
+```
+
+La forma de usar la API es la siguiente:
+
+- Importar los modulos deseados:
+```
+import demeterpy as demeter
+import demeterapitypes as tp
+import pandas as pd
+import datetime
+import endpoints
+```
+- Seleccionar el servidor con el cual se quiere comunicar (se puede modificar en todo momento):
+```
+# Set server
+demeter.set_server(endpoints.Server.MAIN)
+```
+
+- Realizar el login en dicho servidor
+```
+# Login
+demeter.login('USERNAME', 'PASSWORD')
+```
+
+Una vez seguidos los anteriores pasos, se puede realizar cualquier consulta sobre el sistema.
+Algunas de ellas son:
+
+- Búsqueda
+```
+# Search
+df = demeter.search(text='SAT', element_types=[tp.Element.COUNTER, tp.Element.ANALOG_INPUT, tp.Element.RTU], status=tp.Status.ENABLED, pandas=True)
+print(df)
+```
+
+- Obtención de historicos
+```
+# Get historics
+df = demeter.get_historics(start_date=datetime.datetime.now(), end_date=datetime.datetime.now(), element_ids=[1000], subtype=tp.AnalogInputHist.subtype, subcode=[tp.AnalogInputHist.subcode], pandas=True)
+print(df)
+```
+
+- Obtención de elementos
+```
+# Get
+df = demeter.get_rtus(element_id=17512, pandas=True)
+print(df)
+```
+La API define también una excepción especial cuando la llamada al endpoint de Demeter no devuelve el resultado esperado.
+La excepción de denomina "DemeterStatusCodeException" y contiene el código de error HTTP.
+```
+# Exception treatment
+try:
+    df = demeter.get_rtus(element_id=17512, pandas=True)
+except demeter.DemeterStatusCodeException as status_code:
+    print('Error {}'.format(status_code))
+```
+- Por último, se debería hacer un logout en el servidor
+```
+demeter.logout()
+```
+
+

hidroconta-1.0.0/hidroconta.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+hidroconta/__init__.py
+hidroconta/api.py
+hidroconta/endpoints.py
+hidroconta/hist.py
+hidroconta/time.py
+hidroconta/types.py
+hidroconta.egg-info/PKG-INFO
+hidroconta.egg-info/SOURCES.txt
+hidroconta.egg-info/dependency_links.txt
+hidroconta.egg-info/requires.txt
+hidroconta.egg-info/top_level.txt

hidroconta-1.0.0/hidroconta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hidroconta-1.0.0/hidroconta.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pandas
+requests
+datetime

hidroconta-1.0.0/hidroconta.egg-info/top_level.txt

@@ -0,0 +1 @@
+hidroconta

hidroconta-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hidroconta-1.0.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup
+
+setup(
+    name='hidroconta',
+    version='1.0.0',
+    packages=['hidroconta'],
+    install_requires=[
+        'pandas',
+        'requests',
+        'datetime'
+    ],
+    author='JavierL',
+    author_email='javier.lopez@hidroconta.com',
+    description='API to easily access Demeter REST API provided by Hidroconta S.A.U.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+)