ellipsis 3.1.45__tar.gz → 3.1.46__tar.gz

{ellipsis-3.1.45 → ellipsis-3.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ellipsis
-Version: 3.1.45
+Version: 3.1.46
 Summary: Package to interact with the Ellipsis API
 Home-page: https://github.com/ellipsis-drive-internal/python-package
 Author: Daniel van der Maas

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/__init__.py

@@ -4,10 +4,9 @@
 from ellipsis import account
 from ellipsis import user
 from ellipsis import path
-from ellipsis import view
 from ellipsis import util
 
-__version__ = '3.1.45'
+__version__ = '3.1.46'
 
 
 

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/__init__.py

@@ -8,4 +8,5 @@ from ellipsis.path import pointCloud
 from ellipsis.path import usage
 from ellipsis.path import folder
 from ellipsis.path import file
+from ellipsis.path import bookmark
 

ellipsis-3.1.46/ellipsis/path/bookmark/__init__.py

@@ -0,0 +1,2 @@
+
+from ellipsis.path.bookmark.root import add, get, edit

ellipsis-3.1.46/ellipsis/path/bookmark/root.py

@@ -0,0 +1,39 @@
+from ellipsis import apiManager
+from ellipsis import sanitize
+
+
+def get(pathId, token=None):
+    token = sanitize.validString('token', token, False)
+    pathId = sanitize.validUuid('pathId', pathId, True)
+
+    r = apiManager.get('/path/' + pathId + '/bookmark', {}, token)
+        
+    return r
+
+
+
+def add(name, bookmark, token, parentId = None, publicAccess = None, metadata=None):
+    token = sanitize.validString('token', token, True)
+    bookmark = sanitize.validObject('bookmark', bookmark, True)
+    name = sanitize.validString('pathId', name, False)
+    metadata = sanitize.validObject('metadata', metadata, False)
+    publicAccess = sanitize.validObject('publicAccess', publicAccess, False)
+    parentId = sanitize.validUuid('parentId', parentId, False)
+
+    r = apiManager.post('/path/bookmark', {'name':name, 'bookmark':bookmark , 'parentId':parentId, 'publicAccess':publicAccess, 'metadata':metadata}, token)
+        
+    return r
+
+
+def edit(pathId, token, layers=None, dems=None):
+    layers = sanitize.validObject('layers', layers, False)
+    dems = sanitize.validObject('dems', dems, False)
+    pathId = sanitize.validUuid('pathId', pathId, True)
+
+    r = apiManager.patch('/path/' + pathId + '/bookmark', {'layers':layers, 'dems':dems}, token)
+        
+    return r
+
+
+
+

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/pointCloud/timestamp/file/root.py

@@ -6,19 +6,34 @@ import os
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None):
+def add(pathId, timestampId, token, fileFormat, filePath = None, memFile =None, name=None, epsg = None):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
+    filePath = sanitize.validString('filePath', filePath, False)
     epsg = sanitize.validInt('epsg', epsg, True)
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
+    name = sanitize.validString('name', name, False)
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
 
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
     
     body = {'name':fileName, 'epsg':epsg, 'format':fileFormat}
-    r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , name, body, token, memfile=memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart= None, listAll = True):

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/raster/timestamp/__init__.py

@@ -6,13 +6,11 @@ from ellipsis.path.raster.timestamp.root import deactivate
 from ellipsis.path.raster.timestamp.root import getBounds
 from ellipsis.path.raster.timestamp.root import analyse
 from ellipsis.path.raster.timestamp.root import getRaster
-from ellipsis.path.raster.timestamp.root import getDownsampledRaster
 from ellipsis.path.raster.timestamp.root import trash
 from ellipsis.path.raster.timestamp.root import recover
 from ellipsis.path.raster.timestamp.root import getSampledRaster
-from ellipsis.path.raster.timestamp.root import getValuesAlongLine
 from ellipsis.path.raster.timestamp.root import contour
