pycistem 0.3.5__cp39-cp39-manylinux_2_27_x86_64.whl → 0.4.1__cp39-cp39-manylinux_2_27_x86_64.whl

pycistem/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.3.5"
+__version__ = "0.4.1"
 
 #from . import core
-from pycistem import database, programs
+from pycistem import database, programs, utils
 from pycistem.config import set_cistem_path
 
 

pycistem/core/core.cpp

@@ -268,7 +268,7 @@ PYBIND11_MODULE(core, m)
       .def("DefocusGivenAzimuth", &CTF::DefocusGivenAzimuth)
       .def("BeamTiltGivenAzimuth", &CTF::BeamTiltGivenAzimuth)
       .def("ParticleShiftGivenAzimuth", &CTF::ParticleShiftGivenAzimuth)
-      .def("WavelengthGivenAccelerationVoltage", &CTF::WavelengthGivenAccelerationVoltage)
+      //.def("WavelengthGivenAccelerationVoltage", &CTF::WavelengthGivenAccelerationVoltage)
       .def("GetLowestFrequencyForFitting", &CTF::GetLowestFrequencyForFitting)
       .def("GetHighestFrequencyForFitting", &CTF::GetHighestFrequencyForFitting)
       .def("GetHighestFrequencyWithGoodFit", &CTF::GetHighestFrequencyWithGoodFit)
@@ -611,7 +611,7 @@ PYBIND11_MODULE(core, m)
       .def("Normalize", &Image::Normalize)
       //.def("NormalizeSumOfSquares", &Image::NormalizeSumOfSquares)
       .def("ZeroFloatOutside", &Image::ZeroFloatOutside)
-      .def("ReplaceOutliersWithMean", &Image::ReplaceOutliersWithMean)
+      .def("ReplaceOutliersWithMean", static_cast<void (Image::*)(float)>(&Image::ReplaceOutliersWithMean))
       .def("ReturnVarianceOfRealValues", &Image::ReturnVarianceOfRealValues)
       .def("ReturnDistributionOfRealValues", &Image::ReturnDistributionOfRealValues)
       .def("UpdateDistributionOfRealValues", &Image::UpdateDistributionOfRealValues)

pycistem/database/__init__.py

@@ -197,7 +197,7 @@ def write_match_template_to_starfile(project, match_template_job_id, filename,ov
         "cisTEMAngleTheta": pd.Series(dtype="float"),
         "cisTEMAnglePhi": pd.Series(dtype="float"),
         "cisTEMPixelSize": pd.Series(dtype="float"),
-        "cisTEMScore": pd.Series(dtype="float")
+        "cisTEMScore": pd.Series(dtype="float"),
         })
 
     with contextlib.closing(sqlite3.connect(project)) as con:
