extranormal3-0.0.3/0000755005375400003410000000000013432336246017260 5ustar roudenkoinstrumentation00000000000000extranormal3-0.0.3/scripts/0000755005375400003410000000000013432336246020747 5ustar roudenkoinstrumentation00000000000000extranormal3-0.0.3/scripts/ab_test.py0000755005375400003410000000626213364605432022753 0ustar roudenkoinstrumentation00000000000000#!/usr/bin/env python3 ####################################### import sys import os import os.path import time #import re import logging # ------------------------ logging levels ------------------------------------ logging.basicConfig(level= logging.INFO, format='%(module)s.%(funcName)s: %(levelname)-7s: %(message)s') config_log = logging.INFO # ---------------------------------------------------------------------------- from optparse import OptionParser import numpy from scipy import optimize import matplotlib.pyplot as plt from extranormal3 import normal_xas #---------- test ----------- E0 = 20003.9 PRE_EDGE_START = -200 PRE_EDGE_END = -60 PRE_FIT_DEGREE = 1 POST_EDGE_START = 100 POST_EDGE_END = 1200 POST_FIT_DEGREE = 2 #--------------------------- if __name__ == '__main__': parser = OptionParser() ''' parser.add_option("-p", "--parallel", dest="parallel", action="store_true", default=False, help="parallel execution (using mpirun)") ''' (options, args) = parser.parse_args() if len(args) == 0: print ("Usage: "+ os.path.basename(__file__) +" data_file") sys.exit() if not os.path.exists(args[0]): logging.error(" Data file "+ args[0] +" does not exist") sys.exit() data_file = args[0] edge = E0 preedge_params = {} preedge_params['from'] = edge + PRE_EDGE_START preedge_params['to'] = edge + PRE_EDGE_END preedge_params['deg'] = PRE_FIT_DEGREE postedge_params = {} postedge_params['from'] = edge + POST_EDGE_START postedge_params['to'] = edge + POST_EDGE_END postedge_params['deg'] = POST_FIT_DEGREE spectrum = numpy.loadtxt(data_file, comments = '#', usecols=(0,2), unpack=True ) ref = numpy.loadtxt(data_file, comments = '#', usecols=(3,), unpack=True ) fig, ax = plt.subplots() line1, = ax.plot(spectrum[0], spectrum[1], label='Measured spectrum') norm_vals = normal_xas.normalize(spectrum, edge, preedge_params, postedge_params)[0] ''' print (norm_vals) print (norm_vals.shape) norm_const = normal_xas.normalize(spectrum, edge, preedge_params, postedge_params)[1] print (norm_const) print (numpy.array([norm_const]).shape) print (numpy.concatenate((norm_vals, numpy.array([norm_const])), axis=0)) ''' line2, = ax.plot(spectrum[0], norm_vals, label='Normalized spectrum') ax.legend(loc='lower right') plt.grid() #plt.show() norm_spectra, norm_consts = normal_xas.normalize_all(spectrum[0], [spectrum[1], ref], edge, preedge_params, postedge_params) print (norm_spectra.shape) #print (numpy.ones((len(norm_consts), 1)).shape ) #print (numpy.hstack((norm_spectra, numpy.ones((len(norm_consts), 1)))) ) norm_consts = norm_consts.reshape((len(norm_consts),1)) print (norm_consts.shape) print (norm_consts) print (numpy.hstack((norm_spectra, norm_consts)) ) #print (normal_xas.normalize_all(spectrum[0], [spectrum[1], ref], edge, preedge_params, postedge_params)) #print (norm_params) extranormal3-0.0.3/extranormal3/0000755005375400003410000000000013432336246021677 5ustar roudenkoinstrumentation00000000000000extranormal3-0.0.3/extranormal3/extra_exafs.py0000644005375400003410000001372013401501623024552 0ustar roudenkoinstrumentation00000000000000#!/usr/bin/env python3 ####################################### import sys import os import os.path import logging # ------------------------ logging levels ------------------------------------ logging.basicConfig(level= logging.DEBUG, format='%(module)s.%(funcName)s: %(levelname)-7s: %(message)s') config_log = logging.INFO # ---------------------------------------------------------------------------- import numpy from scipy import optimize, interpolate from extranormal3 import curved_tools #------------ K_step = 0.05 K_max_margin = 1 #------------ def get_idx_bounds(ene, sample_edge, ek_start, ek_end): E_bounds = True if E_bounds: logging.debug('Emin = '+ str(ek_start) +', Emax = '+ str(ek_end)) rel_Ebounds = True if sample_edge > ek_start else False logging.debug('In get_idx_bounds: ABSOLUTE values for energy bounds are given') ''' if not rel_Ebounds: # get them relative e_start = e_start - edge e_end = e_end - edge rel_Ebounds = True ''' if rel_Ebounds: start_idx = min(ene.searchsorted(sample_edge + ek_start), len(ene)-10) end_idx = min(ene.searchsorted(sample_edge + ek_end), len(ene)-1) else: start_idx = min(ene.searchsorted(ek_start), len(ene)-10) end_idx = min(ene.searchsorted(ek_end), len(ene)-1) logging.debug(' Idx bounds: '+ str(start_idx) +' and '+ str(end_idx)) else: # k2energy logging.debug(' K bounds given: '+ str(ek_start) +', '+ str(ek_end)) e_start = ek_start**2/0.2625 e_end = ek_end**2/0.2625 logging.debug(" E bounds: "+ str(e_start) +', '+ str(e_end)) start_idx = ene.searchsorted(sample_edge + e_start) if ene[start_idx]- (sample_edge + e_start) > (sample_edge + e_start) - ene[start_idx-1]: start_idx -= 1 end_idx = min(ene.searchsorted(sample_edge + e_end), len(ene)-1) logging.debug(' Idx bounds: '+ str(start_idx) +' and '+ str(end_idx)) return start_idx, end_idx def get_K_points(ene, sample_edge, start_idx, end_idx): ''' should be called just ones ''' if ene[start_idx] < sample_edge: raise Exception(' Invalid index when converting E to K') E_points = ene[start_idx:end_idx] K_points = numpy.sqrt(0.2625 * (E_points-sample_edge)) nb_points = int((K_points[-1] - K_points[0])/K_step) K_interp = numpy.array([K_points[0] + K_step*i for i in range(nb_points)]) return K_interp, K_points def polynomial(k_points, mu_in_bounds, k_interp, I_jump, poly_deg, kweight, plot=False): if I_jump == 0.: raise Exception(' Intensity jump at edge cannot aqual to zero') mu_calc = interpolate.interp1d(k_points, mu_in_bounds, 'linear', bounds_error=False, fill_value=0.) mu_interp = mu_calc(k_interp) ''' fit_sigma = [k_interp[-1]**kweight for i in range(20)] fit_sigma = fit_sigma + [1./k_interp[i]**kweight for i in range(20, len(k_interp))] ''' bkg_polynomial = optimize.curve_fit(curved_tools.poly_calc, k_interp, mu_interp, [1.,]*poly_deg+[mu_interp[0]], sigma=1./k_interp**kweight #sigma=fit_sigma )[0] bkg = numpy.polyval(bkg_polynomial, k_interp) if plot: import pylab pylab.plot(k_interp, bkg) chi_vals = (mu_interp - bkg)/I_jump return chi_vals, bkg #class NoJunpsEx(Exception): pass def extract_all(energies, abs_data, edge, I_jumps, e_start, e_end, poly_deg, kweight, m): ''' *** This function is applicable to the interpolated data *** data : data[0] = energies, data[1:] = absorbance columns ''' if any([len(energies) != len(vals) for vals in abs_data]): raise Exception(' Invalid data format') if len(I_jumps) != len(abs_data): raise Exception(' Invalid data format or inconsistent meta data') #raise NoJunpsEx(' Invalid data format or inconsistent meta data') ''' rel_Ebounds = True if edge > e_start else False if not rel_Ebounds: # get them relative e_start = e_start - edge e_end = e_end - edge rel_Ebounds = True ''' # e_start, e_end are for the moment ABSOLUTE (not relative to Edge) start_idx, end_idx = get_idx_bounds(energies, edge, e_start, e_end) k_interp, k_points = get_K_points(energies, edge, start_idx, end_idx) logging.debug(' Kmin = '+ str(k_points[0]) +', Kmax = '+ str(k_points[-1])) ''' end_idx = min(energies.searchsorted(edge + e_end), len(energies)-1) kmax_extra = numpy.sqrt(0.2625 * (energies[end_idx] - edge)) ''' kmax_extra = k_points[-1] if poly_deg <= 0: poly_deg = min(9, int(numpy.round(kmax_extra/2.))) print ('Auto defined poly_deg = '+ str(poly_deg)) if kweight <= 0: if kmax_extra >=16: kweight = 3 elif 12 < kmax_extra < 16: kweight = 2 elif kmax_extra < 12: kweight =1 print ('Auto defined kweight = '+ str(kweight)) otvet = [polynomial(k_points, abs_data[i][start_idx: end_idx], k_interp, I_jumps[i], poly_deg, kweight) for i in range(len(abs_data))] exafs_list = [] Km_exafs_list = [] bkgr_list = [] for tuple_instance in otvet: exafs_list.append(tuple_instance[0]) Km_exafs_list.append((k_interp**m)*tuple_instance[0]) bkgr_list.append(tuple_instance[1]) exafs = numpy.array(exafs_list) Km_exafs= numpy.array(Km_exafs_list) bkgr = numpy.array(bkgr_list) return Km_exafs, exafs, bkgr extranormal3-0.0.3/extranormal3/curved_tools.py0000644005375400003410000001242713432323514024761 0ustar roudenkoinstrumentation00000000000000#!/usr/bin/env python ####################################### import sys import os import os.path import time #import re import logging # ------------------------ logging levels ------------------------------------ logging.basicConfig(level= logging.DEBUG, format='%(module)s.%(funcName)s: %(levelname)-7s: %(message)s') config_log = logging.INFO # ---------------------------------------------------------------------------- #from optparse import OptionParser from math import factorial import numpy from scipy import interpolate #optimize, signal #scipy.signal.savgol_filter(x, window_length, polyorder, deriv=0, delta=1.0, axis=-1, mode='interp', cval=0.0)[source] #from matplotlib import pylab # ----------------------- updated funcs -------------------- def poly_fit(spectrum, user_params): start_ix, end_ix = spectrum[0].searchsorted([user_params['from'], user_params['to']]) if end_ix <= start_ix: print (start_ix, end_ix) sys.tracebacklimit = -1 raise Exception('Invalid energy bounds for fit') fit_coeffs = numpy.polyfit(spectrum[0][start_ix:end_ix], spectrum[1][start_ix:end_ix], user_params['deg']) return numpy.array([spectrum[0], numpy.polyval(fit_coeffs, spectrum[0])]), fit_coeffs def centered_polynomial(x, *args): # tupo res = [] for i in range(len(x)): res.append(numpy.dot(numpy.array([x[i]**(n+1) for n in range(len(args))]), args)) return numpy.array(res) def poly_calc(x, *args): #return pylab.polyval(args, x) return numpy.polyval(args, x) def equalstep_interp(x, y, step): ''' ddk=numpy.diff(x) #print 'init steps:' + str(ddk) # debug if not(numpy.allclose(ddk[0],ddk)): ''' if 1==1: logging.debug(' x[0]= '+ str(x[0]) +', x[-1]= '+ str(x[-1]) +'; '+ str(len(x)) + ' points') lin_y = interpolate.interp1d(x, y, 'linear', bounds_error=False, fill_value=0.) x = numpy.arange(x[0], x[-1] + step, step) y = lin_y(x) logging.debug('interp_x[0]= '+ str(x[0]) +', interp_x[-1]= '+ str(x[-1]) +'; '+ str(len(x)) + ' points') return x, y # -------------------- funcs on stand by ------------------- def derivative_3points(curve): f_diffs = curve[1,2:] - curve[1, :-2] f_diffs = numpy.concatenate(([curve[1,1] - curve[1,0]], f_diffs, [curve[1,-1] - curve[1,-2]])) x_diffs = curve[0,2:] - curve[0,:-2] x_diffs = numpy.concatenate( ([curve[0,1] - curve[0,0]], x_diffs, [curve[0,-1] - curve[0,-2]]) ) return f_diffs/x_diffs def derivative_5points(curve): f_diffs = curve[1,4:] - curve[1, :-4] f_diffs = numpy.concatenate(([curve[1,1] - curve[1,0]], [curve[1,2] - curve[1,0]], f_diffs, [curve[1,-1] - curve[1,-3]], [curve[1,-1] - curve[1,-2]])) x_diffs = curve[0,4:] - curve[0,:-4] x_diffs = numpy.concatenate( ([curve[0,1] - curve[0,0]], [curve[0,2] - curve[0,0]], x_diffs, [curve[0,-1] - curve[0,-3]], [curve[0,-1] - curve[0,-2]]) ) return f_diffs/x_diffs def derivative_vals(curve, points_nb=5): if points_nb == 5: return derivative_5points(curve) else: return derivative_3points(curve) def max_deriv_pos(spectrum, deriv_over=3): ''' deriv_over how many points: 3 or 5 are available ''' if deriv_over == 5: deriv_vals = derivative_5points(spectrum) else: deriv_vals = derivative_3points(spectrum) edge_indx = numpy.argmax(deriv_vals) # - index return spectrum[0][edge_indx] #http://stackoverflow.com/questions/22988882/how-to-smooth-a-curve-in-python def savitzky_golay(y, window_size, order, deriv=0, rate=1): import numpy as np try: window_size = np.abs(np.int(window_size)) order = np.abs(np.int(order)) except ValueError: raise ValueError("window_size and order have to be of type int") if window_size % 2 != 1 or window_size < 1: raise TypeError("window_size size must be a positive odd number") if window_size < order + 2: raise TypeError("window_size is too small for the polynomials order") order_range = range(order+1) half_window = (window_size -1) // 2 # precompute coefficients b = np.mat([[k**i for i in order_range] for k in range(-half_window, half_window+1)]) m = np.linalg.pinv(b).A[deriv] * rate**deriv * factorial(deriv) #print b #print m # pad the signal at the extremes with # values taken from the signal itself firstvals = y[0] - np.abs( y[1:half_window+1][::-1] - y[0] ) lastvals = y[-1] + np.abs(y[-half_window-1:-1][::-1] - y[-1]) y = np.concatenate((firstvals, y, lastvals)) return np.convolve( m[::-1], y, mode='valid') extranormal3-0.0.3/extranormal3/__init__.py0000644005375400003410000000003113430251525023774 0ustar roudenkoinstrumentation00000000000000# -*- coding: utf-8 -*- extranormal3-0.0.3/extranormal3/forward_fourier.py0000644005375400003410000000661013401233160025436 0ustar roudenkoinstrumentation00000000000000#!/usr/bin/env python3 ####################################### import sys import os import os.path import logging # ------------------------ logging levels ------------------------------------ logging.basicConfig(level= logging.DEBUG, format='%(module)s.%(funcName)s: %(levelname)-7s: %(message)s') config_log = logging.INFO # ---------------------------------------------------------------------------- import numpy from scipy import fftpack from extranormal3 import curved_tools #------------------------------------ dx=0.05 smoothfactor=7 #------------------------------------ def kaiser_window(x, x_min, x_max, tau, dx): pos = int(numpy.round((x_min - x[0])/dx)) logging.debug(' pos = '+str(pos)) #print x[0], x_min lenx = int(numpy.round(x_max - x_min)/dx) logging.debug(' lenx = '+str(lenx)) win = numpy.zeros(len(x)) win[pos : pos+lenx] = numpy.kaiser(lenx, tau) return win def get_r_points(k_points): print ('coucou') return k_points def la_fouriere(x, y, k_min, k_max, tau=2, smoothfactor=7, dx=0.05, kaiser=True): #def ft(chi,k1,k2,kw=1,tau=2,np=1024,kaiser=True) """ - scipy based fourier transform - usable on exafs data for forward fourier transform - tau is the tau of the kaiser window (called dk in Athena) - k_min and k_max are the limits of the window (When kaiser is not used a box window is used instead.) - return frequencies, imaginary part, real part and envelope """ logging.debug(' la_fouriere function........') if len(x) != len(y): logging.error(' Invalid data length') raise Exception(' Invalid data length') x, y = curved_tools.equalstep_interp(x, y, dx) if kaiser: win = kaiser_window(x, k_min, k_max, tau, dx) else: win = numpy.ones(len(x)) win[(x < k_min) + (x > k_max)] = 0. # N = lenk number of samplepoints # T = dk sample spacing freqsx2 = len(x)*smoothfactor #y = numpy.array(y) * numpy.array(x)**kw * win #yf = fftpack.fft(numpy.array(y) * numpy.array(x)**kw * win, freqsx2) yf = fftpack.fft(numpy.array(y)*win, freqsx2) #xf = numpy.linspace(0.0, 1.0/(2.0*dx), freqsx2) xf = numpy.fft.fftfreq(freqsx2, dx/numpy.pi) #return xf, yf lenx = len(xf) magnitudes = numpy.abs(yf[:lenx/2]) return xf[:lenx/2], magnitudes def fouriere4all(k_points, exafs_data, k_min, k_max, tau=2, kaiser=True): otvet = [la_fouriere(k_points, exafs_data[i], k_min, k_max, tau=2, smoothfactor=smoothfactor, dx=dx, kaiser=True) for i in range(len(exafs_data))] return otvet fourier_matrix = [] for i in range(len(exafs_data)): #try: if 1==1: r, yf = la_fouriere(x, exafs_data[i], k_min, k_max, tau=tau, smoothfactor=smoothfactor) lenr = len(r) ampli_yf = numpy.abs(yf[:lenr/2]) if len(fourier_matrix)==0: fourier_matrix.append(r[:lenr/2]) fourier_matrix.append(ampli_yf) ''' except: print 'Unexpected format: file ', f sys.exit() ''' extranormal3-0.0.3/extranormal3/normal_xas.py0000644005375400003410000001123713432335066024417 0ustar roudenkoinstrumentation00000000000000#!/usr/bin/env python3 ####################################### import sys import os import os.path import logging # ------------------------ logging levels ------------------------------------ logging.basicConfig(level= logging.INFO, format='%(module)s.%(funcName)s: %(levelname)-7s: %(message)s') config_log = logging.INFO # ---------------------------------------------------------------------------- import numpy from extranormal3 import curved_tools class InvalidInput(Exception): pass def process_params(energies, edge, preedge_params, postedge_params): if not (energies[0] < edge and edge < energies[-1]): sys.tracebacklimit = -1 raise Exception('Edge value does not belong to the data energy range') if preedge_params['from']<0 and preedge_params['to']<0: # relative pre-edge fit bounds preedge_params['from'] += edge preedge_params['to'] += edge postedge_params['from'] += edge postedge_params['to'] += edge if preedge_params['from'] < energies[0]: preedge_params['from'] = energies[0] if postedge_params['to'] > energies[-1]: postedge_params['to'] = energies[-1] def flatten(spectrum, edge, preedge_fit, postedge_fit): ''' spectrum is supposed to be shifted to the edge by now preedge_fit = self.preedge_params['fit_func'] from normal_gui.NormalWindow postedge_fit = self.postedge_params['fit_func'] from normal_gui.NormalWindow ''' flattening_params = list(postedge_fit)[:-1]+[0.] flattening_params[-2] -= preedge_fit[-2] #print flattening_params beforeE0_inxs, = numpy.where(spectrum[0] < edge) afterE0_inxs, = numpy.where(spectrum[0] >= edge) flattening = numpy.zeros(len(spectrum[0])) flattening[afterE0_inxs] = numpy.polyval(flattening_params, spectrum[0][afterE0_inxs]) flattening[afterE0_inxs] = (flattening[afterE0_inxs] - numpy.polyval(flattening_params, edge)) return flattening def normalize(spectrum, edge, preedge_params, postedge_params, checked_params=False): if not checked_params: process_params(spectrum[0], edge, preedge_params, postedge_params) try: preedge_fitcurve, preedge_fitcoeffs = curved_tools.poly_fit(spectrum, preedge_params) postedge_fitcurve, postedge_fitcoeffs = curved_tools.poly_fit(spectrum, postedge_params) except: #sys.tracebacklimit = -1 raise Exception('Invalid fit parameters') # http://cars9.uchicago.edu/~ravel/software/doc/Athena/html/bkg/norm.html norm_const = (numpy.polyval(postedge_fitcoeffs, edge)- numpy.polyval(preedge_fitcoeffs, edge)) flattening = flatten(spectrum, edge, preedge_fitcoeffs, postedge_fitcoeffs) #return numpy.array([spectrum[0], (spectrum[1]-preedge_fitcurve[1]-flattening)/norm_const]) return numpy.array((spectrum[1]-preedge_fitcurve[1]-flattening)/norm_const), norm_const def normalize_all(energies, abs_data, edge, preedge_params, postedge_params): ''' *** This function is only applicable to the interpolated data *** ''' #print(energies, abs_data) if any([len(energies) != len(vals) for vals in abs_data]): sys.tracebacklimit = -1 raise InvalidInput(' Invalid data format') #raise Exception(' Invalid data format') try: process_params(energies, edge, preedge_params, postedge_params) except: sys.tracebacklimit = -1 raise InvalidInput('Invalid or inconsistent normalization parameters') ''' otvet = numpy.asarray([normalize(numpy.array([energies, abs_vals]), edge, preedge_params, postedge_params) for abs_vals in abs_data]) ''' otvet = [normalize(numpy.array([energies, abs_vals]), edge, preedge_params, postedge_params) for abs_vals in abs_data] norm_spectra_list = [] norm_consts_list = [] for tuple_instance in otvet: norm_spectra_list.append(tuple_instance[0]) norm_consts_list.append(tuple_instance[1]) norm_spectra = numpy.array(norm_spectra_list) norm_consts = numpy.array(norm_consts_list) return norm_spectra, norm_consts ''' return numpy.array([normalize(numpy.array([energies, abs_vals]), edge, preedge_params, postedge_params, True) for abs_vals in abs_data]) ''' extranormal3-0.0.3/PKG-INFO0000644005375400003410000000043513432336246020357 0ustar roudenkoinstrumentation00000000000000Metadata-Version: 1.0 Name: extranormal3 Version: 0.0.3 Summary: Quick normalization of a bunch of Quick-EXAFS spectra Home-page: UNKNOWN Author: Olga Roudenko Author-email: olga.roudenko@synchrotron-soleil.fr License: GPL >= v.3 Description: UNKNOWN Platform: Linux Platform: Windows extranormal3-0.0.3/setup.py0000644005375400003410000000131713432336236020773 0ustar roudenkoinstrumentation00000000000000import os.path #from distutils.core import setup from setuptools import setup version = '0.0.3' packages = ['extranormal3'] #package_data = {'extranormal.addons': ['imgs/*']} #scripts = [os.path.join('scripts', f) for f in ['ab_test.py']] ''' if os.name != 'posix': # windows scripts = [os.path.join('scripts', f) for f in ['test.py']] ''' setup(name='extranormal3', version=version, description='Quick normalization of a bunch of Quick-EXAFS spectra', author='Olga Roudenko', author_email='olga.roudenko@synchrotron-soleil.fr', license='GPL >= v.3', platforms=['Linux', 'Windows'], packages=packages, #package_data=package_data, #scripts=scripts ) extranormal3-0.0.3/extranormal3.egg-info/0000755005375400003410000000000013432336246023371 5ustar roudenkoinstrumentation00000000000000extranormal3-0.0.3/extranormal3.egg-info/PKG-INFO0000644005375400003410000000043513432336246024470 0ustar roudenkoinstrumentation00000000000000Metadata-Version: 1.0 Name: extranormal3 Version: 0.0.3 Summary: Quick normalization of a bunch of Quick-EXAFS spectra Home-page: UNKNOWN Author: Olga Roudenko Author-email: olga.roudenko@synchrotron-soleil.fr License: GPL >= v.3 Description: UNKNOWN Platform: Linux Platform: Windows extranormal3-0.0.3/extranormal3.egg-info/top_level.txt0000644005375400003410000000001513432336246026117 0ustar roudenkoinstrumentation00000000000000extranormal3 extranormal3-0.0.3/extranormal3.egg-info/SOURCES.txt0000644005375400003410000000047013432336246025256 0ustar roudenkoinstrumentation00000000000000setup.py extranormal3/__init__.py extranormal3/curved_tools.py extranormal3/extra_exafs.py extranormal3/forward_fourier.py extranormal3/normal_xas.py extranormal3.egg-info/PKG-INFO extranormal3.egg-info/SOURCES.txt extranormal3.egg-info/dependency_links.txt extranormal3.egg-info/top_level.txt scripts/ab_test.pyextranormal3-0.0.3/extranormal3.egg-info/dependency_links.txt0000644005375400003410000000000113432336246027437 0ustar roudenkoinstrumentation00000000000000 extranormal3-0.0.3/setup.cfg0000644005375400003410000000004613432336246021101 0ustar roudenkoinstrumentation00000000000000[egg_info] tag_build = tag_date = 0