-
+from ellipsis.path.raster.timestamp.root import getLocationInfo
 from ellipsis.path.raster.timestamp import file
 from ellipsis.path.raster.timestamp import order
 

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/raster/timestamp/file/root.py

@@ -6,21 +6,35 @@ import os
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None, noDataValue = None, mosaicPriority = None):
+def add(pathId, timestampId, token, fileFormat, filePath=None, memFile = None, epsg = None, noDataValue = None, mosaicPriority = None, name = None):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
-    noDataValue = sanitize.validFloat('noDataValue', noDataValue, False)    
+    filePath = sanitize.validString('filePath', filePath, False)
+    name = sanitize.validString('name', name, False)
+    noDataValue = sanitize.validFloat('noDataValue', noDataValue, False)
     epsg = sanitize.validInt('epsg', epsg, False)    
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
     mosaicPriority = sanitize.validString('mosaicPriority', mosaicPriority, False)    
-        
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
-    
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
+
     body = {'name':fileName, 'epsg':epsg, 'noDataValue': noDataValue, 'format':fileFormat, 'mosaicPriority':mosaicPriority}
-    r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , name, body, token, memfile = memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart= None, listAll = True):

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/raster/timestamp/root.py

@@ -23,42 +23,41 @@ import requests
 from skimage.measure import find_contours
 from shapely.geometry import Point, LineString
 
-def getDownsampledRaster(pathId, timestampId, extent, width, height, epsg=3857, style = None, token = None):
-    return getSampledRaster(pathId, timestampId, extent, width, height, epsg, style, token)
-
-def getSampledRaster(pathId, timestampId, extent, width, height, epsg=4326, style = None, token = None):
-    bounds = extent
+def getSampledRaster(pathId, timestampId, extent, width, height, epsg=3857, token = None):
     token = sanitize.validString('token', token, False)
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
-    bounds = sanitize.validBounds('bounds', bounds, True)
-    style = sanitize.validObject('style', style, False)
+    extent = sanitize.validBounds('extent', extent, True)
     epsg = sanitize.validInt('epsg', epsg, True)
-    body = {'pathId':pathId, 'timestampId':timestampId, 'extent':bounds, 'width':width, 'height':height, 'style':style, 'epsg':epsg}
 
-    if str(type(style)) == str(type(None)):
-        body['applyStyle'] = False
+    res = getActualExtent(extent['xMin'], extent['xMax'], extent['yMin'], extent['yMax'], 'EPSG:' + str(epsg))
+
+    if res['status'] == '400':
+        raise ValueError('Invalid epsg and extent combination')
+
+    extentWeb = res['message']
+
+
+
+    body = {'pathId':pathId, 'timestampId':timestampId, 'extent':extentWeb, 'width':width, 'height':height, 'applyStyle':False}
+
 
     r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/rasterByExtent', body, token, crash = True, parseJson = False)
 
 
-    if type(style) == type(None):
-        r = tifffile.imread(BytesIO(r.content))
-    else:
-        r = np.array(Image.open(BytesIO(r.content)))
-    #tif also has bands in last channel
-    r = np.transpose(r, [2,0,1])
+    r = tifffile.imread(BytesIO(r.content))
 
-    xMin = bounds['xMin']
-    yMin = bounds['yMin']
-    xMax = bounds['xMax']
-    yMax = bounds['yMax']
+    r = np.transpose(r, [2,0,1])
 
 
 
-    trans = rasterio.transform.from_bounds(xMin, yMin, xMax, yMax, r.shape[2], r.shape[1])
 
-    return {'raster': r, 'transform':trans, 'extent': {'xMin' : xMin, 'yMin': yMin, 'xMax': xMax, 'yMax': yMax}, 'crs':"EPSG:" + str(epsg) }
+    if epsg != 3857:
+        return reprojectRaster(r=r, sourceExtent=extentWeb, targetExtent=extent, targetWidth=r.shape[2],
+                               targetHeight=r.shape[1], sourceEpsg=3857, targetEpsg=epsg, interpolation='nearest')
+    else:
+        trans = rasterio.transform.from_bounds( extent['xMin'], extent['yMin'], extent['xMax'], extent['yMax'], r.shape[2], r.shape[1])
+        return {'raster': r, 'transform':trans, 'extent': extent, 'crs':"EPSG:" + str(epsg) }
 
 
 def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg = 4326, bandNumber = 1, token = None):