@@ -231,9 +231,9 @@ def write_match_template_to_starfile(project, match_template_job_id, filename,ov
     # Due to a bug in cisTEM in earlier matches phi and psi are switched in the
     # database
     if(switch_phi_psi):
-        temp = result_peaks["phi"]
-        result_peaks["phi"] = result_peaks["psi"]
-        result_peaks["psi"] = temp
+        temp = result_peaks["cisTEMAnglePhi"]
+        result_peaks["cisTEMAnglePhi"] = result_peaks["cisTEMAnglePsi"]
+        result_peaks["cisTEMAnglePsi"] = temp
     starfile.write(result_peaks, filename=filename, overwrite=overwrite)
 
 
@@ -267,20 +267,33 @@ def get_already_processed_images(database, match_template_job_id):
 def get_num_already_processed_images(database, match_template_job_id):
     with contextlib.closing(sqlite3.connect(database)) as con:
         cur = con.cursor()
-        cur.execute(f"SELECT COUNT(*) FROM TEMPLATE_MATCH_LIST WHERE TEMPLATE_MATCH_JOB_ID = {match_template_job_id}")
+        cur.execute(f"SELECT COUNT(1) FROM TEMPLATE_MATCH_LIST WHERE TEMPLATE_MATCH_JOB_ID = {match_template_job_id}")
         num_already_processed_images = cur.fetchone()[0]
     return(num_already_processed_images)
 
+def get_num_matches(database, match_template_job_id):
+    with contextlib.closing(sqlite3.connect(database)) as con:
+        cur = con.cursor()
+        cur.execute(f"SELECT TEMPLATE_MATCH_ID FROM TEMPLATE_MATCH_LIST WHERE TEMPLATE_MATCH_JOB_ID = {match_template_job_id}")
+        match_template_ids = cur.fetchall()
+        total = 0
+        for mti in match_template_ids:
+            cur.execute(f"SELECT MAX(RowId) FROM TEMPLATE_MATCH_PEAK_LIST_{mti[0]}")
+            num_matches = cur.fetchone()[0]
+            if num_matches is not None:
+                total += num_matches
+    return(total)
+
 def get_num_images(database):
     with contextlib.closing(sqlite3.connect(database)) as con:
         cur = con.cursor()
-        cur.execute("SELECT COUNT(*) FROM IMAGE_ASSETS")
+        cur.execute("SELECT COUNT(1) FROM IMAGE_ASSETS WHERE CTF_ESTIMATION_ID IS NOT -1")
         num_images = cur.fetchone()[0]
     return(num_images)
 
 def get_num_movies(database):
     with contextlib.closing(sqlite3.connect(database)) as con:
         cur = con.cursor()
-        cur.execute("SELECT COUNT(*) FROM MOVIE_ASSETS")
+        cur.execute("SELECT COUNT(1) FROM MOVIE_ASSETS")
         num_movies = cur.fetchone()[0]
-    return(num_movies)
+    return(num_movies)

pycistem/programs/__init__.py

@@ -3,4 +3,8 @@ from pycistem.programs.cistem_program import *
 from pycistem.programs.refine_template import *
 from pycistem.programs.refine_template_niko import *
 from pycistem.programs.refine_template_dev import *
+from pycistem.programs.refine_ctf import *
+from pycistem.programs.estimate_beamtilt import *
 from pycistem.programs.run_profile import *
+from pycistem.programs.reconstruct3d import *
+from pycistem.programs.resample import *

pycistem/programs/_cistem_constants.py

@@ -10,7 +10,7 @@ socket_send_next_job  = b"z7PnJh=x;[b#f/6L"
 socket_time_to_die  = b")[czL7$#Sg/d4-*K"
 socket_ready_to_send_single_job  = b"-TDv(X*kY.:d`D5:"
 socket_i_have_an_error  = b"8TU.cDc3jr,rb[SN"
-socket_i_have_info  = b"+5nxvY@\t.!_R#Vn"
+socket_i_have_info  = b"+5nxvY@zt.!_R#Vn"
 socket_job_finished  = b"jNA[3!VdLdkb$LwM"
 socket_number_of_connections  = b"Uu6tsQ,z}M''T`7f"
 socket_all_jobs_finished  = b"aL)yaH[$3s;9Ymk6"

pycistem/programs/apply_ctf.py

@@ -43,9 +43,9 @@ def parameters_from_database(database, image_asset_id, output_filename, **kwargs
                              **kwargs)
     return(par)
 
-def run(parameters: Union[ApplyCtfParameters,list[ApplyCtfParameters]]):
+def run(parameters: Union[ApplyCtfParameters,list[ApplyCtfParameters]],**kwargs):
     if not isinstance(parameters, list):
         parameters = [parameters]
 
 
-    asyncio.run(cistem_program.run("applyctf",parameters))
+    asyncio.run(cistem_program.run("applyctf",parameters,**kwargs))

pycistem/programs/cistem_program.py

@@ -112,8 +112,9 @@ async def handle_leader(reader, writer, buffers, signal_handlers,results):
             cont = True
             while cont:
                 data = await reader.readexactly(16)
+                log.debug(f"In no sig {addr} sent {data}")
                 result = None
-                if data != socket_job_result_queue:
+                if data != socket_job_result_queue and data != socket_i_have_info:
                     cont = False
                 else:
                     await signal_handlers[data](reader,writer,log)
@@ -133,6 +134,7 @@ async def handle_leader(reader, writer, buffers, signal_handlers,results):
         while cont:
             if socket_send_next_job not in signal_handlers:
                 data = await reader.readexactly(16)
+                log.debug(f"In cont {addr} sent {data}")
                 if data != socket_send_next_job:
                     if data == socket_job_result_queue:
                         res = await signal_handlers[data](reader,writer,log)

pycistem/programs/estimate_beamtilt.py

@@ -0,0 +1,60 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Union
+import numpy as np
+import struct
+import mrcfile
+from functools import partial
+import pandas as pd
+
+
+from pycistem.programs import cistem_program
+from pycistem.programs._cistem_constants import socket_send_next_job, socket_job_result_queue
+from pycistem.core import Image
+
+@dataclass
+class EstimateBeamtiltParameters:
+    input_phase_difference_image: str
+    pixel_size: float = 1.0
+    voltage_kV: float = 300.0      
+    spherical_aberration_mm: float  = 2.7
+    first_position_to_search: int = 0  
+    last_position_to_search: int = 0
+
+async def handle_results(reader, writer, logger):
+    #logger.info("Handling results")
+    await reader.read(4)
+    length = await reader.read(4)
+    number_of_bytes = int.from_bytes(length, byteorder="little")
+    results = await reader.read(number_of_bytes*4)
+    score = struct.unpack("<f",results[0:4])[0]
+    beam_tilt_x = struct.unpack("<f",results[4:8])[0]
+    beam_tilt_y = struct.unpack("<f",results[8:12])[0]
+    particle_shift_x = struct.unpack("<f",results[12:16])[0]
+    particle_shift_y = struct.unpack("<f",results[16:20])[0]
+    return(score,beam_tilt_x,beam_tilt_y,particle_shift_x,particle_shift_y)
+
+async def handle_job_result_queue(reader, writer, logger):
+
+    length = await reader.readexactly(4)
+    number_of_bytes = int.from_bytes(length, byteorder="little")
+    results = await reader.readexactly(number_of_bytes)
+    return(results)
+
+def run(parameters: Union[EstimateBeamtiltParameters,list[EstimateBeamtiltParameters]],**kwargs) -> pd.DataFrame:
+
+    if not isinstance(parameters, list):
+        parameters = [parameters]
+    signal_handlers = {
+        socket_send_next_job : handle_results,
+        socket_job_result_queue : handle_job_result_queue,
+
+    }   
+    result = asyncio.run(cistem_program.run("estimate_beamtilt", parameters, signal_handlers=signal_handlers,**kwargs))
+    result = pd.DataFrame([a[1] for a in result],
+                            index = [a[0] for a in result],
+                            columns=["score","beam_tilt_x","beam_tilt_y","particle_shift_x","particle_shift_y"])
+    return(result)
+        
+        
+        

pycistem/programs/match_template.py

@@ -41,7 +41,7 @@ class MatchTemplateParameters:
     ctf_refinement: bool = False
     particle_radius_angstroms: float = 0.0
     phase_shift: float = 0.0
-    mip_output_file: str = "mip.mrc"
+    mip_output_file: str = "/dev/null"
     best_psi_output_file: str = "best_psi.mrc"
     best_theta_output_file: str = "best_theta.mrc"
     best_phi_output_file: str = "best_phi.mrc"
@@ -250,6 +250,8 @@ async def handle_results(reader, writer, logger, parameters, write_directly_to_d
             ]
             f.write(" ".join(str(x) for x in temp_double_array) + "\n")
     mrcfile.write(par.scaled_mip_output_file, scaled_mip.astype(np.float32), overwrite=True)
+    if par.mip_output_file != "/dev/null":
+        mrcfile.write(par.mip_output_file, mip.astype(np.float32), overwrite=True)
     peak_coordinates = peak_local_max(scaled_mip, min_distance=int(par.min_peak_radius), exclude_border=50, threshold_abs=expected_threshold)
     result = pd.DataFrame({
         "X_POSITION": peak_coordinates[:,1] * par.pixel_size,

pycistem/programs/reconstruct3d.py

@@ -0,0 +1,79 @@
+import asyncio
+
+from dataclasses import dataclass
+from typing import Union, List
+
+
+from pycistem.programs import cistem_program
+from pycistem.programs._cistem_constants import socket_i_have_info, socket_job_result_queue, socket_send_next_job
+
+@dataclass
+class Reconstruct3dParameters:
+    input_particle_stack: str 
+    input_star_filename: str           
+    input_reconstruction: str         = "/dev/null"
+    output_reconstruction_1: str =  "my_reconstruction1.mrc"
+    output_reconstruction_2: str = "my_reconstruction2.mrc"
+    output_reconstruction_filtered: str = "my_reconstruction_filtered.mrc"
+    output_resolution_statistics: str = "my_resolution_statistics.txt"
+    my_symmetry: str = "C1"
+    first_particle: int = 1
+    last_particle: int = 0
+    pixel_size: float = 1.0
+    molecular_mass_kDa: float = 300.0
+    inner_mask_radius: float = 0.0
+    outer_mask_radius: float = 150.0
+    resolution_limit_rec: float = 0.0
+    resolution_limit_ref: float = 0.0
+    score_weight_conversion: float = 5.0
+    score_threshold: float = 1.0
+    smoothing_factor: float = 1.0
+    padding : float = 1.0
+    normalize_particles: bool = True
+    adjust_scores: bool = True
+    invert_contrast: bool = False
+    exclude_blank_edges: bool = False
+    crop_images: bool = False
+    split_even_odd: bool = True
+    center_mass: bool = False
+    use_input_reconstruction: bool = False
+    threshold_input_3d: bool = True
+    dump_arrays: bool = False
+    dump_file_1: str = "my_dump_file1.dat"
+    dump_file_2: str = "my_dump_file2.dat"
+    correct_ewald_sphere: int = 0
+    max_threads: int = 1
+
+
+async def handle_job_result_queue(reader, writer, logger):
+
+    length = await reader.readexactly(4)
+    number_of_bytes = int.from_bytes(length, byteorder="little")
+    results = await reader.readexactly(number_of_bytes)
+    return(results)
+
+async def handle_socket_i_have_info(reader, writer, logger):
+    data = await reader.readexactly(4)
+    length = int.from_bytes(data, byteorder="little")
+    data = await reader.readexactly(length)
+    print(f"Info: {data.decode('utf-8')}")
+
+async def handle_results(reader, writer, logger):
+    #logger.info("Handling results")
+    await reader.readexactly(4)
+    length = await reader.readexactly(4)
+    number_of_bytes = int.from_bytes(length, byteorder="little")
+    data = await reader.readexactly(number_of_bytes*4)
+
+def run(parameters: Union[Reconstruct3dParameters,list[Reconstruct3dParameters]],**kwargs):
+
+    if not isinstance(parameters, list):
+        parameters = [parameters]
+    signal_handlers = {
+        socket_job_result_queue : handle_job_result_queue,
+        socket_i_have_info: handle_socket_i_have_info,
+        socket_send_next_job: handle_results
+    }   
+    asyncio.run(cistem_program.run("reconstruct3d", parameters, signal_handlers=signal_handlers,**kwargs))
+    
+        

pycistem/programs/refine_ctf.py

@@ -0,0 +1,106 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Union
+import numpy as np
+import struct
+import mrcfile
+from functools import partial
+
+
+from pycistem.programs import cistem_program
+from pycistem.programs._cistem_constants import socket_program_defined_result, socket_job_result_queue, socket_i_have_an_error
+from pycistem.core import Image
+
+@dataclass
+class RefineCtfParameters:
+    input_particle_images: str 
+    input_star_filename: str
+    input_reconstruction: str
+    input_reconstruction_statistics: str = "my_statistics.txt"
+    use_statistics: bool = False
+    ouput_star_filename: str = "/dev/null"
+    ouput_shift_filename: str = "/dev/null"
+    ouput_phase_difference_image: str = "/dev/null"
+    ouput_beamtilt_image: str = "/dev/null"
+    ouput_difference_image: str = "/dev/null"
+    first_particle: int = 0
+    last_particle: int = 0
+    pixel_size: float = 1.0
+    molecular_mass_kDa: float = 300.0
+    inner_mask_radius: float = 0.0
+    outer_mask_radius: float = 150.0
+    low_resolution_limit: float = 300.0
+    high_resolution_limit: float = 3.0
+    defocus_search_range: float = 500.0
+    defocus_step: float = 50.0
+    padding: float = 1.0
+    ctf_refinement: bool = False
+    beamtilt_refinement: bool = False
+    normalize_particles: bool = True
+    invert_contrast: bool = False
+    exclude_blank_edges: bool = True
+    normalize_input_3d: bool = True
+    threshold_input_3d: bool = False
+    job_number_from_gui: int = 0 
+    expected_number_of_results_from_gui: int = 0
+    max_threads: int = 1
+
+def get_np_arrays(bytes,o,i,x,y,numpix):
+    array = np.frombuffer(bytes,offset=o+i*numpix*4, count=numpix,dtype=np.float32).copy()
+    array = array.reshape((y,-1))
+    array = array[:,:x]
+    return array
+
+async def handle_results(reader, writer, logger, parameters):
+    #logger.info("Handling results")
+    size_of_array= await reader.readexactly(4)
+    result_number= await reader.readexactly(4)
+    number_of_expected_results= await reader.readexactly(4)
+    number_of_floats = int.from_bytes(size_of_array, byteorder="little")
+    result_number = int.from_bytes(result_number, byteorder="little")
+    number_of_expected_results = int.from_bytes(number_of_expected_results, byteorder="little")
+    results = await reader.readexactly(number_of_floats*4)
+    x_dim = int(struct.unpack("<f",results[0:4])[0])
+    y_dim = int(struct.unpack("<f",results[4:8])[0])
+    num_pixels = int(struct.unpack("<f",results[8:12])[0])
+    images_to_process = int(struct.unpack("<f",results[12:16])[0])
+    voltage_kV = struct.unpack("<f",results[16:20])[0]
+    spherical_aberration_mm = struct.unpack("<f",results[20:24])[0]
+    phase_difference_image = get_np_arrays(results,24,0,x_dim,y_dim,num_pixels)
+    phase_difference_image_cistem = Image()
+
+    phase_difference_image_cistem.Allocate(x_dim,y_dim,1,False,True)
+    np.copyto(phase_difference_image_cistem.real_values , phase_difference_image)
+    phase_difference_image_cistem.DivideByConstant(images_to_process)
+    phase_difference_image_cistem.CosineMask(0.45, parameters[result_number].pixel_size / 20.0, False, False, 0.0)
+    phase_difference_image_cistem.QuickAndDirtyWriteSlice(parameters[result_number].ouput_phase_difference_image,1,True,0.0)
+    #mrcfile.write("test.mrc", phase_difference_image.astype(np.float32), overwrite=True)
+    return(results)
+
+async def handle_job_result_queue(reader, writer, logger):
+
+    length = await reader.readexactly(4)
+    number_of_bytes = int.from_bytes(length, byteorder="little")
+    results = await reader.readexactly(number_of_bytes)
+    return(results)
+
+async def handle_i_have_an_error(reader, writer, logger):
+    print("I have an error")
+    #number_of_bytes = int.from_bytes(length, byteorder="little")
+    number_of_bytes = 40
+    results = await reader.read(number_of_bytes)
+    print(results)
+    return(results)
+
+def run(parameters: Union[RefineCtfParameters,list[RefineCtfParameters]],**kwargs):
+
+    if not isinstance(parameters, list):
+        parameters = [parameters]
+    for i, par in enumerate(parameters):
+        par.image_number_for_gui = i
+    signal_handlers = {
+        socket_program_defined_result : partial(handle_results,parameters=parameters),
+        socket_job_result_queue : handle_job_result_queue,
+        socket_i_have_an_error: handle_i_have_an_error
+    }   
+    byte_results = asyncio.run(cistem_program.run("refine_ctf", parameters, signal_handlers=signal_handlers,**kwargs))

pycistem/programs/resample.py

@@ -0,0 +1,30 @@
+import asyncio
+
+from dataclasses import dataclass
+from typing import Union, List
+
+
+from pycistem.programs import cistem_program
+from pycistem.programs._cistem_constants import socket_send_next_job
+
+@dataclass
+class ResampleParameters:
+    input_filename: str 
+    output_filename: str 
+    is_a_volume: bool = False  
+    new_x_size: int = 64
+    new_y_size: int = 64
+    new_z_size: int = 1    
+  
+
+
+
+
+def run(parameters: Union[ResampleParameters,list[ResampleParameters]],**kwargs):
+
+    if not isinstance(parameters, list):
+        parameters = [parameters]
+   
+    asyncio.run(cistem_program.run("resample", parameters, **kwargs))
+    
+        

pycistem/programs/unblur.py

@@ -83,7 +83,7 @@ def parameters_from_database(database, decolace=False, **kwargs):
     ) for i,movie in movie_info.iterrows()]
     return(par)
 
-def write_results_to_database(database,  parameters, results):
+def write_results_to_database(database,  parameters, results, change_image_assets=True):
     conn = sqlite3.connect(database)
     cur = conn.cursor()
     results = sorted(results, key=lambda x: x["parameter_index"])
@@ -151,9 +151,9 @@ def write_results_to_database(database,  parameters, results):
         #else:
         #    image_asset_id = existing_image_asset[0]
 
-        
-        cur.execute("REPLACE INTO IMAGE_ASSETS (IMAGE_ASSET_ID, NAME, FILENAME, POSITION_IN_STACK, PARENT_MOVIE_ID, ALIGNMENT_ID, CTF_ESTIMATION_ID, X_SIZE, Y_SIZE, PIXEL_SIZE, VOLTAGE, SPHERICAL_ABERRATION, PROTEIN_IS_WHITE, ORIGINAL_X_SIZE, ORIGINAL_Y_SIZE, CROP_CENTER_X, CROP_CENTER_Y) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-            (image_asset_id, movie_info[3], parameters[result["parameter_index"]].output_filename, 1,movie_info[2],max_alignment_id+1, -1, int(xsize), int(ysize), actual_pixel_size, parameters[result["parameter_index"]].acceleration_voltage, movie_info[5], movie_info[4],result["orig_x"],result["orig_y"],result["crop_x"],result["crop_y"]))
+        if change_image_assets:
+            cur.execute("REPLACE INTO IMAGE_ASSETS (IMAGE_ASSET_ID, NAME, FILENAME, POSITION_IN_STACK, PARENT_MOVIE_ID, ALIGNMENT_ID, CTF_ESTIMATION_ID, X_SIZE, Y_SIZE, PIXEL_SIZE, VOLTAGE, SPHERICAL_ABERRATION, PROTEIN_IS_WHITE, ORIGINAL_X_SIZE, ORIGINAL_Y_SIZE, CROP_CENTER_X, CROP_CENTER_Y) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (image_asset_id, movie_info[3], parameters[result["parameter_index"]].output_filename, 1,movie_info[2],max_alignment_id+1, -1, int(xsize), int(ysize), actual_pixel_size, parameters[result["parameter_index"]].acceleration_voltage, movie_info[5], movie_info[4],result["orig_x"],result["orig_y"],result["crop_x"],result["crop_y"]))
         MOVIE_ALIGNMENT_PARAMETERS = {
             "FRAME_NUMBER": range(1,len(result["x_shifts"])+1),
             "X_SHIFT": result["x_shifts"],

pycistem/utils/__init__.py

@@ -0,0 +1 @@
+from .extract_particles import extract_particles

pycistem/utils/extract_particles.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+def extract_particles(starfile_filename: Path, stack_filename: Path, box_size: int = 256):
+    """Extract particles from a star file and save them as individual images.
+
+    Args:
+        starfile_filename (str): The filename of the star file.
+        box_size (int, optional): The size of the extracted particles. Defaults to 256.
+    """
+    import starfile
+    import mrcfile
+    import numpy as np
+    from itertools import groupby
+    particle_info = starfile.read(starfile_filename)
+    mrc = mrcfile.new_mmap(stack_filename, (len(particle_info), box_size, box_size), mrc_mode=2, overwrite=True)
+    # Iterate over groupby cisTEMOriginalImageFilename
+
+    for micrograph_filename, subparticles in groupby(particle_info.itertuples(), lambda x: x.cisTEMOriginalImageFilename):
+        micrograph = mrcfile.open(micrograph_filename)
+        if micrograph.data.ndim == 3:
+            micrograph_data  = micrograph.data[0].copy()
+        else:
+            micrograph_data = micrograph.data.copy()
+        for particle in subparticles:
+            x = round(particle.cisTEMOriginalXPosition/particle.cisTEMPixelSize)
+            y = round(particle.cisTEMOriginalYPosition/particle.cisTEMPixelSize)
+            particle_image = micrograph_data.take(range(y-box_size//2, y+box_size//2), mode='clip', axis=0).take(range(x-box_size//2, x+box_size//2), mode='clip', axis=1)
+            if particle_image.shape != (box_size, box_size):
+                raise ValueError(f"Particle at {x},{y} from micrograph {micrograph_filename} {micrograph_data.shape} is out of bounds {particle_image.shape}.")
+            
+            particle_image -= particle_image.mean()
+            particle_image /= particle_image.std()
+            mrc.data[particle.cisTEMPositionInStack-1] = particle_image
+            yield
+    mrc.close()
+    return

pycistem/utils/move_class_into_unbinned_particle_stack.py

@@ -0,0 +1,34 @@
+import pandas as pd
+from typing import Union
+import sqlite3
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+import starfile
+
+app = typer.Typer()
+
+
+@app.command()
+def plot(database: Annotated[Path, typer.Argument(...,help="The database file to use")],
+        refinement_id: Annotated[int, typer.Argument(...,help="The refinement to use")],
+        class_id: Annotated[int, typer.Argument(...,help="The class to cus")],
+        input_star_file: Annotated[Path, typer.Argument(...,help="The starfile to use")],
+        output_star_file: Annotated[Path, typer.Argument(...,help="The starfile to write to")],
+        ):
+    db = sqlite3.connect(database)
+    refinements = []
+    refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE REFINEMENT_ID = {refinement_id}", db).iloc[0]
+    refinment_result = pd.read_sql_query(f"SELECT * FROM REFINEMENT_RESULT_{refinement_id}_{class_id}", db)
+    refinment_package_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_PACKAGE_CONTAINED_PARTICLES_{refinment_info['REFINEMENT_PACKAGE_ASSET_ID']}", db)
+    
+    starfile_info = starfile.read(input_star_file)
+
+    original_ids = refinment_package_info["ORIGINAL_PARTICLE_POSITION_ASSET_ID"].to_list()
+    subset_starfile_info = starfile_info.iloc[original_ids].copy()
+    subset_starfile_info["cisTEMOccupancy"] = refinment_result["OCCUPANCY"].to_list()
+    subset_starfile_info["cisTEMScore"] = refinment_result["SCORE"].to_list()
+    starfile.write(subset_starfile_info, output_star_file)
+
+if __name__ == "__main__":
+    app()

pycistem/utils/order_by_class_occupancy.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from typing import Union
+import sqlite3
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+import matplotlib.pyplot as plt
+
+app = typer.Typer()
+
+
+@app.command()
+def plot(database: Annotated[Path, typer.Argument(...,help="The database file to use")],
+        start_refinement: Annotated[int, typer.Argument(...,help="The refinement to start from")]):
+    db = sqlite3.connect(database)
+    refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE REFINEMENT_ID = {start_refinement}", db)
+    class_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_DETAILS_{refinment_info['REFINEMENT_ID'].values[0]}", db)
+    class_info.sort_values(by="AVERAGE_OCCUPANCY", inplace=True)
+    # print as a table the CLASS_NUMBER and AVERAGE_OCCUPANCY
+    print(class_info[['CLASS_NUMBER', 'AVERAGE_OCCUPANCY']])
+
+        
+            
+
+if __name__ == "__main__":
+    app()

pycistem/utils/plot_class_occupancy.py

@@ -0,0 +1,51 @@
+import pandas as pd
+from typing import Union
+import sqlite3
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+import matplotlib.pyplot as plt
+
+app = typer.Typer()
+
+def return_class_occupancies(row, db):
+    class_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_DETAILS_{row['REFINEMENT_ID']}", db)
+    return [row['REFINEMENT_ID']] + class_info['AVERAGE_OCCUPANCY'].to_list()
+
+def return_num_part_with_occ_higher_than(row, db, min_occ):
+    class_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_DETAILS_{row['REFINEMENT_ID']}", db)
+    result = [row['REFINEMENT_ID']]
+    for class_id in class_info['CLASS_NUMBER']:
+        particle_info = pd.read_sql_query(f"SELECT OCCUPANCY FROM REFINEMENT_RESULT_{row['REFINEMENT_ID']}_{class_id}", db)
+        result.append(len(particle_info[particle_info['OCCUPANCY'] > min_occ]))
+    print(result)
+    return result
+
+@app.command()
+def plot(database: Annotated[Path, typer.Argument(...,help="The database file to use")],
+        start_refinement: Annotated[int, typer.Argument(...,help="The refinement to start from")]):
+    db = sqlite3.connect(database)
+    refinements = []
+    refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE REFINEMENT_ID = {start_refinement}", db)
+    while len(refinment_info) == 1:
+        reference_refinement_id = refinment_info["REFINEMENT_ID"].values[0]
+        refinements.append(refinment_info)
+        refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE STARTING_REFINEMENT_ID = {reference_refinement_id}", db)
+    refinements = pd.concat(refinements)
+    av_occs = refinements.apply(return_class_occupancies, axis=1, result_type='expand', args=(db,))
+    av_occs.plot(x=0)
+    plt.savefig("average_occupancies.png")
+    plt.figure()
+    occ_0_5 = refinements.apply(return_num_part_with_occ_higher_than, axis=1, result_type='expand', args=(db, 50))
+    occ_0_5.plot(x=0)
+    plt.savefig("occupancies_0_5.png")
+    plt.figure()
+    occ_0_9 = refinements.apply(return_num_part_with_occ_higher_than, axis=1, result_type='expand', args=(db, 90))
+    occ_0_9.plot(x=0)
+    plt.savefig("occupancies_0_9.png")
+
+        
+            
+
+if __name__ == "__main__":
+    app()

pycistem/utils/plot_classification_fsc_movie.py

@@ -0,0 +1,90 @@
+import pandas as pd
+from typing import Union
+import sqlite3
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+
+app = typer.Typer()
+
+def return_fsc(db,refinement,classid):
+    fsc = pd.read_sql_query(f"SELECT * FROM REFINEMENT_RESOLUTION_STATISTICS_{refinement}_{classid}", db)
+    return(fsc)
+
+
+
+
+@app.command()
+def plot(database: Annotated[Path, typer.Argument(...,help="The database file to use")],
+        start_refinement: Annotated[int, typer.Argument(...,help="The refinement to start from")]):
+    db = sqlite3.connect(database)
+    refinements = []
+    refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE REFINEMENT_ID = {start_refinement}", db)
+    while len(refinment_info) == 1:
+        reference_refinement_id = refinment_info["REFINEMENT_ID"].values[0]
+        refinements.append(refinment_info)
+        refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE STARTING_REFINEMENT_ID = {reference_refinement_id}", db)
+    refinements = pd.concat(refinements)
+
+    fscs = []
+    for i in range(refinements.iloc[0]['NUMBER_OF_CLASSES']):
+        dat = return_fsc(db,refinements.iloc[0]['REFINEMENT_ID'],i+1)
+        dat["CLASS"] = i+1
+        fscs.append(dat)
+    dat = pd.concat(fscs)
+
+
+
+    fig, ax = plt.subplots()
+    linplts = {}
+    for key, grp in dat[dat['RESOLUTION'] > 4.0].groupby(['CLASS']):
+        linplts[key] = plt.plot(grp['SHELL'], grp['PART_FSC'],label=key)[0]
+    print(linplts)
+    plt.ylim(0,1.05)
+
+
+    def update(frame):
+        fscs = []
+        for i in range(refinements.iloc[frame]['NUMBER_OF_CLASSES']):
+            dat = return_fsc(db,refinements.iloc[frame]['REFINEMENT_ID'],i+1)
+            dat["CLASS"] = i+1
+            fscs.append(dat)
+        dat = pd.concat(fscs)
+        for key, grp in dat[dat['RESOLUTION'] > 4.0].groupby(['CLASS']):
+            print(key)
+            linplts[key].set_xdata(grp['SHELL'])
+            linplts[key].set_ydata(grp['PART_FSC'])
+
+
+
+    
+        return linplts.values()
+
+
+    ani = animation.FuncAnimation(fig=fig, func=update, frames=len(refinements), interval=300)
+    plt.show()
+    
+    return()
+
+    
+    
+    
+    av_occs = refinements.apply(return_class_occupancies, axis=1, result_type='expand', args=(db,))
+    av_occs.plot(x=0)
+    plt.savefig("average_occupancies.png")
+    plt.figure()
+    occ_0_5 = refinements.apply(return_num_part_with_occ_higher_than, axis=1, result_type='expand', args=(db, 0.5))
+    occ_0_5.plot(x=0)
+    plt.savefig("occupancies_0_5.png")
+    plt.figure()
+    occ_0_9 = refinements.apply(return_num_part_with_occ_higher_than, axis=1, result_type='expand', args=(db, 0.9))
+    occ_0_9.plot(x=0)
+    plt.savefig("occupancies_0_9.png")
+
+        
+            
+
+if __name__ == "__main__":
+    app()

pycistem/utils/plot_occupancy_by_condition.py

@@ -0,0 +1,129 @@
+import pandas as pd
+from typing import Union
+import sqlite3
+import starfile
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+from collections import defaultdict
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.colors as mcolors
+app = typer.Typer()
+
+
+def return_num_part_per_cond_with_occ_higher_than(row, db, min_occ, tmp):
+    class_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_DETAILS_{row['REFINEMENT_ID']}", db)
+    all_particle_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_PACKAGE_CONTAINED_PARTICLES_{row['REFINEMENT_PACKAGE_ASSET_ID']}", db)
+    
+    result = []
+    for class_id in class_info['CLASS_NUMBER']:
+        particle_info = pd.read_sql_query(f"SELECT POSITION_IN_STACK,PSI,OCCUPANCY FROM REFINEMENT_RESULT_{row['REFINEMENT_ID']}_{class_id}", db)
+        particle_info = particle_info.merge(all_particle_info, on="POSITION_IN_STACK")
+        particle_info = particle_info.merge(tmp,  left_on='ORIGINAL_PARTICLE_POSITION_ASSET_ID', right_index=True)
+        particle_info['experimental_condition'] = particle_info['cisTEMOriginalImageFilename'].str.split("/").str[-4]
+        particle_info = particle_info[particle_info['OCCUPANCY'] > min_occ]
+        result.append(particle_info['experimental_condition'].value_counts())
+    return result
+
+@app.command()
+def plot(database: Annotated[Path, typer.Argument(...,help="The database file to use")],
+        start_refinement: Annotated[int, typer.Argument(...,help="The refinement to start from")],
+        starfile_filename: Annotated[Path, typer.Argument(...,help="The starfile to use")]):
+    db = sqlite3.connect(database)
+    tmp = starfile.read(starfile_filename)
+    counts_in_cond = defaultdict(defaultdict[lambda: 0])
+    refinment_info = pd.read_sql_query(f"SELECT * FROM REFINEMENT_LIST WHERE REFINEMENT_ID = {start_refinement}", db)
+    number_per_class = return_num_part_per_cond_with_occ_higher_than(refinment_info.iloc[0], db, 0.9, tmp)
+    for class_id, class_counts in enumerate(number_per_class):
+        for cond, count in class_counts.items():
+            exp = cond
+            if class_id not in counts_in_cond[exp]:
+                counts_in_cond[exp][class_id] = count
+            else:
+                counts_in_cond[exp][class_id] += count
+    condition_list = sorted(list(counts_in_cond.keys()))
+    ucs = {}
+    for i, condition in enumerate(condition_list):
+        exp = condition.split("_")[2]
+        ucs[exp] = 1
+    
+    #create a categorical colormap using ListedColormap
+    cmap = mcolors.ListedColormap(mcolors.TABLEAU_COLORS.values())
+
+    # get the number of colors in the colormap
+    num_colors = cmap.N
+
+    # create a dictionary mapping each label to a color index
+    color_indices = {label: i for i, label in enumerate(ucs.keys())}
+
+    cond_position = {'24hbr': 3, '48hbr': 4, 'C': 2}
+    states_this= {
+        'A/P/eEF1a' : [15,19,8,4,18,3],
+        'eEF2a': [11,14,10,20,9,12],
+        'pA/P' : [5,2],
+        'pA/P/eEF2': [6],
+
+    }
+    states_pivot = { v:k for k in states_this for v in states_this[k]}
+
+    datas = defaultdict(list)
+    state_count = {}
+    for cond in cond_position.keys():
+        state_count[cond] =  defaultdict(lambda: 0)
+
+    for i, condition in enumerate(condition_list):
+        #if condition.split("_")[0] != "20230317":
+        #    continue
+        exp = condition.split("_")[2]
+
+        counts = np.zeros(20)
+        for i in range(20):
+            if i in counts_in_cond[condition]:
+                counts[i] = counts_in_cond[condition][i]
+        
+        if np.sum(counts) < 1000:
+            continue
+        #make colorkei for exp
+        for classid, frac in enumerate(counts):
+            if classid+1 in states_pivot:
+                state_count[exp][states_pivot[classid+1]] += frac
+            datas[classid * 5 + cond_position[exp]].append(frac/np.sum(counts))
+        #plt.plot(np.arange(len(counts))+1+i*0.1,counts/np.sum(counts), 'o', color=cmap(color_indices[exp]))
+    
+
+    pos = list(datas.keys())
+    data = list(datas.values())
+    state_percent = {}
+    for cond in state_count.keys():
+        state_percent[cond] = {}
+        par_sum = np.sum(list(state_count[cond].values()))
+        for state in state_count[cond].keys():
+            state_percent[cond][state] = state_count[cond][state]/par_sum
+    print(state_percent)
+    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(13, 6))
+
+    bplot = ax.boxplot(data, positions=pos,  widths=0.7, patch_artist=True,)
+    
+    colors = ["red","green","green","yellow","orange"]
+    for i,patch in enumerate(bplot['boxes']):
+        print(i)
+        patch.set_facecolor(colors[pos[i]%5])
+    ax.set_title('Class occupancies grouped by condition', fontsize=10)
+    from matplotlib.lines import Line2D
+    legend_elements = [Line2D([0], [0], marker='o', color='green', label='Control',
+                          markerfacecolor='green', markersize=10),
+                          Line2D([0], [0], marker='o', color='yellow', label='24h brequinar',
+                          markerfacecolor='yellow', markersize=10),
+                          Line2D([0], [0], marker='o', color='orange', label='48h brequinar',
+                          markerfacecolor='orange', markersize=10)]
+    ax.legend(handles=legend_elements, loc='upper left')
+    plt.xticks(ticks = np.arange(20)*5 +3 , labels = np.arange(20)+1)
+    plt.savefig("condition.png")
+        
+
+        
+            
+
+if __name__ == "__main__":
+    app()

{pycistem-0.3.5.dist-info → pycistem-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycistem
-Version: 0.3.5
+Version: 0.4.1
 Summary: Python tools to run cisTEM programs and code
 Project-URL: Documentation, https://github.com/jojoelfe/pycistem#readme
 Project-URL: Issues, https://github.com/jojoelfe/pycistem/issues

pycistem-0.4.1.dist-info/RECORD

@@ -0,0 +1,36 @@
+pycistem/__init__.py,sha256=XZu46-aF_8gLVnOVd3lZMlY3kODX7BefoWRkjG53mno,138
+pycistem/config.py,sha256=kmI0GlEXdj3OQF3dfG0yLcvtnfD-f3Yu9QxTaxDq2Z8,569
+pycistem/core/__init__.py,sha256=fvT4XAcUTVWpRpzX5tJC8K5L9Jpl4EeH23M0eB-TJi4,33
+pycistem/core/core.cpp,sha256=dI1ovIDraXetBo09mTOabyM4hAgPFIQndjT8uvayLwg,55905
+pycistem/core/database.cpp,sha256=pJc031gr89v4wSltEiQ9dGgyZ_gZOZ2gPEOdQqkgzJ4,25174
+pycistem/core/euler_search.cpp,sha256=bKJTSXILbXjUgoZKv63HzOscwkOJBhspetIdnoT3cmI,2986
+pycistem/core/run_profiles.cpp,sha256=yWxplGb2lF-ck9Ov9RTN1M-Y8_0v1qpLPx7WFPQ4rV0,5019
+pycistem/database/__init__.py,sha256=W6kWXa7rbIFGnAPixobO1ctnqZyCQE2EVXTx25cwNNY,13708
+pycistem/programs/__init__.py,sha256=JBwtNchlzyt-sT_FCOmasIUVdOhgr2YYlxGN8HXdJB8,465
+pycistem/programs/_cistem_constants.py,sha256=UarwJf1hG-XmzOm55gdxVpAVqVBXgDGCpwrw-fROBw0,1073
+pycistem/programs/apply_ctf.py,sha256=T3CD8aM4EHARY3rbJEjI0mGHrN84XCS_FEgcyFsPMPE,2090
+pycistem/programs/cistem_program.py,sha256=fuuCB0nzfyvSSx8X19xIPMVkZS08oEwWg7atDGb2N9Q,9662
+pycistem/programs/ctffind.py,sha256=CdEyBSy9Ax6rkwUSCDo0roaXhyfLEmTOFXFNvF-z7aI,11999
+pycistem/programs/estimate_beamtilt.py,sha256=3xU254DpVuNUWqS3kXeB8QbA_mfEay8s29QIxBmfUzM,2192
+pycistem/programs/match_template.py,sha256=7S-jUr9ZqXCTLeDOp99Q_YERxR1EziHxIFb3QbmxfNU,15792
+pycistem/programs/reconstruct3d.py,sha256=vXzg7gSPl34EWRsuXc21GCPjkpfwx3bC8xu7pWI2RZk,2840
+pycistem/programs/refine_ctf.py,sha256=_e08Zpf4M8Fy9fBQ2WtS6v_C8od36SUwS4jEFnelHrE,4454
+pycistem/programs/refine_template.py,sha256=pYcKvxhrnNVc-e_F-_SWefDRv3oc8WHPiJ2Vc6BzVNA,6850
+pycistem/programs/refine_template_dev.py,sha256=mwapt1Xaryf7bMuoblQc0cczCIFLiSHU4FvWprVT9xY,802
+pycistem/programs/refine_template_niko.py,sha256=4ANTZNC5JyNVRzA55wfQvjCty68c_-f6_8LePE6oca0,5730
+pycistem/programs/resample.py,sha256=JOZHbLz3yJne6aT3zDg0c2SWac7G7Q7cC14oAwUP1wM,648
+pycistem/programs/run_profile.py,sha256=iDeFxdhzYvGnRStVEAlu6rb5d91j96XneUKSznSR6JY,431
+pycistem/programs/unblur.py,sha256=nEnAYvL77q4Poa88FEOX7UsQflsjujBLSz8kJYLqrRc,12242
+pycistem/programs/unblur_patch.py,sha256=DIWLoAPHUk3XuJ8zDGEsDgKi4IJ97fw4QNEWphL6iTc,10306
+pycistem/utils/__init__.py,sha256=kh4WR0GtPw_ljuJVvv75j8kkRF2w8hja3IYb2BregUs,48
+pycistem/utils/extract_particles.py,sha256=QqJqmzsXosGEhDh_lflUrge3kzuOBXfQyxVlKpZhX-4,1849
+pycistem/utils/move_class_into_unbinned_particle_stack.py,sha256=ie6b0-4GvyapAhRklqHPPt6jRiLrGY26vFtUb9Gv5tI,1565
+pycistem/utils/order_by_class_occupancy.py,sha256=X1hOnoxtnT0-_0gZcQXJawkpVOyJATZCPoDC3fuICrs,919
+pycistem/utils/plot_class_occupancy.py,sha256=sI7P7L2X8gULg0crc1pNxaJSwYWxORPkw5J6-BviMHQ,2217
+pycistem/utils/plot_classification_fsc_movie.py,sha256=d81aaOVugzkhZPEY1EZX3STWiU-anmkp4sPhjj-PN9Y,2847
+pycistem/utils/plot_occupancy_by_condition.py,sha256=tSa0LYw2HELs50PYqlI3ph37Y8krNL40MWwQGqkK-68,5478
+pycistem/core/core.cpython-39-x86_64-linux-gnu.so,sha256=xTUctEuqOm_0TEpxxA4ONPkbTrH1aEv9M1POkZPtdOo,10516312
+pycistem-0.4.1.dist-info/METADATA,sha256=p9Yn3G2V1nR6ffhR7ou3TWdKUAdICCHCnaPV7MNxGFs,14517
+pycistem-0.4.1.dist-info/WHEEL,sha256=eYSqyObTn_hucsbuKs9hUiciCBrXf581UimCwMaWnh0,107
+pycistem-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pycistem-0.4.1.dist-info/RECORD,,

{pycistem-0.3.5.dist-info → pycistem-0.4.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.18.0
+Generator: hatchling 1.21.1
 Root-Is-Purelib: false
 Tag: cp39-cp39-manylinux_2_27_x86_64

pycistem-0.3.5.dist-info/RECORD

@@ -1,25 +0,0 @@
-pycistem/__init__.py,sha256=Ttm0g5ElZOQuJSmY9u_dg4ne7i3zH7pg1WEunerNsO0,131
-pycistem/config.py,sha256=kmI0GlEXdj3OQF3dfG0yLcvtnfD-f3Yu9QxTaxDq2Z8,569
-pycistem/core/__init__.py,sha256=fvT4XAcUTVWpRpzX5tJC8K5L9Jpl4EeH23M0eB-TJi4,33
-pycistem/core/core.cpp,sha256=L3OWaVhZSyrgM-6e3b-1KhFHr-8ktuxYkTzTADxVnsM,55866
-pycistem/core/database.cpp,sha256=pJc031gr89v4wSltEiQ9dGgyZ_gZOZ2gPEOdQqkgzJ4,25174
-pycistem/core/euler_search.cpp,sha256=bKJTSXILbXjUgoZKv63HzOscwkOJBhspetIdnoT3cmI,2986
-pycistem/core/run_profiles.cpp,sha256=yWxplGb2lF-ck9Ov9RTN1M-Y8_0v1qpLPx7WFPQ4rV0,5019
-pycistem/database/__init__.py,sha256=vXaaxnJp5hNO69I7cC6xL6AeuHx5mEh2ryXRxD-Zs3s,13030
-pycistem/programs/__init__.py,sha256=hgNeKgKGNKC1qmHXqa3fextal740IRlpQxrgQ0aewOg,286
-pycistem/programs/_cistem_constants.py,sha256=Lzn1yV-GiUuvERoyPjpwsj6vxJBYD7coya-vuvK7VfI,1073
-pycistem/programs/apply_ctf.py,sha256=OP9jw7C0t4moc9EJeqYhb58DafUwUUJbySPFbNxJb1U,2072
-pycistem/programs/cistem_program.py,sha256=BQxR5SuCzJu6MDae3DXUEHemMuUcGkvnoDVXpKTZKC0,9515
-pycistem/programs/ctffind.py,sha256=CdEyBSy9Ax6rkwUSCDo0roaXhyfLEmTOFXFNvF-z7aI,11999
-pycistem/programs/match_template.py,sha256=p7YgJiE6sHtsyY6PMbWZbi6hw7c9CrEUACSMX-_Ov1Q,15664
-pycistem/programs/refine_template.py,sha256=pYcKvxhrnNVc-e_F-_SWefDRv3oc8WHPiJ2Vc6BzVNA,6850
-pycistem/programs/refine_template_dev.py,sha256=mwapt1Xaryf7bMuoblQc0cczCIFLiSHU4FvWprVT9xY,802
-pycistem/programs/refine_template_niko.py,sha256=4ANTZNC5JyNVRzA55wfQvjCty68c_-f6_8LePE6oca0,5730
-pycistem/programs/run_profile.py,sha256=iDeFxdhzYvGnRStVEAlu6rb5d91j96XneUKSznSR6JY,431
-pycistem/programs/unblur.py,sha256=rX11xb2kmIhv6aIr4_PZfszLqvmFq0ws4xN6QYXW-dA,12185
-pycistem/programs/unblur_patch.py,sha256=DIWLoAPHUk3XuJ8zDGEsDgKi4IJ97fw4QNEWphL6iTc,10306
-pycistem/core/core.cpython-39-x86_64-linux-gnu.so,sha256=RlUSHkiVlpqRIwwB5sbijXNfpVEcSzfUOMZLnqkYDhA,10486752
-pycistem-0.3.5.dist-info/METADATA,sha256=HzCtlEwoh3QV0yQkILqc6A8OFBDdgp3txckoKrLg4zY,14517
-pycistem-0.3.5.dist-info/WHEEL,sha256=X8v6HhkuwCgMl2F0p69ECbgxU3jrwPtSnuX-mulqon0,107
-pycistem-0.3.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pycistem-0.3.5.dist-info/RECORD,,