def copyThumbnailToPyarch(self, task): imagePath = task.inData["image"] thumbNailPath = task.outData["thumbNail"] pyarchThumbnailDir = UtilsPath.createPyarchFilePath( os.path.dirname(imagePath)) if pyarchThumbnailDir is None: pyarchThumbnailPath = thumbNailPath else: if not os.path.exists(pyarchThumbnailDir): os.makedirs(pyarchThumbnailDir, 0o755) pyarchThumbnailPath = os.path.join(pyarchThumbnailDir, os.path.basename(thumbNailPath)) shutil.copy2(thumbNailPath, pyarchThumbnailPath) return pyarchThumbnailPath
def run(self, inData): # Wait for file if it's not already on disk' if "file" not in inData: raise BaseException("No expected file path in input!") filePath = pathlib.Path(self.inData["file"]) expectedSize = inData.get("expectedSize", None) configTimeOut = UtilsConfig.get(self, "timeOut", DEFAULT_TIMEOUT) timeOut = inData.get("timeOut", configTimeOut) hasTimedOut, finalSize = UtilsPath.waitForFile( filePath, expectedSize=expectedSize, timeOut=timeOut) outData = {"timedOut": hasTimedOut} if finalSize is not None: outData["finalSize"] = finalSize return outData
def executeRun(self): inData = self.getInData() hasValidInDataSchema = False hasValidOutDataSchema = False if self.getInDataSchema() is not None: instance = inData schema = self.getInDataSchema() try: jsonschema.validate(instance=instance, schema=schema) hasValidInDataSchema = True except Exception as e: logger.exception(e) else: hasValidInDataSchema = True if hasValidInDataSchema: self._workingDirectory = UtilsPath.getWorkingDirectory( self, inData, workingDirectorySuffix=self._workingDirectorySuffix) self.writeInputData(inData) self._oldDir = os.getcwd() os.chdir(str(self._workingDirectory)) outData = self.run(inData) os.chdir(self._oldDir) else: raise RuntimeError("Schema validation error for inData") if self.getOutDataSchema() is not None: instance = outData schema = self.getOutDataSchema() try: jsonschema.validate(instance=instance, schema=schema) hasValidOutDataSchema = True except Exception as e: logger.exception(e) else: hasValidOutDataSchema = True if hasValidOutDataSchema: self.writeOutputData(outData) else: raise RuntimeError("Schema validation error for outData") if not os.listdir(str(self._workingDirectory)): os.rmdir(str(self._workingDirectory))
def createHdf5HeaderData(cls, imagePath, skipNumberOfImages=False, hasOverlap=False, isFastMesh=False): h5MasterFilePath, h5DataFilePath, h5FileNumber = UtilsImage.getH5FilePath( pathlib.Path(imagePath), isFastMesh=isFastMesh, hasOverlap=hasOverlap) # Waiting for file timedOut, finalSize = UtilsPath.waitForFile(h5MasterFilePath, expectedSize=100000, timeOut=DEFAULT_TIME_OUT) if timedOut: errorMessage = "Timeout when waiting for image %s" % imagePath logger.error(errorMessage) raise BaseException(errorMessage) dictHeader = cls.readHdf5Header(h5MasterFilePath) description = dictHeader['description'] if 'Eiger 4M' in description: detectorName = 'EIGER 4M' detectorType = 'eiger4m' numberPixelX = 2070 numberPixelY = 2167 else: raise RuntimeError( '{0} cannot read image header from images with detector type {1}' .format(cls.__class__.__name__, description)) # Find out size of data set prefix = str(h5MasterFilePath).split('master')[0] listDataImage = [] noImages = 0 if not skipNumberOfImages: for data in dictHeader['data']: dataFilePath = prefix + data + '.h5' timedOut, finalSize = UtilsPath.waitForFile( dataFilePath, expectedSize=1000000, timeOut=DEFAULT_TIME_OUT) if timedOut: raise RuntimeError( 'Timeout waiting for file {0}'.format(dataFilePath)) # listDataImage.append({ # 'path': dataFilePath # }) f = h5py.File(dataFilePath, 'r') dataShape = f['entry']['data']['data'].shape noImages += dataShape[0] f.close() experimentalCondition = {} # Pixel size and beam position detector = { 'numberPixelX': int(numberPixelX), 'numberPixelY': int(numberPixelY), 'pixelSizeX': round(dictHeader['x_pixel_size'] * 1000, 3), 'pixelSizeY': round(dictHeader['y_pixel_size'] * 1000, 3), 'beamPositionX': round( float(dictHeader['beam_center_x'] * dictHeader['x_pixel_size'] * 1000), 3), 'beamPositionY': round( float(dictHeader['beam_center_y'] * dictHeader['y_pixel_size'] * 1000), 3), 'distance': round(float(dictHeader['detector_distance']) * 1000, 3), 'serialNumber': dictHeader['detector_number'], 'name': detectorName, 'type': detectorType } experimentalCondition['detector'] = detector # Beam object beam = { 'wavelength': round(float(dictHeader['wavelength']), 6), 'exposureTime': round(float(dictHeader['count_time']), 6) } experimentalCondition['beam'] = beam # Goniostat object goniostat = {} rotationAxisStart = round(float(dictHeader['omega_start']), 4) oscillationWidth = round(float(dictHeader['omega_increment']), 4) goniostat['rotationAxisStart'] = rotationAxisStart goniostat[ 'rotationAxisEnd'] = rotationAxisStart + oscillationWidth * noImages goniostat['oscillationWidth'] = oscillationWidth experimentalCondition['goniostat'] = goniostat # Create the image object masterImage = { 'path': imagePath, 'date': dictHeader['data_collection_date'], 'number': 1 } # imageNumber = UtilsImage.getImageNumber(imagePath) # image['number'] = imageNumber subWedge = { 'experimentalCondition': experimentalCondition, 'image': [masterImage] + listDataImage } return subWedge
def createCBFHeaderData(cls, imagePath): # Waiting for file timedOut, finalSize = UtilsPath.waitForFile(imagePath, expectedSize=100000, timeOut=DEFAULT_TIME_OUT) if timedOut: errorMessage = "Timeout when waiting for image %s" % imagePath logger.error(errorMessage) raise BaseException(errorMessage) dictHeader = cls.readCBFHeader(imagePath) detector = dictHeader['Detector:'] if 'PILATUS 3M' in detector or 'PILATUS3 2M' in detector or \ 'PILATUS 2M' in detector or 'PILATUS2 3M' in detector: detectorName = 'PILATUS2 3M' detectorType = 'pilatus2m' numberPixelX = 1475 numberPixelY = 1679 elif 'PILATUS 6M' in detector or 'PILATUS3 6M' in detector: detectorName = 'PILATUS2 6M' detectorType = 'pilatus6m' numberPixelX = 2463 numberPixelY = 2527 else: raise RuntimeError( '{0} cannot read image header from images with dector type {1}' .format(cls.__class__.__name__, detector)) experimentalCondition = {} detector = {'numberPixelX': numberPixelX, 'numberPixelY': numberPixelY} # Pixel size listPixelSizeXY = dictHeader['Pixel_size'].split(' ') detector['pixelSizeX'] = float(listPixelSizeXY[0]) * 1000 detector['pixelSizeY'] = float(listPixelSizeXY[3]) * 1000 # Beam position listBeamPosition = dictHeader['Beam_xy'].replace('(', ' ').replace( ')', ' ').replace(',', ' ').split() detector['beamPositionX'] = float(listBeamPosition[0]) * \ detector['pixelSizeX'] detector['beamPositionY'] = float(listBeamPosition[1]) * \ detector['pixelSizeY'] distance = float(dictHeader['Detector_distance'].split(' ')[0]) * 1000 detector['distance'] = distance detector['serialNumber'] = dictHeader['Detector:'] detector['name'] = detectorName detector['type'] = detectorType experimentalCondition['detector'] = detector # Beam object beam = { 'wavelength': float(dictHeader['Wavelength'].split(' ')[0]), 'exposureTime': float(dictHeader['Exposure_time'].split(' ')[0]) } experimentalCondition['beam'] = beam # Goniostat object goniostat = {} rotationAxisStart = float(dictHeader['Start_angle'].split(' ')[0]) oscillationWidth = float(dictHeader['Angle_increment'].split(' ')[0]) goniostat['rotationAxisStart'] = rotationAxisStart goniostat['rotationAxisEnd'] = rotationAxisStart + oscillationWidth goniostat['oscillationWidth'] = oscillationWidth experimentalCondition['goniostat'] = goniostat # Create the image object image = {'path': imagePath} if 'DateTime' in dictHeader: image['date'] = dictHeader['DateTime'] imageNumber = UtilsImage.getImageNumber(imagePath) image['number'] = imageNumber subWedge = { 'experimentalCondition': experimentalCondition, 'image': [image] } return subWedge
def run(self, inData): # Format suffix format = inData.get("format", "jpeg") if format == "jpeg": thumbSuffix = ".jpeg" elif format == "jpg": thumbSuffix = ".jpg" else: raise RuntimeError("Unsupported format: {0}".format(format)) # Loop through all images listJPEGTask = [] listThumbTask = [] forcedOutputDirectory = inData.get("forcedOutputDirectory", None) for imagePath in inData["image"]: # Check image file extension imageFileName, suffix = os.path.splitext( os.path.basename(imagePath)) if not suffix in [".img", ".marccd", ".mccd", ".cbf", ".h5"]: raise RuntimeError( "Unknown image file name extension for pyarch thumbnail generator: %s" % imagePath) # Wait for image file if suffix == ".h5": h5MasterFilePath, h5DataFilePath, h5FileNumber = UtilsImage.getH5FilePath( imagePath, isFastMesh=True) waitFilePath = h5DataFilePath else: waitFilePath = imagePath expectedSize = self.getExpectedSize(imagePath) hasTimedOut, finalSize = UtilsPath.waitForFile( waitFilePath, expectedSize=expectedSize, timeOut=600) if hasTimedOut: raise RuntimeError( "Waiting for file {0} timed out!".format(imagePath)) outputFileName = imageFileName + thumbSuffix if forcedOutputDirectory is not None: outputPath = os.path.join(forcedOutputDirectory, outputFileName) else: outputPath = None # Create JPEG with resolution rings inDataReadHeader = { "imagePath": [imagePath], "skipNumberOfImages": True, "isFastMesh": True } readHeader = ReadImageHeader( inData=inDataReadHeader, workingDirectorySuffix=imageFileName, ) readHeader.execute() experimentalCondition = readHeader.outData["subWedge"][0][ "experimentalCondition"] detector = experimentalCondition["detector"] beam = experimentalCondition["beam"] inDataCreateJPEG = { "image": imagePath, "height": 1024, "width": 1024, "outputFileName": outputFileName, "outputPath": outputPath, "doResolutionRings": True, "pixelSizeX": detector["pixelSizeX"], "pixelSizeY": detector["pixelSizeY"], "beamPositionX": detector["beamPositionX"], "beamPositionY": detector["beamPositionY"], "distance": detector["distance"], "wavelength": beam["wavelength"], } createJPEG = CreateThumbnail(inData=inDataCreateJPEG, workingDirectorySuffix=imageFileName + "_JPEG") createJPEG.start() listJPEGTask.append(createJPEG) # Create thumbnail outputFileName = imageFileName + ".thumb" + thumbSuffix if forcedOutputDirectory is not None: outputPath = os.path.join(forcedOutputDirectory, outputFileName) else: outputPath = None inDataCreateThumb = { "image": imagePath, "height": 256, "width": 256, "outputFileName": outputFileName, "outputPath": outputPath, "doResolutionRings": True, "pixelSizeX": detector["pixelSizeX"], "pixelSizeY": detector["pixelSizeY"], "beamPositionX": detector["beamPositionX"], "beamPositionY": detector["beamPositionY"], "distance": detector["distance"], "wavelength": beam["wavelength"], } createThumb = CreateThumbnail( inData=inDataCreateThumb, workingDirectorySuffix=imageFileName + "_thumbnail") createThumb.start() listThumbTask.append(createThumb) outData = {"pathToJPEGImage": [], "pathToThumbImage": []} for task in listJPEGTask: task.join() if forcedOutputDirectory: outData["pathToJPEGImage"].append(task.outData["thumbNail"]) else: pyarchPath = self.copyThumbnailToPyarch(task) outData["pathToJPEGImage"].append(pyarchPath) for task in listThumbTask: task.join() if forcedOutputDirectory: outData["pathToThumbImage"].append(task.outData["thumbNail"]) else: pyarchPath = self.copyThumbnailToPyarch(task) outData["pathToThumbImage"].append(pyarchPath) return outData
def setWorkingDirectory(self, inData): self._workingDirectory = UtilsPath.getWorkingDirectory(self, inData)
def createHdf5HeaderData(cls, imagePath, skipNumberOfImages=False, hasOverlap=False, isFastMesh=True): h5MasterFilePath, h5DataFilePath, h5FileNumber = UtilsImage.getH5FilePath( pathlib.Path(imagePath), isFastMesh=isFastMesh, hasOverlap=hasOverlap) # Waiting for file timedOut, finalSize = UtilsPath.waitForFile(h5MasterFilePath, expectedSize=2000000, timeOut=DEFAULT_TIME_OUT) if timedOut: errorMessage = "Timeout when waiting for image %s" % imagePath logger.error(errorMessage) raise BaseException(errorMessage) logger.info("Final size for {0}: {1}".format(h5MasterFilePath, finalSize)) noTrialsLeft = 5 dictHeader = None while noTrialsLeft > 0: try: dictHeader = cls.readHdf5Header(h5MasterFilePath) noTrialsLeft = 0 except Exception as e: logger.warning( "Cannot read header from {0}, no trials left: {1}".format( h5MasterFilePath, noTrialsLeft)) time.sleep(5) noTrialsLeft -= 1 if dictHeader is None: raise RuntimeError( "Cannot read header from {0}!".format(h5MasterFilePath)) description = dictHeader["description"] if "Eiger 4M" in description: detectorName = "EIGER 4M" detectorType = "eiger4m" numberPixelX = 2070 numberPixelY = 2167 elif "eiger" in description.lower() and "16M" in description: detectorName = "EIGER 16M" detectorType = "eiger16m" numberPixelX = 4148 numberPixelY = 4362 else: raise RuntimeError( "{0} cannot read image header from images with detector type {1}" .format(cls.__class__.__name__, description)) # Image number image_number = UtilsImage.getImageNumber(imagePath) # Find out size of data set prefix = str(h5MasterFilePath).split("master")[0] listDataImage = [] noImages = 0 if not skipNumberOfImages: for data in dictHeader["data"]: dataFilePath = prefix + data + ".h5" timedOut, finalSize = UtilsPath.waitForFile( dataFilePath, expectedSize=100000, timeOut=DEFAULT_TIME_OUT) if timedOut: raise RuntimeError( "Timeout waiting for file {0}".format(dataFilePath)) # listDataImage.append({ # 'path': dataFilePath # }) f = h5py.File(dataFilePath, "r") dataShape = f["entry"]["data"]["data"].shape noImages += dataShape[0] f.close() experimentalCondition = {} # Pixel size and beam position detector = { "numberPixelX": int(numberPixelX), "numberPixelY": int(numberPixelY), "pixelSizeX": round(dictHeader["x_pixel_size"] * 1000, 3), "pixelSizeY": round(dictHeader["y_pixel_size"] * 1000, 3), "beamPositionX": round( float(dictHeader["beam_center_x"] * dictHeader["x_pixel_size"] * 1000), 3, ), "beamPositionY": round( float(dictHeader["beam_center_y"] * dictHeader["y_pixel_size"] * 1000), 3, ), "distance": round(float(dictHeader["detector_distance"]) * 1000, 3), "serialNumber": dictHeader["detector_number"], "name": detectorName, "type": detectorType, } experimentalCondition["detector"] = detector # Beam object beam = { "wavelength": round(float(dictHeader["wavelength"]), 6), "exposureTime": round(float(dictHeader["count_time"]), 6), } experimentalCondition["beam"] = beam # Goniostat object goniostat = {} rotationAxisStart = round(float(dictHeader["omega_start"]), 4) oscillationWidth = round(float(dictHeader["omega_range_average"]), 4) # Offset for the image number rotationAxisStart += (image_number - 1) * oscillationWidth goniostat["rotationAxisStart"] = rotationAxisStart goniostat["rotationAxisEnd"] = rotationAxisStart + oscillationWidth goniostat["oscillationWidth"] = oscillationWidth experimentalCondition["goniostat"] = goniostat # Create the image object image_dict = { "path": imagePath, "date": dictHeader["data_collection_date"], "number": 1, } # imageNumber = UtilsImage.getImageNumber(imagePath) # image['number'] = imageNumber subWedge = { "experimentalCondition": experimentalCondition, "image": [image_dict], } return subWedge
def createCBFHeaderData(cls, imagePath): # Waiting for file timedOut, finalSize = UtilsPath.waitForFile(imagePath, expectedSize=100000, timeOut=DEFAULT_TIME_OUT) if timedOut: errorMessage = "Timeout when waiting for image %s" % imagePath logger.error(errorMessage) raise BaseException(errorMessage) dictHeader = cls.readCBFHeader(imagePath) detector = dictHeader["Detector:"] if ("PILATUS 3M" in detector or "PILATUS3 2M" in detector or "PILATUS 2M" in detector or "PILATUS2 3M" in detector): detectorName = "PILATUS2 3M" detectorType = "pilatus2m" numberPixelX = 1475 numberPixelY = 1679 elif "PILATUS 6M" in detector or "PILATUS3 6M" in detector: detectorName = "PILATUS2 6M" detectorType = "pilatus6m" numberPixelX = 2463 numberPixelY = 2527 elif "eiger" in detector.lower() and "4m" in detector.lower(): detectorName = "EIGER 4M" detectorType = "eiger4m" numberPixelX = 2070 numberPixelY = 2167 elif "eiger2" in detector.lower() and "16m" in detector.lower(): detectorName = "EIGER2 16M" detectorType = "eiger16m" numberPixelX = 4148 numberPixelY = 4362 else: raise RuntimeError( "{0} cannot read image header from images with dector type {1}" .format(cls.__class__.__name__, detector)) experimentalCondition = {} detector = {"numberPixelX": numberPixelX, "numberPixelY": numberPixelY} # Pixel size listPixelSizeXY = dictHeader["Pixel_size"].split(" ") detector["pixelSizeX"] = float(listPixelSizeXY[0]) * 1000 detector["pixelSizeY"] = float(listPixelSizeXY[3]) * 1000 # Beam position listBeamPosition = (dictHeader["Beam_xy"].replace("(", " ").replace( ")", " ").replace(",", " ").split()) detector["beamPositionX"] = float( listBeamPosition[0]) * detector["pixelSizeX"] detector["beamPositionY"] = float( listBeamPosition[1]) * detector["pixelSizeY"] distance = float(dictHeader["Detector_distance"].split(" ")[0]) * 1000 detector["distance"] = distance detector["serialNumber"] = dictHeader["Detector:"] detector["name"] = detectorName detector["type"] = detectorType experimentalCondition["detector"] = detector # Beam object beam = { "wavelength": float(dictHeader["Wavelength"].split(" ")[0]), "exposureTime": float(dictHeader["Exposure_time"].split(" ")[0]), } experimentalCondition["beam"] = beam # Goniostat object goniostat = {} rotationAxisStart = float(dictHeader["Start_angle"].split(" ")[0]) oscillationWidth = float(dictHeader["Angle_increment"].split(" ")[0]) goniostat["rotationAxisStart"] = rotationAxisStart goniostat["rotationAxisEnd"] = rotationAxisStart + oscillationWidth goniostat["oscillationWidth"] = oscillationWidth experimentalCondition["goniostat"] = goniostat # Create the image object image = {"path": imagePath} if "DateTime" in dictHeader: image["date"] = dictHeader["DateTime"] imageNumber = UtilsImage.getImageNumber(imagePath) image["number"] = imageNumber subWedge = { "experimentalCondition": experimentalCondition, "image": [image] } return subWedge
def test_createPyarchFilePath(self): self.assertEqual("None", str(UtilsPath.createPyarchFilePath("/")), "/") self.assertEqual("None", str(UtilsPath.createPyarchFilePath("/data")), "/data") self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/visitor")), "/data/visitor", ) self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/visitor/mx415/id14eh2")), "/data/visitor/mx415/id14eh2", ) self.assertEqual( "/data/pyarch/2010/id14eh2/mx415/20100212", str(UtilsPath.createPyarchFilePath("/data/visitor/mx415/id14eh2/20100212")), "/data/visitor/mx415/id14eh2/20100212", ) self.assertEqual( "/data/pyarch/2010/id14eh2/mx415/20100212/1", str( UtilsPath.createPyarchFilePath("/data/visitor/mx415/id14eh2/20100212/1") ), "/data/visitor/mx415/id14eh2/20100212/1", ) self.assertEqual( "/data/pyarch/2010/id14eh2/mx415/20100212/1/2", str( UtilsPath.createPyarchFilePath( "/data/visitor/mx415/id14eh2/20100212/1/2" ) ), "/data/visitor/mx415/id14eh2/20100212/1/2", ) # Test with inhouse account... self.assertEqual("None", str(UtilsPath.createPyarchFilePath("/")), "/") self.assertEqual("None", str(UtilsPath.createPyarchFilePath("/data")), "/data") self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/id23eh2")), "/data/id23eh2", ) self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/id23eh2/inhouse")), "/data/id23eh2/inhouse", ) self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/id23eh2/inhouse/opid232")), "/data/id23eh2/inhouse/opid232", ) self.assertEqual( "/data/pyarch/2010/id23eh2/opid232/20100525", str( UtilsPath.createPyarchFilePath("/data/id23eh2/inhouse/opid232/20100525") ), "/data/id23eh2/inhouse/opid232/20100525", ) self.assertEqual( "/data/pyarch/2010/id23eh2/opid232/20100525/1", str( UtilsPath.createPyarchFilePath( "/data/id23eh2/inhouse/opid232/20100525/1" ) ), "/data/id23eh2/inhouse/opid232/20100525/1", ) self.assertEqual( "/data/pyarch/2010/id23eh2/opid232/20100525/1/2", str( UtilsPath.createPyarchFilePath( "/data/id23eh2/inhouse/opid232/20100525/1/2" ) ), "/data/id23eh2/inhouse/opid232/20100525/1/2", ) self.assertEqual( "/data/pyarch/2014/id30a1/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles", str( UtilsPath.createPyarchFilePath( "/data/id30a1/inhouse/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles" ) ), "/data/id30a1/inhouse/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles", ) # Visitor self.assertEqual( "None", str(UtilsPath.createPyarchFilePath("/data/visitor/mx415/id30a3")), "/data/visitor/mx415/id30a3", ) self.assertEqual( "/data/pyarch/2010/id30a3/mx415/20100212", str(UtilsPath.createPyarchFilePath("/data/visitor/mx415/id30a3/20100212")), "/data/visitor/mx415/id30a3/20100212", ) self.assertEqual( "/data/pyarch/2010/id30a3/mx415/20100212/1", str( UtilsPath.createPyarchFilePath("/data/visitor/mx415/id30a3/20100212/1") ), "/data/visitor/mx415/id30a3/20100212/1", ) self.assertEqual( "/data/pyarch/2010/id30a3/mx415/20100212/1/2", str( UtilsPath.createPyarchFilePath( "/data/visitor/mx415/id30a3/20100212/1/2" ) ), "/data/visitor/mx415/id30a3/20100212/1/2", ) self.assertEqual( "/data/pyarch/2010/id30a3/opid232/20100525", str( UtilsPath.createPyarchFilePath("/data/id30a3/inhouse/opid232/20100525") ), "/data/id30a3/inhouse/opid232/20100525", ) self.assertEqual( "/data/pyarch/2010/id30a3/opid232/20100525/1", str( UtilsPath.createPyarchFilePath( "/data/id30a3/inhouse/opid232/20100525/1" ) ), "/data/id30a3/inhouse/opid232/20100525/1", ) self.assertEqual( "/data/pyarch/2010/id30a3/opid232/20100525/1/2", str( UtilsPath.createPyarchFilePath( "/data/id30a3/inhouse/opid232/20100525/1/2" ) ), "/data/id30a3/inhouse/opid232/20100525/1/2", ) self.assertEqual( "/data/pyarch/2014/id30a3/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles", str( UtilsPath.createPyarchFilePath( "/data/id30a3/inhouse/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles" ) ), "/data/id30a3/inhouse/opid30a1/20140717/RAW_DATA/opid30a1_1_dnafiles", ) # Test with different prefix...: self.assertEqual( "/data/pyarch/2010/id23eh2/opid232/20100525", str( UtilsPath.createPyarchFilePath("/mnt/multipath-shares/data/id23eh2/inhouse/opid232/20100525") ), "/data/id23eh2/inhouse/opid232/20100525", )
def test_stripDataDirectoryPrefix(self): data_directory = "/gpfs/easy/data/id30a2/inhouse/opid30a2" new_data_directory = UtilsPath.stripDataDirectoryPrefix(data_directory) self.assertEqual(str(new_data_directory), "/data/id30a2/inhouse/opid30a2")