@@ -93,9 +92,11 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
     if type(intervals) == type(None):
         minVal = np.min(raster[bandNumber-1, raster[-1,:,:] == 1])
         maxVal = np.max(raster[bandNumber-1, raster[-1,:,:] == 1])
+
+        if type(interval) == type(None):
+            interval = (maxVal - minVal) /10
         
-        
-        cont = minVal + interval
+        cont = minVal
 
         conts = []
         while cont < maxVal:
@@ -114,7 +115,6 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
         lines = find_contours(raster[bandNumber-1,:,:],  mask=raster[-1,:,:] == 1, level = cont)
          
         newLines = []
-        line = lines[0]
         for line in lines:
             newLine = LineString([ Point( xMinWeb + x[0] * Lx  , yMinWeb +  x[1] * Ly )  for x in line])
             newLines = newLines + [newLine]
@@ -130,69 +130,25 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
     return sh
 
 
-def getValuesAlongLine(pathId, timestampId, line, token = None, epsg = 4326):
+def getLocationInfo(pathId, timestampId, locations, epsg = 4326, token= None):
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, False)
-    line = sanitize.validShapely('line', line, True)
     epsg = sanitize.validInt('epsg', epsg, True)
 
-    if line.type != 'LineString':
-        raise ValueError('line must be a shapely lineString')
+    if epsg != 4326:
+        points = [Point(l) for l in locations]
+        sh = gpd.GeoDataFrame({'geometry':points})
+        sh.crs = 'EPSG:' + str(epsg)
+        sh.to_crs('EPSG:4326')
+        locations = [ l for l in zip(sh.bounds['minx'], sh.bounds['miny'] )]
+    body = {'locations':locations}
 
-    temp = gpd.GeoDataFrame({'geometry':[line]})
-    temp.crs = 'EPSG:' + str(epsg)
-    temp = temp.to_crs('EPSG:3857')
-    line = temp['geometry'].values[0]
-    line = list(line.coords)
-        
-    x_of_line = [p[0] for p in line]
-    y_of_line = [p[1] for p in line]
-
-    #the first action is to cacluate a bounding box for the raster we need to retrieve
-    xMin = min(x_of_line)
-    xMax = max(x_of_line)
-    yMin = min(y_of_line)
-    yMax = max(y_of_line)
-    
-    d = (xMax - xMin) * 0.1
-    xMax = xMax + d
-    xMin = xMin -d
-    d = (yMax - yMin) * 0.1
-    yMax = yMax + d
-    yMin = yMin -d
-    
-    
-    
-    #now we retrieve the needed raster we use epsg = 4326 but we can use other coordinates as well
-    extent = {'xMin': xMin, 'xMax':xMax, 'yMin':yMin, 'yMax':yMax}
-
-    size = 1000
-    r = getSampledRaster(pathId = pathId, timestampId = timestampId, extent = extent, width = size, height = size, epsg=3857, token = token)
-    raster = r['raster']
-
-    memfile =  MemoryFile()
-    dataset = memfile.open( driver='GTiff', dtype='float32', height=size, width=size, count = raster.shape[0], crs= r['crs'], transform=r['transform'])
-    dataset.write(raster)
-
-
-
-    values = list(dataset.sample(line))
-
-    memfile.close()
-    return values
-
-def getLocationInfo(pathId, timestampId, locations, epsg = 4326, token= None):
-    pathId = sanitize.validUuid('pathId', pathId, True)
-    timestampId = sanitize.validUuid('timestampId', timestampId, True)
-    token = sanitize.validString('token', token, False)
-    epsg = sanitize.validInt('epsg', epsg, True)
-    body = {'locations':locations,'epsg':epsg}
-    r = apiManager.post('/path/' + pathId + '/raster/timestamp/' + timestampId + '/location', body, token)
+    r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/location', body, token)
     return r
 
     
