def _fetch(self, obj=None): """ fetch data from the server """ if obj is None: try: if self.__space_name__: obj = pychronos._space_api_instance.app_api_space_get( self.__space_name__) elif self.__space_id__: obj = pychronos._raw_space_api_instance.app_api_space_raw_get( self.__space_id__) else: ValueError("space_name or space_id are missing") except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with " f"{pychronos._configuration.host} on port {pychronos._configuration.port}" ) from None except ApiException as e: api_exception_helper(e) # if e.status == 401: # raise ConnectionError("Login failed; login again") from None # # elif e.status == 404: # raise NameError("Space, {}, not found".format(self.__space_name__)) from None # # else: # raise RuntimeError(f"Error: {e}") from None self.__space_id__ = obj.space_id self.__space_title__ = obj.title self.__space_description__ = obj.description self.__real_start__ = obj.real_start self.__real_end__ = obj.real_end
def history(self, real_start: datetime = None, real_end: datetime = None): """fetch historical collection object""" if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") if real_start and not isinstance(real_start, datetime): raise TypeError("real time must be datetime object") if real_start and not isinstance(real_start, datetime): raise TypeError("real time must be datetime object") try: hist = pychronos._raw_space_api_instance.app_api_space_object_history( self.__space_id__, real_start=real_start, real_end=real_end) except ApiException as e: api_exception_helper(e) out = [] for h in hist: c = Space(h.name) c._fetch(obj=h) out += [c] return out
def create(name, title=None, description=None, tags=None, public: bool = None): """ create a new space :return: """ if public is None: visibility = None else: visibility = "public" if public else "private" body = _Space(name=name, title=title, description=description, tags=tags, visibility=visibility) try: obj = pychronos._space_api_instance.app_api_space_post(body) except ApiException as e: api_exception_helper(e) sp = Space(name) sp._fetch(obj) return sp
def login(self, username, password): """Login to ChronosDB""" # basic_auth pychronos._configuration.username = username pychronos._configuration.password = password try: response = pychronos._user_api_instance.app_api_user_login( _request_timeout=pychronos._timeout) # pychronos._configuration.access_token = response.jwt self.set_token(response.jwt) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with {pychronos._chronos_host} " f"on port {pychronos._chronos_port}") from None except ApiException as e: api_exception_helper(e) # # if e.status == 401: # raise ValueError("invalid username and/or password") from None finally: pychronos._configuration.username = "" pychronos._configuration.password = ""
def __getitem__(self, name: Text) -> TimeSeries: """ get TimeSeries """ if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") try: if bson.objectid.ObjectId.is_valid(name): obj = pychronos._raw_timeseries_api_instance.app_api_timeseries_raw_get(coll_id=self.__coll_id__, tsid=str(name)) else: obj = pychronos._timeseries_api_instance.app_api_timeseries_get(self.__space_name__, self.__coll_name__, name) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with {pychronos._configuration.host} on port " f"{pychronos._configuration.port}") from None except ApiValueError as e: raise ValueError(e) except ApiException as e: api_exception_helper(e) ts = TimeSeries(self.__space_name__, self.__coll_name__, name) ts._fetch(obj) return ts
def save(self, series: pd.Series, method: Text = 'update', vintage: Vintage = None, realtime: datetime = None) -> Vintage: """ save observations """ if method not in ("update", "append", "overwrite"): raise ValueError( "invalid save method; must be either 'update', 'overwrite', or 'append'" ) series_data = series_to_SingleTimeSeriesData(series, tsid=self.__tsid__, coll_id=self.__coll_id__) # TODO validate if series_data.dtype != self.dtype: raise ValueError( f"invalid data type, {series_data.dtype}; {self.dtype} is required" ) if series_data.itype != self.itype: raise ValueError( f"invalid index type, {series_data.itype}; {self.itype} is required" ) if series_data.freq != self.freq: raise ValueError( f"invalid frequency, {series_data.freq}; {self.freq} is required" ) if vintage: _vintage = VintageUpdate(name=vintage.name, description=vintage.description, metadata=vintage.metadata) else: _vintage = None body = _RawDataPutRequest(series=[series_data], vintage=_vintage) try: res = pychronos._raw_api_instance.app_api_raw_timeseries_data_put( coll_id=self.__coll_id__, method=method, raw_data_put_request=body, realtime=realtime) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with {pychronos._configuration.host} " f"on port {pychronos._configuration.port}") from None except ApiException as e: api_exception_helper(e) except Exception as e: raise RuntimeError(e) return Vintage._from_response(res.vintage)
def list_spaces(): """ list spaces in the database :return: """ # check if initiated correctly if pychronos._client_instance is None: raise ConnectionError("connection not initiated") try: response = pychronos._space_api_instance.app_api_space_get_list() except ApiException as e: print(pychronos._configuration.access_token) api_exception_helper(e) # print("Exception when calling listing spaces: %s\n" % e) return [x.name for x in response]
def annotations(self): """ list annotations in a collection """ if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") try: res = pychronos._raw_annot_api_instance.app_api_annotation_raw_get_list(self.__coll_id__) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with " f"{pychronos._configuration.host} on port {pychronos._configuration.port}") from None except ApiException as e: api_exception_helper(e) return pychronos.annotation.construct_annotations(self.__coll_id__, res)
def list_collections(self): """ list collection names """ if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") try: response = pychronos._collection_api_instance.app_api_collection_get_list( self.__space_name__) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with " f"{pychronos._configuration.host} on port {pychronos._configuration.port}" ) from None except ApiException as e: api_exception_helper(e) return [x.name for x in response]
def construct_annotations(coll_id, annots: List[_Annotation]): # fetch time series for all annotations tsids = [x.tsid for r in annots for x in r.targets if x.tsid] if len(tsids) > 0: try: ts = pychronos._raw_timeseries_api_instance.app_api_timeseries_raw_get_list( coll_id=coll_id, tsids=tsids) ts = {x.tsid: x for x in ts} except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with " f"{pychronos._configuration.host} on port {pychronos._configuration.port}" ) from None except ApiException as e: api_exception_helper(e) out = [] for _a in annots: a = pychronos.annotation.Annotation(coll_id=_a.coll_id, aid=_a.aid) a.__symbol__ = _a.symbol a.__text__ = _a.text a.___format__ = _a.format a.__targets__ = [ pychronos.annotation.AnnotationTarget._from_response( coll_id=_a.coll_id, aid=_a.aid, tsid=x.tsid, index=x.index, freq=x.freq, real_start=x.real_start) for x in _a.targets ] a.__real_start__ = _a.real_start a.__real_end__ = _a.real_end out.append(a) return out
def history(self, real_time=None): """ history of time series properties changes """ if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") if real_time and not isinstance(real_time, datetime.datetime): raise TypeError("real time must be datetime object") try: hist = pychronos._raw_timeseries_api_instance.app_api_timeseries_object_history( self.__coll_id__, real_start=real_time) except ApiException as e: api_exception_helper(e) out = [] for h in hist: c = TimeSeries(self.__space_name__, self.__coll_name__, self.__ts_name__) c._fetch(obj=h) out += [c] return out
def create(self, name, freq: Freq, dtype: DType, itype: IType = IType.period, fparams: Optional[dict] = None, dparams: Optional[dict] = None, unit=None, title=None, description=None, attributes=None, legend=None, entity=None, variable=None): """create time series""" if self.__real_end__ != TIME_INF: raise TypeError("historical object can't be modified") # check dtype if isinstance(dtype, DType): dtype = dtype.value elif isinstance(dtype, str): dtype = DType(dtype).value else: raise TypeError(f"invalid dtype") # check itype if isinstance(itype, IType): itype = itype.value elif isinstance(itype, str): itype = IType(itype).value else: raise TypeError(f"invalid itype") # check freq if isinstance(freq, Freq): freq = freq.value elif isinstance(freq, str): freq = Freq(freq).value else: raise TypeError(f"invalid freq") # POST try: body = _TimeSeries(name=name, title=title, dtype=dtype, dparams=dparams, itype=itype, freq=freq, fparams=fparams, unit=unit, description=description, attributes=attributes, legend=legend, entity=entity, variable=variable ) except ApiValueError as e: api_exception_helper(e) try: obj = pychronos._raw_timeseries_api_instance.app_api_timeseries_raw_post(coll_id=self.__coll_id__, time_series=body) except MaxRetryError: raise ConnectionError( f"Couldn't establish connection with " f"{pychronos._configuration.host} on port {pychronos._configuration.port}") from None except ApiException as e: api_exception_helper(e) ts = TimeSeries._from_core(space_name=self.__space_name__, coll_name=self.__coll_name__, ts_name=name, core=obj) return ts