-def getRaster(pathId, timestampId, extent, token = None, showProgress = True, epsg = 4326, reproject = False, threads = None, style = None):
+def getRaster(pathId, timestampId, extent, token = None, showProgress = True, epsg = 3857):
     bounds = extent
     
     token = sanitize.validString('token', token, False)
@@ -200,12 +156,7 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     bounds = sanitize.validBounds('bounds', bounds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
-    reproject = sanitize.validBool('reproject', reproject, True)
-    
-    if type(threads)!= type(None):
-        Warning('The parameter threads is deprecated')
-    if type(style)!= type(None):
-        Warning('The parameter style is deprecated')
+
         
     xMin = bounds['xMin']
     yMin = bounds['yMin']
@@ -241,7 +192,6 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
 
     zoom = t['zoom']
 
-    body = {"applyStyle":False}
 
     LEN = 2.003751e+07
 
@@ -294,7 +244,6 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
             
     def fetch(tileX, tileY):
         if tarred:
-
             cuts = cutOfTilesPerZoom[zoom]
             
             zones = [{'name': 'zone0', 'offset':0, 'start':cuts['start'][0] , 'end':cuts['end'][0]},  ]
@@ -316,8 +265,8 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
             frac_w = int(w/2**offset)
             
             url = apiManager.baseUrl + '/path/' + pathId + '/raster/timestamp/' + timestampId + '/tarTile/' + str(zoom_c) + '/' + str(tileX_c) + '/' + str(tileY_c)
-            if str(type(style)) == str(type(None)):
-                url = url + '?applyStyle=false'
+            url = url + '?applyStyle=false'
+
             if str(type(token)) == str(type(None)):
                 r = requests.get(url)
             else:
@@ -327,6 +276,7 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
                     r = requests.get(url, headers={"Authorization":  token})
             
         else:
+            body = {'applyStyle':False}
             r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/tile/' + str(zoom) + '/' + str(tileX) + '/' + str(tileY), body, token, False)
             
         if r.status_code == 403:
@@ -395,10 +345,10 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
     r_total = r_total[:,min_y_index:max_y_index,min_x_index:max_x_index]
 
     mercatorExtent =  {'xMin' : xMinWeb, 'yMin': yMinWeb, 'xMax': xMaxWeb, 'yMax': yMaxWeb}
-    if (not reproject) or epsg == 3857:
+    if epsg == 3857:
         trans = rasterio.transform.from_bounds(xMinWeb, yMinWeb, xMaxWeb, yMaxWeb, r_total.shape[2], r_total.shape[1])
     
-        return {'raster': r_total, 'transform':trans, 'extent':mercatorExtent, 'epsg':3857}
+        return {'raster': r_total, 'transform':trans, 'extent':mercatorExtent, 'crs': 'EPSG:' + str(3857)}
     else:
         return reprojectRaster(r = r_total, sourceExtent = mercatorExtent, targetExtent = extent, targetWidth=r_total.shape[2], targetHeight=r_total.shape[1], sourceEpsg = 3857, targetEpsg= epsg, interpolation = 'nearest')
 

ellipsis-3.1.46/ellipsis/path/vector/timestamp/feature/root.py

@@ -0,0 +1,184 @@
+from ellipsis import apiManager
+from ellipsis import sanitize
+from ellipsis.util import chunks
+from ellipsis.util import loadingBar
+from ellipsis.util.root import stringToDate
+from ellipsis.util.root import recurse
+
+import numpy as np
+import json
+import geopandas as gpd
+
+
+
+def add(pathId, timestampId, features, token, showProgress = True, cores = 1):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
+    token = sanitize.validString('token', token, True)
+    showProgress = sanitize.validBool('showProgress', showProgress, True)
+    cores = sanitize.validInt('cores', cores, True)
+    features = sanitize.validGeopandas('features', features, True, cores = cores)
+
+    features_json = features.to_json(na='drop')
+    features_json = json.loads(features_json)
+    features_json = np.array(features_json['features'])
+
+    #check if first time
+    firstTime = apiManager.get('/path/' + pathId, None, token)
+    if not 'vector' in firstTime.keys():
+        raise ValueError('Can only add features if path is of type vector')
+    firstTime = len(firstTime['vector']['properties']) ==0
+
+    if firstTime:
+        print('no properties known for this timestamp adding them automatically')
+        columns = features.columns
+        columns = [c for c in columns if c != 'geometry']
+        for c in columns:
+            if 'int' in str(features.dtypes[c]) or 'Int' in str(features.dtypes[c]):
+                propertyType = 'integer'
+            elif 'float' in str(features.dtypes[c]) or 'Float' in str(features.dtypes[c]):
+                propertyType = 'float'
+            elif 'bool' in str(features.dtypes[c]):
+                propertyType = 'boolean'
+            elif 'datetime' in str(features.dtypes[c]):
+                propertyType = 'datetime'
+            else:
+                propertyType = 'string'
+
+
+            ###date
+            body = {'name': c , 'type': propertyType , 'required': False, 'private': False}
+            apiManager.post('/path/' + pathId + '/vector/property', body, token)
+    indices = chunks(np.arange(features.shape[0]))
+
+
+    addedIds = []
+    for i in np.arange(len(indices)):
+        indices_sub = indices[i]
+        features_sub = features_json[indices_sub]
+
+
+        featuresBody = [{'feature': features_sub[i] } for i in np.arange(len(indices_sub))]
+        body = {"features":featuresBody}
+        r = apiManager.post('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature', body, token)
+        addedIds = addedIds + r
+        if showProgress:
+            loadingBar(i*3000 + len(indices_sub),features.shape[0])
+        i = i+1
+
+    return(addedIds)
+
+
+
+def edit(pathId, timestampId, featureIds, token, features, showProgress = True, cores = 1):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
+    token = sanitize.validString('token', token, True)
+    featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
+    showProgress = sanitize.validBool('showProgress', showProgress, True)
+    cores = sanitize.validInt('cores', cores, True)
+    features = sanitize.validGeopandas('features', features, False, cores=cores)
+
+
+
+    if type(features) != type(None) and features.shape[0] != len(featureIds):
+        raise ValueError('featureIds must be of same length as the features geopandas dataframe')
+
+
+    indices = chunks(np.arange(len(featureIds)),1000)
+    i=0
+    for i in np.arange(len(indices)):
+        indices_sub = indices[i]
+        featureIds_sub = list( np.array(featureIds)[indices_sub])
+
+        if type(features) != type(None):
+            features_sub = features.iloc[indices_sub]
+            features_sub =features_sub.to_json(na='drop')
+            features_sub = json.loads(features_sub)
+
+
+        changes = [{'featureId':x[0] , 'newProperties':x[1]['properties'], 'newGeometry':x[1]['geometry']} for x in zip(featureIds_sub, features_sub['features'])]
+
+        body = {'changes':changes}
+        r = apiManager.patch('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature', body, token)
+
+        if len(indices) > 1 and showProgress:
+            loadingBar(i*1000 + len(indices_sub),len(featureIds))
+
+    return r
+
+
+def trash(pathId, timestampId, featureIds, token, showProgress = True):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
+    token = sanitize.validString('token', token, True)
+    featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
+    showProgress = sanitize.validBool('showProgress', showProgress, True)
+
+    indices = chunks(np.arange(len(featureIds)),1000)
+    i=0
+    for i in np.arange(len(indices)):
+        indices_sub = indices[i]
+        featureIds_sub = list(np.array(featureIds)[indices_sub])
+
+        body = {'featureIds': featureIds_sub, 'trashed': True}
+        r = apiManager.put('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature/trashed', body, token)
+
+        if len(indices) > 1 and showProgress:
+            loadingBar(i*1000 + len(indices_sub),len(featureIds))
+
+    return r
+
+
+def recover(pathId, timestampId, featureIds, token, showProgress = True):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
+    token = sanitize.validString('token', token, True)
+    featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
+    showProgress = sanitize.validBool('showProgress', showProgress, True)
+
+    indices = chunks(np.arange(len(featureIds)),1000)
+    i=0
+    for i in np.arange(len(indices)):
+        indices_sub = indices[i]
+        featureIds_sub = list(np.array(featureIds)[indices_sub])
+
+        body = {'featureIds': featureIds_sub, 'trashed': False}
+        r = apiManager.put('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature/trashed', body, token)
+
+        if len(indices) > 1 and showProgress:
+            loadingBar(i*1000 + len(indices_sub),len(featureIds))
+
+    return r
+
+
+
+def versions(pathId, timestampId, featureId, token = None, pageStart = None, listAll = True):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
+    token = sanitize.validString('token', token, False)
+    featureId = sanitize.validUuid('featureId', featureId, True)
+    pageStart = sanitize.validUuid('pageStart', pageStart, False)
+    listAll = sanitize.validBool('listAll', listAll, True)
+
+    body = {'returnType':'all'}
+    def f(body):
+        return apiManager.get('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature/' + featureId + '/version', body, token)
+
+    r = recurse(f, body, listAll)
+
+    features = [ x['feature'] for x in r['result']]
+    dates = [stringToDate(x['date']) for x in r['result'] ]
+    usernames = [x['user']['username'] for x in r['result'] ]
+    userIds = [x['user']['id'] for x in r['result'] ]
+
+    sh = gpd.GeoDataFrame.from_features(features)
+    sh['username'] = usernames
+    sh['userId'] = userIds
+    sh['dates'] = dates
+
+    sh.crs = {'init': 'epsg:4326'}
+    r['result'] = sh
+    return(r)
+
+

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/vector/timestamp/file/root.py

@@ -5,27 +5,43 @@ from ellipsis.util.root import recurse
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None, dateColumns = None, datePatterns = None, method= 'simplify', fastUpload = True):
+def add(pathId, timestampId, token, fileFormat, filePath=None, memFile = None, name = None, epsg = None, dateColumns = None, datePatterns = None, method= 'simplify', fastUpload = True):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
+    filePath = sanitize.validString('filePath', filePath, False)
     epsg = sanitize.validInt('epsg', epsg, False)
-    method = sanitize.validString('method', method, True)
-    fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
+    fileFormat = sanitize.validString('fileFormat', fileFormat, True)
     dateColumns = sanitize.validStringArray('dateColumns', dateColumns, False)    
     datePatterns = sanitize.validStringArray('datePatterns', datePatterns, False)    
+    name = sanitize.validString('name', name, False)
     fastUpload = sanitize.validBool('fastUpload', fastUpload, True)
     if fastUpload:
         fastUpload='true'
     else:
         fastUpload = 'false'
 
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
-    
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
+
+
     body = {'name':fileName, 'epsg':epsg, 'format':fileFormat, 'dateColumns': dateColumns, 'datePatterns':datePatterns, 'fastUpload':fastUpload}
-    r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file', name, body, token,
+                              memfile=memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart = None, listAll = True):

{ellipsis-3.1.45 → ellipsis-3.1.46}/ellipsis/path/vector/timestamp/order/root.py

@@ -6,16 +6,17 @@ def get(token):
     r = apiManager.get('/path/vector/timestamp/order', None, token)
     return r
 
-def add(pathId, timestampId, token, extent = None, fileFormat = 'geojson'):
+def add(pathId, timestampId, token, extent = None, fileFormat = 'geojson', epsg = 4326):
     
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     extent = sanitize.validBounds('extent', extent, False)
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)
+    epsg = sanitize.validInt('epsg', epsg, True)
 
 
-    body = { 'extent':extent, 'format' :fileFormat}
+    body = { 'extent':extent, 'format' :fileFormat, 'epsg':epsg}
     
     r = apiManager.post('/path/' + pathId + '/vector/timestamp/' + timestampId + '/order', body, token)